diff --git a/c++/greptime/v1/flow/server.pb.cc b/c++/greptime/v1/flow/server.pb.cc index f7f1df5f..0b48e766 100644 --- a/c++/greptime/v1/flow/server.pb.cc +++ b/c++/greptime/v1/flow/server.pb.cc @@ -161,10 +161,23 @@ struct DropRequestDefaultTypeInternal { }; }; PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DropRequestDefaultTypeInternal _DropRequest_default_instance_; +PROTOBUF_CONSTEXPR FlushFlow::FlushFlow( + ::_pbi::ConstantInitialized): _impl_{ + /*decltype(_impl_.flow_id_)*/nullptr + , /*decltype(_impl_._cached_size_)*/{}} {} +struct FlushFlowDefaultTypeInternal { + PROTOBUF_CONSTEXPR FlushFlowDefaultTypeInternal() + : _instance(::_pbi::ConstantInitialized{}) {} + ~FlushFlowDefaultTypeInternal() {} + union { + FlushFlow _instance; + }; +}; +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FlushFlowDefaultTypeInternal _FlushFlow_default_instance_; } // namespace flow } // namespace v1 } // namespace greptime -static ::_pb::Metadata file_level_metadata_greptime_2fv1_2fflow_2fserver_2eproto[10]; +static ::_pb::Metadata file_level_metadata_greptime_2fv1_2fflow_2fserver_2eproto[11]; static constexpr ::_pb::EnumDescriptor const** file_level_enum_descriptors_greptime_2fv1_2fflow_2fserver_2eproto = nullptr; static constexpr ::_pb::ServiceDescriptor const** file_level_service_descriptors_greptime_2fv1_2fflow_2fserver_2eproto = nullptr; @@ -211,6 +224,7 @@ const uint32_t TableStruct_greptime_2fv1_2fflow_2fserver_2eproto::offsets[] PROT PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::FlowRequest, _impl_.header_), ::_pbi::kInvalidFieldOffsetTag, ::_pbi::kInvalidFieldOffsetTag, + ::_pbi::kInvalidFieldOffsetTag, PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::FlowRequest, _impl_.body_), PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::FlowResponse_ExtensionEntry_DoNotUse, _has_bits_), PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::FlowResponse_ExtensionEntry_DoNotUse, _internal_metadata_), @@ -263,6 +277,13 @@ const uint32_t TableStruct_greptime_2fv1_2fflow_2fserver_2eproto::offsets[] PROT ~0u, // no _weak_field_map_ ~0u, // no _inlined_string_donated_ PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::DropRequest, _impl_.flow_id_), + ~0u, // no _has_bits_ + PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::FlushFlow, _internal_metadata_), + ~0u, // no _extensions_ + ~0u, // no _oneof_case_ + ~0u, // no _weak_field_map_ + ~0u, // no _inlined_string_donated_ + PROTOBUF_FIELD_OFFSET(::greptime::v1::flow::FlushFlow, _impl_.flow_id_), }; static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = { { 0, 8, -1, sizeof(::greptime::v1::flow::FlowRequestHeader_TracingContextEntry_DoNotUse)}, @@ -270,11 +291,12 @@ static const ::_pbi::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protode { 18, -1, -1, sizeof(::greptime::v1::flow::InsertRequests)}, { 25, -1, -1, sizeof(::greptime::v1::flow::InsertRequest)}, { 33, -1, -1, sizeof(::greptime::v1::flow::FlowRequest)}, - { 43, 51, -1, sizeof(::greptime::v1::flow::FlowResponse_ExtensionEntry_DoNotUse)}, - { 53, -1, -1, sizeof(::greptime::v1::flow::FlowResponse)}, - { 63, 71, -1, sizeof(::greptime::v1::flow::CreateRequest_FlowOptionsEntry_DoNotUse)}, - { 73, -1, -1, sizeof(::greptime::v1::flow::CreateRequest)}, - { 87, -1, -1, sizeof(::greptime::v1::flow::DropRequest)}, + { 44, 52, -1, sizeof(::greptime::v1::flow::FlowResponse_ExtensionEntry_DoNotUse)}, + { 54, -1, -1, sizeof(::greptime::v1::flow::FlowResponse)}, + { 64, 72, -1, sizeof(::greptime::v1::flow::CreateRequest_FlowOptionsEntry_DoNotUse)}, + { 74, -1, -1, sizeof(::greptime::v1::flow::CreateRequest)}, + { 88, -1, -1, sizeof(::greptime::v1::flow::DropRequest)}, + { 95, -1, -1, sizeof(::greptime::v1::flow::FlushFlow)}, }; static const ::_pb::Message* const file_default_instances[] = { @@ -288,6 +310,7 @@ static const ::_pb::Message* const file_default_instances[] = { &::greptime::v1::flow::_CreateRequest_FlowOptionsEntry_DoNotUse_default_instance_._instance, &::greptime::v1::flow::_CreateRequest_default_instance_._instance, &::greptime::v1::flow::_DropRequest_default_instance_._instance, + &::greptime::v1::flow::_FlushFlow_default_instance_._instance, }; const char descriptor_table_protodef_greptime_2fv1_2fflow_2fserver_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = @@ -302,36 +325,38 @@ const char descriptor_table_protodef_greptime_2fv1_2fflow_2fserver_2eproto[] PRO "\030\002 \001(\t:\0028\001\"C\n\016InsertRequests\0221\n\010requests" "\030\001 \003(\0132\037.greptime.v1.flow.InsertRequest\"" "C\n\rInsertRequest\022\021\n\tregion_id\030\001 \001(\004\022\037\n\004r" - "ows\030\002 \001(\0132\021.greptime.v1.Rows\"\254\001\n\013FlowReq" + "ows\030\002 \001(\0132\021.greptime.v1.Rows\"\332\001\n\013FlowReq" "uest\0223\n\006header\030@ \001(\0132#.greptime.v1.flow." "FlowRequestHeader\0221\n\006create\030\001 \001(\0132\037.grep" "time.v1.flow.CreateRequestH\000\022-\n\004drop\030\002 \001" - "(\0132\035.greptime.v1.flow.DropRequestH\000B\006\n\004b" - "ody\"\363\001\n\014FlowResponse\022+\n\006header\030\001 \001(\0132\033.g" - "reptime.v1.ResponseHeader\022\025\n\raffected_ro" - "ws\030\002 \001(\004\022+\n\016affected_flows\030\003 \003(\0132\023.grept" - "ime.v1.FlowId\022@\n\textension\030\004 \003(\0132-.grept" - "ime.v1.flow.FlowResponse.ExtensionEntry\032" - "0\n\016ExtensionEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030" - "\002 \001(\014:\0028\001\"\376\002\n\rCreateRequest\022$\n\007flow_id\030\001" - " \001(\0132\023.greptime.v1.FlowId\022.\n\020source_tabl" - "e_ids\030\002 \003(\0132\024.greptime.v1.TableId\022/\n\017sin" - "k_table_name\030\003 \001(\0132\026.greptime.v1.TableNa" - "me\022\034\n\024create_if_not_exists\030\004 \001(\010\022.\n\014expi" - "re_after\030\005 \001(\0132\030.greptime.v1.ExpireAfter" - "\022\017\n\007comment\030\006 \001(\t\022\013\n\003sql\030\007 \001(\t\022F\n\014flow_o" - "ptions\030\010 \003(\01320.greptime.v1.flow.CreateRe" - "quest.FlowOptionsEntry\0322\n\020FlowOptionsEnt" - "ry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t:\0028\001\"3\n\013Dr" - "opRequest\022$\n\007flow_id\030\001 \001(\0132\023.greptime.v1" - ".FlowId2\264\001\n\004Flow\022S\n\022HandleCreateRemove\022\035" - ".greptime.v1.flow.FlowRequest\032\036.greptime" - ".v1.flow.FlowResponse\022W\n\023HandleMirrorReq" - "uest\022 .greptime.v1.flow.InsertRequests\032\036" - ".greptime.v1.flow.FlowResponseBY\n\023io.gre" - "ptime.v1.flowB\006ServerZ:github.com/Grepti" - "meTeam/greptime-proto/go/greptime/v1/flo" - "wb\006proto3" + "(\0132\035.greptime.v1.flow.DropRequestH\000\022,\n\005f" + "lush\030\003 \001(\0132\033.greptime.v1.flow.FlushFlowH" + "\000B\006\n\004body\"\363\001\n\014FlowResponse\022+\n\006header\030\001 \001" + "(\0132\033.greptime.v1.ResponseHeader\022\025\n\raffec" + "ted_rows\030\002 \001(\004\022+\n\016affected_flows\030\003 \003(\0132\023" + ".greptime.v1.FlowId\022@\n\textension\030\004 \003(\0132-" + ".greptime.v1.flow.FlowResponse.Extension" + "Entry\0320\n\016ExtensionEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005" + "value\030\002 \001(\014:\0028\001\"\376\002\n\rCreateRequest\022$\n\007flo" + "w_id\030\001 \001(\0132\023.greptime.v1.FlowId\022.\n\020sourc" + "e_table_ids\030\002 \003(\0132\024.greptime.v1.TableId\022" + "/\n\017sink_table_name\030\003 \001(\0132\026.greptime.v1.T" + "ableName\022\034\n\024create_if_not_exists\030\004 \001(\010\022." + "\n\014expire_after\030\005 \001(\0132\030.greptime.v1.Expir" + "eAfter\022\017\n\007comment\030\006 \001(\t\022\013\n\003sql\030\007 \001(\t\022F\n\014" + "flow_options\030\010 \003(\01320.greptime.v1.flow.Cr" + "eateRequest.FlowOptionsEntry\0322\n\020FlowOpti" + "onsEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t:\0028\001" + "\"3\n\013DropRequest\022$\n\007flow_id\030\001 \001(\0132\023.grept" + "ime.v1.FlowId\"1\n\tFlushFlow\022$\n\007flow_id\030\001 " + "\001(\0132\023.greptime.v1.FlowId2\264\001\n\004Flow\022S\n\022Han" + "dleCreateRemove\022\035.greptime.v1.flow.FlowR" + "equest\032\036.greptime.v1.flow.FlowResponse\022W" + "\n\023HandleMirrorRequest\022 .greptime.v1.flow" + ".InsertRequests\032\036.greptime.v1.flow.FlowR" + "esponseBY\n\023io.greptime.v1.flowB\006ServerZ:" + "github.com/GreptimeTeam/greptime-proto/g" + "o/greptime/v1/flowb\006proto3" ; static const ::_pbi::DescriptorTable* const descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_deps[3] = { &::descriptor_table_greptime_2fv1_2fcommon_2eproto, @@ -340,9 +365,9 @@ static const ::_pbi::DescriptorTable* const descriptor_table_greptime_2fv1_2fflo }; static ::_pbi::once_flag descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_once; const ::_pbi::DescriptorTable descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto = { - false, false, 1609, descriptor_table_protodef_greptime_2fv1_2fflow_2fserver_2eproto, + false, false, 1706, descriptor_table_protodef_greptime_2fv1_2fflow_2fserver_2eproto, "greptime/v1/flow/server.proto", - &descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_once, descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_deps, 3, 10, + &descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_once, descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_deps, 3, 11, schemas, file_default_instances, TableStruct_greptime_2fv1_2fflow_2fserver_2eproto::offsets, file_level_metadata_greptime_2fv1_2fflow_2fserver_2eproto, file_level_enum_descriptors_greptime_2fv1_2fflow_2fserver_2eproto, file_level_service_descriptors_greptime_2fv1_2fflow_2fserver_2eproto, @@ -1060,6 +1085,7 @@ class FlowRequest::_Internal { static const ::greptime::v1::flow::FlowRequestHeader& header(const FlowRequest* msg); static const ::greptime::v1::flow::CreateRequest& create(const FlowRequest* msg); static const ::greptime::v1::flow::DropRequest& drop(const FlowRequest* msg); + static const ::greptime::v1::flow::FlushFlow& flush(const FlowRequest* msg); }; const ::greptime::v1::flow::FlowRequestHeader& @@ -1074,6 +1100,10 @@ const ::greptime::v1::flow::DropRequest& FlowRequest::_Internal::drop(const FlowRequest* msg) { return *msg->_impl_.body_.drop_; } +const ::greptime::v1::flow::FlushFlow& +FlowRequest::_Internal::flush(const FlowRequest* msg) { + return *msg->_impl_.body_.flush_; +} void FlowRequest::set_allocated_create(::greptime::v1::flow::CreateRequest* create) { ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); clear_body(); @@ -1104,6 +1134,21 @@ void FlowRequest::set_allocated_drop(::greptime::v1::flow::DropRequest* drop) { } // @@protoc_insertion_point(field_set_allocated:greptime.v1.flow.FlowRequest.drop) } +void FlowRequest::set_allocated_flush(::greptime::v1::flow::FlushFlow* flush) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + clear_body(); + if (flush) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena(flush); + if (message_arena != submessage_arena) { + flush = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, flush, submessage_arena); + } + set_has_flush(); + _impl_.body_.flush_ = flush; + } + // @@protoc_insertion_point(field_set_allocated:greptime.v1.flow.FlowRequest.flush) +} FlowRequest::FlowRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned) : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { @@ -1135,6 +1180,11 @@ FlowRequest::FlowRequest(const FlowRequest& from) from._internal_drop()); break; } + case kFlush: { + _this->_internal_mutable_flush()->::greptime::v1::flow::FlushFlow::MergeFrom( + from._internal_flush()); + break; + } case BODY_NOT_SET: { break; } @@ -1191,6 +1241,12 @@ void FlowRequest::clear_body() { } break; } + case kFlush: { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.body_.flush_; + } + break; + } case BODY_NOT_SET: { break; } @@ -1235,6 +1291,14 @@ const char* FlowRequest::_InternalParse(const char* ptr, ::_pbi::ParseContext* c } else goto handle_unusual; continue; + // .greptime.v1.flow.FlushFlow flush = 3; + case 3: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 26)) { + ptr = ctx->ParseMessage(_internal_mutable_flush(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; // .greptime.v1.flow.FlowRequestHeader header = 64; case 64: if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 2)) { @@ -1286,6 +1350,13 @@ uint8_t* FlowRequest::_InternalSerialize( _Internal::drop(this).GetCachedSize(), target, stream); } + // .greptime.v1.flow.FlushFlow flush = 3; + if (_internal_has_flush()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(3, _Internal::flush(this), + _Internal::flush(this).GetCachedSize(), target, stream); + } + // .greptime.v1.flow.FlowRequestHeader header = 64; if (this->_internal_has_header()) { target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: @@ -1331,6 +1402,13 @@ size_t FlowRequest::ByteSizeLong() const { *_impl_.body_.drop_); break; } + // .greptime.v1.flow.FlushFlow flush = 3; + case kFlush: { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.body_.flush_); + break; + } case BODY_NOT_SET: { break; } @@ -1368,6 +1446,11 @@ void FlowRequest::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PR from._internal_drop()); break; } + case kFlush: { + _this->_internal_mutable_flush()->::greptime::v1::flow::FlushFlow::MergeFrom( + from._internal_flush()); + break; + } case BODY_NOT_SET: { break; } @@ -2489,6 +2572,205 @@ ::PROTOBUF_NAMESPACE_ID::Metadata DropRequest::GetMetadata() const { file_level_metadata_greptime_2fv1_2fflow_2fserver_2eproto[9]); } +// =================================================================== + +class FlushFlow::_Internal { + public: + static const ::greptime::v1::FlowId& flow_id(const FlushFlow* msg); +}; + +const ::greptime::v1::FlowId& +FlushFlow::_Internal::flow_id(const FlushFlow* msg) { + return *msg->_impl_.flow_id_; +} +void FlushFlow::clear_flow_id() { + if (GetArenaForAllocation() == nullptr && _impl_.flow_id_ != nullptr) { + delete _impl_.flow_id_; + } + _impl_.flow_id_ = nullptr; +} +FlushFlow::FlushFlow(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned) + : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) { + SharedCtor(arena, is_message_owned); + // @@protoc_insertion_point(arena_constructor:greptime.v1.flow.FlushFlow) +} +FlushFlow::FlushFlow(const FlushFlow& from) + : ::PROTOBUF_NAMESPACE_ID::Message() { + FlushFlow* const _this = this; (void)_this; + new (&_impl_) Impl_{ + decltype(_impl_.flow_id_){nullptr} + , /*decltype(_impl_._cached_size_)*/{}}; + + _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); + if (from._internal_has_flow_id()) { + _this->_impl_.flow_id_ = new ::greptime::v1::FlowId(*from._impl_.flow_id_); + } + // @@protoc_insertion_point(copy_constructor:greptime.v1.flow.FlushFlow) +} + +inline void FlushFlow::SharedCtor( + ::_pb::Arena* arena, bool is_message_owned) { + (void)arena; + (void)is_message_owned; + new (&_impl_) Impl_{ + decltype(_impl_.flow_id_){nullptr} + , /*decltype(_impl_._cached_size_)*/{} + }; +} + +FlushFlow::~FlushFlow() { + // @@protoc_insertion_point(destructor:greptime.v1.flow.FlushFlow) + if (auto *arena = _internal_metadata_.DeleteReturnArena<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>()) { + (void)arena; + return; + } + SharedDtor(); +} + +inline void FlushFlow::SharedDtor() { + GOOGLE_DCHECK(GetArenaForAllocation() == nullptr); + if (this != internal_default_instance()) delete _impl_.flow_id_; +} + +void FlushFlow::SetCachedSize(int size) const { + _impl_._cached_size_.Set(size); +} + +void FlushFlow::Clear() { +// @@protoc_insertion_point(message_clear_start:greptime.v1.flow.FlushFlow) + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + if (GetArenaForAllocation() == nullptr && _impl_.flow_id_ != nullptr) { + delete _impl_.flow_id_; + } + _impl_.flow_id_ = nullptr; + _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(); +} + +const char* FlushFlow::_InternalParse(const char* ptr, ::_pbi::ParseContext* ctx) { +#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure + while (!ctx->Done(&ptr)) { + uint32_t tag; + ptr = ::_pbi::ReadTag(ptr, &tag); + switch (tag >> 3) { + // .greptime.v1.FlowId flow_id = 1; + case 1: + if (PROTOBUF_PREDICT_TRUE(static_cast(tag) == 10)) { + ptr = ctx->ParseMessage(_internal_mutable_flow_id(), ptr); + CHK_(ptr); + } else + goto handle_unusual; + continue; + default: + goto handle_unusual; + } // switch + handle_unusual: + if ((tag == 0) || ((tag & 7) == 4)) { + CHK_(ptr); + ctx->SetLastTag(tag); + goto message_done; + } + ptr = UnknownFieldParse( + tag, + _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(), + ptr, ctx); + CHK_(ptr != nullptr); + } // while +message_done: + return ptr; +failure: + ptr = nullptr; + goto message_done; +#undef CHK_ +} + +uint8_t* FlushFlow::_InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const { + // @@protoc_insertion_point(serialize_to_array_start:greptime.v1.flow.FlushFlow) + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + // .greptime.v1.FlowId flow_id = 1; + if (this->_internal_has_flow_id()) { + target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite:: + InternalWriteMessage(1, _Internal::flow_id(this), + _Internal::flow_id(this).GetCachedSize(), target, stream); + } + + 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); + } + // @@protoc_insertion_point(serialize_to_array_end:greptime.v1.flow.FlushFlow) + return target; +} + +size_t FlushFlow::ByteSizeLong() const { +// @@protoc_insertion_point(message_byte_size_start:greptime.v1.flow.FlushFlow) + size_t total_size = 0; + + uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + // .greptime.v1.FlowId flow_id = 1; + if (this->_internal_has_flow_id()) { + total_size += 1 + + ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize( + *_impl_.flow_id_); + } + + return MaybeComputeUnknownFieldsSize(total_size, &_impl_._cached_size_); +} + +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData FlushFlow::_class_data_ = { + ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSourceCheck, + FlushFlow::MergeImpl +}; +const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*FlushFlow::GetClassData() const { return &_class_data_; } + + +void FlushFlow::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:greptime.v1.flow.FlushFlow) + GOOGLE_DCHECK_NE(&from, _this); + uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_has_flow_id()) { + _this->_internal_mutable_flow_id()->::greptime::v1::FlowId::MergeFrom( + from._internal_flow_id()); + } + _this->_internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_); +} + +void FlushFlow::CopyFrom(const FlushFlow& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:greptime.v1.flow.FlushFlow) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool FlushFlow::IsInitialized() const { + return true; +} + +void FlushFlow::InternalSwap(FlushFlow* other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.flow_id_, other->_impl_.flow_id_); +} + +::PROTOBUF_NAMESPACE_ID::Metadata FlushFlow::GetMetadata() const { + return ::_pbi::AssignDescriptors( + &descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_getter, &descriptor_table_greptime_2fv1_2fflow_2fserver_2eproto_once, + file_level_metadata_greptime_2fv1_2fflow_2fserver_2eproto[10]); +} + // @@protoc_insertion_point(namespace_scope) } // namespace flow } // namespace v1 @@ -2534,6 +2816,10 @@ template<> PROTOBUF_NOINLINE ::greptime::v1::flow::DropRequest* Arena::CreateMaybeMessage< ::greptime::v1::flow::DropRequest >(Arena* arena) { return Arena::CreateMessageInternal< ::greptime::v1::flow::DropRequest >(arena); } +template<> PROTOBUF_NOINLINE ::greptime::v1::flow::FlushFlow* +Arena::CreateMaybeMessage< ::greptime::v1::flow::FlushFlow >(Arena* arena) { + return Arena::CreateMessageInternal< ::greptime::v1::flow::FlushFlow >(arena); +} PROTOBUF_NAMESPACE_CLOSE // @@protoc_insertion_point(global_scope) diff --git a/c++/greptime/v1/flow/server.pb.h b/c++/greptime/v1/flow/server.pb.h index dd641c56..4aaab9e3 100644 --- a/c++/greptime/v1/flow/server.pb.h +++ b/c++/greptime/v1/flow/server.pb.h @@ -77,6 +77,9 @@ extern FlowResponseDefaultTypeInternal _FlowResponse_default_instance_; class FlowResponse_ExtensionEntry_DoNotUse; struct FlowResponse_ExtensionEntry_DoNotUseDefaultTypeInternal; extern FlowResponse_ExtensionEntry_DoNotUseDefaultTypeInternal _FlowResponse_ExtensionEntry_DoNotUse_default_instance_; +class FlushFlow; +struct FlushFlowDefaultTypeInternal; +extern FlushFlowDefaultTypeInternal _FlushFlow_default_instance_; class InsertRequest; struct InsertRequestDefaultTypeInternal; extern InsertRequestDefaultTypeInternal _InsertRequest_default_instance_; @@ -95,6 +98,7 @@ template<> ::greptime::v1::flow::FlowRequestHeader* Arena::CreateMaybeMessage<:: template<> ::greptime::v1::flow::FlowRequestHeader_TracingContextEntry_DoNotUse* Arena::CreateMaybeMessage<::greptime::v1::flow::FlowRequestHeader_TracingContextEntry_DoNotUse>(Arena*); template<> ::greptime::v1::flow::FlowResponse* Arena::CreateMaybeMessage<::greptime::v1::flow::FlowResponse>(Arena*); template<> ::greptime::v1::flow::FlowResponse_ExtensionEntry_DoNotUse* Arena::CreateMaybeMessage<::greptime::v1::flow::FlowResponse_ExtensionEntry_DoNotUse>(Arena*); +template<> ::greptime::v1::flow::FlushFlow* Arena::CreateMaybeMessage<::greptime::v1::flow::FlushFlow>(Arena*); template<> ::greptime::v1::flow::InsertRequest* Arena::CreateMaybeMessage<::greptime::v1::flow::InsertRequest>(Arena*); template<> ::greptime::v1::flow::InsertRequests* Arena::CreateMaybeMessage<::greptime::v1::flow::InsertRequests>(Arena*); PROTOBUF_NAMESPACE_CLOSE @@ -686,6 +690,7 @@ class FlowRequest final : enum BodyCase { kCreate = 1, kDrop = 2, + kFlush = 3, BODY_NOT_SET = 0, }; @@ -770,6 +775,7 @@ class FlowRequest final : kHeaderFieldNumber = 64, kCreateFieldNumber = 1, kDropFieldNumber = 2, + kFlushFieldNumber = 3, }; // .greptime.v1.flow.FlowRequestHeader header = 64; bool has_header() const; @@ -825,6 +831,24 @@ class FlowRequest final : ::greptime::v1::flow::DropRequest* drop); ::greptime::v1::flow::DropRequest* unsafe_arena_release_drop(); + // .greptime.v1.flow.FlushFlow flush = 3; + bool has_flush() const; + private: + bool _internal_has_flush() const; + public: + void clear_flush(); + const ::greptime::v1::flow::FlushFlow& flush() const; + PROTOBUF_NODISCARD ::greptime::v1::flow::FlushFlow* release_flush(); + ::greptime::v1::flow::FlushFlow* mutable_flush(); + void set_allocated_flush(::greptime::v1::flow::FlushFlow* flush); + private: + const ::greptime::v1::flow::FlushFlow& _internal_flush() const; + ::greptime::v1::flow::FlushFlow* _internal_mutable_flush(); + public: + void unsafe_arena_set_allocated_flush( + ::greptime::v1::flow::FlushFlow* flush); + ::greptime::v1::flow::FlushFlow* unsafe_arena_release_flush(); + void clear_body(); BodyCase body_case() const; // @@protoc_insertion_point(class_scope:greptime.v1.flow.FlowRequest) @@ -832,6 +856,7 @@ class FlowRequest final : class _Internal; void set_has_create(); void set_has_drop(); + void set_has_flush(); inline bool has_body() const; inline void clear_has_body(); @@ -846,6 +871,7 @@ class FlowRequest final : ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_; ::greptime::v1::flow::CreateRequest* create_; ::greptime::v1::flow::DropRequest* drop_; + ::greptime::v1::flow::FlushFlow* flush_; } body_; mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; uint32_t _oneof_case_[1]; @@ -1565,6 +1591,163 @@ class DropRequest final : union { Impl_ _impl_; }; friend struct ::TableStruct_greptime_2fv1_2fflow_2fserver_2eproto; }; +// ------------------------------------------------------------------- + +class FlushFlow final : + public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:greptime.v1.flow.FlushFlow) */ { + public: + inline FlushFlow() : FlushFlow(nullptr) {} + ~FlushFlow() override; + explicit PROTOBUF_CONSTEXPR FlushFlow(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized); + + FlushFlow(const FlushFlow& from); + FlushFlow(FlushFlow&& from) noexcept + : FlushFlow() { + *this = ::std::move(from); + } + + inline FlushFlow& operator=(const FlushFlow& from) { + CopyFrom(from); + return *this; + } + inline FlushFlow& operator=(FlushFlow&& from) noexcept { + if (this == &from) return *this; + if (GetOwningArena() == from.GetOwningArena() + #ifdef PROTOBUF_FORCE_COPY_IN_MOVE + && GetOwningArena() != nullptr + #endif // !PROTOBUF_FORCE_COPY_IN_MOVE + ) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() { + return GetDescriptor(); + } + static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() { + return default_instance().GetMetadata().descriptor; + } + static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() { + return default_instance().GetMetadata().reflection; + } + static const FlushFlow& default_instance() { + return *internal_default_instance(); + } + static inline const FlushFlow* internal_default_instance() { + return reinterpret_cast( + &_FlushFlow_default_instance_); + } + static constexpr int kIndexInFileMessages = + 10; + + friend void swap(FlushFlow& a, FlushFlow& b) { + a.Swap(&b); + } + inline void Swap(FlushFlow* other) { + if (other == this) return; + #ifdef PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() != nullptr && + GetOwningArena() == other->GetOwningArena()) { + #else // PROTOBUF_FORCE_COPY_IN_SWAP + if (GetOwningArena() == other->GetOwningArena()) { + #endif // !PROTOBUF_FORCE_COPY_IN_SWAP + InternalSwap(other); + } else { + ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FlushFlow* other) { + if (other == this) return; + GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FlushFlow* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final { + return CreateMaybeMessage(arena); + } + using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom; + void CopyFrom(const FlushFlow& from); + using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom; + void MergeFrom( const FlushFlow& from) { + FlushFlow::MergeImpl(*this, from); + } + private: + static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message& to_msg, const ::PROTOBUF_NAMESPACE_ID::Message& from_msg); + public: + PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final; + bool IsInitialized() const final; + + size_t ByteSizeLong() const final; + const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final; + uint8_t* _InternalSerialize( + uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final; + int GetCachedSize() const final { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::PROTOBUF_NAMESPACE_ID::Arena* arena, bool is_message_owned); + void SharedDtor(); + void SetCachedSize(int size) const final; + void InternalSwap(FlushFlow* other); + + private: + friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata; + static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() { + return "greptime.v1.flow.FlushFlow"; + } + protected: + explicit FlushFlow(::PROTOBUF_NAMESPACE_ID::Arena* arena, + bool is_message_owned = false); + public: + + static const ClassData _class_data_; + const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final; + + ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + enum : int { + kFlowIdFieldNumber = 1, + }; + // .greptime.v1.FlowId flow_id = 1; + bool has_flow_id() const; + private: + bool _internal_has_flow_id() const; + public: + void clear_flow_id(); + const ::greptime::v1::FlowId& flow_id() const; + PROTOBUF_NODISCARD ::greptime::v1::FlowId* release_flow_id(); + ::greptime::v1::FlowId* mutable_flow_id(); + void set_allocated_flow_id(::greptime::v1::FlowId* flow_id); + private: + const ::greptime::v1::FlowId& _internal_flow_id() const; + ::greptime::v1::FlowId* _internal_mutable_flow_id(); + public: + void unsafe_arena_set_allocated_flow_id( + ::greptime::v1::FlowId* flow_id); + ::greptime::v1::FlowId* unsafe_arena_release_flow_id(); + + // @@protoc_insertion_point(class_scope:greptime.v1.flow.FlushFlow) + private: + class _Internal; + + template friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper; + typedef void InternalArenaConstructable_; + typedef void DestructorSkippable_; + struct Impl_ { + ::greptime::v1::FlowId* flow_id_; + mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_; + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_greptime_2fv1_2fflow_2fserver_2eproto; +}; // =================================================================== @@ -2087,6 +2270,80 @@ inline ::greptime::v1::flow::DropRequest* FlowRequest::mutable_drop() { return _msg; } +// .greptime.v1.flow.FlushFlow flush = 3; +inline bool FlowRequest::_internal_has_flush() const { + return body_case() == kFlush; +} +inline bool FlowRequest::has_flush() const { + return _internal_has_flush(); +} +inline void FlowRequest::set_has_flush() { + _impl_._oneof_case_[0] = kFlush; +} +inline void FlowRequest::clear_flush() { + if (_internal_has_flush()) { + if (GetArenaForAllocation() == nullptr) { + delete _impl_.body_.flush_; + } + clear_has_body(); + } +} +inline ::greptime::v1::flow::FlushFlow* FlowRequest::release_flush() { + // @@protoc_insertion_point(field_release:greptime.v1.flow.FlowRequest.flush) + if (_internal_has_flush()) { + clear_has_body(); + ::greptime::v1::flow::FlushFlow* temp = _impl_.body_.flush_; + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } + _impl_.body_.flush_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::greptime::v1::flow::FlushFlow& FlowRequest::_internal_flush() const { + return _internal_has_flush() + ? *_impl_.body_.flush_ + : reinterpret_cast< ::greptime::v1::flow::FlushFlow&>(::greptime::v1::flow::_FlushFlow_default_instance_); +} +inline const ::greptime::v1::flow::FlushFlow& FlowRequest::flush() const { + // @@protoc_insertion_point(field_get:greptime.v1.flow.FlowRequest.flush) + return _internal_flush(); +} +inline ::greptime::v1::flow::FlushFlow* FlowRequest::unsafe_arena_release_flush() { + // @@protoc_insertion_point(field_unsafe_arena_release:greptime.v1.flow.FlowRequest.flush) + if (_internal_has_flush()) { + clear_has_body(); + ::greptime::v1::flow::FlushFlow* temp = _impl_.body_.flush_; + _impl_.body_.flush_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void FlowRequest::unsafe_arena_set_allocated_flush(::greptime::v1::flow::FlushFlow* flush) { + clear_body(); + if (flush) { + set_has_flush(); + _impl_.body_.flush_ = flush; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.flow.FlowRequest.flush) +} +inline ::greptime::v1::flow::FlushFlow* FlowRequest::_internal_mutable_flush() { + if (!_internal_has_flush()) { + clear_body(); + set_has_flush(); + _impl_.body_.flush_ = CreateMaybeMessage< ::greptime::v1::flow::FlushFlow >(GetArenaForAllocation()); + } + return _impl_.body_.flush_; +} +inline ::greptime::v1::flow::FlushFlow* FlowRequest::mutable_flush() { + ::greptime::v1::flow::FlushFlow* _msg = _internal_mutable_flush(); + // @@protoc_insertion_point(field_mutable:greptime.v1.flow.FlowRequest.flush) + return _msg; +} + inline bool FlowRequest::has_body() const { return body_case() != BODY_NOT_SET; } @@ -2809,6 +3066,95 @@ inline void DropRequest::set_allocated_flow_id(::greptime::v1::FlowId* flow_id) // @@protoc_insertion_point(field_set_allocated:greptime.v1.flow.DropRequest.flow_id) } +// ------------------------------------------------------------------- + +// FlushFlow + +// .greptime.v1.FlowId flow_id = 1; +inline bool FlushFlow::_internal_has_flow_id() const { + return this != internal_default_instance() && _impl_.flow_id_ != nullptr; +} +inline bool FlushFlow::has_flow_id() const { + return _internal_has_flow_id(); +} +inline const ::greptime::v1::FlowId& FlushFlow::_internal_flow_id() const { + const ::greptime::v1::FlowId* p = _impl_.flow_id_; + return p != nullptr ? *p : reinterpret_cast( + ::greptime::v1::_FlowId_default_instance_); +} +inline const ::greptime::v1::FlowId& FlushFlow::flow_id() const { + // @@protoc_insertion_point(field_get:greptime.v1.flow.FlushFlow.flow_id) + return _internal_flow_id(); +} +inline void FlushFlow::unsafe_arena_set_allocated_flow_id( + ::greptime::v1::FlowId* flow_id) { + if (GetArenaForAllocation() == nullptr) { + delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.flow_id_); + } + _impl_.flow_id_ = flow_id; + if (flow_id) { + + } else { + + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:greptime.v1.flow.FlushFlow.flow_id) +} +inline ::greptime::v1::FlowId* FlushFlow::release_flow_id() { + + ::greptime::v1::FlowId* temp = _impl_.flow_id_; + _impl_.flow_id_ = nullptr; +#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE + auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp); + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + if (GetArenaForAllocation() == nullptr) { delete old; } +#else // PROTOBUF_FORCE_COPY_IN_RELEASE + if (GetArenaForAllocation() != nullptr) { + temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp); + } +#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE + return temp; +} +inline ::greptime::v1::FlowId* FlushFlow::unsafe_arena_release_flow_id() { + // @@protoc_insertion_point(field_release:greptime.v1.flow.FlushFlow.flow_id) + + ::greptime::v1::FlowId* temp = _impl_.flow_id_; + _impl_.flow_id_ = nullptr; + return temp; +} +inline ::greptime::v1::FlowId* FlushFlow::_internal_mutable_flow_id() { + + if (_impl_.flow_id_ == nullptr) { + auto* p = CreateMaybeMessage<::greptime::v1::FlowId>(GetArenaForAllocation()); + _impl_.flow_id_ = p; + } + return _impl_.flow_id_; +} +inline ::greptime::v1::FlowId* FlushFlow::mutable_flow_id() { + ::greptime::v1::FlowId* _msg = _internal_mutable_flow_id(); + // @@protoc_insertion_point(field_mutable:greptime.v1.flow.FlushFlow.flow_id) + return _msg; +} +inline void FlushFlow::set_allocated_flow_id(::greptime::v1::FlowId* flow_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation(); + if (message_arena == nullptr) { + delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(_impl_.flow_id_); + } + if (flow_id) { + ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = + ::PROTOBUF_NAMESPACE_ID::Arena::InternalGetOwningArena( + reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(flow_id)); + if (message_arena != submessage_arena) { + flow_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage( + message_arena, flow_id, submessage_arena); + } + + } else { + + } + _impl_.flow_id_ = flow_id; + // @@protoc_insertion_point(field_set_allocated:greptime.v1.flow.FlushFlow.flow_id) +} + #ifdef __GNUC__ #pragma GCC diagnostic pop #endif // __GNUC__ @@ -2830,6 +3176,8 @@ inline void DropRequest::set_allocated_flow_id(::greptime::v1::FlowId* flow_id) // ------------------------------------------------------------------- +// ------------------------------------------------------------------- + // @@protoc_insertion_point(namespace_scope) diff --git a/java/src/main/java/io/greptime/v1/flow/Server.java b/java/src/main/java/io/greptime/v1/flow/Server.java index 7588b785..0036ab95 100644 --- a/java/src/main/java/io/greptime/v1/flow/Server.java +++ b/java/src/main/java/io/greptime/v1/flow/Server.java @@ -2640,6 +2640,21 @@ public interface FlowRequestOrBuilder extends */ io.greptime.v1.flow.Server.DropRequestOrBuilder getDropOrBuilder(); + /** + * .greptime.v1.flow.FlushFlow flush = 3; + * @return Whether the flush field is set. + */ + boolean hasFlush(); + /** + * .greptime.v1.flow.FlushFlow flush = 3; + * @return The flush. + */ + io.greptime.v1.flow.Server.FlushFlow getFlush(); + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + io.greptime.v1.flow.Server.FlushFlowOrBuilder getFlushOrBuilder(); + public io.greptime.v1.flow.Server.FlowRequest.BodyCase getBodyCase(); } /** @@ -2715,6 +2730,20 @@ private FlowRequest( bodyCase_ = 2; break; } + case 26: { + io.greptime.v1.flow.Server.FlushFlow.Builder subBuilder = null; + if (bodyCase_ == 3) { + subBuilder = ((io.greptime.v1.flow.Server.FlushFlow) body_).toBuilder(); + } + body_ = + input.readMessage(io.greptime.v1.flow.Server.FlushFlow.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom((io.greptime.v1.flow.Server.FlushFlow) body_); + body_ = subBuilder.buildPartial(); + } + bodyCase_ = 3; + break; + } case 514: { io.greptime.v1.flow.Server.FlowRequestHeader.Builder subBuilder = null; if (header_ != null) { @@ -2769,6 +2798,7 @@ public enum BodyCase com.google.protobuf.AbstractMessage.InternalOneOfEnum { CREATE(1), DROP(2), + FLUSH(3), BODY_NOT_SET(0); private final int value; private BodyCase(int value) { @@ -2788,6 +2818,7 @@ public static BodyCase forNumber(int value) { switch (value) { case 1: return CREATE; case 2: return DROP; + case 3: return FLUSH; case 0: return BODY_NOT_SET; default: return null; } @@ -2891,6 +2922,37 @@ public io.greptime.v1.flow.Server.DropRequestOrBuilder getDropOrBuilder() { return io.greptime.v1.flow.Server.DropRequest.getDefaultInstance(); } + public static final int FLUSH_FIELD_NUMBER = 3; + /** + * .greptime.v1.flow.FlushFlow flush = 3; + * @return Whether the flush field is set. + */ + @java.lang.Override + public boolean hasFlush() { + return bodyCase_ == 3; + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + * @return The flush. + */ + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlow getFlush() { + if (bodyCase_ == 3) { + return (io.greptime.v1.flow.Server.FlushFlow) body_; + } + return io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlowOrBuilder getFlushOrBuilder() { + if (bodyCase_ == 3) { + return (io.greptime.v1.flow.Server.FlushFlow) body_; + } + return io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } + private byte memoizedIsInitialized = -1; @java.lang.Override public final boolean isInitialized() { @@ -2911,6 +2973,9 @@ public void writeTo(com.google.protobuf.CodedOutputStream output) if (bodyCase_ == 2) { output.writeMessage(2, (io.greptime.v1.flow.Server.DropRequest) body_); } + if (bodyCase_ == 3) { + output.writeMessage(3, (io.greptime.v1.flow.Server.FlushFlow) body_); + } if (header_ != null) { output.writeMessage(64, getHeader()); } @@ -2931,6 +2996,10 @@ public int getSerializedSize() { size += com.google.protobuf.CodedOutputStream .computeMessageSize(2, (io.greptime.v1.flow.Server.DropRequest) body_); } + if (bodyCase_ == 3) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, (io.greptime.v1.flow.Server.FlushFlow) body_); + } if (header_ != null) { size += com.google.protobuf.CodedOutputStream .computeMessageSize(64, getHeader()); @@ -2965,6 +3034,10 @@ public boolean equals(final java.lang.Object obj) { if (!getDrop() .equals(other.getDrop())) return false; break; + case 3: + if (!getFlush() + .equals(other.getFlush())) return false; + break; case 0: default: } @@ -2992,6 +3065,10 @@ public int hashCode() { hash = (37 * hash) + DROP_FIELD_NUMBER; hash = (53 * hash) + getDrop().hashCode(); break; + case 3: + hash = (37 * hash) + FLUSH_FIELD_NUMBER; + hash = (53 * hash) + getFlush().hashCode(); + break; case 0: default: } @@ -3181,6 +3258,13 @@ public io.greptime.v1.flow.Server.FlowRequest buildPartial() { result.body_ = dropBuilder_.build(); } } + if (bodyCase_ == 3) { + if (flushBuilder_ == null) { + result.body_ = body_; + } else { + result.body_ = flushBuilder_.build(); + } + } result.bodyCase_ = bodyCase_; onBuilt(); return result; @@ -3242,6 +3326,10 @@ public Builder mergeFrom(io.greptime.v1.flow.Server.FlowRequest other) { mergeDrop(other.getDrop()); break; } + case FLUSH: { + mergeFlush(other.getFlush()); + break; + } case BODY_NOT_SET: { break; } @@ -3692,6 +3780,148 @@ public io.greptime.v1.flow.Server.DropRequestOrBuilder getDropOrBuilder() { onChanged();; return dropBuilder_; } + + private com.google.protobuf.SingleFieldBuilderV3< + io.greptime.v1.flow.Server.FlushFlow, io.greptime.v1.flow.Server.FlushFlow.Builder, io.greptime.v1.flow.Server.FlushFlowOrBuilder> flushBuilder_; + /** + * .greptime.v1.flow.FlushFlow flush = 3; + * @return Whether the flush field is set. + */ + @java.lang.Override + public boolean hasFlush() { + return bodyCase_ == 3; + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + * @return The flush. + */ + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlow getFlush() { + if (flushBuilder_ == null) { + if (bodyCase_ == 3) { + return (io.greptime.v1.flow.Server.FlushFlow) body_; + } + return io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } else { + if (bodyCase_ == 3) { + return flushBuilder_.getMessage(); + } + return io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + public Builder setFlush(io.greptime.v1.flow.Server.FlushFlow value) { + if (flushBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + body_ = value; + onChanged(); + } else { + flushBuilder_.setMessage(value); + } + bodyCase_ = 3; + return this; + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + public Builder setFlush( + io.greptime.v1.flow.Server.FlushFlow.Builder builderForValue) { + if (flushBuilder_ == null) { + body_ = builderForValue.build(); + onChanged(); + } else { + flushBuilder_.setMessage(builderForValue.build()); + } + bodyCase_ = 3; + return this; + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + public Builder mergeFlush(io.greptime.v1.flow.Server.FlushFlow value) { + if (flushBuilder_ == null) { + if (bodyCase_ == 3 && + body_ != io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance()) { + body_ = io.greptime.v1.flow.Server.FlushFlow.newBuilder((io.greptime.v1.flow.Server.FlushFlow) body_) + .mergeFrom(value).buildPartial(); + } else { + body_ = value; + } + onChanged(); + } else { + if (bodyCase_ == 3) { + flushBuilder_.mergeFrom(value); + } else { + flushBuilder_.setMessage(value); + } + } + bodyCase_ = 3; + return this; + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + public Builder clearFlush() { + if (flushBuilder_ == null) { + if (bodyCase_ == 3) { + bodyCase_ = 0; + body_ = null; + onChanged(); + } + } else { + if (bodyCase_ == 3) { + bodyCase_ = 0; + body_ = null; + } + flushBuilder_.clear(); + } + return this; + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + public io.greptime.v1.flow.Server.FlushFlow.Builder getFlushBuilder() { + return getFlushFieldBuilder().getBuilder(); + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlowOrBuilder getFlushOrBuilder() { + if ((bodyCase_ == 3) && (flushBuilder_ != null)) { + return flushBuilder_.getMessageOrBuilder(); + } else { + if (bodyCase_ == 3) { + return (io.greptime.v1.flow.Server.FlushFlow) body_; + } + return io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } + } + /** + * .greptime.v1.flow.FlushFlow flush = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.greptime.v1.flow.Server.FlushFlow, io.greptime.v1.flow.Server.FlushFlow.Builder, io.greptime.v1.flow.Server.FlushFlowOrBuilder> + getFlushFieldBuilder() { + if (flushBuilder_ == null) { + if (!(bodyCase_ == 3)) { + body_ = io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } + flushBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.greptime.v1.flow.Server.FlushFlow, io.greptime.v1.flow.Server.FlushFlow.Builder, io.greptime.v1.flow.Server.FlushFlowOrBuilder>( + (io.greptime.v1.flow.Server.FlushFlow) body_, + getParentForChildren(), + isClean()); + body_ = null; + } + bodyCase_ = 3; + onChanged();; + return flushBuilder_; + } @java.lang.Override public final Builder setUnknownFields( final com.google.protobuf.UnknownFieldSet unknownFields) { @@ -8040,157 +8270,787 @@ public io.greptime.v1.flow.Server.DropRequest getDefaultInstanceForType() { } - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_FlowRequestHeader_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_FlowRequestHeader_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_InsertRequests_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_InsertRequests_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_InsertRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_InsertRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_FlowRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_FlowRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_FlowResponse_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_FlowResponse_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_CreateRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_CreateRequest_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_CreateRequest_FlowOptionsEntry_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_CreateRequest_FlowOptionsEntry_fieldAccessorTable; - private static final com.google.protobuf.Descriptors.Descriptor - internal_static_greptime_v1_flow_DropRequest_descriptor; - private static final - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable - internal_static_greptime_v1_flow_DropRequest_fieldAccessorTable; + public interface FlushFlowOrBuilder extends + // @@protoc_insertion_point(interface_extends:greptime.v1.flow.FlushFlow) + com.google.protobuf.MessageOrBuilder { - public static com.google.protobuf.Descriptors.FileDescriptor - getDescriptor() { - return descriptor; + /** + * .greptime.v1.FlowId flow_id = 1; + * @return Whether the flowId field is set. + */ + boolean hasFlowId(); + /** + * .greptime.v1.FlowId flow_id = 1; + * @return The flowId. + */ + io.greptime.v1.Ddl.FlowId getFlowId(); + /** + * .greptime.v1.FlowId flow_id = 1; + */ + io.greptime.v1.Ddl.FlowIdOrBuilder getFlowIdOrBuilder(); } - private static com.google.protobuf.Descriptors.FileDescriptor - descriptor; - static { - java.lang.String[] descriptorData = { - "\n\035greptime/v1/flow/server.proto\022\020greptim" + - "e.v1.flow\032\030greptime/v1/common.proto\032\025gre" + - "ptime/v1/ddl.proto\032\025greptime/v1/row.prot" + - "o\"\316\001\n\021FlowRequestHeader\022P\n\017tracing_conte" + - "xt\030\001 \003(\01327.greptime.v1.flow.FlowRequestH" + - "eader.TracingContextEntry\0220\n\rquery_conte" + - "xt\030\002 \001(\0132\031.greptime.v1.QueryContext\0325\n\023T" + - "racingContextEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value" + - "\030\002 \001(\t:\0028\001\"C\n\016InsertRequests\0221\n\010requests" + - "\030\001 \003(\0132\037.greptime.v1.flow.InsertRequest\"" + - "C\n\rInsertRequest\022\021\n\tregion_id\030\001 \001(\004\022\037\n\004r" + - "ows\030\002 \001(\0132\021.greptime.v1.Rows\"\254\001\n\013FlowReq" + - "uest\0223\n\006header\030@ \001(\0132#.greptime.v1.flow." + - "FlowRequestHeader\0221\n\006create\030\001 \001(\0132\037.grep" + - "time.v1.flow.CreateRequestH\000\022-\n\004drop\030\002 \001" + - "(\0132\035.greptime.v1.flow.DropRequestH\000B\006\n\004b" + - "ody\"\363\001\n\014FlowResponse\022+\n\006header\030\001 \001(\0132\033.g" + - "reptime.v1.ResponseHeader\022\025\n\raffected_ro" + - "ws\030\002 \001(\004\022+\n\016affected_flows\030\003 \003(\0132\023.grept" + - "ime.v1.FlowId\022@\n\textension\030\004 \003(\0132-.grept" + - "ime.v1.flow.FlowResponse.ExtensionEntry\032" + - "0\n\016ExtensionEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030" + - "\002 \001(\014:\0028\001\"\376\002\n\rCreateRequest\022$\n\007flow_id\030\001" + - " \001(\0132\023.greptime.v1.FlowId\022.\n\020source_tabl" + - "e_ids\030\002 \003(\0132\024.greptime.v1.TableId\022/\n\017sin" + - "k_table_name\030\003 \001(\0132\026.greptime.v1.TableNa" + - "me\022\034\n\024create_if_not_exists\030\004 \001(\010\022.\n\014expi" + - "re_after\030\005 \001(\0132\030.greptime.v1.ExpireAfter" + - "\022\017\n\007comment\030\006 \001(\t\022\013\n\003sql\030\007 \001(\t\022F\n\014flow_o" + - "ptions\030\010 \003(\01320.greptime.v1.flow.CreateRe" + - "quest.FlowOptionsEntry\0322\n\020FlowOptionsEnt" + - "ry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t:\0028\001\"3\n\013Dr" + - "opRequest\022$\n\007flow_id\030\001 \001(\0132\023.greptime.v1" + - ".FlowId2\264\001\n\004Flow\022S\n\022HandleCreateRemove\022\035" + - ".greptime.v1.flow.FlowRequest\032\036.greptime" + - ".v1.flow.FlowResponse\022W\n\023HandleMirrorReq" + - "uest\022 .greptime.v1.flow.InsertRequests\032\036" + - ".greptime.v1.flow.FlowResponseBY\n\023io.gre" + - "ptime.v1.flowB\006ServerZ:github.com/Grepti" + - "meTeam/greptime-proto/go/greptime/v1/flo" + - "wb\006proto3" - }; - descriptor = com.google.protobuf.Descriptors.FileDescriptor - .internalBuildGeneratedFileFrom(descriptorData, - new com.google.protobuf.Descriptors.FileDescriptor[] { - io.greptime.v1.Common.getDescriptor(), - io.greptime.v1.Ddl.getDescriptor(), - io.greptime.v1.RowData.getDescriptor(), - }); - internal_static_greptime_v1_flow_FlowRequestHeader_descriptor = - getDescriptor().getMessageTypes().get(0); - internal_static_greptime_v1_flow_FlowRequestHeader_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_FlowRequestHeader_descriptor, - new java.lang.String[] { "TracingContext", "QueryContext", }); - internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_descriptor = - internal_static_greptime_v1_flow_FlowRequestHeader_descriptor.getNestedTypes().get(0); - internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_descriptor, - new java.lang.String[] { "Key", "Value", }); - internal_static_greptime_v1_flow_InsertRequests_descriptor = - getDescriptor().getMessageTypes().get(1); - internal_static_greptime_v1_flow_InsertRequests_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_InsertRequests_descriptor, - new java.lang.String[] { "Requests", }); - internal_static_greptime_v1_flow_InsertRequest_descriptor = - getDescriptor().getMessageTypes().get(2); - internal_static_greptime_v1_flow_InsertRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_InsertRequest_descriptor, - new java.lang.String[] { "RegionId", "Rows", }); - internal_static_greptime_v1_flow_FlowRequest_descriptor = - getDescriptor().getMessageTypes().get(3); - internal_static_greptime_v1_flow_FlowRequest_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_FlowRequest_descriptor, - new java.lang.String[] { "Header", "Create", "Drop", "Body", }); - internal_static_greptime_v1_flow_FlowResponse_descriptor = - getDescriptor().getMessageTypes().get(4); - internal_static_greptime_v1_flow_FlowResponse_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_FlowResponse_descriptor, - new java.lang.String[] { "Header", "AffectedRows", "AffectedFlows", "Extension", }); - internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_descriptor = - internal_static_greptime_v1_flow_FlowResponse_descriptor.getNestedTypes().get(0); - internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_fieldAccessorTable = new - com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( - internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_descriptor, - new java.lang.String[] { "Key", "Value", }); - internal_static_greptime_v1_flow_CreateRequest_descriptor = + /** + * Protobuf type {@code greptime.v1.flow.FlushFlow} + */ + public static final class FlushFlow extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:greptime.v1.flow.FlushFlow) + FlushFlowOrBuilder { + private static final long serialVersionUID = 0L; + // Use FlushFlow.newBuilder() to construct. + private FlushFlow(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FlushFlow() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FlushFlow(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FlushFlow( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + io.greptime.v1.Ddl.FlowId.Builder subBuilder = null; + if (flowId_ != null) { + subBuilder = flowId_.toBuilder(); + } + flowId_ = input.readMessage(io.greptime.v1.Ddl.FlowId.parser(), extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(flowId_); + flowId_ = subBuilder.buildPartial(); + } + + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.greptime.v1.flow.Server.internal_static_greptime_v1_flow_FlushFlow_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.greptime.v1.flow.Server.internal_static_greptime_v1_flow_FlushFlow_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.greptime.v1.flow.Server.FlushFlow.class, io.greptime.v1.flow.Server.FlushFlow.Builder.class); + } + + public static final int FLOW_ID_FIELD_NUMBER = 1; + private io.greptime.v1.Ddl.FlowId flowId_; + /** + * .greptime.v1.FlowId flow_id = 1; + * @return Whether the flowId field is set. + */ + @java.lang.Override + public boolean hasFlowId() { + return flowId_ != null; + } + /** + * .greptime.v1.FlowId flow_id = 1; + * @return The flowId. + */ + @java.lang.Override + public io.greptime.v1.Ddl.FlowId getFlowId() { + return flowId_ == null ? io.greptime.v1.Ddl.FlowId.getDefaultInstance() : flowId_; + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + @java.lang.Override + public io.greptime.v1.Ddl.FlowIdOrBuilder getFlowIdOrBuilder() { + return getFlowId(); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (flowId_ != null) { + output.writeMessage(1, getFlowId()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (flowId_ != null) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getFlowId()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof io.greptime.v1.flow.Server.FlushFlow)) { + return super.equals(obj); + } + io.greptime.v1.flow.Server.FlushFlow other = (io.greptime.v1.flow.Server.FlushFlow) obj; + + if (hasFlowId() != other.hasFlowId()) return false; + if (hasFlowId()) { + if (!getFlowId() + .equals(other.getFlowId())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasFlowId()) { + hash = (37 * hash) + FLOW_ID_FIELD_NUMBER; + hash = (53 * hash) + getFlowId().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static io.greptime.v1.flow.Server.FlushFlow parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static io.greptime.v1.flow.Server.FlushFlow parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static io.greptime.v1.flow.Server.FlushFlow parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(io.greptime.v1.flow.Server.FlushFlow prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code greptime.v1.flow.FlushFlow} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:greptime.v1.flow.FlushFlow) + io.greptime.v1.flow.Server.FlushFlowOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return io.greptime.v1.flow.Server.internal_static_greptime_v1_flow_FlushFlow_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return io.greptime.v1.flow.Server.internal_static_greptime_v1_flow_FlushFlow_fieldAccessorTable + .ensureFieldAccessorsInitialized( + io.greptime.v1.flow.Server.FlushFlow.class, io.greptime.v1.flow.Server.FlushFlow.Builder.class); + } + + // Construct using io.greptime.v1.flow.Server.FlushFlow.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (flowIdBuilder_ == null) { + flowId_ = null; + } else { + flowId_ = null; + flowIdBuilder_ = null; + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return io.greptime.v1.flow.Server.internal_static_greptime_v1_flow_FlushFlow_descriptor; + } + + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlow getDefaultInstanceForType() { + return io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance(); + } + + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlow build() { + io.greptime.v1.flow.Server.FlushFlow result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlow buildPartial() { + io.greptime.v1.flow.Server.FlushFlow result = new io.greptime.v1.flow.Server.FlushFlow(this); + if (flowIdBuilder_ == null) { + result.flowId_ = flowId_; + } else { + result.flowId_ = flowIdBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof io.greptime.v1.flow.Server.FlushFlow) { + return mergeFrom((io.greptime.v1.flow.Server.FlushFlow)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(io.greptime.v1.flow.Server.FlushFlow other) { + if (other == io.greptime.v1.flow.Server.FlushFlow.getDefaultInstance()) return this; + if (other.hasFlowId()) { + mergeFlowId(other.getFlowId()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + io.greptime.v1.flow.Server.FlushFlow parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (io.greptime.v1.flow.Server.FlushFlow) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + + private io.greptime.v1.Ddl.FlowId flowId_; + private com.google.protobuf.SingleFieldBuilderV3< + io.greptime.v1.Ddl.FlowId, io.greptime.v1.Ddl.FlowId.Builder, io.greptime.v1.Ddl.FlowIdOrBuilder> flowIdBuilder_; + /** + * .greptime.v1.FlowId flow_id = 1; + * @return Whether the flowId field is set. + */ + public boolean hasFlowId() { + return flowIdBuilder_ != null || flowId_ != null; + } + /** + * .greptime.v1.FlowId flow_id = 1; + * @return The flowId. + */ + public io.greptime.v1.Ddl.FlowId getFlowId() { + if (flowIdBuilder_ == null) { + return flowId_ == null ? io.greptime.v1.Ddl.FlowId.getDefaultInstance() : flowId_; + } else { + return flowIdBuilder_.getMessage(); + } + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + public Builder setFlowId(io.greptime.v1.Ddl.FlowId value) { + if (flowIdBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + flowId_ = value; + onChanged(); + } else { + flowIdBuilder_.setMessage(value); + } + + return this; + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + public Builder setFlowId( + io.greptime.v1.Ddl.FlowId.Builder builderForValue) { + if (flowIdBuilder_ == null) { + flowId_ = builderForValue.build(); + onChanged(); + } else { + flowIdBuilder_.setMessage(builderForValue.build()); + } + + return this; + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + public Builder mergeFlowId(io.greptime.v1.Ddl.FlowId value) { + if (flowIdBuilder_ == null) { + if (flowId_ != null) { + flowId_ = + io.greptime.v1.Ddl.FlowId.newBuilder(flowId_).mergeFrom(value).buildPartial(); + } else { + flowId_ = value; + } + onChanged(); + } else { + flowIdBuilder_.mergeFrom(value); + } + + return this; + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + public Builder clearFlowId() { + if (flowIdBuilder_ == null) { + flowId_ = null; + onChanged(); + } else { + flowId_ = null; + flowIdBuilder_ = null; + } + + return this; + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + public io.greptime.v1.Ddl.FlowId.Builder getFlowIdBuilder() { + + onChanged(); + return getFlowIdFieldBuilder().getBuilder(); + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + public io.greptime.v1.Ddl.FlowIdOrBuilder getFlowIdOrBuilder() { + if (flowIdBuilder_ != null) { + return flowIdBuilder_.getMessageOrBuilder(); + } else { + return flowId_ == null ? + io.greptime.v1.Ddl.FlowId.getDefaultInstance() : flowId_; + } + } + /** + * .greptime.v1.FlowId flow_id = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + io.greptime.v1.Ddl.FlowId, io.greptime.v1.Ddl.FlowId.Builder, io.greptime.v1.Ddl.FlowIdOrBuilder> + getFlowIdFieldBuilder() { + if (flowIdBuilder_ == null) { + flowIdBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + io.greptime.v1.Ddl.FlowId, io.greptime.v1.Ddl.FlowId.Builder, io.greptime.v1.Ddl.FlowIdOrBuilder>( + getFlowId(), + getParentForChildren(), + isClean()); + flowId_ = null; + } + return flowIdBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:greptime.v1.flow.FlushFlow) + } + + // @@protoc_insertion_point(class_scope:greptime.v1.flow.FlushFlow) + private static final io.greptime.v1.flow.Server.FlushFlow DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new io.greptime.v1.flow.Server.FlushFlow(); + } + + public static io.greptime.v1.flow.Server.FlushFlow getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FlushFlow parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FlushFlow(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public io.greptime.v1.flow.Server.FlushFlow getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_FlowRequestHeader_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_FlowRequestHeader_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_InsertRequests_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_InsertRequests_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_InsertRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_InsertRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_FlowRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_FlowRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_FlowResponse_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_FlowResponse_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_CreateRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_CreateRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_CreateRequest_FlowOptionsEntry_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_CreateRequest_FlowOptionsEntry_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_DropRequest_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_DropRequest_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_greptime_v1_flow_FlushFlow_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_greptime_v1_flow_FlushFlow_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\035greptime/v1/flow/server.proto\022\020greptim" + + "e.v1.flow\032\030greptime/v1/common.proto\032\025gre" + + "ptime/v1/ddl.proto\032\025greptime/v1/row.prot" + + "o\"\316\001\n\021FlowRequestHeader\022P\n\017tracing_conte" + + "xt\030\001 \003(\01327.greptime.v1.flow.FlowRequestH" + + "eader.TracingContextEntry\0220\n\rquery_conte" + + "xt\030\002 \001(\0132\031.greptime.v1.QueryContext\0325\n\023T" + + "racingContextEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value" + + "\030\002 \001(\t:\0028\001\"C\n\016InsertRequests\0221\n\010requests" + + "\030\001 \003(\0132\037.greptime.v1.flow.InsertRequest\"" + + "C\n\rInsertRequest\022\021\n\tregion_id\030\001 \001(\004\022\037\n\004r" + + "ows\030\002 \001(\0132\021.greptime.v1.Rows\"\332\001\n\013FlowReq" + + "uest\0223\n\006header\030@ \001(\0132#.greptime.v1.flow." + + "FlowRequestHeader\0221\n\006create\030\001 \001(\0132\037.grep" + + "time.v1.flow.CreateRequestH\000\022-\n\004drop\030\002 \001" + + "(\0132\035.greptime.v1.flow.DropRequestH\000\022,\n\005f" + + "lush\030\003 \001(\0132\033.greptime.v1.flow.FlushFlowH" + + "\000B\006\n\004body\"\363\001\n\014FlowResponse\022+\n\006header\030\001 \001" + + "(\0132\033.greptime.v1.ResponseHeader\022\025\n\raffec" + + "ted_rows\030\002 \001(\004\022+\n\016affected_flows\030\003 \003(\0132\023" + + ".greptime.v1.FlowId\022@\n\textension\030\004 \003(\0132-" + + ".greptime.v1.flow.FlowResponse.Extension" + + "Entry\0320\n\016ExtensionEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005" + + "value\030\002 \001(\014:\0028\001\"\376\002\n\rCreateRequest\022$\n\007flo" + + "w_id\030\001 \001(\0132\023.greptime.v1.FlowId\022.\n\020sourc" + + "e_table_ids\030\002 \003(\0132\024.greptime.v1.TableId\022" + + "/\n\017sink_table_name\030\003 \001(\0132\026.greptime.v1.T" + + "ableName\022\034\n\024create_if_not_exists\030\004 \001(\010\022." + + "\n\014expire_after\030\005 \001(\0132\030.greptime.v1.Expir" + + "eAfter\022\017\n\007comment\030\006 \001(\t\022\013\n\003sql\030\007 \001(\t\022F\n\014" + + "flow_options\030\010 \003(\01320.greptime.v1.flow.Cr" + + "eateRequest.FlowOptionsEntry\0322\n\020FlowOpti" + + "onsEntry\022\013\n\003key\030\001 \001(\t\022\r\n\005value\030\002 \001(\t:\0028\001" + + "\"3\n\013DropRequest\022$\n\007flow_id\030\001 \001(\0132\023.grept" + + "ime.v1.FlowId\"1\n\tFlushFlow\022$\n\007flow_id\030\001 " + + "\001(\0132\023.greptime.v1.FlowId2\264\001\n\004Flow\022S\n\022Han" + + "dleCreateRemove\022\035.greptime.v1.flow.FlowR" + + "equest\032\036.greptime.v1.flow.FlowResponse\022W" + + "\n\023HandleMirrorRequest\022 .greptime.v1.flow" + + ".InsertRequests\032\036.greptime.v1.flow.FlowR" + + "esponseBY\n\023io.greptime.v1.flowB\006ServerZ:" + + "github.com/GreptimeTeam/greptime-proto/g" + + "o/greptime/v1/flowb\006proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + io.greptime.v1.Common.getDescriptor(), + io.greptime.v1.Ddl.getDescriptor(), + io.greptime.v1.RowData.getDescriptor(), + }); + internal_static_greptime_v1_flow_FlowRequestHeader_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_greptime_v1_flow_FlowRequestHeader_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_FlowRequestHeader_descriptor, + new java.lang.String[] { "TracingContext", "QueryContext", }); + internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_descriptor = + internal_static_greptime_v1_flow_FlowRequestHeader_descriptor.getNestedTypes().get(0); + internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_FlowRequestHeader_TracingContextEntry_descriptor, + new java.lang.String[] { "Key", "Value", }); + internal_static_greptime_v1_flow_InsertRequests_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_greptime_v1_flow_InsertRequests_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_InsertRequests_descriptor, + new java.lang.String[] { "Requests", }); + internal_static_greptime_v1_flow_InsertRequest_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_greptime_v1_flow_InsertRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_InsertRequest_descriptor, + new java.lang.String[] { "RegionId", "Rows", }); + internal_static_greptime_v1_flow_FlowRequest_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_greptime_v1_flow_FlowRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_FlowRequest_descriptor, + new java.lang.String[] { "Header", "Create", "Drop", "Flush", "Body", }); + internal_static_greptime_v1_flow_FlowResponse_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_greptime_v1_flow_FlowResponse_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_FlowResponse_descriptor, + new java.lang.String[] { "Header", "AffectedRows", "AffectedFlows", "Extension", }); + internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_descriptor = + internal_static_greptime_v1_flow_FlowResponse_descriptor.getNestedTypes().get(0); + internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_FlowResponse_ExtensionEntry_descriptor, + new java.lang.String[] { "Key", "Value", }); + internal_static_greptime_v1_flow_CreateRequest_descriptor = getDescriptor().getMessageTypes().get(5); internal_static_greptime_v1_flow_CreateRequest_fieldAccessorTable = new com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( @@ -8208,6 +9068,12 @@ public io.greptime.v1.flow.Server.DropRequest getDefaultInstanceForType() { com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( internal_static_greptime_v1_flow_DropRequest_descriptor, new java.lang.String[] { "FlowId", }); + internal_static_greptime_v1_flow_FlushFlow_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_greptime_v1_flow_FlushFlow_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_greptime_v1_flow_FlushFlow_descriptor, + new java.lang.String[] { "FlowId", }); io.greptime.v1.Common.getDescriptor(); io.greptime.v1.Ddl.getDescriptor(); io.greptime.v1.RowData.getDescriptor(); diff --git a/proto/greptime/v1/flow/server.proto b/proto/greptime/v1/flow/server.proto index 7ac3a13b..27734699 100644 --- a/proto/greptime/v1/flow/server.proto +++ b/proto/greptime/v1/flow/server.proto @@ -53,6 +53,7 @@ message FlowRequest { oneof body { CreateRequest create = 1; DropRequest drop = 2; + FlushFlow flush = 3; } } @@ -81,3 +82,7 @@ message CreateRequest { } message DropRequest { FlowId flow_id = 1; } + +message FlushFlow { + FlowId flow_id = 1; +}