From 9d3f28d07d29607d0e3c1823f4a4d2bc229d05b9 Mon Sep 17 00:00:00 2001 From: Wei <47681251+QuenKar@users.noreply.github.com> Date: Mon, 18 Sep 2023 19:08:44 +0800 Subject: [PATCH] feat: add duration column. (#105) --- c++/greptime/v1/column.pb.cc | 199 ++++- c++/greptime/v1/column.pb.h | 288 +++++++ c++/greptime/v1/common.pb.cc | 17 +- c++/greptime/v1/common.pb.h | 6 +- c++/greptime/v1/row.pb.cc | 150 +++- c++/greptime/v1/row.pb.h | 220 +++++ go/greptime/v1/column.pb.go | 64 +- go/greptime/v1/common.pb.go | 34 +- go/greptime/v1/row.pb.go | 91 +- .../src/main/java/io/greptime/v1/Columns.java | 789 +++++++++++++++++- java/src/main/java/io/greptime/v1/Common.java | 47 +- .../src/main/java/io/greptime/v1/RowData.java | 434 +++++++++- proto/greptime/v1/column.proto | 4 + proto/greptime/v1/common.proto | 4 + proto/greptime/v1/row.proto | 4 + 15 files changed, 2292 insertions(+), 59 deletions(-) diff --git a/c++/greptime/v1/column.pb.cc b/c++/greptime/v1/column.pb.cc index ee88a2f..bc71bcc 100644 --- a/c++/greptime/v1/column.pb.cc +++ b/c++/greptime/v1/column.pb.cc @@ -70,6 +70,14 @@ PROTOBUF_CONSTEXPR Column_Values::Column_Values( , /*decltype(_impl_.interval_day_time_values_)*/{} , /*decltype(_impl_._interval_day_time_values_cached_byte_size_)*/{0} , /*decltype(_impl_.interval_month_day_nano_values_)*/{} + , /*decltype(_impl_.duration_second_values_)*/{} + , /*decltype(_impl_._duration_second_values_cached_byte_size_)*/{0} + , /*decltype(_impl_.duration_millisecond_values_)*/{} + , /*decltype(_impl_._duration_millisecond_values_cached_byte_size_)*/{0} + , /*decltype(_impl_.duration_microsecond_values_)*/{} + , /*decltype(_impl_._duration_microsecond_values_cached_byte_size_)*/{0} + , /*decltype(_impl_.duration_nanosecond_values_)*/{} + , /*decltype(_impl_._duration_nanosecond_values_cached_byte_size_)*/{0} , /*decltype(_impl_._cached_size_)*/{}} {} struct Column_ValuesDefaultTypeInternal { PROTOBUF_CONSTEXPR Column_ValuesDefaultTypeInternal() @@ -136,6 +144,10 @@ const uint32_t TableStruct_greptime_2fv1_2fcolumn_2eproto::offsets[] PROTOBUF_SE PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.interval_year_month_values_), PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.interval_day_time_values_), PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.interval_month_day_nano_values_), + PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.duration_second_values_), + PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.duration_millisecond_values_), + PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.duration_microsecond_values_), + PROTOBUF_FIELD_OFFSET(::greptime::v1::Column_Values, _impl_.duration_nanosecond_values_), ~0u, // no _has_bits_ PROTOBUF_FIELD_OFFSET(::greptime::v1::Column, _internal_metadata_), ~0u, // no _extensions_ @@ -150,7 +162,7 @@ const uint32_t TableStruct_greptime_2fv1_2fcolumn_2eproto::offsets[] PROTOBUF_SE }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, -1, -1, sizeof(::greptime::v1::Column_Values)}, - { 32, -1, -1, sizeof(::greptime::v1::Column)}, + { 36, -1, -1, sizeof(::greptime::v1::Column)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -160,12 +172,12 @@ static const ::_pb::Message* const file_default_instances[] = { const char descriptor_table_protodef_greptime_2fv1_2fcolumn_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = "\n\030greptime/v1/column.proto\022\013greptime.v1\032" - "\030greptime/v1/common.proto\"\240\007\n\006Column\022\023\n\013" + "\030greptime/v1/common.proto\"\256\010\n\006Column\022\023\n\013" "column_name\030\001 \001(\t\0220\n\rsemantic_type\030\002 \001(\016" "2\031.greptime.v1.SemanticType\022*\n\006values\030\003 " "\001(\0132\032.greptime.v1.Column.Values\022\021\n\tnull_" "mask\030\004 \001(\014\022-\n\010datatype\030\005 \001(\0162\033.greptime." - "v1.ColumnDataType\032\340\005\n\006Values\022\021\n\ti8_value" + "v1.ColumnDataType\032\356\006\n\006Values\022\021\n\ti8_value" "s\030\001 \003(\005\022\022\n\ni16_values\030\002 \003(\005\022\022\n\ni32_value" "s\030\003 \003(\005\022\022\n\ni64_values\030\004 \003(\003\022\021\n\tu8_values" "\030\005 \003(\r\022\022\n\nu16_values\030\006 \003(\r\022\022\n\nu32_values" @@ -183,17 +195,20 @@ const char descriptor_table_protodef_greptime_2fv1_2fcolumn_2eproto[] PROTOBUF_S "alues\030\027 \003(\003\022\"\n\032interval_year_month_value" "s\030\030 \003(\005\022 \n\030interval_day_time_values\030\031 \003(" "\003\022I\n\036interval_month_day_nano_values\030\032 \003(" - "\0132!.greptime.v1.IntervalMonthDayNanoBP\n\016" - "io.greptime.v1B\007ColumnsZ5github.com/Grep" - "timeTeam/greptime-proto/go/greptime/v1b\006" - "proto3" + "\0132!.greptime.v1.IntervalMonthDayNano\022\036\n\026" + "duration_second_values\030\033 \003(\003\022#\n\033duration" + "_millisecond_values\030\034 \003(\003\022#\n\033duration_mi" + "crosecond_values\030\035 \003(\003\022\"\n\032duration_nanos" + "econd_values\030\036 \003(\003BP\n\016io.greptime.v1B\007Co" + "lumnsZ5github.com/GreptimeTeam/greptime-" + "proto/go/greptime/v1b\006proto3" ; static const ::_pbi::DescriptorTable* const descriptor_table_greptime_2fv1_2fcolumn_2eproto_deps[1] = { &::descriptor_table_greptime_2fv1_2fcommon_2eproto, }; static ::_pbi::once_flag descriptor_table_greptime_2fv1_2fcolumn_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_greptime_2fv1_2fcolumn_2eproto = { - false, false, 1086, descriptor_table_protodef_greptime_2fv1_2fcolumn_2eproto, + false, false, 1228, descriptor_table_protodef_greptime_2fv1_2fcolumn_2eproto, "greptime/v1/column.proto", &descriptor_table_greptime_2fv1_2fcolumn_2eproto_once, descriptor_table_greptime_2fv1_2fcolumn_2eproto_deps, 1, 2, schemas, file_default_instances, TableStruct_greptime_2fv1_2fcolumn_2eproto::offsets, @@ -274,6 +289,14 @@ Column_Values::Column_Values(const Column_Values& from) , decltype(_impl_.interval_day_time_values_){from._impl_.interval_day_time_values_} , /*decltype(_impl_._interval_day_time_values_cached_byte_size_)*/{0} , decltype(_impl_.interval_month_day_nano_values_){from._impl_.interval_month_day_nano_values_} + , decltype(_impl_.duration_second_values_){from._impl_.duration_second_values_} + , /*decltype(_impl_._duration_second_values_cached_byte_size_)*/{0} + , decltype(_impl_.duration_millisecond_values_){from._impl_.duration_millisecond_values_} + , /*decltype(_impl_._duration_millisecond_values_cached_byte_size_)*/{0} + , decltype(_impl_.duration_microsecond_values_){from._impl_.duration_microsecond_values_} + , /*decltype(_impl_._duration_microsecond_values_cached_byte_size_)*/{0} + , decltype(_impl_.duration_nanosecond_values_){from._impl_.duration_nanosecond_values_} + , /*decltype(_impl_._duration_nanosecond_values_cached_byte_size_)*/{0} , /*decltype(_impl_._cached_size_)*/{}}; _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); @@ -331,6 +354,14 @@ inline void Column_Values::SharedCtor( , decltype(_impl_.interval_day_time_values_){arena} , /*decltype(_impl_._interval_day_time_values_cached_byte_size_)*/{0} , decltype(_impl_.interval_month_day_nano_values_){arena} + , decltype(_impl_.duration_second_values_){arena} + , /*decltype(_impl_._duration_second_values_cached_byte_size_)*/{0} + , decltype(_impl_.duration_millisecond_values_){arena} + , /*decltype(_impl_._duration_millisecond_values_cached_byte_size_)*/{0} + , decltype(_impl_.duration_microsecond_values_){arena} + , /*decltype(_impl_._duration_microsecond_values_cached_byte_size_)*/{0} + , decltype(_impl_.duration_nanosecond_values_){arena} + , /*decltype(_impl_._duration_nanosecond_values_cached_byte_size_)*/{0} , /*decltype(_impl_._cached_size_)*/{} }; } @@ -372,6 +403,10 @@ inline void Column_Values::SharedDtor() { _impl_.interval_year_month_values_.~RepeatedField(); _impl_.interval_day_time_values_.~RepeatedField(); _impl_.interval_month_day_nano_values_.~RepeatedPtrField(); + _impl_.duration_second_values_.~RepeatedField(); + _impl_.duration_millisecond_values_.~RepeatedField(); + _impl_.duration_microsecond_values_.~RepeatedField(); + _impl_.duration_nanosecond_values_.~RepeatedField(); } void Column_Values::SetCachedSize(int size) const { @@ -410,6 +445,10 @@ void Column_Values::Clear() { _impl_.interval_year_month_values_.Clear(); _impl_.interval_day_time_values_.Clear(); _impl_.interval_month_day_nano_values_.Clear(); + _impl_.duration_second_values_.Clear(); + _impl_.duration_millisecond_values_.Clear(); + _impl_.duration_microsecond_values_.Clear(); + _impl_.duration_nanosecond_values_.Clear(); _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); } @@ -714,6 +753,50 @@ const char* Column_Values::_InternalParse(const char* ptr, ::_pbi::ParseContext* } else goto handle_unusual; continue; + // repeated int64 duration_second_values = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 218)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_duration_second_values(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 216) { + _internal_add_duration_second_values(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated int64 duration_millisecond_values = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 226)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_duration_millisecond_values(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 224) { + _internal_add_duration_millisecond_values(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated int64 duration_microsecond_values = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 234)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_duration_microsecond_values(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 232) { + _internal_add_duration_microsecond_values(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // repeated int64 duration_nanosecond_values = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 242)) { + ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt64Parser(_internal_mutable_duration_nanosecond_values(), ptr, ctx); + CHK_(ptr); + } else if (static_cast(tag) == 240) { + _internal_add_duration_nanosecond_values(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -962,6 +1045,42 @@ uint8_t* Column_Values::_InternalSerialize( InternalWriteMessage(26, repfield, repfield.GetCachedSize(), target, stream); } + // repeated int64 duration_second_values = 27; + { + int byte_size = _impl_._duration_second_values_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt64Packed( + 27, _internal_duration_second_values(), byte_size, target); + } + } + + // repeated int64 duration_millisecond_values = 28; + { + int byte_size = _impl_._duration_millisecond_values_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt64Packed( + 28, _internal_duration_millisecond_values(), byte_size, target); + } + } + + // repeated int64 duration_microsecond_values = 29; + { + int byte_size = _impl_._duration_microsecond_values_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt64Packed( + 29, _internal_duration_microsecond_values(), byte_size, target); + } + } + + // repeated int64 duration_nanosecond_values = 30; + { + int byte_size = _impl_._duration_nanosecond_values_cached_byte_size_.load(std::memory_order_relaxed); + if (byte_size > 0) { + target = stream->WriteInt64Packed( + 30, _internal_duration_nanosecond_values(), byte_size, target); + } + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -1314,6 +1433,62 @@ size_t Column_Values::ByteSizeLong() const { ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(msg); } + // repeated int64 duration_second_values = 27; + { + size_t data_size = ::_pbi::WireFormatLite:: + Int64Size(this->_impl_.duration_second_values_); + if (data_size > 0) { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._duration_second_values_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated int64 duration_millisecond_values = 28; + { + size_t data_size = ::_pbi::WireFormatLite:: + Int64Size(this->_impl_.duration_millisecond_values_); + if (data_size > 0) { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._duration_millisecond_values_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated int64 duration_microsecond_values = 29; + { + size_t data_size = ::_pbi::WireFormatLite:: + Int64Size(this->_impl_.duration_microsecond_values_); + if (data_size > 0) { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._duration_microsecond_values_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + + // repeated int64 duration_nanosecond_values = 30; + { + size_t data_size = ::_pbi::WireFormatLite:: + Int64Size(this->_impl_.duration_nanosecond_values_); + if (data_size > 0) { + total_size += 2 + + ::_pbi::WireFormatLite::Int32Size(static_cast(data_size)); + } + int cached_size = ::_pbi::ToCachedSize(data_size); + _impl_._duration_nanosecond_values_cached_byte_size_.store(cached_size, + std::memory_order_relaxed); + total_size += data_size; + } + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); } @@ -1358,6 +1533,10 @@ void Column_Values::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const :: _this->_impl_.interval_year_month_values_.MergeFrom(from._impl_.interval_year_month_values_); _this->_impl_.interval_day_time_values_.MergeFrom(from._impl_.interval_day_time_values_); _this->_impl_.interval_month_day_nano_values_.MergeFrom(from._impl_.interval_month_day_nano_values_); + _this->_impl_.duration_second_values_.MergeFrom(from._impl_.duration_second_values_); + _this->_impl_.duration_millisecond_values_.MergeFrom(from._impl_.duration_millisecond_values_); + _this->_impl_.duration_microsecond_values_.MergeFrom(from._impl_.duration_microsecond_values_); + _this->_impl_.duration_nanosecond_values_.MergeFrom(from._impl_.duration_nanosecond_values_); _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); } @@ -1401,6 +1580,10 @@ void Column_Values::InternalSwap(Column_Values* other) { _impl_.interval_year_month_values_.InternalSwap(&other->_impl_.interval_year_month_values_); _impl_.interval_day_time_values_.InternalSwap(&other->_impl_.interval_day_time_values_); _impl_.interval_month_day_nano_values_.InternalSwap(&other->_impl_.interval_month_day_nano_values_); + _impl_.duration_second_values_.InternalSwap(&other->_impl_.duration_second_values_); + _impl_.duration_millisecond_values_.InternalSwap(&other->_impl_.duration_millisecond_values_); + _impl_.duration_microsecond_values_.InternalSwap(&other->_impl_.duration_microsecond_values_); + _impl_.duration_nanosecond_values_.InternalSwap(&other->_impl_.duration_nanosecond_values_); } ::PROTOBUF_NAMESPACE_ID::Metadata Column_Values::GetMetadata() const { diff --git a/c++/greptime/v1/column.pb.h b/c++/greptime/v1/column.pb.h index 14c8d91..cbcbca4 100644 --- a/c++/greptime/v1/column.pb.h +++ b/c++/greptime/v1/column.pb.h @@ -211,6 +211,10 @@ class Column_Values final : kIntervalYearMonthValuesFieldNumber = 24, kIntervalDayTimeValuesFieldNumber = 25, kIntervalMonthDayNanoValuesFieldNumber = 26, + kDurationSecondValuesFieldNumber = 27, + kDurationMillisecondValuesFieldNumber = 28, + kDurationMicrosecondValuesFieldNumber = 29, + kDurationNanosecondValuesFieldNumber = 30, }; // repeated int32 i8_values = 1; int i8_values_size() const; @@ -784,6 +788,94 @@ class Column_Values final : const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::IntervalMonthDayNano >& interval_month_day_nano_values() const; + // repeated int64 duration_second_values = 27; + int duration_second_values_size() const; + private: + int _internal_duration_second_values_size() const; + public: + void clear_duration_second_values(); + private: + int64_t _internal_duration_second_values(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + _internal_duration_second_values() const; + void _internal_add_duration_second_values(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + _internal_mutable_duration_second_values(); + public: + int64_t duration_second_values(int index) const; + void set_duration_second_values(int index, int64_t value); + void add_duration_second_values(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + duration_second_values() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + mutable_duration_second_values(); + + // repeated int64 duration_millisecond_values = 28; + int duration_millisecond_values_size() const; + private: + int _internal_duration_millisecond_values_size() const; + public: + void clear_duration_millisecond_values(); + private: + int64_t _internal_duration_millisecond_values(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + _internal_duration_millisecond_values() const; + void _internal_add_duration_millisecond_values(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + _internal_mutable_duration_millisecond_values(); + public: + int64_t duration_millisecond_values(int index) const; + void set_duration_millisecond_values(int index, int64_t value); + void add_duration_millisecond_values(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + duration_millisecond_values() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + mutable_duration_millisecond_values(); + + // repeated int64 duration_microsecond_values = 29; + int duration_microsecond_values_size() const; + private: + int _internal_duration_microsecond_values_size() const; + public: + void clear_duration_microsecond_values(); + private: + int64_t _internal_duration_microsecond_values(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + _internal_duration_microsecond_values() const; + void _internal_add_duration_microsecond_values(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + _internal_mutable_duration_microsecond_values(); + public: + int64_t duration_microsecond_values(int index) const; + void set_duration_microsecond_values(int index, int64_t value); + void add_duration_microsecond_values(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + duration_microsecond_values() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + mutable_duration_microsecond_values(); + + // repeated int64 duration_nanosecond_values = 30; + int duration_nanosecond_values_size() const; + private: + int _internal_duration_nanosecond_values_size() const; + public: + void clear_duration_nanosecond_values(); + private: + int64_t _internal_duration_nanosecond_values(int index) const; + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + _internal_duration_nanosecond_values() const; + void _internal_add_duration_nanosecond_values(int64_t value); + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + _internal_mutable_duration_nanosecond_values(); + public: + int64_t duration_nanosecond_values(int index) const; + void set_duration_nanosecond_values(int index, int64_t value); + void add_duration_nanosecond_values(int64_t value); + const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& + duration_nanosecond_values() const; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* + mutable_duration_nanosecond_values(); + // @@protoc_insertion_point(class_scope:greptime.v1.Column.Values) private: class _Internal; @@ -838,6 +930,14 @@ class Column_Values final : ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > interval_day_time_values_; mutable std::atomic _interval_day_time_values_cached_byte_size_; ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::greptime::v1::IntervalMonthDayNano > interval_month_day_nano_values_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > duration_second_values_; + mutable std::atomic _duration_second_values_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > duration_millisecond_values_; + mutable std::atomic _duration_millisecond_values_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > duration_microsecond_values_; + mutable std::atomic _duration_microsecond_values_cached_byte_size_; + ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t > duration_nanosecond_values_; + mutable std::atomic _duration_nanosecond_values_cached_byte_size_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; }; union { Impl_ _impl_; }; @@ -2335,6 +2435,194 @@ Column_Values::interval_month_day_nano_values() const { return _impl_.interval_month_day_nano_values_; } +// repeated int64 duration_second_values = 27; +inline int Column_Values::_internal_duration_second_values_size() const { + return _impl_.duration_second_values_.size(); +} +inline int Column_Values::duration_second_values_size() const { + return _internal_duration_second_values_size(); +} +inline void Column_Values::clear_duration_second_values() { + _impl_.duration_second_values_.Clear(); +} +inline int64_t Column_Values::_internal_duration_second_values(int index) const { + return _impl_.duration_second_values_.Get(index); +} +inline int64_t Column_Values::duration_second_values(int index) const { + // @@protoc_insertion_point(field_get:greptime.v1.Column.Values.duration_second_values) + return _internal_duration_second_values(index); +} +inline void Column_Values::set_duration_second_values(int index, int64_t value) { + _impl_.duration_second_values_.Set(index, value); + // @@protoc_insertion_point(field_set:greptime.v1.Column.Values.duration_second_values) +} +inline void Column_Values::_internal_add_duration_second_values(int64_t value) { + _impl_.duration_second_values_.Add(value); +} +inline void Column_Values::add_duration_second_values(int64_t value) { + _internal_add_duration_second_values(value); + // @@protoc_insertion_point(field_add:greptime.v1.Column.Values.duration_second_values) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::_internal_duration_second_values() const { + return _impl_.duration_second_values_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::duration_second_values() const { + // @@protoc_insertion_point(field_list:greptime.v1.Column.Values.duration_second_values) + return _internal_duration_second_values(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::_internal_mutable_duration_second_values() { + return &_impl_.duration_second_values_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::mutable_duration_second_values() { + // @@protoc_insertion_point(field_mutable_list:greptime.v1.Column.Values.duration_second_values) + return _internal_mutable_duration_second_values(); +} + +// repeated int64 duration_millisecond_values = 28; +inline int Column_Values::_internal_duration_millisecond_values_size() const { + return _impl_.duration_millisecond_values_.size(); +} +inline int Column_Values::duration_millisecond_values_size() const { + return _internal_duration_millisecond_values_size(); +} +inline void Column_Values::clear_duration_millisecond_values() { + _impl_.duration_millisecond_values_.Clear(); +} +inline int64_t Column_Values::_internal_duration_millisecond_values(int index) const { + return _impl_.duration_millisecond_values_.Get(index); +} +inline int64_t Column_Values::duration_millisecond_values(int index) const { + // @@protoc_insertion_point(field_get:greptime.v1.Column.Values.duration_millisecond_values) + return _internal_duration_millisecond_values(index); +} +inline void Column_Values::set_duration_millisecond_values(int index, int64_t value) { + _impl_.duration_millisecond_values_.Set(index, value); + // @@protoc_insertion_point(field_set:greptime.v1.Column.Values.duration_millisecond_values) +} +inline void Column_Values::_internal_add_duration_millisecond_values(int64_t value) { + _impl_.duration_millisecond_values_.Add(value); +} +inline void Column_Values::add_duration_millisecond_values(int64_t value) { + _internal_add_duration_millisecond_values(value); + // @@protoc_insertion_point(field_add:greptime.v1.Column.Values.duration_millisecond_values) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::_internal_duration_millisecond_values() const { + return _impl_.duration_millisecond_values_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::duration_millisecond_values() const { + // @@protoc_insertion_point(field_list:greptime.v1.Column.Values.duration_millisecond_values) + return _internal_duration_millisecond_values(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::_internal_mutable_duration_millisecond_values() { + return &_impl_.duration_millisecond_values_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::mutable_duration_millisecond_values() { + // @@protoc_insertion_point(field_mutable_list:greptime.v1.Column.Values.duration_millisecond_values) + return _internal_mutable_duration_millisecond_values(); +} + +// repeated int64 duration_microsecond_values = 29; +inline int Column_Values::_internal_duration_microsecond_values_size() const { + return _impl_.duration_microsecond_values_.size(); +} +inline int Column_Values::duration_microsecond_values_size() const { + return _internal_duration_microsecond_values_size(); +} +inline void Column_Values::clear_duration_microsecond_values() { + _impl_.duration_microsecond_values_.Clear(); +} +inline int64_t Column_Values::_internal_duration_microsecond_values(int index) const { + return _impl_.duration_microsecond_values_.Get(index); +} +inline int64_t Column_Values::duration_microsecond_values(int index) const { + // @@protoc_insertion_point(field_get:greptime.v1.Column.Values.duration_microsecond_values) + return _internal_duration_microsecond_values(index); +} +inline void Column_Values::set_duration_microsecond_values(int index, int64_t value) { + _impl_.duration_microsecond_values_.Set(index, value); + // @@protoc_insertion_point(field_set:greptime.v1.Column.Values.duration_microsecond_values) +} +inline void Column_Values::_internal_add_duration_microsecond_values(int64_t value) { + _impl_.duration_microsecond_values_.Add(value); +} +inline void Column_Values::add_duration_microsecond_values(int64_t value) { + _internal_add_duration_microsecond_values(value); + // @@protoc_insertion_point(field_add:greptime.v1.Column.Values.duration_microsecond_values) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::_internal_duration_microsecond_values() const { + return _impl_.duration_microsecond_values_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::duration_microsecond_values() const { + // @@protoc_insertion_point(field_list:greptime.v1.Column.Values.duration_microsecond_values) + return _internal_duration_microsecond_values(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::_internal_mutable_duration_microsecond_values() { + return &_impl_.duration_microsecond_values_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::mutable_duration_microsecond_values() { + // @@protoc_insertion_point(field_mutable_list:greptime.v1.Column.Values.duration_microsecond_values) + return _internal_mutable_duration_microsecond_values(); +} + +// repeated int64 duration_nanosecond_values = 30; +inline int Column_Values::_internal_duration_nanosecond_values_size() const { + return _impl_.duration_nanosecond_values_.size(); +} +inline int Column_Values::duration_nanosecond_values_size() const { + return _internal_duration_nanosecond_values_size(); +} +inline void Column_Values::clear_duration_nanosecond_values() { + _impl_.duration_nanosecond_values_.Clear(); +} +inline int64_t Column_Values::_internal_duration_nanosecond_values(int index) const { + return _impl_.duration_nanosecond_values_.Get(index); +} +inline int64_t Column_Values::duration_nanosecond_values(int index) const { + // @@protoc_insertion_point(field_get:greptime.v1.Column.Values.duration_nanosecond_values) + return _internal_duration_nanosecond_values(index); +} +inline void Column_Values::set_duration_nanosecond_values(int index, int64_t value) { + _impl_.duration_nanosecond_values_.Set(index, value); + // @@protoc_insertion_point(field_set:greptime.v1.Column.Values.duration_nanosecond_values) +} +inline void Column_Values::_internal_add_duration_nanosecond_values(int64_t value) { + _impl_.duration_nanosecond_values_.Add(value); +} +inline void Column_Values::add_duration_nanosecond_values(int64_t value) { + _internal_add_duration_nanosecond_values(value); + // @@protoc_insertion_point(field_add:greptime.v1.Column.Values.duration_nanosecond_values) +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::_internal_duration_nanosecond_values() const { + return _impl_.duration_nanosecond_values_; +} +inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >& +Column_Values::duration_nanosecond_values() const { + // @@protoc_insertion_point(field_list:greptime.v1.Column.Values.duration_nanosecond_values) + return _internal_duration_nanosecond_values(); +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::_internal_mutable_duration_nanosecond_values() { + return &_impl_.duration_nanosecond_values_; +} +inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< int64_t >* +Column_Values::mutable_duration_nanosecond_values() { + // @@protoc_insertion_point(field_mutable_list:greptime.v1.Column.Values.duration_nanosecond_values) + return _internal_mutable_duration_nanosecond_values(); +} + // ------------------------------------------------------------------- // Column diff --git a/c++/greptime/v1/common.pb.cc b/c++/greptime/v1/common.pb.cc index 9f12556..c4e68fe 100644 --- a/c++/greptime/v1/common.pb.cc +++ b/c++/greptime/v1/common.pb.cc @@ -273,7 +273,7 @@ const char descriptor_table_protodef_greptime_2fv1_2fcommon_2eproto[] PROTOBUF_S "ows\"I\n\024IntervalMonthDayNano\022\016\n\006months\030\001 " "\001(\005\022\014\n\004days\030\002 \001(\005\022\023\n\013nanoseconds\030\003 \001(\003*1" "\n\014SemanticType\022\007\n\003TAG\020\000\022\t\n\005FIELD\020\001\022\r\n\tTI" - "MESTAMP\020\002*\306\003\n\016ColumnDataType\022\013\n\007BOOLEAN\020" + "MESTAMP\020\002*\250\004\n\016ColumnDataType\022\013\n\007BOOLEAN\020" "\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005INT" "64\020\004\022\t\n\005UINT8\020\005\022\n\n\006UINT16\020\006\022\n\n\006UINT32\020\007\022" "\n\n\006UINT64\020\010\022\013\n\007FLOAT32\020\t\022\013\n\007FLOAT64\020\n\022\n\n" @@ -284,13 +284,16 @@ const char descriptor_table_protodef_greptime_2fv1_2fcommon_2eproto[] PROTOBUF_S "ND\020\023\022\024\n\020TIME_MILLISECOND\020\024\022\024\n\020TIME_MICRO" "SECOND\020\025\022\023\n\017TIME_NANOSECOND\020\026\022\027\n\023INTERVA" "L_YEAR_MONTH\020\027\022\025\n\021INTERVAL_DAY_TIME\020\030\022\033\n" - "\027INTERVAL_MONTH_DAY_NANO\020\031BO\n\016io.greptim" - "e.v1B\006CommonZ5github.com/GreptimeTeam/gr" - "eptime-proto/go/greptime/v1b\006proto3" + "\027INTERVAL_MONTH_DAY_NANO\020\031\022\023\n\017DURATION_S" + "ECOND\020\032\022\030\n\024DURATION_MILLISECOND\020\033\022\030\n\024DUR" + "ATION_MICROSECOND\020\034\022\027\n\023DURATION_NANOSECO" + "ND\020\035BO\n\016io.greptime.v1B\006CommonZ5github.c" + "om/GreptimeTeam/greptime-proto/go/grepti" + "me/v1b\006proto3" ; static ::_pbi::once_flag descriptor_table_greptime_2fv1_2fcommon_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_greptime_2fv1_2fcommon_2eproto = { - false, false, 1235, descriptor_table_protodef_greptime_2fv1_2fcommon_2eproto, + false, false, 1333, descriptor_table_protodef_greptime_2fv1_2fcommon_2eproto, "greptime/v1/common.proto", &descriptor_table_greptime_2fv1_2fcommon_2eproto_once, nullptr, 0, 9, schemas, file_default_instances, TableStruct_greptime_2fv1_2fcommon_2eproto::offsets, @@ -352,6 +355,10 @@ bool ColumnDataType_IsValid(int value) { case 23: case 24: case 25: + case 26: + case 27: + case 28: + case 29: return true; default: return false; diff --git a/c++/greptime/v1/common.pb.h b/c++/greptime/v1/common.pb.h index 7ab046a..c0fe1d9 100644 --- a/c++/greptime/v1/common.pb.h +++ b/c++/greptime/v1/common.pb.h @@ -143,12 +143,16 @@ enum ColumnDataType : int { INTERVAL_YEAR_MONTH = 23, INTERVAL_DAY_TIME = 24, INTERVAL_MONTH_DAY_NANO = 25, + DURATION_SECOND = 26, + DURATION_MILLISECOND = 27, + DURATION_MICROSECOND = 28, + DURATION_NANOSECOND = 29, ColumnDataType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits::min(), ColumnDataType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits::max() }; bool ColumnDataType_IsValid(int value); constexpr ColumnDataType ColumnDataType_MIN = BOOLEAN; -constexpr ColumnDataType ColumnDataType_MAX = INTERVAL_MONTH_DAY_NANO; +constexpr ColumnDataType ColumnDataType_MAX = DURATION_NANOSECOND; constexpr int ColumnDataType_ARRAYSIZE = ColumnDataType_MAX + 1; const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ColumnDataType_descriptor(); diff --git a/c++/greptime/v1/row.pb.cc b/c++/greptime/v1/row.pb.cc index 38fb2ba..d3befea 100644 --- a/c++/greptime/v1/row.pb.cc +++ b/c++/greptime/v1/row.pb.cc @@ -141,6 +141,10 @@ const uint32_t TableStruct_greptime_2fv1_2frow_2eproto::offsets[] PROTOBUF_SECTI ::_pbi::kInvalidFieldOffsetTag, ::_pbi::kInvalidFieldOffsetTag, ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::greptime::v1::Value, _impl_.value_data_), }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { @@ -166,7 +170,7 @@ const char descriptor_table_protodef_greptime_2fv1_2frow_2eproto[] PROTOBUF_SECT "\0162\033.greptime.v1.ColumnDataType\0220\n\rsemant" "ic_type\030\003 \001(\0162\031.greptime.v1.SemanticType" "\")\n\003Row\022\"\n\006values\030\001 \003(\0132\022.greptime.v1.Va" - "lue\"\212\006\n\005Value\022\022\n\010i8_value\030\001 \001(\005H\000\022\023\n\ti16" + "lue\"\234\007\n\005Value\022\022\n\010i8_value\030\001 \001(\005H\000\022\023\n\ti16" "_value\030\002 \001(\005H\000\022\023\n\ti32_value\030\003 \001(\005H\000\022\023\n\ti" "64_value\030\004 \001(\003H\000\022\022\n\010u8_value\030\005 \001(\rH\000\022\023\n\t" "u16_value\030\006 \001(\rH\000\022\023\n\tu32_value\030\007 \001(\rH\000\022\023" @@ -185,16 +189,20 @@ const char descriptor_table_protodef_greptime_2fv1_2frow_2eproto[] PROTOBUF_SECT "th_values\030\030 \001(\005H\000\022\"\n\030interval_day_time_v" "alues\030\031 \001(\003H\000\022K\n\036interval_month_day_nano" "_values\030\032 \001(\0132!.greptime.v1.IntervalMont" - "hDayNanoH\000B\014\n\nvalue_dataBP\n\016io.greptime." - "v1B\007RowDataZ5github.com/GreptimeTeam/gre" - "ptime-proto/go/greptime/v1b\006proto3" + "hDayNanoH\000\022\037\n\025duration_second_value\030\033 \001(" + "\003H\000\022$\n\032duration_millisecond_value\030\034 \001(\003H" + "\000\022$\n\032duration_microsecond_value\030\035 \001(\003H\000\022" + "#\n\031duration_nanosecond_value\030\036 \001(\003H\000B\014\n\n" + "value_dataBP\n\016io.greptime.v1B\007RowDataZ5g" + "ithub.com/GreptimeTeam/greptime-proto/go" + "/greptime/v1b\006proto3" ; static const ::_pbi::DescriptorTable* const descriptor_table_greptime_2fv1_2frow_2eproto_deps[1] = { &::descriptor_table_greptime_2fv1_2fcommon_2eproto, }; static ::_pbi::once_flag descriptor_table_greptime_2fv1_2frow_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_greptime_2fv1_2frow_2eproto = { - false, false, 1194, descriptor_table_protodef_greptime_2fv1_2frow_2eproto, + false, false, 1340, descriptor_table_protodef_greptime_2fv1_2frow_2eproto, "greptime/v1/row.proto", &descriptor_table_greptime_2fv1_2frow_2eproto_once, descriptor_table_greptime_2fv1_2frow_2eproto_deps, 1, 4, schemas, file_default_instances, TableStruct_greptime_2fv1_2frow_2eproto::offsets, @@ -1040,6 +1048,22 @@ Value::Value(const Value& from) from._internal_interval_month_day_nano_values()); break; } + case kDurationSecondValue: { + _this->_internal_set_duration_second_value(from._internal_duration_second_value()); + break; + } + case kDurationMillisecondValue: { + _this->_internal_set_duration_millisecond_value(from._internal_duration_millisecond_value()); + break; + } + case kDurationMicrosecondValue: { + _this->_internal_set_duration_microsecond_value(from._internal_duration_microsecond_value()); + break; + } + case kDurationNanosecondValue: { + _this->_internal_set_duration_nanosecond_value(from._internal_duration_nanosecond_value()); + break; + } case VALUE_DATA_NOT_SET: { break; } @@ -1188,6 +1212,22 @@ void Value::clear_value_data() { } break; } + case kDurationSecondValue: { + // No need to clear + break; + } + case kDurationMillisecondValue: { + // No need to clear + break; + } + case kDurationMicrosecondValue: { + // No need to clear + break; + } + case kDurationNanosecondValue: { + // No need to clear + break; + } case VALUE_DATA_NOT_SET: { break; } @@ -1423,6 +1463,38 @@ const char* Value::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { } else goto handle_unusual; continue; + // int64 duration_second_value = 27; + case 27: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 216)) { + _internal_set_duration_second_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // int64 duration_millisecond_value = 28; + case 28: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 224)) { + _internal_set_duration_millisecond_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // int64 duration_microsecond_value = 29; + case 29: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 232)) { + _internal_set_duration_microsecond_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; + // int64 duration_nanosecond_value = 30; + case 30: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 240)) { + _internal_set_duration_nanosecond_value(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); + CHK_(ptr); + } else + goto handle_unusual; + continue; default: goto handle_unusual; } // switch @@ -1613,6 +1685,30 @@ uint8_t* Value::_InternalSerialize( _Internal::interval_month_day_nano_values(this).GetCachedSize(), target, stream); } + // int64 duration_second_value = 27; + if (_internal_has_duration_second_value()) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(27, this->_internal_duration_second_value(), target); + } + + // int64 duration_millisecond_value = 28; + if (_internal_has_duration_millisecond_value()) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(28, this->_internal_duration_millisecond_value(), target); + } + + // int64 duration_microsecond_value = 29; + if (_internal_has_duration_microsecond_value()) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(29, this->_internal_duration_microsecond_value(), target); + } + + // int64 duration_nanosecond_value = 30; + if (_internal_has_duration_nanosecond_value()) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteInt64ToArray(30, this->_internal_duration_nanosecond_value(), target); + } + if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) { target = ::_pbi::WireFormat::InternalSerializeUnknownFieldsToArray( _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream); @@ -1786,6 +1882,34 @@ size_t Value::ByteSizeLong() const { *_impl_.value_data_.interval_month_day_nano_values_); break; } + // int64 duration_second_value = 27; + case kDurationSecondValue: { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_duration_second_value()); + break; + } + // int64 duration_millisecond_value = 28; + case kDurationMillisecondValue: { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_duration_millisecond_value()); + break; + } + // int64 duration_microsecond_value = 29; + case kDurationMicrosecondValue: { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_duration_microsecond_value()); + break; + } + // int64 duration_nanosecond_value = 30; + case kDurationNanosecondValue: { + total_size += 2 + + ::_pbi::WireFormatLite::Int64Size( + this->_internal_duration_nanosecond_value()); + break; + } case VALUE_DATA_NOT_SET: { break; } @@ -1914,6 +2038,22 @@ void Value::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF from._internal_interval_month_day_nano_values()); break; } + case kDurationSecondValue: { + _this->_internal_set_duration_second_value(from._internal_duration_second_value()); + break; + } + case kDurationMillisecondValue: { + _this->_internal_set_duration_millisecond_value(from._internal_duration_millisecond_value()); + break; + } + case kDurationMicrosecondValue: { + _this->_internal_set_duration_microsecond_value(from._internal_duration_microsecond_value()); + break; + } + case kDurationNanosecondValue: { + _this->_internal_set_duration_nanosecond_value(from._internal_duration_nanosecond_value()); + break; + } case VALUE_DATA_NOT_SET: { break; } diff --git a/c++/greptime/v1/row.pb.h b/c++/greptime/v1/row.pb.h index 29595f0..cc63733 100644 --- a/c++/greptime/v1/row.pb.h +++ b/c++/greptime/v1/row.pb.h @@ -651,6 +651,10 @@ class Value final : kIntervalYearMonthValues = 24, kIntervalDayTimeValues = 25, kIntervalMonthDayNanoValues = 26, + kDurationSecondValue = 27, + kDurationMillisecondValue = 28, + kDurationMicrosecondValue = 29, + kDurationNanosecondValue = 30, VALUE_DATA_NOT_SET = 0, }; @@ -758,6 +762,10 @@ class Value final : kIntervalYearMonthValuesFieldNumber = 24, kIntervalDayTimeValuesFieldNumber = 25, kIntervalMonthDayNanoValuesFieldNumber = 26, + kDurationSecondValueFieldNumber = 27, + kDurationMillisecondValueFieldNumber = 28, + kDurationMicrosecondValueFieldNumber = 29, + kDurationNanosecondValueFieldNumber = 30, }; // int32 i8_value = 1; bool has_i8_value() const; @@ -1112,6 +1120,58 @@ class Value final : ::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_values); ::greptime::v1::IntervalMonthDayNano* unsafe_arena_release_interval_month_day_nano_values(); + // 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: + void clear_value_data(); ValueDataCase value_data_case() const; // @@protoc_insertion_point(class_scope:greptime.v1.Value) @@ -1143,6 +1203,10 @@ class Value final : void set_has_interval_year_month_values(); void set_has_interval_day_time_values(); void set_has_interval_month_day_nano_values(); + void set_has_duration_second_value(); + void set_has_duration_millisecond_value(); + void set_has_duration_microsecond_value(); + void set_has_duration_nanosecond_value(); inline bool has_value_data() const; inline void clear_has_value_data(); @@ -1180,6 +1244,10 @@ class Value final : int32_t interval_year_month_values_; int64_t interval_day_time_values_; ::greptime::v1::IntervalMonthDayNano* interval_month_day_nano_values_; + int64_t duration_second_value_; + int64_t duration_millisecond_value_; + int64_t duration_microsecond_value_; + int64_t duration_nanosecond_value_; } value_data_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; uint32_t _oneof_case_[1]; @@ -2515,6 +2583,158 @@ inline ::greptime::v1::IntervalMonthDayNano* Value::mutable_interval_month_day_n 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) +} + inline bool Value::has_value_data() const { return value_data_case() != VALUE_DATA_NOT_SET; } diff --git a/go/greptime/v1/column.pb.go b/go/greptime/v1/column.pb.go index 1e39f64..617cd76 100644 --- a/go/greptime/v1/column.pb.go +++ b/go/greptime/v1/column.pb.go @@ -158,6 +158,10 @@ type Column_Values struct { IntervalYearMonthValues []int32 `protobuf:"varint,24,rep,packed,name=interval_year_month_values,json=intervalYearMonthValues,proto3" json:"interval_year_month_values,omitempty"` IntervalDayTimeValues []int64 `protobuf:"varint,25,rep,packed,name=interval_day_time_values,json=intervalDayTimeValues,proto3" json:"interval_day_time_values,omitempty"` IntervalMonthDayNanoValues []*IntervalMonthDayNano `protobuf:"bytes,26,rep,name=interval_month_day_nano_values,json=intervalMonthDayNanoValues,proto3" json:"interval_month_day_nano_values,omitempty"` + DurationSecondValues []int64 `protobuf:"varint,27,rep,packed,name=duration_second_values,json=durationSecondValues,proto3" json:"duration_second_values,omitempty"` + DurationMillisecondValues []int64 `protobuf:"varint,28,rep,packed,name=duration_millisecond_values,json=durationMillisecondValues,proto3" json:"duration_millisecond_values,omitempty"` + DurationMicrosecondValues []int64 `protobuf:"varint,29,rep,packed,name=duration_microsecond_values,json=durationMicrosecondValues,proto3" json:"duration_microsecond_values,omitempty"` + DurationNanosecondValues []int64 `protobuf:"varint,30,rep,packed,name=duration_nanosecond_values,json=durationNanosecondValues,proto3" json:"duration_nanosecond_values,omitempty"` } func (x *Column_Values) Reset() { @@ -374,6 +378,34 @@ func (x *Column_Values) GetIntervalMonthDayNanoValues() []*IntervalMonthDayNano return nil } +func (x *Column_Values) GetDurationSecondValues() []int64 { + if x != nil { + return x.DurationSecondValues + } + return nil +} + +func (x *Column_Values) GetDurationMillisecondValues() []int64 { + if x != nil { + return x.DurationMillisecondValues + } + return nil +} + +func (x *Column_Values) GetDurationMicrosecondValues() []int64 { + if x != nil { + return x.DurationMicrosecondValues + } + return nil +} + +func (x *Column_Values) GetDurationNanosecondValues() []int64 { + if x != nil { + return x.DurationNanosecondValues + } + return nil +} + var File_greptime_v1_column_proto protoreflect.FileDescriptor var file_greptime_v1_column_proto_rawDesc = []byte{ @@ -381,7 +413,7 @@ var file_greptime_v1_column_proto_rawDesc = []byte{ 0x6c, 0x75, 0x6d, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x0b, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x1a, 0x18, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x2f, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x22, 0x92, 0x0b, 0x0a, 0x06, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, + 0x6f, 0x22, 0x86, 0x0d, 0x0a, 0x06, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x3e, 0x0a, 0x0d, 0x73, 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x02, @@ -396,7 +428,7 @@ var file_greptime_v1_column_proto_rawDesc = []byte{ 0x0a, 0x08, 0x64, 0x61, 0x74, 0x61, 0x74, 0x79, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x64, - 0x61, 0x74, 0x61, 0x74, 0x79, 0x70, 0x65, 0x1a, 0x9c, 0x09, 0x0a, 0x06, 0x56, 0x61, 0x6c, 0x75, + 0x61, 0x74, 0x61, 0x74, 0x79, 0x70, 0x65, 0x1a, 0x90, 0x0b, 0x0a, 0x06, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x05, 0x52, 0x08, 0x69, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x31, 0x36, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x02, 0x20, @@ -470,12 +502,28 @@ var file_greptime_v1_column_proto_rawDesc = []byte{ 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, 0x49, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x4d, 0x6f, 0x6e, 0x74, 0x68, 0x44, 0x61, 0x79, 0x4e, 0x61, 0x6e, 0x6f, 0x52, 0x1a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x4d, 0x6f, 0x6e, 0x74, 0x68, 0x44, 0x61, 0x79, 0x4e, 0x61, 0x6e, 0x6f, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x42, 0x50, 0x0a, 0x0e, 0x69, 0x6f, 0x2e, 0x67, 0x72, 0x65, - 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, - 0x73, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x47, 0x72, - 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x65, 0x61, 0x6d, 0x2f, 0x67, 0x72, 0x65, 0x70, 0x74, - 0x69, 0x6d, 0x65, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x72, 0x65, - 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x34, 0x0a, 0x16, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x18, 0x1b, 0x20, 0x03, 0x28, 0x03, 0x52, 0x14, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, + 0x53, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x1b, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x1c, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x19, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6c, 0x6c, 0x69, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x3e, 0x0a, 0x1b, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x1d, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x19, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x63, 0x72, 0x6f, + 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x1a, + 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x65, 0x63, + 0x6f, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x1e, 0x20, 0x03, 0x28, 0x03, + 0x52, 0x18, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6e, 0x6f, 0x73, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x42, 0x50, 0x0a, 0x0e, 0x69, 0x6f, + 0x2e, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x43, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x47, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x65, 0x61, 0x6d, 0x2f, 0x67, + 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, + 0x2f, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x33, } var ( diff --git a/go/greptime/v1/common.pb.go b/go/greptime/v1/common.pb.go index 66080be..a61872c 100644 --- a/go/greptime/v1/common.pb.go +++ b/go/greptime/v1/common.pb.go @@ -112,6 +112,10 @@ const ( ColumnDataType_INTERVAL_YEAR_MONTH ColumnDataType = 23 ColumnDataType_INTERVAL_DAY_TIME ColumnDataType = 24 ColumnDataType_INTERVAL_MONTH_DAY_NANO ColumnDataType = 25 + ColumnDataType_DURATION_SECOND ColumnDataType = 26 + ColumnDataType_DURATION_MILLISECOND ColumnDataType = 27 + ColumnDataType_DURATION_MICROSECOND ColumnDataType = 28 + ColumnDataType_DURATION_NANOSECOND ColumnDataType = 29 ) // Enum value maps for ColumnDataType. @@ -143,6 +147,10 @@ var ( 23: "INTERVAL_YEAR_MONTH", 24: "INTERVAL_DAY_TIME", 25: "INTERVAL_MONTH_DAY_NANO", + 26: "DURATION_SECOND", + 27: "DURATION_MILLISECOND", + 28: "DURATION_MICROSECOND", + 29: "DURATION_NANOSECOND", } ColumnDataType_value = map[string]int32{ "BOOLEAN": 0, @@ -171,6 +179,10 @@ var ( "INTERVAL_YEAR_MONTH": 23, "INTERVAL_DAY_TIME": 24, "INTERVAL_MONTH_DAY_NANO": 25, + "DURATION_SECOND": 26, + "DURATION_MILLISECOND": 27, + "DURATION_MICROSECOND": 28, + "DURATION_NANOSECOND": 29, } ) @@ -794,7 +806,7 @@ var file_greptime_v1_common_proto_rawDesc = []byte{ 0x53, 0x65, 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x07, 0x0a, 0x03, 0x54, 0x41, 0x47, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x46, 0x49, 0x45, 0x4c, 0x44, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x54, 0x49, 0x4d, 0x45, 0x53, 0x54, 0x41, 0x4d, 0x50, 0x10, 0x02, 0x2a, - 0xc6, 0x03, 0x0a, 0x0e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x54, 0x79, + 0xa8, 0x04, 0x0a, 0x0e, 0x43, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x44, 0x61, 0x74, 0x61, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x42, 0x4f, 0x4f, 0x4c, 0x45, 0x41, 0x4e, 0x10, 0x00, 0x12, 0x08, 0x0a, 0x04, 0x49, 0x4e, 0x54, 0x38, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x49, 0x4e, 0x54, 0x31, 0x36, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x49, 0x4e, 0x54, 0x33, 0x32, 0x10, 0x03, 0x12, @@ -822,13 +834,19 @@ var file_greptime_v1_common_proto_rawDesc = []byte{ 0x54, 0x48, 0x10, 0x17, 0x12, 0x15, 0x0a, 0x11, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x56, 0x41, 0x4c, 0x5f, 0x44, 0x41, 0x59, 0x5f, 0x54, 0x49, 0x4d, 0x45, 0x10, 0x18, 0x12, 0x1b, 0x0a, 0x17, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x56, 0x41, 0x4c, 0x5f, 0x4d, 0x4f, 0x4e, 0x54, 0x48, 0x5f, 0x44, 0x41, - 0x59, 0x5f, 0x4e, 0x41, 0x4e, 0x4f, 0x10, 0x19, 0x42, 0x4f, 0x0a, 0x0e, 0x69, 0x6f, 0x2e, 0x67, - 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x06, 0x43, 0x6f, 0x6d, 0x6d, - 0x6f, 0x6e, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x47, - 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x65, 0x61, 0x6d, 0x2f, 0x67, 0x72, 0x65, 0x70, - 0x74, 0x69, 0x6d, 0x65, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x72, - 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x33, + 0x59, 0x5f, 0x4e, 0x41, 0x4e, 0x4f, 0x10, 0x19, 0x12, 0x13, 0x0a, 0x0f, 0x44, 0x55, 0x52, 0x41, + 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x53, 0x45, 0x43, 0x4f, 0x4e, 0x44, 0x10, 0x1a, 0x12, 0x18, 0x0a, + 0x14, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x49, 0x4c, 0x4c, 0x49, 0x53, + 0x45, 0x43, 0x4f, 0x4e, 0x44, 0x10, 0x1b, 0x12, 0x18, 0x0a, 0x14, 0x44, 0x55, 0x52, 0x41, 0x54, + 0x49, 0x4f, 0x4e, 0x5f, 0x4d, 0x49, 0x43, 0x52, 0x4f, 0x53, 0x45, 0x43, 0x4f, 0x4e, 0x44, 0x10, + 0x1c, 0x12, 0x17, 0x0a, 0x13, 0x44, 0x55, 0x52, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x5f, 0x4e, 0x41, + 0x4e, 0x4f, 0x53, 0x45, 0x43, 0x4f, 0x4e, 0x44, 0x10, 0x1d, 0x42, 0x4f, 0x0a, 0x0e, 0x69, 0x6f, + 0x2e, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x06, 0x43, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, + 0x2f, 0x47, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x54, 0x65, 0x61, 0x6d, 0x2f, 0x67, 0x72, + 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, + 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x33, } var ( diff --git a/go/greptime/v1/row.pb.go b/go/greptime/v1/row.pb.go index c66e3f6..feec127 100644 --- a/go/greptime/v1/row.pb.go +++ b/go/greptime/v1/row.pb.go @@ -232,6 +232,10 @@ type Value struct { // *Value_IntervalYearMonthValues // *Value_IntervalDayTimeValues // *Value_IntervalMonthDayNanoValues + // *Value_DurationSecondValue + // *Value_DurationMillisecondValue + // *Value_DurationMicrosecondValue + // *Value_DurationNanosecondValue ValueData isValue_ValueData `protobuf_oneof:"value_data"` } @@ -456,6 +460,34 @@ func (x *Value) GetIntervalMonthDayNanoValues() *IntervalMonthDayNano { return nil } +func (x *Value) GetDurationSecondValue() int64 { + if x, ok := x.GetValueData().(*Value_DurationSecondValue); ok { + return x.DurationSecondValue + } + return 0 +} + +func (x *Value) GetDurationMillisecondValue() int64 { + if x, ok := x.GetValueData().(*Value_DurationMillisecondValue); ok { + return x.DurationMillisecondValue + } + return 0 +} + +func (x *Value) GetDurationMicrosecondValue() int64 { + if x, ok := x.GetValueData().(*Value_DurationMicrosecondValue); ok { + return x.DurationMicrosecondValue + } + return 0 +} + +func (x *Value) GetDurationNanosecondValue() int64 { + if x, ok := x.GetValueData().(*Value_DurationNanosecondValue); ok { + return x.DurationNanosecondValue + } + return 0 +} + type isValue_ValueData interface { isValue_ValueData() } @@ -564,6 +596,22 @@ type Value_IntervalMonthDayNanoValues struct { IntervalMonthDayNanoValues *IntervalMonthDayNano `protobuf:"bytes,26,opt,name=interval_month_day_nano_values,json=intervalMonthDayNanoValues,proto3,oneof"` } +type Value_DurationSecondValue struct { + DurationSecondValue int64 `protobuf:"varint,27,opt,name=duration_second_value,json=durationSecondValue,proto3,oneof"` +} + +type Value_DurationMillisecondValue struct { + DurationMillisecondValue int64 `protobuf:"varint,28,opt,name=duration_millisecond_value,json=durationMillisecondValue,proto3,oneof"` +} + +type Value_DurationMicrosecondValue struct { + DurationMicrosecondValue int64 `protobuf:"varint,29,opt,name=duration_microsecond_value,json=durationMicrosecondValue,proto3,oneof"` +} + +type Value_DurationNanosecondValue struct { + DurationNanosecondValue int64 `protobuf:"varint,30,opt,name=duration_nanosecond_value,json=durationNanosecondValue,proto3,oneof"` +} + func (*Value_I8Value) isValue_ValueData() {} func (*Value_I16Value) isValue_ValueData() {} @@ -616,6 +664,14 @@ func (*Value_IntervalDayTimeValues) isValue_ValueData() {} func (*Value_IntervalMonthDayNanoValues) isValue_ValueData() {} +func (*Value_DurationSecondValue) isValue_ValueData() {} + +func (*Value_DurationMillisecondValue) isValue_ValueData() {} + +func (*Value_DurationMicrosecondValue) isValue_ValueData() {} + +func (*Value_DurationNanosecondValue) isValue_ValueData() {} + var File_greptime_v1_row_proto protoreflect.FileDescriptor var file_greptime_v1_row_proto_rawDesc = []byte{ @@ -642,7 +698,7 @@ var file_greptime_v1_row_proto_rawDesc = []byte{ 0x6d, 0x61, 0x6e, 0x74, 0x69, 0x63, 0x54, 0x79, 0x70, 0x65, 0x22, 0x31, 0x0a, 0x03, 0x52, 0x6f, 0x77, 0x12, 0x2a, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x2e, - 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xaf, 0x09, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0xa3, 0x0b, 0x0a, 0x05, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1b, 0x0a, 0x08, 0x69, 0x38, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x07, 0x69, 0x38, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1d, 0x0a, 0x09, 0x69, 0x31, 0x36, 0x5f, 0x76, 0x61, 0x6c, 0x75, @@ -717,13 +773,28 @@ var file_greptime_v1_row_proto_rawDesc = []byte{ 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x4d, 0x6f, 0x6e, 0x74, 0x68, 0x44, 0x61, 0x79, 0x4e, 0x61, 0x6e, 0x6f, 0x48, 0x00, 0x52, 0x1a, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x76, 0x61, 0x6c, 0x4d, 0x6f, 0x6e, 0x74, 0x68, 0x44, 0x61, 0x79, 0x4e, 0x61, 0x6e, 0x6f, 0x56, 0x61, 0x6c, 0x75, 0x65, - 0x73, 0x42, 0x0c, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x64, 0x61, 0x74, 0x61, 0x42, - 0x50, 0x0a, 0x0e, 0x69, 0x6f, 0x2e, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2e, 0x76, - 0x31, 0x42, 0x07, 0x52, 0x6f, 0x77, 0x44, 0x61, 0x74, 0x61, 0x5a, 0x35, 0x67, 0x69, 0x74, 0x68, - 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x47, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x54, - 0x65, 0x61, 0x6d, 0x2f, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2d, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, 0x2f, 0x76, - 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x73, 0x12, 0x34, 0x0a, 0x15, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x65, + 0x63, 0x6f, 0x6e, 0x64, 0x5f, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x03, + 0x48, 0x00, 0x52, 0x13, 0x64, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3e, 0x0a, 0x1a, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x18, 0x64, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x6c, 0x6c, 0x69, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3e, 0x0a, 0x1a, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x6d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x5f, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x18, 0x64, + 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4d, 0x69, 0x63, 0x72, 0x6f, 0x73, 0x65, 0x63, 0x6f, + 0x6e, 0x64, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x3c, 0x0a, 0x19, 0x64, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x6e, 0x61, 0x6e, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x5f, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x17, 0x64, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x4e, 0x61, 0x6e, 0x6f, 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x0c, 0x0a, 0x0a, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x5f, 0x64, + 0x61, 0x74, 0x61, 0x42, 0x50, 0x0a, 0x0e, 0x69, 0x6f, 0x2e, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, + 0x6d, 0x65, 0x2e, 0x76, 0x31, 0x42, 0x07, 0x52, 0x6f, 0x77, 0x44, 0x61, 0x74, 0x61, 0x5a, 0x35, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x47, 0x72, 0x65, 0x70, 0x74, + 0x69, 0x6d, 0x65, 0x54, 0x65, 0x61, 0x6d, 0x2f, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, 0x6d, 0x65, + 0x2d, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6f, 0x2f, 0x67, 0x72, 0x65, 0x70, 0x74, 0x69, + 0x6d, 0x65, 0x2f, 0x76, 0x31, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -845,6 +916,10 @@ func file_greptime_v1_row_proto_init() { (*Value_IntervalYearMonthValues)(nil), (*Value_IntervalDayTimeValues)(nil), (*Value_IntervalMonthDayNanoValues)(nil), + (*Value_DurationSecondValue)(nil), + (*Value_DurationMillisecondValue)(nil), + (*Value_DurationMicrosecondValue)(nil), + (*Value_DurationNanosecondValue)(nil), } type x struct{} out := protoimpl.TypeBuilder{ diff --git a/java/src/main/java/io/greptime/v1/Columns.java b/java/src/main/java/io/greptime/v1/Columns.java index 2c6e19a..6a13d93 100644 --- a/java/src/main/java/io/greptime/v1/Columns.java +++ b/java/src/main/java/io/greptime/v1/Columns.java @@ -699,6 +699,74 @@ public final class Columns { */ io.greptime.v1.Common.IntervalMonthDayNanoOrBuilder getIntervalMonthDayNanoValuesOrBuilder( int index); + + /** + * repeated int64 duration_second_values = 27; + * @return A list containing the durationSecondValues. + */ + java.util.List getDurationSecondValuesList(); + /** + * repeated int64 duration_second_values = 27; + * @return The count of durationSecondValues. + */ + int getDurationSecondValuesCount(); + /** + * repeated int64 duration_second_values = 27; + * @param index The index of the element to return. + * @return The durationSecondValues at the given index. + */ + long getDurationSecondValues(int index); + + /** + * repeated int64 duration_millisecond_values = 28; + * @return A list containing the durationMillisecondValues. + */ + java.util.List getDurationMillisecondValuesList(); + /** + * repeated int64 duration_millisecond_values = 28; + * @return The count of durationMillisecondValues. + */ + int getDurationMillisecondValuesCount(); + /** + * repeated int64 duration_millisecond_values = 28; + * @param index The index of the element to return. + * @return The durationMillisecondValues at the given index. + */ + long getDurationMillisecondValues(int index); + + /** + * repeated int64 duration_microsecond_values = 29; + * @return A list containing the durationMicrosecondValues. + */ + java.util.List getDurationMicrosecondValuesList(); + /** + * repeated int64 duration_microsecond_values = 29; + * @return The count of durationMicrosecondValues. + */ + int getDurationMicrosecondValuesCount(); + /** + * repeated int64 duration_microsecond_values = 29; + * @param index The index of the element to return. + * @return The durationMicrosecondValues at the given index. + */ + long getDurationMicrosecondValues(int index); + + /** + * repeated int64 duration_nanosecond_values = 30; + * @return A list containing the durationNanosecondValues. + */ + java.util.List getDurationNanosecondValuesList(); + /** + * repeated int64 duration_nanosecond_values = 30; + * @return The count of durationNanosecondValues. + */ + int getDurationNanosecondValuesCount(); + /** + * repeated int64 duration_nanosecond_values = 30; + * @param index The index of the element to return. + * @return The durationNanosecondValues at the given index. + */ + long getDurationNanosecondValues(int index); } /** * Protobuf type {@code greptime.v1.Column.Values} @@ -739,6 +807,10 @@ public final class Columns { intervalYearMonthValues_ = emptyIntList(); intervalDayTimeValues_ = emptyLongList(); intervalMonthDayNanoValues_ = java.util.Collections.emptyList(); + durationSecondValues_ = emptyLongList(); + durationMillisecondValues_ = emptyLongList(); + durationMicrosecondValues_ = emptyLongList(); + durationNanosecondValues_ = emptyLongList(); } @java.lang.Override @@ -1281,6 +1353,90 @@ public final class Columns { input.readMessage(io.greptime.v1.Common.IntervalMonthDayNano.parser(), extensionRegistry)); break; } + case 216: { + if (!((mutable_bitField0_ & 0x04000000) != 0)) { + durationSecondValues_ = newLongList(); + mutable_bitField0_ |= 0x04000000; + } + durationSecondValues_.addLong(input.readInt64()); + break; + } + case 218: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x04000000) != 0) && input.getBytesUntilLimit() > 0) { + durationSecondValues_ = newLongList(); + mutable_bitField0_ |= 0x04000000; + } + while (input.getBytesUntilLimit() > 0) { + durationSecondValues_.addLong(input.readInt64()); + } + input.popLimit(limit); + break; + } + case 224: { + if (!((mutable_bitField0_ & 0x08000000) != 0)) { + durationMillisecondValues_ = newLongList(); + mutable_bitField0_ |= 0x08000000; + } + durationMillisecondValues_.addLong(input.readInt64()); + break; + } + case 226: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x08000000) != 0) && input.getBytesUntilLimit() > 0) { + durationMillisecondValues_ = newLongList(); + mutable_bitField0_ |= 0x08000000; + } + while (input.getBytesUntilLimit() > 0) { + durationMillisecondValues_.addLong(input.readInt64()); + } + input.popLimit(limit); + break; + } + case 232: { + if (!((mutable_bitField0_ & 0x10000000) != 0)) { + durationMicrosecondValues_ = newLongList(); + mutable_bitField0_ |= 0x10000000; + } + durationMicrosecondValues_.addLong(input.readInt64()); + break; + } + case 234: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x10000000) != 0) && input.getBytesUntilLimit() > 0) { + durationMicrosecondValues_ = newLongList(); + mutable_bitField0_ |= 0x10000000; + } + while (input.getBytesUntilLimit() > 0) { + durationMicrosecondValues_.addLong(input.readInt64()); + } + input.popLimit(limit); + break; + } + case 240: { + if (!((mutable_bitField0_ & 0x20000000) != 0)) { + durationNanosecondValues_ = newLongList(); + mutable_bitField0_ |= 0x20000000; + } + durationNanosecondValues_.addLong(input.readInt64()); + break; + } + case 242: { + int length = input.readRawVarint32(); + int limit = input.pushLimit(length); + if (!((mutable_bitField0_ & 0x20000000) != 0) && input.getBytesUntilLimit() > 0) { + durationNanosecondValues_ = newLongList(); + mutable_bitField0_ |= 0x20000000; + } + while (input.getBytesUntilLimit() > 0) { + durationNanosecondValues_.addLong(input.readInt64()); + } + input.popLimit(limit); + break; + } default: { if (!parseUnknownField( input, unknownFields, extensionRegistry, tag)) { @@ -1376,6 +1532,18 @@ public final class Columns { if (((mutable_bitField0_ & 0x02000000) != 0)) { intervalMonthDayNanoValues_ = java.util.Collections.unmodifiableList(intervalMonthDayNanoValues_); } + if (((mutable_bitField0_ & 0x04000000) != 0)) { + durationSecondValues_.makeImmutable(); // C + } + if (((mutable_bitField0_ & 0x08000000) != 0)) { + durationMillisecondValues_.makeImmutable(); // C + } + if (((mutable_bitField0_ & 0x10000000) != 0)) { + durationMicrosecondValues_.makeImmutable(); // C + } + if (((mutable_bitField0_ & 0x20000000) != 0)) { + durationNanosecondValues_.makeImmutable(); // C + } this.unknownFields = unknownFields.build(); makeExtensionsImmutable(); } @@ -2139,6 +2307,118 @@ public final class Columns { return intervalMonthDayNanoValues_.get(index); } + public static final int DURATION_SECOND_VALUES_FIELD_NUMBER = 27; + private com.google.protobuf.Internal.LongList durationSecondValues_; + /** + * repeated int64 duration_second_values = 27; + * @return A list containing the durationSecondValues. + */ + @java.lang.Override + public java.util.List + getDurationSecondValuesList() { + return durationSecondValues_; + } + /** + * repeated int64 duration_second_values = 27; + * @return The count of durationSecondValues. + */ + public int getDurationSecondValuesCount() { + return durationSecondValues_.size(); + } + /** + * repeated int64 duration_second_values = 27; + * @param index The index of the element to return. + * @return The durationSecondValues at the given index. + */ + public long getDurationSecondValues(int index) { + return durationSecondValues_.getLong(index); + } + private int durationSecondValuesMemoizedSerializedSize = -1; + + public static final int DURATION_MILLISECOND_VALUES_FIELD_NUMBER = 28; + private com.google.protobuf.Internal.LongList durationMillisecondValues_; + /** + * repeated int64 duration_millisecond_values = 28; + * @return A list containing the durationMillisecondValues. + */ + @java.lang.Override + public java.util.List + getDurationMillisecondValuesList() { + return durationMillisecondValues_; + } + /** + * repeated int64 duration_millisecond_values = 28; + * @return The count of durationMillisecondValues. + */ + public int getDurationMillisecondValuesCount() { + return durationMillisecondValues_.size(); + } + /** + * repeated int64 duration_millisecond_values = 28; + * @param index The index of the element to return. + * @return The durationMillisecondValues at the given index. + */ + public long getDurationMillisecondValues(int index) { + return durationMillisecondValues_.getLong(index); + } + private int durationMillisecondValuesMemoizedSerializedSize = -1; + + public static final int DURATION_MICROSECOND_VALUES_FIELD_NUMBER = 29; + private com.google.protobuf.Internal.LongList durationMicrosecondValues_; + /** + * repeated int64 duration_microsecond_values = 29; + * @return A list containing the durationMicrosecondValues. + */ + @java.lang.Override + public java.util.List + getDurationMicrosecondValuesList() { + return durationMicrosecondValues_; + } + /** + * repeated int64 duration_microsecond_values = 29; + * @return The count of durationMicrosecondValues. + */ + public int getDurationMicrosecondValuesCount() { + return durationMicrosecondValues_.size(); + } + /** + * repeated int64 duration_microsecond_values = 29; + * @param index The index of the element to return. + * @return The durationMicrosecondValues at the given index. + */ + public long getDurationMicrosecondValues(int index) { + return durationMicrosecondValues_.getLong(index); + } + private int durationMicrosecondValuesMemoizedSerializedSize = -1; + + public static final int DURATION_NANOSECOND_VALUES_FIELD_NUMBER = 30; + private com.google.protobuf.Internal.LongList durationNanosecondValues_; + /** + * repeated int64 duration_nanosecond_values = 30; + * @return A list containing the durationNanosecondValues. + */ + @java.lang.Override + public java.util.List + getDurationNanosecondValuesList() { + return durationNanosecondValues_; + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @return The count of durationNanosecondValues. + */ + public int getDurationNanosecondValuesCount() { + return durationNanosecondValues_.size(); + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @param index The index of the element to return. + * @return The durationNanosecondValues at the given index. + */ + public long getDurationNanosecondValues(int index) { + return durationNanosecondValues_.getLong(index); + } + private int durationNanosecondValuesMemoizedSerializedSize = -1; + private byte memoizedIsInitialized = -1; @java.lang.Override public final boolean isInitialized() { @@ -2324,6 +2604,34 @@ public final class Columns { for (int i = 0; i < intervalMonthDayNanoValues_.size(); i++) { output.writeMessage(26, intervalMonthDayNanoValues_.get(i)); } + if (getDurationSecondValuesList().size() > 0) { + output.writeUInt32NoTag(218); + output.writeUInt32NoTag(durationSecondValuesMemoizedSerializedSize); + } + for (int i = 0; i < durationSecondValues_.size(); i++) { + output.writeInt64NoTag(durationSecondValues_.getLong(i)); + } + if (getDurationMillisecondValuesList().size() > 0) { + output.writeUInt32NoTag(226); + output.writeUInt32NoTag(durationMillisecondValuesMemoizedSerializedSize); + } + for (int i = 0; i < durationMillisecondValues_.size(); i++) { + output.writeInt64NoTag(durationMillisecondValues_.getLong(i)); + } + if (getDurationMicrosecondValuesList().size() > 0) { + output.writeUInt32NoTag(234); + output.writeUInt32NoTag(durationMicrosecondValuesMemoizedSerializedSize); + } + for (int i = 0; i < durationMicrosecondValues_.size(); i++) { + output.writeInt64NoTag(durationMicrosecondValues_.getLong(i)); + } + if (getDurationNanosecondValuesList().size() > 0) { + output.writeUInt32NoTag(242); + output.writeUInt32NoTag(durationNanosecondValuesMemoizedSerializedSize); + } + for (int i = 0; i < durationNanosecondValues_.size(); i++) { + output.writeInt64NoTag(durationNanosecondValues_.getLong(i)); + } unknownFields.writeTo(output); } @@ -2667,6 +2975,62 @@ public final class Columns { size += com.google.protobuf.CodedOutputStream .computeMessageSize(26, intervalMonthDayNanoValues_.get(i)); } + { + int dataSize = 0; + for (int i = 0; i < durationSecondValues_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt64SizeNoTag(durationSecondValues_.getLong(i)); + } + size += dataSize; + if (!getDurationSecondValuesList().isEmpty()) { + size += 2; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + durationSecondValuesMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < durationMillisecondValues_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt64SizeNoTag(durationMillisecondValues_.getLong(i)); + } + size += dataSize; + if (!getDurationMillisecondValuesList().isEmpty()) { + size += 2; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + durationMillisecondValuesMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < durationMicrosecondValues_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt64SizeNoTag(durationMicrosecondValues_.getLong(i)); + } + size += dataSize; + if (!getDurationMicrosecondValuesList().isEmpty()) { + size += 2; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + durationMicrosecondValuesMemoizedSerializedSize = dataSize; + } + { + int dataSize = 0; + for (int i = 0; i < durationNanosecondValues_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeInt64SizeNoTag(durationNanosecondValues_.getLong(i)); + } + size += dataSize; + if (!getDurationNanosecondValuesList().isEmpty()) { + size += 2; + size += com.google.protobuf.CodedOutputStream + .computeInt32SizeNoTag(dataSize); + } + durationNanosecondValuesMemoizedSerializedSize = dataSize; + } size += unknownFields.getSerializedSize(); memoizedSize = size; return size; @@ -2734,6 +3098,14 @@ public final class Columns { .equals(other.getIntervalDayTimeValuesList())) return false; if (!getIntervalMonthDayNanoValuesList() .equals(other.getIntervalMonthDayNanoValuesList())) return false; + if (!getDurationSecondValuesList() + .equals(other.getDurationSecondValuesList())) return false; + if (!getDurationMillisecondValuesList() + .equals(other.getDurationMillisecondValuesList())) return false; + if (!getDurationMicrosecondValuesList() + .equals(other.getDurationMicrosecondValuesList())) return false; + if (!getDurationNanosecondValuesList() + .equals(other.getDurationNanosecondValuesList())) return false; if (!unknownFields.equals(other.unknownFields)) return false; return true; } @@ -2849,6 +3221,22 @@ public final class Columns { hash = (37 * hash) + INTERVAL_MONTH_DAY_NANO_VALUES_FIELD_NUMBER; hash = (53 * hash) + getIntervalMonthDayNanoValuesList().hashCode(); } + if (getDurationSecondValuesCount() > 0) { + hash = (37 * hash) + DURATION_SECOND_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getDurationSecondValuesList().hashCode(); + } + if (getDurationMillisecondValuesCount() > 0) { + hash = (37 * hash) + DURATION_MILLISECOND_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getDurationMillisecondValuesList().hashCode(); + } + if (getDurationMicrosecondValuesCount() > 0) { + hash = (37 * hash) + DURATION_MICROSECOND_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getDurationMicrosecondValuesList().hashCode(); + } + if (getDurationNanosecondValuesCount() > 0) { + hash = (37 * hash) + DURATION_NANOSECOND_VALUES_FIELD_NUMBER; + hash = (53 * hash) + getDurationNanosecondValuesList().hashCode(); + } hash = (29 * hash) + unknownFields.hashCode(); memoizedHashCode = hash; return hash; @@ -3039,6 +3427,14 @@ public final class Columns { } else { intervalMonthDayNanoValuesBuilder_.clear(); } + durationSecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x04000000); + durationMillisecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x08000000); + durationMicrosecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x10000000); + durationNanosecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x20000000); return this; } @@ -3200,6 +3596,26 @@ public final class Columns { } else { result.intervalMonthDayNanoValues_ = intervalMonthDayNanoValuesBuilder_.build(); } + if (((bitField0_ & 0x04000000) != 0)) { + durationSecondValues_.makeImmutable(); + bitField0_ = (bitField0_ & ~0x04000000); + } + result.durationSecondValues_ = durationSecondValues_; + if (((bitField0_ & 0x08000000) != 0)) { + durationMillisecondValues_.makeImmutable(); + bitField0_ = (bitField0_ & ~0x08000000); + } + result.durationMillisecondValues_ = durationMillisecondValues_; + if (((bitField0_ & 0x10000000) != 0)) { + durationMicrosecondValues_.makeImmutable(); + bitField0_ = (bitField0_ & ~0x10000000); + } + result.durationMicrosecondValues_ = durationMicrosecondValues_; + if (((bitField0_ & 0x20000000) != 0)) { + durationNanosecondValues_.makeImmutable(); + bitField0_ = (bitField0_ & ~0x20000000); + } + result.durationNanosecondValues_ = durationNanosecondValues_; onBuilt(); return result; } @@ -3524,6 +3940,46 @@ public final class Columns { } } } + if (!other.durationSecondValues_.isEmpty()) { + if (durationSecondValues_.isEmpty()) { + durationSecondValues_ = other.durationSecondValues_; + bitField0_ = (bitField0_ & ~0x04000000); + } else { + ensureDurationSecondValuesIsMutable(); + durationSecondValues_.addAll(other.durationSecondValues_); + } + onChanged(); + } + if (!other.durationMillisecondValues_.isEmpty()) { + if (durationMillisecondValues_.isEmpty()) { + durationMillisecondValues_ = other.durationMillisecondValues_; + bitField0_ = (bitField0_ & ~0x08000000); + } else { + ensureDurationMillisecondValuesIsMutable(); + durationMillisecondValues_.addAll(other.durationMillisecondValues_); + } + onChanged(); + } + if (!other.durationMicrosecondValues_.isEmpty()) { + if (durationMicrosecondValues_.isEmpty()) { + durationMicrosecondValues_ = other.durationMicrosecondValues_; + bitField0_ = (bitField0_ & ~0x10000000); + } else { + ensureDurationMicrosecondValuesIsMutable(); + durationMicrosecondValues_.addAll(other.durationMicrosecondValues_); + } + onChanged(); + } + if (!other.durationNanosecondValues_.isEmpty()) { + if (durationNanosecondValues_.isEmpty()) { + durationNanosecondValues_ = other.durationNanosecondValues_; + bitField0_ = (bitField0_ & ~0x20000000); + } else { + ensureDurationNanosecondValuesIsMutable(); + durationNanosecondValues_.addAll(other.durationNanosecondValues_); + } + onChanged(); + } this.mergeUnknownFields(other.unknownFields); onChanged(); return this; @@ -5805,6 +6261,322 @@ public final class Columns { } return intervalMonthDayNanoValuesBuilder_; } + + private com.google.protobuf.Internal.LongList durationSecondValues_ = emptyLongList(); + private void ensureDurationSecondValuesIsMutable() { + if (!((bitField0_ & 0x04000000) != 0)) { + durationSecondValues_ = mutableCopy(durationSecondValues_); + bitField0_ |= 0x04000000; + } + } + /** + * repeated int64 duration_second_values = 27; + * @return A list containing the durationSecondValues. + */ + public java.util.List + getDurationSecondValuesList() { + return ((bitField0_ & 0x04000000) != 0) ? + java.util.Collections.unmodifiableList(durationSecondValues_) : durationSecondValues_; + } + /** + * repeated int64 duration_second_values = 27; + * @return The count of durationSecondValues. + */ + public int getDurationSecondValuesCount() { + return durationSecondValues_.size(); + } + /** + * repeated int64 duration_second_values = 27; + * @param index The index of the element to return. + * @return The durationSecondValues at the given index. + */ + public long getDurationSecondValues(int index) { + return durationSecondValues_.getLong(index); + } + /** + * repeated int64 duration_second_values = 27; + * @param index The index to set the value at. + * @param value The durationSecondValues to set. + * @return This builder for chaining. + */ + public Builder setDurationSecondValues( + int index, long value) { + ensureDurationSecondValuesIsMutable(); + durationSecondValues_.setLong(index, value); + onChanged(); + return this; + } + /** + * repeated int64 duration_second_values = 27; + * @param value The durationSecondValues to add. + * @return This builder for chaining. + */ + public Builder addDurationSecondValues(long value) { + ensureDurationSecondValuesIsMutable(); + durationSecondValues_.addLong(value); + onChanged(); + return this; + } + /** + * repeated int64 duration_second_values = 27; + * @param values The durationSecondValues to add. + * @return This builder for chaining. + */ + public Builder addAllDurationSecondValues( + java.lang.Iterable values) { + ensureDurationSecondValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, durationSecondValues_); + onChanged(); + return this; + } + /** + * repeated int64 duration_second_values = 27; + * @return This builder for chaining. + */ + public Builder clearDurationSecondValues() { + durationSecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x04000000); + onChanged(); + return this; + } + + private com.google.protobuf.Internal.LongList durationMillisecondValues_ = emptyLongList(); + private void ensureDurationMillisecondValuesIsMutable() { + if (!((bitField0_ & 0x08000000) != 0)) { + durationMillisecondValues_ = mutableCopy(durationMillisecondValues_); + bitField0_ |= 0x08000000; + } + } + /** + * repeated int64 duration_millisecond_values = 28; + * @return A list containing the durationMillisecondValues. + */ + public java.util.List + getDurationMillisecondValuesList() { + return ((bitField0_ & 0x08000000) != 0) ? + java.util.Collections.unmodifiableList(durationMillisecondValues_) : durationMillisecondValues_; + } + /** + * repeated int64 duration_millisecond_values = 28; + * @return The count of durationMillisecondValues. + */ + public int getDurationMillisecondValuesCount() { + return durationMillisecondValues_.size(); + } + /** + * repeated int64 duration_millisecond_values = 28; + * @param index The index of the element to return. + * @return The durationMillisecondValues at the given index. + */ + public long getDurationMillisecondValues(int index) { + return durationMillisecondValues_.getLong(index); + } + /** + * repeated int64 duration_millisecond_values = 28; + * @param index The index to set the value at. + * @param value The durationMillisecondValues to set. + * @return This builder for chaining. + */ + public Builder setDurationMillisecondValues( + int index, long value) { + ensureDurationMillisecondValuesIsMutable(); + durationMillisecondValues_.setLong(index, value); + onChanged(); + return this; + } + /** + * repeated int64 duration_millisecond_values = 28; + * @param value The durationMillisecondValues to add. + * @return This builder for chaining. + */ + public Builder addDurationMillisecondValues(long value) { + ensureDurationMillisecondValuesIsMutable(); + durationMillisecondValues_.addLong(value); + onChanged(); + return this; + } + /** + * repeated int64 duration_millisecond_values = 28; + * @param values The durationMillisecondValues to add. + * @return This builder for chaining. + */ + public Builder addAllDurationMillisecondValues( + java.lang.Iterable values) { + ensureDurationMillisecondValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, durationMillisecondValues_); + onChanged(); + return this; + } + /** + * repeated int64 duration_millisecond_values = 28; + * @return This builder for chaining. + */ + public Builder clearDurationMillisecondValues() { + durationMillisecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x08000000); + onChanged(); + return this; + } + + private com.google.protobuf.Internal.LongList durationMicrosecondValues_ = emptyLongList(); + private void ensureDurationMicrosecondValuesIsMutable() { + if (!((bitField0_ & 0x10000000) != 0)) { + durationMicrosecondValues_ = mutableCopy(durationMicrosecondValues_); + bitField0_ |= 0x10000000; + } + } + /** + * repeated int64 duration_microsecond_values = 29; + * @return A list containing the durationMicrosecondValues. + */ + public java.util.List + getDurationMicrosecondValuesList() { + return ((bitField0_ & 0x10000000) != 0) ? + java.util.Collections.unmodifiableList(durationMicrosecondValues_) : durationMicrosecondValues_; + } + /** + * repeated int64 duration_microsecond_values = 29; + * @return The count of durationMicrosecondValues. + */ + public int getDurationMicrosecondValuesCount() { + return durationMicrosecondValues_.size(); + } + /** + * repeated int64 duration_microsecond_values = 29; + * @param index The index of the element to return. + * @return The durationMicrosecondValues at the given index. + */ + public long getDurationMicrosecondValues(int index) { + return durationMicrosecondValues_.getLong(index); + } + /** + * repeated int64 duration_microsecond_values = 29; + * @param index The index to set the value at. + * @param value The durationMicrosecondValues to set. + * @return This builder for chaining. + */ + public Builder setDurationMicrosecondValues( + int index, long value) { + ensureDurationMicrosecondValuesIsMutable(); + durationMicrosecondValues_.setLong(index, value); + onChanged(); + return this; + } + /** + * repeated int64 duration_microsecond_values = 29; + * @param value The durationMicrosecondValues to add. + * @return This builder for chaining. + */ + public Builder addDurationMicrosecondValues(long value) { + ensureDurationMicrosecondValuesIsMutable(); + durationMicrosecondValues_.addLong(value); + onChanged(); + return this; + } + /** + * repeated int64 duration_microsecond_values = 29; + * @param values The durationMicrosecondValues to add. + * @return This builder for chaining. + */ + public Builder addAllDurationMicrosecondValues( + java.lang.Iterable values) { + ensureDurationMicrosecondValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, durationMicrosecondValues_); + onChanged(); + return this; + } + /** + * repeated int64 duration_microsecond_values = 29; + * @return This builder for chaining. + */ + public Builder clearDurationMicrosecondValues() { + durationMicrosecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x10000000); + onChanged(); + return this; + } + + private com.google.protobuf.Internal.LongList durationNanosecondValues_ = emptyLongList(); + private void ensureDurationNanosecondValuesIsMutable() { + if (!((bitField0_ & 0x20000000) != 0)) { + durationNanosecondValues_ = mutableCopy(durationNanosecondValues_); + bitField0_ |= 0x20000000; + } + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @return A list containing the durationNanosecondValues. + */ + public java.util.List + getDurationNanosecondValuesList() { + return ((bitField0_ & 0x20000000) != 0) ? + java.util.Collections.unmodifiableList(durationNanosecondValues_) : durationNanosecondValues_; + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @return The count of durationNanosecondValues. + */ + public int getDurationNanosecondValuesCount() { + return durationNanosecondValues_.size(); + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @param index The index of the element to return. + * @return The durationNanosecondValues at the given index. + */ + public long getDurationNanosecondValues(int index) { + return durationNanosecondValues_.getLong(index); + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @param index The index to set the value at. + * @param value The durationNanosecondValues to set. + * @return This builder for chaining. + */ + public Builder setDurationNanosecondValues( + int index, long value) { + ensureDurationNanosecondValuesIsMutable(); + durationNanosecondValues_.setLong(index, value); + onChanged(); + return this; + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @param value The durationNanosecondValues to add. + * @return This builder for chaining. + */ + public Builder addDurationNanosecondValues(long value) { + ensureDurationNanosecondValuesIsMutable(); + durationNanosecondValues_.addLong(value); + onChanged(); + return this; + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @param values The durationNanosecondValues to add. + * @return This builder for chaining. + */ + public Builder addAllDurationNanosecondValues( + java.lang.Iterable values) { + ensureDurationNanosecondValuesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, durationNanosecondValues_); + onChanged(); + return this; + } + /** + * repeated int64 duration_nanosecond_values = 30; + * @return This builder for chaining. + */ + public Builder clearDurationNanosecondValues() { + durationNanosecondValues_ = emptyLongList(); + bitField0_ = (bitField0_ & ~0x20000000); + onChanged(); + return this; + } @java.lang.Override public final Builder setUnknownFields( final com.google.protobuf.UnknownFieldSet unknownFields) { @@ -6945,12 +7717,12 @@ public final class Columns { static { java.lang.String[] descriptorData = { "\n\030greptime/v1/column.proto\022\013greptime.v1\032" + - "\030greptime/v1/common.proto\"\240\007\n\006Column\022\023\n\013" + + "\030greptime/v1/common.proto\"\256\010\n\006Column\022\023\n\013" + "column_name\030\001 \001(\t\0220\n\rsemantic_type\030\002 \001(\016" + "2\031.greptime.v1.SemanticType\022*\n\006values\030\003 " + "\001(\0132\032.greptime.v1.Column.Values\022\021\n\tnull_" + "mask\030\004 \001(\014\022-\n\010datatype\030\005 \001(\0162\033.greptime." + - "v1.ColumnDataType\032\340\005\n\006Values\022\021\n\ti8_value" + + "v1.ColumnDataType\032\356\006\n\006Values\022\021\n\ti8_value" + "s\030\001 \003(\005\022\022\n\ni16_values\030\002 \003(\005\022\022\n\ni32_value" + "s\030\003 \003(\005\022\022\n\ni64_values\030\004 \003(\003\022\021\n\tu8_values" + "\030\005 \003(\r\022\022\n\nu16_values\030\006 \003(\r\022\022\n\nu32_values" + @@ -6968,10 +7740,13 @@ public final class Columns { "alues\030\027 \003(\003\022\"\n\032interval_year_month_value" + "s\030\030 \003(\005\022 \n\030interval_day_time_values\030\031 \003(" + "\003\022I\n\036interval_month_day_nano_values\030\032 \003(" + - "\0132!.greptime.v1.IntervalMonthDayNanoBP\n\016" + - "io.greptime.v1B\007ColumnsZ5github.com/Grep" + - "timeTeam/greptime-proto/go/greptime/v1b\006" + - "proto3" + "\0132!.greptime.v1.IntervalMonthDayNano\022\036\n\026" + + "duration_second_values\030\033 \003(\003\022#\n\033duration" + + "_millisecond_values\030\034 \003(\003\022#\n\033duration_mi" + + "crosecond_values\030\035 \003(\003\022\"\n\032duration_nanos" + + "econd_values\030\036 \003(\003BP\n\016io.greptime.v1B\007Co" + + "lumnsZ5github.com/GreptimeTeam/greptime-" + + "proto/go/greptime/v1b\006proto3" }; descriptor = com.google.protobuf.Descriptors.FileDescriptor .internalBuildGeneratedFileFrom(descriptorData, @@ -6989,7 +7764,7 @@ public final class Columns { internal_static_greptime_v1_Column_Values_fieldAccessorTable = new com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( internal_static_greptime_v1_Column_Values_descriptor, - new java.lang.String[] { "I8Values", "I16Values", "I32Values", "I64Values", "U8Values", "U16Values", "U32Values", "U64Values", "F32Values", "F64Values", "BoolValues", "BinaryValues", "StringValues", "DateValues", "DatetimeValues", "TimestampSecondValues", "TimestampMillisecondValues", "TimestampMicrosecondValues", "TimestampNanosecondValues", "TimeSecondValues", "TimeMillisecondValues", "TimeMicrosecondValues", "TimeNanosecondValues", "IntervalYearMonthValues", "IntervalDayTimeValues", "IntervalMonthDayNanoValues", }); + new java.lang.String[] { "I8Values", "I16Values", "I32Values", "I64Values", "U8Values", "U16Values", "U32Values", "U64Values", "F32Values", "F64Values", "BoolValues", "BinaryValues", "StringValues", "DateValues", "DatetimeValues", "TimestampSecondValues", "TimestampMillisecondValues", "TimestampMicrosecondValues", "TimestampNanosecondValues", "TimeSecondValues", "TimeMillisecondValues", "TimeMicrosecondValues", "TimeNanosecondValues", "IntervalYearMonthValues", "IntervalDayTimeValues", "IntervalMonthDayNanoValues", "DurationSecondValues", "DurationMillisecondValues", "DurationMicrosecondValues", "DurationNanosecondValues", }); io.greptime.v1.Common.getDescriptor(); } diff --git a/java/src/main/java/io/greptime/v1/Common.java b/java/src/main/java/io/greptime/v1/Common.java index b240e70..8c0c0a5 100644 --- a/java/src/main/java/io/greptime/v1/Common.java +++ b/java/src/main/java/io/greptime/v1/Common.java @@ -240,6 +240,22 @@ public final class Common { * INTERVAL_MONTH_DAY_NANO = 25; */ INTERVAL_MONTH_DAY_NANO(25), + /** + * DURATION_SECOND = 26; + */ + DURATION_SECOND(26), + /** + * DURATION_MILLISECOND = 27; + */ + DURATION_MILLISECOND(27), + /** + * DURATION_MICROSECOND = 28; + */ + DURATION_MICROSECOND(28), + /** + * DURATION_NANOSECOND = 29; + */ + DURATION_NANOSECOND(29), UNRECOGNIZED(-1), ; @@ -347,6 +363,22 @@ public final class Common { * INTERVAL_MONTH_DAY_NANO = 25; */ public static final int INTERVAL_MONTH_DAY_NANO_VALUE = 25; + /** + * DURATION_SECOND = 26; + */ + public static final int DURATION_SECOND_VALUE = 26; + /** + * DURATION_MILLISECOND = 27; + */ + public static final int DURATION_MILLISECOND_VALUE = 27; + /** + * DURATION_MICROSECOND = 28; + */ + public static final int DURATION_MICROSECOND_VALUE = 28; + /** + * DURATION_NANOSECOND = 29; + */ + public static final int DURATION_NANOSECOND_VALUE = 29; public final int getNumber() { @@ -399,6 +431,10 @@ public final class Common { case 23: return INTERVAL_YEAR_MONTH; case 24: return INTERVAL_DAY_TIME; case 25: return INTERVAL_MONTH_DAY_NANO; + case 26: return DURATION_SECOND; + case 27: return DURATION_MILLISECOND; + case 28: return DURATION_MICROSECOND; + case 29: return DURATION_NANOSECOND; default: return null; } } @@ -7217,7 +7253,7 @@ public final class Common { "ows\"I\n\024IntervalMonthDayNano\022\016\n\006months\030\001 " + "\001(\005\022\014\n\004days\030\002 \001(\005\022\023\n\013nanoseconds\030\003 \001(\003*1" + "\n\014SemanticType\022\007\n\003TAG\020\000\022\t\n\005FIELD\020\001\022\r\n\tTI" + - "MESTAMP\020\002*\306\003\n\016ColumnDataType\022\013\n\007BOOLEAN\020" + + "MESTAMP\020\002*\250\004\n\016ColumnDataType\022\013\n\007BOOLEAN\020" + "\000\022\010\n\004INT8\020\001\022\t\n\005INT16\020\002\022\t\n\005INT32\020\003\022\t\n\005INT" + "64\020\004\022\t\n\005UINT8\020\005\022\n\n\006UINT16\020\006\022\n\n\006UINT32\020\007\022" + "\n\n\006UINT64\020\010\022\013\n\007FLOAT32\020\t\022\013\n\007FLOAT64\020\n\022\n\n" + @@ -7228,9 +7264,12 @@ public final class Common { "ND\020\023\022\024\n\020TIME_MILLISECOND\020\024\022\024\n\020TIME_MICRO" + "SECOND\020\025\022\023\n\017TIME_NANOSECOND\020\026\022\027\n\023INTERVA" + "L_YEAR_MONTH\020\027\022\025\n\021INTERVAL_DAY_TIME\020\030\022\033\n" + - "\027INTERVAL_MONTH_DAY_NANO\020\031BO\n\016io.greptim" + - "e.v1B\006CommonZ5github.com/GreptimeTeam/gr" + - "eptime-proto/go/greptime/v1b\006proto3" + "\027INTERVAL_MONTH_DAY_NANO\020\031\022\023\n\017DURATION_S" + + "ECOND\020\032\022\030\n\024DURATION_MILLISECOND\020\033\022\030\n\024DUR" + + "ATION_MICROSECOND\020\034\022\027\n\023DURATION_NANOSECO" + + "ND\020\035BO\n\016io.greptime.v1B\006CommonZ5github.c" + + "om/GreptimeTeam/greptime-proto/go/grepti" + + "me/v1b\006proto3" }; descriptor = com.google.protobuf.Descriptors.FileDescriptor .internalBuildGeneratedFileFrom(descriptorData, diff --git a/java/src/main/java/io/greptime/v1/RowData.java b/java/src/main/java/io/greptime/v1/RowData.java index 54a25d1..1bb4a7d 100644 --- a/java/src/main/java/io/greptime/v1/RowData.java +++ b/java/src/main/java/io/greptime/v1/RowData.java @@ -3060,6 +3060,50 @@ public final class RowData { */ io.greptime.v1.Common.IntervalMonthDayNanoOrBuilder getIntervalMonthDayNanoValuesOrBuilder(); + /** + * int64 duration_second_value = 27; + * @return Whether the durationSecondValue field is set. + */ + boolean hasDurationSecondValue(); + /** + * int64 duration_second_value = 27; + * @return The durationSecondValue. + */ + long getDurationSecondValue(); + + /** + * int64 duration_millisecond_value = 28; + * @return Whether the durationMillisecondValue field is set. + */ + boolean hasDurationMillisecondValue(); + /** + * int64 duration_millisecond_value = 28; + * @return The durationMillisecondValue. + */ + long getDurationMillisecondValue(); + + /** + * int64 duration_microsecond_value = 29; + * @return Whether the durationMicrosecondValue field is set. + */ + boolean hasDurationMicrosecondValue(); + /** + * int64 duration_microsecond_value = 29; + * @return The durationMicrosecondValue. + */ + long getDurationMicrosecondValue(); + + /** + * int64 duration_nanosecond_value = 30; + * @return Whether the durationNanosecondValue field is set. + */ + boolean hasDurationNanosecondValue(); + /** + * int64 duration_nanosecond_value = 30; + * @return The durationNanosecondValue. + */ + long getDurationNanosecondValue(); + public io.greptime.v1.RowData.Value.ValueDataCase getValueDataCase(); } /** @@ -3247,6 +3291,26 @@ public final class RowData { valueDataCase_ = 26; break; } + case 216: { + valueData_ = input.readInt64(); + valueDataCase_ = 27; + break; + } + case 224: { + valueData_ = input.readInt64(); + valueDataCase_ = 28; + break; + } + case 232: { + valueData_ = input.readInt64(); + valueDataCase_ = 29; + break; + } + case 240: { + valueData_ = input.readInt64(); + valueDataCase_ = 30; + break; + } default: { if (!parseUnknownField( input, unknownFields, extensionRegistry, tag)) { @@ -3312,6 +3376,10 @@ public final class RowData { INTERVAL_YEAR_MONTH_VALUES(24), INTERVAL_DAY_TIME_VALUES(25), INTERVAL_MONTH_DAY_NANO_VALUES(26), + DURATION_SECOND_VALUE(27), + DURATION_MILLISECOND_VALUE(28), + DURATION_MICROSECOND_VALUE(29), + DURATION_NANOSECOND_VALUE(30), VALUEDATA_NOT_SET(0); private final int value; private ValueDataCase(int value) { @@ -3355,6 +3423,10 @@ public final class RowData { case 24: return INTERVAL_YEAR_MONTH_VALUES; case 25: return INTERVAL_DAY_TIME_VALUES; case 26: return INTERVAL_MONTH_DAY_NANO_VALUES; + case 27: return DURATION_SECOND_VALUE; + case 28: return DURATION_MILLISECOND_VALUE; + case 29: return DURATION_MICROSECOND_VALUE; + case 30: return DURATION_NANOSECOND_VALUE; case 0: return VALUEDATA_NOT_SET; default: return null; } @@ -3957,6 +4029,90 @@ public final class RowData { return io.greptime.v1.Common.IntervalMonthDayNano.getDefaultInstance(); } + public static final int DURATION_SECOND_VALUE_FIELD_NUMBER = 27; + /** + * int64 duration_second_value = 27; + * @return Whether the durationSecondValue field is set. + */ + @java.lang.Override + public boolean hasDurationSecondValue() { + return valueDataCase_ == 27; + } + /** + * int64 duration_second_value = 27; + * @return The durationSecondValue. + */ + @java.lang.Override + public long getDurationSecondValue() { + if (valueDataCase_ == 27) { + return (java.lang.Long) valueData_; + } + return 0L; + } + + public static final int DURATION_MILLISECOND_VALUE_FIELD_NUMBER = 28; + /** + * int64 duration_millisecond_value = 28; + * @return Whether the durationMillisecondValue field is set. + */ + @java.lang.Override + public boolean hasDurationMillisecondValue() { + return valueDataCase_ == 28; + } + /** + * int64 duration_millisecond_value = 28; + * @return The durationMillisecondValue. + */ + @java.lang.Override + public long getDurationMillisecondValue() { + if (valueDataCase_ == 28) { + return (java.lang.Long) valueData_; + } + return 0L; + } + + public static final int DURATION_MICROSECOND_VALUE_FIELD_NUMBER = 29; + /** + * int64 duration_microsecond_value = 29; + * @return Whether the durationMicrosecondValue field is set. + */ + @java.lang.Override + public boolean hasDurationMicrosecondValue() { + return valueDataCase_ == 29; + } + /** + * int64 duration_microsecond_value = 29; + * @return The durationMicrosecondValue. + */ + @java.lang.Override + public long getDurationMicrosecondValue() { + if (valueDataCase_ == 29) { + return (java.lang.Long) valueData_; + } + return 0L; + } + + public static final int DURATION_NANOSECOND_VALUE_FIELD_NUMBER = 30; + /** + * int64 duration_nanosecond_value = 30; + * @return Whether the durationNanosecondValue field is set. + */ + @java.lang.Override + public boolean hasDurationNanosecondValue() { + return valueDataCase_ == 30; + } + /** + * int64 duration_nanosecond_value = 30; + * @return The durationNanosecondValue. + */ + @java.lang.Override + public long getDurationNanosecondValue() { + if (valueDataCase_ == 30) { + return (java.lang.Long) valueData_; + } + return 0L; + } + private byte memoizedIsInitialized = -1; @java.lang.Override public final boolean isInitialized() { @@ -4073,6 +4229,22 @@ public final class RowData { if (valueDataCase_ == 26) { output.writeMessage(26, (io.greptime.v1.Common.IntervalMonthDayNano) valueData_); } + if (valueDataCase_ == 27) { + output.writeInt64( + 27, (long)((java.lang.Long) valueData_)); + } + if (valueDataCase_ == 28) { + output.writeInt64( + 28, (long)((java.lang.Long) valueData_)); + } + if (valueDataCase_ == 29) { + output.writeInt64( + 29, (long)((java.lang.Long) valueData_)); + } + if (valueDataCase_ == 30) { + output.writeInt64( + 30, (long)((java.lang.Long) valueData_)); + } unknownFields.writeTo(output); } @@ -4209,6 +4381,26 @@ public final class RowData { size += com.google.protobuf.CodedOutputStream .computeMessageSize(26, (io.greptime.v1.Common.IntervalMonthDayNano) valueData_); } + if (valueDataCase_ == 27) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size( + 27, (long)((java.lang.Long) valueData_)); + } + if (valueDataCase_ == 28) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size( + 28, (long)((java.lang.Long) valueData_)); + } + if (valueDataCase_ == 29) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size( + 29, (long)((java.lang.Long) valueData_)); + } + if (valueDataCase_ == 30) { + size += com.google.protobuf.CodedOutputStream + .computeInt64Size( + 30, (long)((java.lang.Long) valueData_)); + } size += unknownFields.getSerializedSize(); memoizedSize = size; return size; @@ -4332,6 +4524,22 @@ public final class RowData { if (!getIntervalMonthDayNanoValues() .equals(other.getIntervalMonthDayNanoValues())) return false; break; + case 27: + if (getDurationSecondValue() + != other.getDurationSecondValue()) return false; + break; + case 28: + if (getDurationMillisecondValue() + != other.getDurationMillisecondValue()) return false; + break; + case 29: + if (getDurationMicrosecondValue() + != other.getDurationMicrosecondValue()) return false; + break; + case 30: + if (getDurationNanosecondValue() + != other.getDurationNanosecondValue()) return false; + break; case 0: default: } @@ -4466,6 +4674,26 @@ public final class RowData { hash = (37 * hash) + INTERVAL_MONTH_DAY_NANO_VALUES_FIELD_NUMBER; hash = (53 * hash) + getIntervalMonthDayNanoValues().hashCode(); break; + case 27: + hash = (37 * hash) + DURATION_SECOND_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getDurationSecondValue()); + break; + case 28: + hash = (37 * hash) + DURATION_MILLISECOND_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getDurationMillisecondValue()); + break; + case 29: + hash = (37 * hash) + DURATION_MICROSECOND_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getDurationMicrosecondValue()); + break; + case 30: + hash = (37 * hash) + DURATION_NANOSECOND_VALUE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getDurationNanosecondValue()); + break; case 0: default: } @@ -4712,6 +4940,18 @@ public final class RowData { result.valueData_ = intervalMonthDayNanoValuesBuilder_.build(); } } + if (valueDataCase_ == 27) { + result.valueData_ = valueData_; + } + if (valueDataCase_ == 28) { + result.valueData_ = valueData_; + } + if (valueDataCase_ == 29) { + result.valueData_ = valueData_; + } + if (valueDataCase_ == 30) { + result.valueData_ = valueData_; + } result.valueDataCase_ = valueDataCase_; onBuilt(); return result; @@ -4868,6 +5108,22 @@ public final class RowData { mergeIntervalMonthDayNanoValues(other.getIntervalMonthDayNanoValues()); break; } + case DURATION_SECOND_VALUE: { + setDurationSecondValue(other.getDurationSecondValue()); + break; + } + case DURATION_MILLISECOND_VALUE: { + setDurationMillisecondValue(other.getDurationMillisecondValue()); + break; + } + case DURATION_MICROSECOND_VALUE: { + setDurationMicrosecondValue(other.getDurationMicrosecondValue()); + break; + } + case DURATION_NANOSECOND_VALUE: { + setDurationNanosecondValue(other.getDurationNanosecondValue()); + break; + } case VALUEDATA_NOT_SET: { break; } @@ -6141,6 +6397,170 @@ public final class RowData { onChanged();; return intervalMonthDayNanoValuesBuilder_; } + + /** + * int64 duration_second_value = 27; + * @return Whether the durationSecondValue field is set. + */ + public boolean hasDurationSecondValue() { + return valueDataCase_ == 27; + } + /** + * int64 duration_second_value = 27; + * @return The durationSecondValue. + */ + public long getDurationSecondValue() { + if (valueDataCase_ == 27) { + return (java.lang.Long) valueData_; + } + return 0L; + } + /** + * int64 duration_second_value = 27; + * @param value The durationSecondValue to set. + * @return This builder for chaining. + */ + public Builder setDurationSecondValue(long value) { + valueDataCase_ = 27; + valueData_ = value; + onChanged(); + return this; + } + /** + * int64 duration_second_value = 27; + * @return This builder for chaining. + */ + public Builder clearDurationSecondValue() { + if (valueDataCase_ == 27) { + valueDataCase_ = 0; + valueData_ = null; + onChanged(); + } + return this; + } + + /** + * int64 duration_millisecond_value = 28; + * @return Whether the durationMillisecondValue field is set. + */ + public boolean hasDurationMillisecondValue() { + return valueDataCase_ == 28; + } + /** + * int64 duration_millisecond_value = 28; + * @return The durationMillisecondValue. + */ + public long getDurationMillisecondValue() { + if (valueDataCase_ == 28) { + return (java.lang.Long) valueData_; + } + return 0L; + } + /** + * int64 duration_millisecond_value = 28; + * @param value The durationMillisecondValue to set. + * @return This builder for chaining. + */ + public Builder setDurationMillisecondValue(long value) { + valueDataCase_ = 28; + valueData_ = value; + onChanged(); + return this; + } + /** + * int64 duration_millisecond_value = 28; + * @return This builder for chaining. + */ + public Builder clearDurationMillisecondValue() { + if (valueDataCase_ == 28) { + valueDataCase_ = 0; + valueData_ = null; + onChanged(); + } + return this; + } + + /** + * int64 duration_microsecond_value = 29; + * @return Whether the durationMicrosecondValue field is set. + */ + public boolean hasDurationMicrosecondValue() { + return valueDataCase_ == 29; + } + /** + * int64 duration_microsecond_value = 29; + * @return The durationMicrosecondValue. + */ + public long getDurationMicrosecondValue() { + if (valueDataCase_ == 29) { + return (java.lang.Long) valueData_; + } + return 0L; + } + /** + * int64 duration_microsecond_value = 29; + * @param value The durationMicrosecondValue to set. + * @return This builder for chaining. + */ + public Builder setDurationMicrosecondValue(long value) { + valueDataCase_ = 29; + valueData_ = value; + onChanged(); + return this; + } + /** + * int64 duration_microsecond_value = 29; + * @return This builder for chaining. + */ + public Builder clearDurationMicrosecondValue() { + if (valueDataCase_ == 29) { + valueDataCase_ = 0; + valueData_ = null; + onChanged(); + } + return this; + } + + /** + * int64 duration_nanosecond_value = 30; + * @return Whether the durationNanosecondValue field is set. + */ + public boolean hasDurationNanosecondValue() { + return valueDataCase_ == 30; + } + /** + * int64 duration_nanosecond_value = 30; + * @return The durationNanosecondValue. + */ + public long getDurationNanosecondValue() { + if (valueDataCase_ == 30) { + return (java.lang.Long) valueData_; + } + return 0L; + } + /** + * int64 duration_nanosecond_value = 30; + * @param value The durationNanosecondValue to set. + * @return This builder for chaining. + */ + public Builder setDurationNanosecondValue(long value) { + valueDataCase_ = 30; + valueData_ = value; + onChanged(); + return this; + } + /** + * int64 duration_nanosecond_value = 30; + * @return This builder for chaining. + */ + public Builder clearDurationNanosecondValue() { + if (valueDataCase_ == 30) { + valueDataCase_ = 0; + valueData_ = null; + onChanged(); + } + return this; + } @java.lang.Override public final Builder setUnknownFields( final com.google.protobuf.UnknownFieldSet unknownFields) { @@ -6231,7 +6651,7 @@ public final class RowData { "\0162\033.greptime.v1.ColumnDataType\0220\n\rsemant" + "ic_type\030\003 \001(\0162\031.greptime.v1.SemanticType" + "\")\n\003Row\022\"\n\006values\030\001 \003(\0132\022.greptime.v1.Va" + - "lue\"\212\006\n\005Value\022\022\n\010i8_value\030\001 \001(\005H\000\022\023\n\ti16" + + "lue\"\234\007\n\005Value\022\022\n\010i8_value\030\001 \001(\005H\000\022\023\n\ti16" + "_value\030\002 \001(\005H\000\022\023\n\ti32_value\030\003 \001(\005H\000\022\023\n\ti" + "64_value\030\004 \001(\003H\000\022\022\n\010u8_value\030\005 \001(\rH\000\022\023\n\t" + "u16_value\030\006 \001(\rH\000\022\023\n\tu32_value\030\007 \001(\rH\000\022\023" + @@ -6250,9 +6670,13 @@ public final class RowData { "th_values\030\030 \001(\005H\000\022\"\n\030interval_day_time_v" + "alues\030\031 \001(\003H\000\022K\n\036interval_month_day_nano" + "_values\030\032 \001(\0132!.greptime.v1.IntervalMont" + - "hDayNanoH\000B\014\n\nvalue_dataBP\n\016io.greptime." + - "v1B\007RowDataZ5github.com/GreptimeTeam/gre" + - "ptime-proto/go/greptime/v1b\006proto3" + "hDayNanoH\000\022\037\n\025duration_second_value\030\033 \001(" + + "\003H\000\022$\n\032duration_millisecond_value\030\034 \001(\003H" + + "\000\022$\n\032duration_microsecond_value\030\035 \001(\003H\000\022" + + "#\n\031duration_nanosecond_value\030\036 \001(\003H\000B\014\n\n" + + "value_dataBP\n\016io.greptime.v1B\007RowDataZ5g" + + "ithub.com/GreptimeTeam/greptime-proto/go" + + "/greptime/v1b\006proto3" }; descriptor = com.google.protobuf.Descriptors.FileDescriptor .internalBuildGeneratedFileFrom(descriptorData, @@ -6282,7 +6706,7 @@ public final class RowData { internal_static_greptime_v1_Value_fieldAccessorTable = new com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( internal_static_greptime_v1_Value_descriptor, - new java.lang.String[] { "I8Value", "I16Value", "I32Value", "I64Value", "U8Value", "U16Value", "U32Value", "U64Value", "F32Value", "F64Value", "BoolValue", "BinaryValue", "StringValue", "DateValue", "DatetimeValue", "TimestampSecondValue", "TimestampMillisecondValue", "TimestampMicrosecondValue", "TimestampNanosecondValue", "TimeSecondValue", "TimeMillisecondValue", "TimeMicrosecondValue", "TimeNanosecondValue", "IntervalYearMonthValues", "IntervalDayTimeValues", "IntervalMonthDayNanoValues", "ValueData", }); + new java.lang.String[] { "I8Value", "I16Value", "I32Value", "I64Value", "U8Value", "U16Value", "U32Value", "U64Value", "F32Value", "F64Value", "BoolValue", "BinaryValue", "StringValue", "DateValue", "DatetimeValue", "TimestampSecondValue", "TimestampMillisecondValue", "TimestampMicrosecondValue", "TimestampNanosecondValue", "TimeSecondValue", "TimeMillisecondValue", "TimeMicrosecondValue", "TimeNanosecondValue", "IntervalYearMonthValues", "IntervalDayTimeValues", "IntervalMonthDayNanoValues", "DurationSecondValue", "DurationMillisecondValue", "DurationMicrosecondValue", "DurationNanosecondValue", "ValueData", }); io.greptime.v1.Common.getDescriptor(); } diff --git a/proto/greptime/v1/column.proto b/proto/greptime/v1/column.proto index 7450f0c..df0ecbe 100644 --- a/proto/greptime/v1/column.proto +++ b/proto/greptime/v1/column.proto @@ -57,6 +57,10 @@ message Column { repeated int32 interval_year_month_values = 24; repeated int64 interval_day_time_values = 25; repeated IntervalMonthDayNano interval_month_day_nano_values = 26; + repeated int64 duration_second_values = 27; + repeated int64 duration_millisecond_values = 28; + repeated int64 duration_microsecond_values = 29; + repeated int64 duration_nanosecond_values = 30; } // The array of non-null values in this column. // diff --git a/proto/greptime/v1/common.proto b/proto/greptime/v1/common.proto index e59b3ff..2de5ee3 100644 --- a/proto/greptime/v1/common.proto +++ b/proto/greptime/v1/common.proto @@ -94,6 +94,10 @@ enum ColumnDataType { INTERVAL_YEAR_MONTH = 23; INTERVAL_DAY_TIME = 24; INTERVAL_MONTH_DAY_NANO = 25; + DURATION_SECOND = 26; + DURATION_MILLISECOND = 27; + DURATION_MICROSECOND = 28; + DURATION_NANOSECOND = 29; } message IntervalMonthDayNano { diff --git a/proto/greptime/v1/row.proto b/proto/greptime/v1/row.proto index bcdaa73..00cb79f 100644 --- a/proto/greptime/v1/row.proto +++ b/proto/greptime/v1/row.proto @@ -67,5 +67,9 @@ message Value { int32 interval_year_month_values = 24; int64 interval_day_time_values = 25; IntervalMonthDayNano interval_month_day_nano_values = 26; + int64 duration_second_value = 27; + int64 duration_millisecond_value = 28; + int64 duration_microsecond_value = 29; + int64 duration_nanosecond_value = 30; } }