From fc876639cfcb9ea3c797522aa21d696a5578501d Mon Sep 17 00:00:00 2001 From: zhagnlu <1542303831@qq.com> Date: Mon, 1 Sep 2025 10:49:52 +0800 Subject: [PATCH] enhance: support json stats with shredding design (#42534) #42533 Co-authored-by: luzhang --- configs/milvus.yaml | 7 +- internal/core/conanfile.py | 1 + internal/core/src/common/ChunkWriter.cpp | 3 +- internal/core/src/common/Common.cpp | 9 - internal/core/src/common/Common.h | 4 - internal/core/src/common/Consts.h | 14 +- internal/core/src/common/ScopedTimer.h | 75 + internal/core/src/common/Types.h | 1 - internal/core/src/common/bson_view.h | 537 ++ internal/core/src/common/init_c.cpp | 5 - internal/core/src/common/init_c.h | 3 - internal/core/src/exec/QueryContext.h | 11 +- .../src/exec/expression/BinaryRangeExpr.cpp | 397 +- .../src/exec/expression/BinaryRangeExpr.h | 2 +- internal/core/src/exec/expression/Element.h | 31 +- .../core/src/exec/expression/ExistsExpr.cpp | 64 +- .../core/src/exec/expression/ExistsExpr.h | 2 +- internal/core/src/exec/expression/Expr.h | 37 +- .../src/exec/expression/JsonContainsExpr.cpp | 1051 ++-- .../src/exec/expression/JsonContainsExpr.h | 429 +- .../core/src/exec/expression/TermExpr.cpp | 275 +- internal/core/src/exec/expression/TermExpr.h | 4 +- .../core/src/exec/expression/UnaryExpr.cpp | 752 +-- internal/core/src/exec/expression/UnaryExpr.h | 353 +- internal/core/src/exec/expression/Utils.h | 90 +- internal/core/src/index/IndexStats.h | 5 + .../core/src/index/InvertedIndexTantivy.h | 2 +- .../src/index/JsonKeyStatsInvertedIndex.cpp | 539 -- .../src/index/JsonKeyStatsInvertedIndex.h | 353 -- internal/core/src/index/Meta.h | 1 + internal/core/src/index/ScalarIndex.h | 1 + internal/core/src/index/Utils.h | 5 + .../src/index/json_stats/JsonKeyStats.cpp | 1015 ++++ .../core/src/index/json_stats/JsonKeyStats.h | 672 +++ .../src/index/json_stats/bson_builder.cpp | 328 ++ .../core/src/index/json_stats/bson_builder.h | 97 + .../src/index/json_stats/bson_inverted.cpp | 222 + .../core/src/index/json_stats/bson_inverted.h | 95 + .../src/index/json_stats/parquet_writer.cpp | 260 + .../src/index/json_stats/parquet_writer.h | 244 + internal/core/src/index/json_stats/utils.cpp | 221 + internal/core/src/index/json_stats/utils.h | 520 ++ internal/core/src/indexbuilder/index_c.cpp | 16 +- internal/core/src/mmap/ChunkedColumn.h | 24 + internal/core/src/mmap/ChunkedColumnGroup.h | 31 + .../core/src/mmap/ChunkedColumnInterface.h | 28 +- internal/core/src/monitor/Monitor.cpp | 24 + internal/core/src/monitor/Monitor.h | 7 + internal/core/src/plan/PlanNode.h | 3 +- .../core/src/query/ExecPlanNodeVisitor.cpp | 7 +- internal/core/src/query/PlanNode.h | 7 + internal/core/src/query/PlanProto.cpp | 15 + internal/core/src/query/PlanProto.h | 4 + .../src/segcore/ChunkedSegmentSealedImpl.h | 27 +- .../core/src/segcore/SegmentGrowingImpl.cpp | 74 - .../core/src/segcore/SegmentGrowingImpl.h | 14 - .../core/src/segcore/SegmentInterface.cpp | 20 +- internal/core/src/segcore/SegmentInterface.h | 18 +- internal/core/src/segcore/SegmentSealed.h | 11 +- internal/core/src/segcore/Utils.cpp | 54 + internal/core/src/segcore/Utils.h | 4 + internal/core/src/segcore/segment_c.cpp | 29 +- .../GroupChunkTranslator.cpp | 1 + .../core/src/storage/DiskFileManagerImpl.cpp | 131 +- .../core/src/storage/DiskFileManagerImpl.h | 40 +- internal/core/src/storage/LocalChunkManager.h | 10 +- internal/core/src/storage/MinioChunkManager.h | 1 + internal/core/src/storage/Util.cpp | 92 +- internal/core/src/storage/Util.h | 37 +- .../GcpNativeChunkManager.h | 2 +- .../src/storage/opendal/OpenDALChunkManager.h | 4 +- internal/core/unittest/CMakeLists.txt | 2 +- internal/core/unittest/test_c_api.cpp | 35 + .../unittest/test_disk_file_manager_test.cpp | 14 +- internal/core/unittest/test_exec.cpp | 3 + .../unittest/test_json_key_stats_index.cpp | 640 --- .../unittest/test_json_stats/CMakeLists.txt | 32 + .../test_json_stats/test_bson_builder.cpp | 476 ++ .../test_json_stats/test_bson_view.cpp | 313 ++ .../test_json_stats/test_json_key_stats.cpp | 562 +++ .../test_json_stats/test_parquet_writer.cpp | 108 + .../unittest/test_json_stats/test_utils.cpp | 70 + .../unittest/test_string_chunk_writer.cpp | 125 + internal/datacoord/garbage_collector.go | 101 +- internal/datacoord/stats_inspector.go | 6 + internal/datacoord/task_stats.go | 17 +- internal/datanode/index/task_manager_test.go | 3 +- internal/datanode/index/task_stats.go | 69 +- internal/datanode/index/task_stats_test.go | 8 +- .../parser/planparserv2/plan_parser_v2.go | 29 + .../querycoordv2/checkers/index_checker.go | 13 +- internal/querycoordv2/dist/dist_handler.go | 2 +- .../querycoordv2/meta/segment_dist_manager.go | 2 +- .../querynodev2/segments/load_index_info.go | 20 - internal/querynodev2/segments/mock_segment.go | 8 +- internal/querynodev2/segments/segment.go | 38 +- .../querynodev2/segments/segment_interface.go | 2 +- internal/querynodev2/segments/segment_l0.go | 2 +- internal/querynodev2/server.go | 4 +- internal/querynodev2/services.go | 2 +- internal/util/initcore/init_core.go | 9 - internal/util/initcore/util.go | 4 - pkg/common/common.go | 12 + pkg/proto/index_cgo_msg.proto | 4 + pkg/proto/indexcgopb/index_cgo_msg.pb.go | 158 +- pkg/proto/plan.proto | 5 + pkg/proto/planpb/plan.pb.go | 229 +- pkg/proto/query_coord.proto | 9 + pkg/proto/querypb/query_coord.pb.go | 4362 +++++++++-------- pkg/proto/worker.proto | 3 + pkg/proto/workerpb/worker.pb.go | 490 +- pkg/util/paramtable/component_param.go | 75 +- scripts/3rdparty_build.sh | 5 + scripts/run_cpp_unittest.sh | 7 + scripts/setenv.sh | 6 +- 115 files changed, 11569 insertions(+), 5987 deletions(-) create mode 100644 internal/core/src/common/ScopedTimer.h create mode 100644 internal/core/src/common/bson_view.h delete mode 100644 internal/core/src/index/JsonKeyStatsInvertedIndex.cpp delete mode 100644 internal/core/src/index/JsonKeyStatsInvertedIndex.h create mode 100644 internal/core/src/index/json_stats/JsonKeyStats.cpp create mode 100644 internal/core/src/index/json_stats/JsonKeyStats.h create mode 100644 internal/core/src/index/json_stats/bson_builder.cpp create mode 100644 internal/core/src/index/json_stats/bson_builder.h create mode 100644 internal/core/src/index/json_stats/bson_inverted.cpp create mode 100644 internal/core/src/index/json_stats/bson_inverted.h create mode 100644 internal/core/src/index/json_stats/parquet_writer.cpp create mode 100644 internal/core/src/index/json_stats/parquet_writer.h create mode 100644 internal/core/src/index/json_stats/utils.cpp create mode 100644 internal/core/src/index/json_stats/utils.h delete mode 100644 internal/core/unittest/test_json_key_stats_index.cpp create mode 100644 internal/core/unittest/test_json_stats/CMakeLists.txt create mode 100644 internal/core/unittest/test_json_stats/test_bson_builder.cpp create mode 100644 internal/core/unittest/test_json_stats/test_bson_view.cpp create mode 100644 internal/core/unittest/test_json_stats/test_json_key_stats.cpp create mode 100644 internal/core/unittest/test_json_stats/test_parquet_writer.cpp create mode 100644 internal/core/unittest/test_json_stats/test_utils.cpp create mode 100644 internal/core/unittest/test_string_chunk_writer.cpp diff --git a/configs/milvus.yaml b/configs/milvus.yaml index 84496fc322..461f80d4de 100644 --- a/configs/milvus.yaml +++ b/configs/milvus.yaml @@ -501,7 +501,6 @@ queryNode: # If set to 0, time based eviction is disabled. cacheTtl: 0 knowhereScoreConsistency: false # Enable knowhere strong consistency score computation logic - jsonKeyStatsCommitInterval: 200 # the commit interval for the JSON key Stats to commit loadMemoryUsageFactor: 1 # The multiply factor of calculating the memory usage while loading segments enableDisk: false # enable querynode load disk index, and search on disk index maxDiskUsagePercentage: 95 @@ -513,6 +512,7 @@ queryNode: vectorIndex: false # Enable mmap for loading vector index scalarField: false # Enable mmap for loading scalar data scalarIndex: false # Enable mmap for loading scalar index + jsonStats: true # Enable mmap for loading json stats # Enable memory mapping (mmap) to optimize the handling of growing raw data. # By activating this feature, the memory overhead associated with newly added or modified data will be significantly minimized. # However, this optimization may come at the cost of a slight decrease in query latency for the affected data segments. @@ -732,7 +732,9 @@ dataCoord: analyzeTaskSlotUsage: 65535 # slot usage of analyze task jsonStatsTriggerCount: 10 # jsonkey stats task count per trigger jsonStatsTriggerInterval: 10 # jsonkey task interval per trigger - jsonKeyStatsMemoryBudgetInTantivy: 16777216 # the memory budget for the JSON index In Tantivy, the unit is bytes + jsonStatsMaxShreddingColumns: 1024 # the max number of columns to shred + jsonStatsShreddingRatioThreshold: 0.3 # the ratio threshold to shred + jsonStatsWriteBatchSize: 819200 # the batch size to write ip: # TCP/IP address of dataCoord. If not specified, use the first unicastable address port: 13333 # TCP port of dataCoord grpc: @@ -1017,6 +1019,7 @@ common: enabledGrowingSegmentJSONKeyStats: false # Indicates growingsegment whether to enable JSON key stats enableConfigParamTypeCheck: true # Indicates whether to enable config param type check enablePosixMode: false # Specifies whether to run in POSIX mode for enhanced file system compatibility + UsingJSONStatsForQuery: true # Indicates whether to use json stats when query # QuotaConfig, configurations of Milvus quota and limits. # By default, we enable: diff --git a/internal/core/conanfile.py b/internal/core/conanfile.py index 5b3f5ccf86..3bae826b86 100644 --- a/internal/core/conanfile.py +++ b/internal/core/conanfile.py @@ -48,6 +48,7 @@ class MilvusConan(ConanFile): "simde/0.8.2#5e1edfd5cba92f25d79bf6ef4616b972", "xxhash/0.8.3#199e63ab9800302c232d030b27accec0", "unordered_dense/4.4.0#6a855c992618cc4c63019109a2e47298", + "mongo-cxx-driver/3.11.0#ae206de0e90fb8cb2fb95465fb8b2f01" ) generators = ("cmake", "cmake_find_package") default_options = { diff --git a/internal/core/src/common/ChunkWriter.cpp b/internal/core/src/common/ChunkWriter.cpp index 2709884fae..ddcb1af977 100644 --- a/internal/core/src/common/ChunkWriter.cpp +++ b/internal/core/src/common/ChunkWriter.cpp @@ -38,7 +38,8 @@ StringChunkWriter::write(const arrow::ArrayVector& array_vec) { // tuple std::vector> null_bitmaps; for (const auto& data : array_vec) { - auto array = std::dynamic_pointer_cast(data); + // for bson, we use binary array to store the string + auto array = std::dynamic_pointer_cast(data); for (int i = 0; i < array->length(); i++) { auto str = array->GetView(i); strs.emplace_back(str); diff --git a/internal/core/src/common/Common.cpp b/internal/core/src/common/Common.cpp index 8013ea8e2d..66860046d0 100644 --- a/internal/core/src/common/Common.cpp +++ b/internal/core/src/common/Common.cpp @@ -25,8 +25,6 @@ std::atomic EXEC_EVAL_EXPR_BATCH_SIZE( DEFAULT_EXEC_EVAL_EXPR_BATCH_SIZE); std::atomic OPTIMIZE_EXPR_ENABLED(DEFAULT_OPTIMIZE_EXPR_ENABLED); -std::atomic JSON_KEY_STATS_COMMIT_INTERVAL( - DEFAULT_JSON_KEY_STATS_COMMIT_INTERVAL); std::atomic GROWING_JSON_KEY_STATS_ENABLED( DEFAULT_GROWING_JSON_KEY_STATS_ENABLED); std::atomic CONFIG_PARAM_TYPE_CHECK_ENABLED( @@ -52,13 +50,6 @@ SetDefaultOptimizeExprEnable(bool val) { OPTIMIZE_EXPR_ENABLED.load()); } -void -SetDefaultJSONKeyStatsCommitInterval(int64_t val) { - JSON_KEY_STATS_COMMIT_INTERVAL.store(val); - LOG_INFO("set default json key Stats commit interval: {}", - JSON_KEY_STATS_COMMIT_INTERVAL.load()); -} - void SetDefaultGrowingJSONKeyStatsEnable(bool val) { GROWING_JSON_KEY_STATS_ENABLED.store(val); diff --git a/internal/core/src/common/Common.h b/internal/core/src/common/Common.h index 8d99f06ce6..af8d9fb264 100644 --- a/internal/core/src/common/Common.h +++ b/internal/core/src/common/Common.h @@ -27,7 +27,6 @@ namespace milvus { extern std::atomic FILE_SLICE_SIZE; extern std::atomic EXEC_EVAL_EXPR_BATCH_SIZE; -extern std::atomic JSON_KEY_STATS_COMMIT_INTERVAL; extern std::atomic OPTIMIZE_EXPR_ENABLED; extern std::atomic GROWING_JSON_KEY_STATS_ENABLED; extern std::atomic CONFIG_PARAM_TYPE_CHECK_ENABLED; @@ -41,9 +40,6 @@ SetDefaultExecEvalExprBatchSize(int64_t val); void SetDefaultOptimizeExprEnable(bool val); -void -SetDefaultJSONKeyStatsCommitInterval(int64_t val); - void SetDefaultGrowingJSONKeyStatsEnable(bool val); diff --git a/internal/core/src/common/Consts.h b/internal/core/src/common/Consts.h index dfc80230ce..a97331fe3e 100644 --- a/internal/core/src/common/Consts.h +++ b/internal/core/src/common/Consts.h @@ -23,6 +23,7 @@ const int64_t INVALID_FIELD_ID = -1; const int64_t INVALID_SEG_OFFSET = -1; +const int64_t INVALID_ARRAY_INDEX = -1; const milvus::PkType INVALID_PK; // of std::monostate if not set. // TODO: default field start id, could get from config.yaml const int64_t START_USER_FIELDID = 100; @@ -51,8 +52,20 @@ const char PAGE_RETAIN_ORDER[] = "page_retain_order"; const char TEXT_LOG_ROOT_PATH[] = "text_log"; const char ITERATIVE_FILTER[] = "iterative_filter"; const char HINTS[] = "hints"; +// json stats related const char JSON_KEY_INDEX_LOG_ROOT_PATH[] = "json_key_index_log"; const char NGRAM_LOG_ROOT_PATH[] = "ngram_log"; +constexpr const char* JSON_STATS_ROOT_PATH = "json_stats"; +constexpr const char* JSON_STATS_DATA_FORMAT_VERSION = "2"; +constexpr const char* JSON_STATS_SHARED_INDEX_PATH = "shared_key_index"; +constexpr const char* JSON_STATS_SHREDDING_DATA_PATH = "shredding_data"; +constexpr const char* JSON_KEY_STATS_SHARED_FIELD_NAME = "__shared"; +// store key layout type in parquet file metadata +inline constexpr const char* JSON_STATS_META_KEY_LAYOUT_TYPE_MAP = + "key_layout_type_map"; +// start json stats field id for mock column +const int64_t START_JSON_STATS_FIELD_ID = 1000; +const int64_t END_JSON_STATS_FIELD_ID = 10000; const char DEFAULT_PLANNODE_ID[] = "0"; const char DEAFULT_QUERY_ID[] = "0"; @@ -84,7 +97,6 @@ const bool DEFAULT_OPTIMIZE_EXPR_ENABLED = true; const int64_t DEFAULT_CONVERT_OR_TO_IN_NUMERIC_LIMIT = 150; const int64_t DEFAULT_JSON_INDEX_MEMORY_BUDGET = 16777216; // bytes, 16MB const bool DEFAULT_GROWING_JSON_KEY_STATS_ENABLED = false; -const int64_t DEFAULT_JSON_KEY_STATS_COMMIT_INTERVAL = 200; const bool DEFAULT_CONFIG_PARAM_TYPE_CHECK_ENABLED = true; // index config related diff --git a/internal/core/src/common/ScopedTimer.h b/internal/core/src/common/ScopedTimer.h new file mode 100644 index 0000000000..d4659762a7 --- /dev/null +++ b/internal/core/src/common/ScopedTimer.h @@ -0,0 +1,75 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once +#include +#include +#include +#include +#include + +namespace milvus { + +class ScopedTimer { + public: + enum class LogLevel { + Trace, + Debug, + Info, + Warn, + Error, + }; + + ScopedTimer(std::string_view name, + std::function reporter, + LogLevel level = LogLevel::Debug) + : name_(name), + reporter_(std::move(reporter)), + start_(std::chrono::steady_clock::now()), + level_(level) { + } + + ~ScopedTimer() { + auto end = std::chrono::steady_clock::now(); + auto duration_us = + std::chrono::duration(end - start_).count(); + reporter_(duration_us / 1000.0); // report in milliseconds + switch (level_) { + case LogLevel::Trace: + LOG_TRACE("{} time: {} ms", name_, duration_us / 1000.0); + break; + case LogLevel::Debug: + LOG_DEBUG("{} time: {} ms", name_, duration_us / 1000.0); + break; + case LogLevel::Info: + LOG_INFO("{} time: {} ms", name_, duration_us / 1000.0); + break; + case LogLevel::Warn: + LOG_WARN("{} time: {} ms", name_, duration_us / 1000.0); + break; + case LogLevel::Error: + LOG_ERROR("{} time: {} ms", name_, duration_us / 1000.0); + break; + } + } + + private: + std::string name_; + std::function reporter_; + std::chrono::steady_clock::time_point start_; + LogLevel level_; +}; +} // namespace milvus diff --git a/internal/core/src/common/Types.h b/internal/core/src/common/Types.h index 0e667fc004..adb2d43963 100644 --- a/internal/core/src/common/Types.h +++ b/internal/core/src/common/Types.h @@ -24,7 +24,6 @@ #include #include #include -#include #include #include diff --git a/internal/core/src/common/bson_view.h b/internal/core/src/common/bson_view.h new file mode 100644 index 0000000000..050dcfa509 --- /dev/null +++ b/internal/core/src/common/bson_view.h @@ -0,0 +1,537 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "fmt/format.h" +#include "log/Log.h" +#include "common/EasyAssert.h" + +template <> +struct fmt::formatter : fmt::formatter { + auto + format(bsoncxx::type type, fmt::format_context& ctx) const { + std::string name; + switch (type) { + case bsoncxx::type::k_int32: + name = "int32"; + break; + case bsoncxx::type::k_int64: + name = "int64"; + break; + case bsoncxx::type::k_double: + name = "double"; + break; + case bsoncxx::type::k_string: + name = "string"; + break; + case bsoncxx::type::k_bool: + name = "bool"; + break; + case bsoncxx::type::k_null: + name = "null"; + break; + case bsoncxx::type::k_document: + name = "document"; + break; + case bsoncxx::type::k_array: + name = "array"; + break; + default: + name = "Unknown"; + } + return fmt::formatter::format(name, ctx); + } +}; + +namespace milvus { + +struct BsonRawField { + bsoncxx::type type; + std::string key; + const uint8_t* value_ptr; // points to value (not including type/key) +}; + +inline int32_t +ReadInt32(const uint8_t* ptr) { + return *reinterpret_cast(ptr); +} + +inline int64_t +ReadInt64(const uint8_t* ptr) { + return *reinterpret_cast(ptr); +} + +inline double +ReadDouble(const uint8_t* ptr) { + return *reinterpret_cast(ptr); +} + +inline std::string +ReadUtf8(const uint8_t* ptr) { + int32_t len = *reinterpret_cast(ptr); + return std::string(reinterpret_cast(ptr + 4), + len - 1); // exclude trailing '\0' +} + +inline std::string_view +ReadUtf8View(const uint8_t* ptr) { + int32_t len = *reinterpret_cast(ptr); + return std::string_view(reinterpret_cast(ptr + 4), + len - 1); // exclude trailing '\0' +} + +inline bool +ReadBool(const uint8_t* ptr) { + return *ptr != 0; +} + +inline std::vector +ReadRawDocOrArray(const uint8_t* ptr) { + int32_t len = *reinterpret_cast(ptr); + return std::vector(ptr, ptr + len); +} + +inline bsoncxx::document::view +ParseAsDocument(const uint8_t* ptr) { + int32_t len = *reinterpret_cast(ptr); + return bsoncxx::document::view(ptr, len); +} + +inline bsoncxx::array::view +ParseAsArray(const uint8_t* ptr) { + int32_t len = *reinterpret_cast(ptr); + return bsoncxx::array::view(ptr, len); +} + +template +T +GetValue(const uint8_t* ptr); + +template <> +inline int32_t +GetValue(const uint8_t* ptr) { + return ReadInt32(ptr); +} + +template <> +inline int64_t +GetValue(const uint8_t* ptr) { + return ReadInt64(ptr); +} + +template <> +inline double +GetValue(const uint8_t* ptr) { + return ReadDouble(ptr); +} + +template <> +inline bool +GetValue(const uint8_t* ptr) { + return ReadBool(ptr); +} + +template <> +inline std::string +GetValue(const uint8_t* ptr) { + return ReadUtf8(ptr); +} + +template <> +inline std::string_view +GetValue(const uint8_t* ptr) { + return ReadUtf8View(ptr); +} + +template <> +inline std::vector +GetValue>(const uint8_t* ptr) { + return ReadRawDocOrArray(ptr); +} + +inline std::string +BsonHexDebugString(const uint8_t* data, size_t size) { + std::ostringstream oss; + oss << "BSON hex dump (" << size << " bytes): "; + + for (size_t i = 0; i < size; ++i) { + oss << std::hex << std::setw(2) << std::setfill('0') + << static_cast(data[i]) << " "; + } + return oss.str(); +} + +// may lose precision for big int64_t more than 2^53 +inline bool +CanConvertToInt64(double x) { + return std::trunc(x) == x && x >= std::numeric_limits::min() && + x <= std::numeric_limits::max(); +} + +class BsonView { + public: + explicit BsonView(const std::vector& data) + : data_(data.data()), size_(data.size()) { + } + + explicit BsonView(const uint8_t* data, size_t size) + : data_(data), size_(size) { + } + + ~BsonView() { + } + + std::string + ToString() const { + bsoncxx::document::view view(data_, size_); + return bsoncxx::to_json(view); + } + + bool + IsNullAtOffset(size_t offset) { + const uint8_t* ptr = data_ + offset; + AssertInfo(offset < size_, "bson offset out of range"); + + auto type_tag = static_cast(*ptr++); + return type_tag == bsoncxx::type::k_null; + } + + template + std::optional + ParseAsValueAtOffset(size_t offset) { + LOG_TRACE("bson hex: {}", + BsonHexDebugString(data_ + offset, size_ - offset)); + const uint8_t* ptr = data_ + offset; + + // check offset + AssertInfo( + offset < size_, "bson offset:{} out of range:{}", offset, size_); + + // parse type tag + auto type_tag = static_cast(*ptr++); + + // parse key + const char* key_cstr = reinterpret_cast(ptr); + size_t key_len = strlen(key_cstr); + ptr += key_len + 1; // +1 for null terminator + + // parse value + switch (type_tag) { + case bsoncxx::type::k_int32: + if constexpr (std::is_same_v) { + return GetValue(ptr); + } + if constexpr (std::is_same_v) { + return static_cast(GetValue(ptr)); + } + break; + case bsoncxx::type::k_int64: + if constexpr (std::is_same_v) { + return GetValue(ptr); + } else if constexpr (std::is_same_v) { + return static_cast(GetValue(ptr)); + } + break; + case bsoncxx::type::k_double: + if constexpr (std::is_same_v) { + return GetValue(ptr); + } + // if constexpr (std::is_same_v) { + // if (CanConvertToInt64(GetValue(ptr))) { + // return static_cast(GetValue(ptr)); + // } + // } + break; + case bsoncxx::type::k_bool: + if constexpr (std::is_same_v) { + return GetValue(ptr); + } + break; + case bsoncxx::type::k_string: + if (ptr + 4 > data_ + size_) { + return std::nullopt; + } + if constexpr (std::is_same_v) { + return GetValue(ptr); + } + if constexpr (std::is_same_v) { + return GetValue(ptr); + } + break; + case bsoncxx::type::k_null: + case bsoncxx::type::k_document: + case bsoncxx::type::k_array: + break; + default: + ThrowInfo( + ErrorCode::Unsupported, "unknown BSON type {}", type_tag); + } + return std::nullopt; + } + + std::optional + ParseAsArrayAtOffset(size_t offset) { + if (offset == 0) { + // if offset is 0, it means the array is the whole bson_view + return bsoncxx::array::view(data_, size_); + } + + // check offset + AssertInfo(offset < size_, "bson offset out of range"); + const uint8_t* ptr = data_ + offset; + + // check type + AssertInfo(static_cast(*ptr) == bsoncxx::type::k_array, + "ParseAsArrayAtOffset expects an array at offset {}", + offset); + ptr++; + + // skip key + const char* key_start = reinterpret_cast(ptr); + size_t key_len = strlen(key_start); + ptr += key_len + 1; // +1 for null terminator + const uint8_t* view_start = ptr; + // parse length + int32_t len = *reinterpret_cast(ptr); + if (ptr + len > data_ + size_) { + ThrowInfo(ErrorCode::UnexpectedError, + "ParseAsArrayAtOffset out of range"); + } + return bsoncxx::array::view(view_start, len); + } + + inline std::optional + FindByPath(const bsoncxx::document::view& doc_view, + const std::vector& path, + size_t idx = 0) { + if (idx >= path.size()) + return std::nullopt; + + for (const auto& elem : doc_view) { + const std::string_view key{elem.key().data(), elem.key().length()}; + if (key != path[idx]) + continue; + + const auto& value = elem.get_value(); + if (idx == path.size() - 1) + return value; // found the target + + // Recursively process nested structures + switch (value.type()) { + case bsoncxx::type::k_document: { + auto sub_doc = value.get_document(); + return FindByPath(sub_doc.view(), path, idx + 1); + } + case bsoncxx::type::k_array: + // TODO: may support array index from parent json for now + break; + default: + break; + } + } + return std::nullopt; + } + + // extract pointer to the N-th value in a BSON array + template + static std::optional + GetNthElementInArray(const uint8_t* array_ptr, size_t index) { + const uint8_t* ptr = array_ptr + 4; + for (size_t i = 0; i <= index; ++i) { + auto type_tag = *ptr++; + if (type_tag == 0x00) + break; + + while (*ptr != '\0') ++ptr; + ++ptr; + + if (i == index) { + switch (static_cast(type_tag)) { + case bsoncxx::type::k_int32: + if constexpr (std::is_same_v) { + return ReadInt32(ptr); + } + break; + case bsoncxx::type::k_int64: + if constexpr (std::is_same_v) { + return ReadInt64(ptr); + } + break; + case bsoncxx::type::k_double: + if constexpr (std::is_same_v) { + return ReadDouble(ptr); + } + break; + case bsoncxx::type::k_bool: + if constexpr (std::is_same_v) { + return ReadBool(ptr); + } + break; + case bsoncxx::type::k_string: + if constexpr (std::is_same_v) { + return ReadUtf8(ptr); + } + if constexpr (std::is_same_v) { + return ReadUtf8View(ptr); + } + break; + case bsoncxx::type::k_array: + if constexpr (std::is_same_v) { + return ParseAsArray(ptr); + } + break; + default: + return std::nullopt; + } + } + + switch (static_cast(type_tag)) { + case bsoncxx::type::k_string: { + int32_t len = *reinterpret_cast(ptr); + ptr += 4 + len; + break; + } + case bsoncxx::type::k_int32: + ptr += 4; + break; + case bsoncxx::type::k_int64: + ptr += 8; + break; + case bsoncxx::type::k_double: + ptr += 8; + break; + case bsoncxx::type::k_bool: + ptr += 1; + break; + case bsoncxx::type::k_array: + case bsoncxx::type::k_document: { + int32_t len = *reinterpret_cast(ptr); + ptr += len; + break; + } + default: + return std::nullopt; + } + } + + return std::nullopt; + } + + inline BsonRawField + ParseBsonField(const uint8_t* bson_data, size_t offset) { + const uint8_t* ptr = bson_data + offset; + auto type_tag = static_cast(*ptr++); + + const char* key_cstr = reinterpret_cast(ptr); + size_t key_len = strlen(key_cstr); + ptr += key_len + 1; + + return BsonRawField{ + .type = type_tag, .key = key_cstr, .value_ptr = ptr}; + } + + template + static std::optional + GetValueFromElement(const bsoncxx::document::element& element) { + if constexpr (std::is_same_v) { + if (element.type() == bsoncxx::type::k_int32) { + return element.get_int32().value; + } + } else if constexpr (std::is_same_v) { + if (element.type() == bsoncxx::type::k_int64) { + return element.get_int64().value; + } + } else if constexpr (std::is_same_v) { + if (element.type() == bsoncxx::type::k_double) { + return element.get_double().value; + } + } else if constexpr (std::is_same_v) { + if (element.type() == bsoncxx::type::k_bool) { + return element.get_bool().value; + } + } else if constexpr (std::is_same_v) { + if (element.type() == bsoncxx::type::k_string) { + return std::string(element.get_string().value.data(), + element.get_string().value.size()); + } + } else if constexpr (std::is_same_v) { + if (element.type() == bsoncxx::type::k_string) { + return std::string_view(element.get_string().value.data(), + element.get_string().value.size()); + } + } + return std::nullopt; + } + + template + static std::optional + GetValueFromBsonView(const bsoncxx::types::bson_value::view& value_view) { + switch (value_view.type()) { + case bsoncxx::type::k_int32: + if constexpr (std::is_same_v) + return value_view.get_int32().value; + break; + case bsoncxx::type::k_int64: + if constexpr (std::is_same_v) + return value_view.get_int64().value; + if constexpr (std::is_same_v) + return static_cast(value_view.get_int64().value); + break; + case bsoncxx::type::k_double: + if constexpr (std::is_same_v) + return value_view.get_double().value; + break; + case bsoncxx::type::k_bool: + if constexpr (std::is_same_v) + return value_view.get_bool().value; + break; + case bsoncxx::type::k_string: + if constexpr (std::is_same_v) { + return std::string(value_view.get_string().value.data(), + value_view.get_string().value.size()); + } else if constexpr (std::is_same_v) { + return std::string_view( + value_view.get_string().value.data(), + value_view.get_string().value.size()); + } + break; + case bsoncxx::type::k_array: + if constexpr (std::is_same_v) { + return value_view.get_array().value; + } + break; + // other types... + default: + break; + } + return std::nullopt; + } + const uint8_t* data_; + size_t size_; +}; + +} // namespace milvus \ No newline at end of file diff --git a/internal/core/src/common/init_c.cpp b/internal/core/src/common/init_c.cpp index be3252fa1c..e1f5603075 100644 --- a/internal/core/src/common/init_c.cpp +++ b/internal/core/src/common/init_c.cpp @@ -60,11 +60,6 @@ SetDefaultOptimizeExprEnable(bool val) { milvus::SetDefaultOptimizeExprEnable(val); } -void -SetDefaultJSONKeyStatsCommitInterval(int64_t val) { - milvus::SetDefaultJSONKeyStatsCommitInterval(val); -} - void SetDefaultGrowingJSONKeyStatsEnable(bool val) { milvus::SetDefaultGrowingJSONKeyStatsEnable(val); diff --git a/internal/core/src/common/init_c.h b/internal/core/src/common/init_c.h index 84ecfd3485..fc87a3daaf 100644 --- a/internal/core/src/common/init_c.h +++ b/internal/core/src/common/init_c.h @@ -45,9 +45,6 @@ SetDefaultExprEvalBatchSize(int64_t val); void SetDefaultOptimizeExprEnable(bool val); -void -SetDefaultJSONKeyStatsCommitInterval(int64_t val); - void SetDefaultGrowingJSONKeyStatsEnable(bool val); diff --git a/internal/core/src/exec/QueryContext.h b/internal/core/src/exec/QueryContext.h index 15a022525a..e03e07d588 100644 --- a/internal/core/src/exec/QueryContext.h +++ b/internal/core/src/exec/QueryContext.h @@ -178,6 +178,7 @@ class QueryContext : public Context { milvus::Timestamp timestamp, milvus::Timestamp collection_ttl = 0, int32_t consistency_level = 0, + const query::PlanOptions& plan_options = query::PlanOptions(), std::shared_ptr query_config = std::make_shared(), folly::Executor* executor = nullptr, @@ -191,7 +192,8 @@ class QueryContext : public Context { collection_ttl_timestamp_(collection_ttl), query_config_(query_config), executor_(executor), - consistency_level_(consistency_level) { + consistency_level_(consistency_level), + plan_options_(plan_options) { } folly::Executor* @@ -284,6 +286,11 @@ class QueryContext : public Context { return consistency_level_; } + const query::PlanOptions& + get_plan_options() const { + return plan_options_; + } + private: folly::Executor* executor_; //folly::Executor::KeepAlive<> executor_keepalive_; @@ -307,6 +314,8 @@ class QueryContext : public Context { milvus::RetrieveResult retrieve_result_; int32_t consistency_level_ = 0; + + query::PlanOptions plan_options_; }; // Represent the state of one thread of query execution. diff --git a/internal/core/src/exec/expression/BinaryRangeExpr.cpp b/internal/core/src/exec/expression/BinaryRangeExpr.cpp index 3f9b9f123b..4a8e1bc8e3 100644 --- a/internal/core/src/exec/expression/BinaryRangeExpr.cpp +++ b/internal/core/src/exec/expression/BinaryRangeExpr.cpp @@ -18,7 +18,7 @@ #include #include "query/Utils.h" - +#include "index/json_stats/JsonKeyStats.h" namespace milvus { namespace exec { @@ -421,8 +421,8 @@ PhyBinaryRangeFilterExpr::ExecRangeVisitorImplForJson(EvalCtx& context) { const auto& bitmap_input = context.get_bitmap_input(); auto* input = context.get_offset_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecRangeVisitorImplForJsonForIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecRangeVisitorImplForJsonStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -546,281 +546,176 @@ PhyBinaryRangeFilterExpr::ExecRangeVisitorImplForJson(EvalCtx& context) { template VectorPtr -PhyBinaryRangeFilterExpr::ExecRangeVisitorImplForJsonForIndex() { +PhyBinaryRangeFilterExpr::ExecRangeVisitorImplForJsonStats() { using GetType = std::conditional_t, std::string_view, ValueType>; - auto real_batch_size = - (current_data_chunk_pos_ + batch_size_ > active_count_) - ? active_count_ - current_data_chunk_pos_ - : batch_size_; - auto pointer = milvus::Json::pointer(expr_->column_.nested_path_); -#define BinaryRangeJSONIndexCompare(cmp) \ - do { \ - auto val = json.at(offset, size); \ - if (val.error()) { \ - if constexpr (std::is_same_v) { \ - auto val = json.at(offset, size); \ - return !val.error() && (cmp); \ - } \ - return false; \ - } \ - return (cmp); \ - } while (false) -#define BinaryRangeJSONTypeCompare(cmp) \ - do { \ - if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::STRING)) { \ - auto val = json.at_string(offset, size); \ - return (cmp); \ - } else { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::INT64)) { \ - auto val = \ - std::stoll(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else if (type == uint8_t(milvus::index::JSONType::DOUBLE)) { \ - auto val = \ - std::stod(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::INT64)) { \ - auto val = \ - std::stoll(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else if (type == uint8_t(milvus::index::JSONType::DOUBLE)) { \ - auto val = \ - std::stod(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else { \ - return false; \ - } \ - } \ - } while (false) - -#define BinaryRangeJSONTypeCompareWithValue(cmp) \ - do { \ - if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - float val = *reinterpret_cast(&value); \ - return (cmp); \ - } else { \ - int64_t val = value; \ - return (cmp); \ - } \ - } else if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - float val = *reinterpret_cast(&value); \ - return (cmp); \ - } else { \ - int64_t val = value; \ - return (cmp); \ - } \ - } else if constexpr (std::is_same_v) { \ - bool val = *reinterpret_cast(&value); \ - return (cmp); \ - } \ - } while (false) + auto real_batch_size = current_data_chunk_pos_ + batch_size_ > active_count_ + ? active_count_ - current_data_chunk_pos_ + : batch_size_; + auto pointer = milvus::index::JsonPointer(expr_->column_.nested_path_); bool lower_inclusive = expr_->lower_inclusive_; bool upper_inclusive = expr_->upper_inclusive_; ValueType val1 = GetValueFromProto(expr_->lower_val_); ValueType val2 = GetValueFromProto(expr_->upper_val_); - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } - auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); - Assert(index != nullptr); - auto filter_func = [segment, - &field_id, - val1, - val2, - lower_inclusive, - upper_inclusive](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (!valid) { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); - continue; - } - auto f = [&]() { - if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::INT32) && - type != uint8_t(milvus::index::JSONType::INT64) && - type != uint8_t(milvus::index::JSONType::FLOAT) && - type != uint8_t(milvus::index::JSONType::DOUBLE)) { - return false; - } - } else if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::STRING) && - type != - uint8_t( - milvus::index::JSONType::STRING_ESCAPE)) { - return false; - } - } else if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::INT32) && - type != uint8_t(milvus::index::JSONType::INT64) && - type != uint8_t(milvus::index::JSONType::FLOAT) && - type != uint8_t(milvus::index::JSONType::DOUBLE)) { - return false; - } - } else if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::BOOL)) { - return false; + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); + auto field_id = expr_->column_.field_id_; + auto* index = segment->GetJsonStats(field_id); + Assert(index != nullptr); + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data + auto try_execute = [&](milvus::index::JSONType json_type, + TargetBitmapView& res_view, + TargetBitmapView& valid_res_view, + auto GetType) { + auto target_field = index->GetShreddingField(pointer, json_type); + if (!target_field.empty()) { + using ColType = decltype(GetType); + auto shredding_executor = + [val1, val2, lower_inclusive, upper_inclusive]( + const ColType* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + if (lower_inclusive && upper_inclusive) { + res[i] = src[i] >= val1 && src[i] <= val2; + } else if (lower_inclusive && !upper_inclusive) { + res[i] = src[i] >= val1 && src[i] < val2; + } else if (!lower_inclusive && upper_inclusive) { + res[i] = src[i] > val1 && src[i] <= val2; + } else { + res[i] = src[i] > val1 && src[i] < val2; + } } + }; + index->ExecutorForShreddingData(target_field, + shredding_executor, + nullptr, + res_view, + valid_res_view); + LOG_DEBUG("using shredding data's field: {} count {}", + target_field, + res_view.count()); + } + }; + + if constexpr (std::is_same_v) { + // int64 compare + try_execute(milvus::index::JSONType::INT64, + res_view, + valid_res_view, + int64_t{}); + // and double compare + TargetBitmap res_double(active_count_, false); + TargetBitmapView res_double_view(res_double); + TargetBitmap res_double_valid(active_count_, true); + TargetBitmapView valid_res_double_view(res_double_valid); + try_execute(milvus::index::JSONType::DOUBLE, + res_double_view, + valid_res_double_view, + double{}); + res_view.inplace_or_with_count(res_double_view, active_count_); + valid_res_view.inplace_or_with_count(valid_res_double_view, + active_count_); + + } else if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::DOUBLE, + res_view, + valid_res_view, + double{}); + // and int64 compare + TargetBitmap res_int64(active_count_, false); + TargetBitmapView res_int64_view(res_int64); + TargetBitmap res_int64_valid(active_count_, true); + TargetBitmapView valid_res_int64_view(res_int64_valid); + try_execute(milvus::index::JSONType::INT64, + res_int64_view, + valid_res_int64_view, + int64_t{}); + res_view.inplace_or_with_count(res_int64_view, active_count_); + valid_res_view.inplace_or_with_count(valid_res_int64_view, + active_count_); + } else if constexpr (std::is_same_v || + std::is_same_v) { + try_execute(milvus::index::JSONType::STRING, + res_view, + valid_res_view, + std::string_view{}); + } + + // process shared data + auto shared_executor = + [val1, val2, lower_inclusive, upper_inclusive, &res_view]( + milvus::BsonView bson, uint32_t row_id, uint32_t value_offset) { + if constexpr (std::is_same_v || + std::is_same_v) { + auto val = bson.ParseAsValueAtOffset(value_offset); + if (!val.has_value()) { + res_view[row_id] = false; + return; } if (lower_inclusive && upper_inclusive) { - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { - BinaryRangeJSONTypeCompareWithValue( - static_cast(val1) <= val && - val <= static_cast(val2)); - } else { - BinaryRangeJSONTypeCompareWithValue(val1 <= val && - val <= val2); - } + res_view[row_id] = + val.value() >= val1 && val.value() <= val2; } else if (lower_inclusive && !upper_inclusive) { - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { - BinaryRangeJSONTypeCompareWithValue( - static_cast(val1) <= val && - val < static_cast(val2)); - } else { - BinaryRangeJSONTypeCompareWithValue(val1 <= val && - val < val2); - } + res_view[row_id] = + val.value() >= val1 && val.value() < val2; } else if (!lower_inclusive && upper_inclusive) { - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { - BinaryRangeJSONTypeCompareWithValue( - static_cast(val1) < val && - val <= static_cast(val2)); - } else { - BinaryRangeJSONTypeCompareWithValue(val1 < val && - val <= val2); - } + res_view[row_id] = + val.value() > val1 && val.value() <= val2; } else { - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { - BinaryRangeJSONTypeCompareWithValue( - static_cast(val1) < val && - val < static_cast(val2)); - } else { - BinaryRangeJSONTypeCompareWithValue(val1 < val && - val < val2); - } - } - }; - bitset[row_id] = f(); - } - - auto f = [&](const milvus::Json& json, - uint8_t type, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - if (lower_inclusive && upper_inclusive) { - if (type == uint8_t(milvus::index::JSONType::STRING) || - type == uint8_t(milvus::index::JSONType::DOUBLE) || - type == uint8_t(milvus::index::JSONType::INT64)) { - BinaryRangeJSONTypeCompare(val1 <= val && val <= val2); - } else { - BinaryRangeJSONIndexCompare( - val1 <= ValueType(val.value()) && - ValueType(val.value()) <= val2); - } - } else if (lower_inclusive && !upper_inclusive) { - if (type == uint8_t(milvus::index::JSONType::STRING) || - type == uint8_t(milvus::index::JSONType::DOUBLE) || - type == uint8_t(milvus::index::JSONType::INT64)) { - BinaryRangeJSONTypeCompare(val1 <= val && val < val2); - } else { - BinaryRangeJSONIndexCompare( - val1 <= ValueType(val.value()) && - ValueType(val.value()) < val2); - } - } else if (!lower_inclusive && upper_inclusive) { - if (type == uint8_t(milvus::index::JSONType::STRING) || - type == uint8_t(milvus::index::JSONType::DOUBLE) || - type == uint8_t(milvus::index::JSONType::INT64)) { - BinaryRangeJSONTypeCompare(val1 < val && val <= val2); - } else { - BinaryRangeJSONIndexCompare( - val1 < ValueType(val.value()) && - ValueType(val.value()) <= val2); + res_view[row_id] = + val.value() > val1 && val.value() < val2; } } else { - if (type == uint8_t(milvus::index::JSONType::STRING) || - type == uint8_t(milvus::index::JSONType::DOUBLE) || - type == uint8_t(milvus::index::JSONType::INT64)) { - BinaryRangeJSONTypeCompare(val1 < val && val < val2); + auto val = bson.ParseAsValueAtOffset(value_offset); + if (!val.has_value()) { + res_view[row_id] = false; + return; + } + if (lower_inclusive && upper_inclusive) { + res_view[row_id] = + val.value() >= val1 && val.value() <= val2; + } else if (lower_inclusive && !upper_inclusive) { + res_view[row_id] = + val.value() >= val1 && val.value() < val2; + } else if (!lower_inclusive && upper_inclusive) { + res_view[row_id] = + val.value() > val1 && val.value() <= val2; } else { - BinaryRangeJSONIndexCompare( - val1 < ValueType(val.value()) && - ValueType(val.value()) < val2); + res_view[row_id] = + val.value() > val1 && val.value() < val2; } } }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, type, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); - }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); MoveCursor(); return std::make_shared(std::move(result), TargetBitmap(real_batch_size, true)); -} +} // namespace exec template VectorPtr @@ -960,5 +855,5 @@ PhyBinaryRangeFilterExpr::ExecRangeVisitorImplForArray(EvalCtx& context) { return res_vec; } -} //namespace exec +} // namespace exec } // namespace milvus diff --git a/internal/core/src/exec/expression/BinaryRangeExpr.h b/internal/core/src/exec/expression/BinaryRangeExpr.h index 71c8b089a7..b622edb772 100644 --- a/internal/core/src/exec/expression/BinaryRangeExpr.h +++ b/internal/core/src/exec/expression/BinaryRangeExpr.h @@ -312,7 +312,7 @@ class PhyBinaryRangeFilterExpr : public SegmentExpr { template VectorPtr - ExecRangeVisitorImplForJsonForIndex(); + ExecRangeVisitorImplForJsonStats(); template VectorPtr diff --git a/internal/core/src/exec/expression/Element.h b/internal/core/src/exec/expression/Element.h index 75b475b8c6..3d7e42db34 100644 --- a/internal/core/src/exec/expression/Element.h +++ b/internal/core/src/exec/expression/Element.h @@ -150,7 +150,21 @@ class SortVectorElement : public MultiElement { bool In(const ValueType& value) const override { AssertInfo(sorted_, "In() should be sorted before"); - if (std::holds_alternative(value)) { + if constexpr (std::is_same_v) { + if (std::holds_alternative(value)) { + return std::binary_search(values_.begin(), + values_.end(), + std::get(value)); + } else if (std::holds_alternative(value)) { + return std::binary_search( + values_.begin(), + values_.end(), + std::string(std::get(value)), + [](const std::string& a, std::string_view b) { + return a < b; + }); + } + } else if (std::holds_alternative(value)) { return std::binary_search( values_.begin(), values_.end(), std::get(value)); } @@ -168,6 +182,11 @@ class SortVectorElement : public MultiElement { values_.push_back(value); } + std::vector + GetElements() const { + return values_; + } + public: std::vector values_; bool sorted_{false}; @@ -257,6 +276,11 @@ class SetElement : public MultiElement { return values_.size(); } + std::vector + GetElements() const { + return std::vector(values_.begin(), values_.end()); + } + public: ankerl::unordered_dense::set values_; }; @@ -313,6 +337,11 @@ class SetElement : public MultiElement { return (contains_true ? 1 : 0) + (contains_false ? 1 : 0); } + std::vector + GetElements() const { + return {contains_true, contains_false}; + } + private: bool contains_true = false; bool contains_false = false; diff --git a/internal/core/src/exec/expression/ExistsExpr.cpp b/internal/core/src/exec/expression/ExistsExpr.cpp index c449047a01..4001b13d0a 100644 --- a/internal/core/src/exec/expression/ExistsExpr.cpp +++ b/internal/core/src/exec/expression/ExistsExpr.cpp @@ -20,6 +20,7 @@ #include "common/Types.h" #include "common/Vector.h" #include "index/JsonInvertedIndex.h" +#include "index/json_stats/JsonKeyStats.h" namespace milvus { namespace exec { @@ -113,8 +114,8 @@ PhyExistsFilterExpr::EvalJsonExistsForDataSegment(EvalCtx& context) { auto* input = context.get_offset_input(); const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return EvalJsonExistsForDataSegmentForIndex(); + if (CanUseJsonStats(context, field_id) && !has_offset_input_) { + return EvalJsonExistsForDataSegmentByStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -178,48 +179,41 @@ PhyExistsFilterExpr::EvalJsonExistsForDataSegment(EvalCtx& context) { } VectorPtr -PhyExistsFilterExpr::EvalJsonExistsForDataSegmentForIndex() { +PhyExistsFilterExpr::EvalJsonExistsForDataSegmentByStats() { auto real_batch_size = GetNextBatchSize(); if (real_batch_size == 0) { return nullptr; } - auto pointer = milvus::Json::pointer(expr_->column_.nested_path_); - if (cached_index_chunk_id_ != 0) { + auto pointer = milvus::index::JsonPointer(expr_->column_.nested_path_); + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { cached_index_chunk_id_ = 0; - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + auto segment = static_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [segment, field_id, pointer]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto row_id = row_id_array[i]; - bitset[row_id] = true; - } - }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data + auto shredding_fields = index->GetShreddingFields(pointer); + for (const auto& field : shredding_fields) { + index->ExecutorForGettingValid(field, valid_res_view); + res_view |= valid_res_view; + } + + if (!index->CanSkipShared(pointer)) { + // process shared data + index->ExecuteExistsPathForSharedData(pointer, res_view); + } + cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); diff --git a/internal/core/src/exec/expression/ExistsExpr.h b/internal/core/src/exec/expression/ExistsExpr.h index 9d646460bc..094536bf75 100644 --- a/internal/core/src/exec/expression/ExistsExpr.h +++ b/internal/core/src/exec/expression/ExistsExpr.h @@ -83,7 +83,7 @@ class PhyExistsFilterExpr : public SegmentExpr { EvalJsonExistsForIndex(); VectorPtr - EvalJsonExistsForDataSegmentForIndex(); + EvalJsonExistsForDataSegmentByStats(); private: std::shared_ptr expr_; diff --git a/internal/core/src/exec/expression/Expr.h b/internal/core/src/exec/expression/Expr.h index 148495f2cc..0da1acc9d1 100644 --- a/internal/core/src/exec/expression/Expr.h +++ b/internal/core/src/exec/expression/Expr.h @@ -1272,23 +1272,6 @@ class SegmentExpr : public Expr { use_index_ = false; } - bool - CanUseJsonKeyIndex(FieldId field_id) const { - if (segment_->type() == SegmentType::Sealed) { - auto sealed_seg = - dynamic_cast(segment_); - Assert(sealed_seg != nullptr); - if (sealed_seg->GetJsonKeyIndex(field_id) != nullptr) { - return true; - } - } else if (segment_->type() == SegmentType ::Growing) { - if (segment_->GetJsonKeyIndex(field_id) != nullptr) { - return true; - } - } - return false; - } - bool CanUseNgramIndex(FieldId field_id) const { return segment_->HasNgramIndex(field_id); @@ -1300,6 +1283,26 @@ class SegmentExpr : public Expr { return segment_->HasNgramIndexForJson(field_id, nested_path); } + bool + PlanUseJsonStats(EvalCtx& context) const { + return context.get_exec_context() + ->get_query_context() + ->get_plan_options() + .expr_use_json_stats; + } + + bool + HasJsonStats(FieldId field_id) const { + return segment_->type() == SegmentType::Sealed && + static_cast(segment_) + ->GetJsonStats(field_id) != nullptr; + } + + bool + CanUseJsonStats(EvalCtx& context, FieldId field_id) const { + return PlanUseJsonStats(context) && HasJsonStats(field_id); + } + protected: const segcore::SegmentInternalInterface* segment_; const FieldId field_id_; diff --git a/internal/core/src/exec/expression/JsonContainsExpr.cpp b/internal/core/src/exec/expression/JsonContainsExpr.cpp index 38da8243aa..b841038428 100644 --- a/internal/core/src/exec/expression/JsonContainsExpr.cpp +++ b/internal/core/src/exec/expression/JsonContainsExpr.cpp @@ -295,8 +295,8 @@ PhyJsonContainsFilterExpr::ExecJsonContains(EvalCtx& context) { const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonContainsByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonContainsByStats(); } auto real_batch_size = @@ -391,7 +391,7 @@ PhyJsonContainsFilterExpr::ExecJsonContains(EvalCtx& context) { template VectorPtr -PhyJsonContainsFilterExpr::ExecJsonContainsByKeyIndex() { +PhyJsonContainsFilterExpr::ExecJsonContainsByStats() { using GetType = std::conditional_t, std::string_view, @@ -404,6 +404,19 @@ PhyJsonContainsFilterExpr::ExecJsonContainsByKeyIndex() { auto pointer = milvus::Json::pointer(expr_->column_.nested_path_); if (!arg_inited_) { arg_set_ = std::make_shared>(expr_->vals_); + if constexpr (std::is_same_v) { + // for int64_t, we need to a double vector to store the values + auto sort_arg_set = + std::dynamic_pointer_cast>(arg_set_); + std::vector double_vals; + for (const auto& val : sort_arg_set->GetElements()) { + double_vals.emplace_back(static_cast(val)); + } + arg_set_double_ = + std::make_shared>(double_vals); + } else if constexpr (std::is_same_v) { + arg_set_double_ = arg_set_; + } arg_inited_ = true; } @@ -413,90 +426,70 @@ PhyJsonContainsFilterExpr::ExecJsonContainsByKeyIndex() { TargetBitmap(real_batch_size, false), TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [this, segment, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (valid) { - bitset[row_id] = false; + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + // process shredding data for ARRAY type (non-shared) + { + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonContainsAnyExecutor executor( + arg_set_, arg_set_double_); + + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); + } + } + // process shared data + auto shared_executor = [this, &res_view](milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + auto val = bson.ParseAsArrayAtOffset(value_offset); + + if (!val.has_value()) { + res_view[row_offset] = false; + return; + } + + for (const auto& element : val.value()) { + if constexpr (std::is_same_v || + std::is_same_v) { + auto value = milvus::BsonView::GetValueFromBsonView( + element.get_value()); + if (value.has_value() && + this->arg_set_double_->In(value.value())) { + res_view[row_offset] = true; + return; + } } else { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); + auto value = + milvus::BsonView::GetValueFromBsonView( + element.get_value()); + if (value.has_value() && + this->arg_set_->In(value.value())) { + res_view[row_offset] = true; + return; + } } } - auto f = [&](const milvus::Json& json, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - for (auto&& it : array) { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (this->arg_set_->In(val.value())) { - return true; - } - } - return false; - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); @@ -510,8 +503,8 @@ PhyJsonContainsFilterExpr::ExecJsonContainsArray(EvalCtx& context) { auto* input = context.get_offset_input(); const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonContainsArrayByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonContainsArrayByStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -613,7 +606,7 @@ PhyJsonContainsFilterExpr::ExecJsonContainsArray(EvalCtx& context) { } VectorPtr -PhyJsonContainsFilterExpr::ExecJsonContainsArrayByKeyIndex() { +PhyJsonContainsFilterExpr::ExecJsonContainsArrayByStats() { auto real_batch_size = (current_data_chunk_pos_ + batch_size_ > active_count_) ? active_count_ - current_data_chunk_pos_ @@ -629,92 +622,61 @@ PhyJsonContainsFilterExpr::ExecJsonContainsArrayByKeyIndex() { TargetBitmap(real_batch_size, false), TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [segment, &elements, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (valid) { - bitset[row_id] = false; - } else { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data for ARRAY type (non-shared) + { + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonContainsArrayExecutor executor(elements); + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); + } + } + + auto shared_executor = [&elements, &res_view](milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + auto array = bson.ParseAsArrayAtOffset(value_offset); + + if (!array.has_value()) { + res_view[row_offset] = false; + } + + for (const auto& sub_value : array.value()) { + auto sub_array = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + + if (!sub_array.has_value()) + continue; + + for (const auto& element : elements) { + if (CompareTwoJsonArray(sub_array.value(), element)) { + return true; + } } } - auto f = [&](const milvus::Json& json, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - for (auto&& it : array) { - auto val = it.get_array(); - if (val.error()) { - continue; - } - for (auto const& element : elements) { - if (CompareTwoJsonArray(val, element)) { - return true; - } - } - } - return false; - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); + return false; }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); @@ -822,8 +784,8 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAll(EvalCtx& context) { const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonContainsAllByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonContainsAllByStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -920,7 +882,7 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAll(EvalCtx& context) { template VectorPtr -PhyJsonContainsFilterExpr::ExecJsonContainsAllByKeyIndex() { +PhyJsonContainsFilterExpr::ExecJsonContainsAllByStats() { using GetType = std::conditional_t, std::string_view, @@ -940,92 +902,64 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllByKeyIndex() { TargetBitmap(real_batch_size, false), TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [segment, &elements, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (valid) { - bitset[row_id] = false; - } else { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + // process shredding data for ARRAY type (non-shared) + { + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonContainsAllExecutor executor( + elements); + + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); + } + } + // process shared data + auto shared_executor = [this, &elements, &res_view]( + milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + auto val = bson.ParseAsArrayAtOffset(value_offset); + + if (!val.has_value()) { + res_view[row_offset] = false; + return; + } + + std::set tmp_elements(elements); + for (const auto& element : val.value()) { + auto value = milvus::BsonView::GetValueFromBsonView( + element.get_value()); + if (!value.has_value()) { + continue; + } + tmp_elements.erase(value.value()); + if (tmp_elements.size() == 0) { + res_view[row_offset] = true; + return; } } - auto f = [&](const milvus::Json& json, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - std::set tmp_elements(elements); - for (auto&& it : array) { - auto val = it.template get(); - if (val.error()) { - continue; - } - tmp_elements.erase(val.value()); - if (tmp_elements.size() == 0) { - return true; - } - } - return tmp_elements.empty(); - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); + res_view[row_offset] = tmp_elements.empty(); }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); @@ -1039,8 +973,8 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllWithDiffType(EvalCtx& context) { auto* input = context.get_offset_input(); const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonContainsAllWithDiffTypeByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonContainsAllWithDiffTypeByStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -1201,7 +1135,7 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllWithDiffType(EvalCtx& context) { } VectorPtr -PhyJsonContainsFilterExpr::ExecJsonContainsAllWithDiffTypeByKeyIndex() { +PhyJsonContainsFilterExpr::ExecJsonContainsAllWithDiffTypeByStats() { auto real_batch_size = (current_data_chunk_pos_ + batch_size_ > active_count_) ? active_count_ - current_data_chunk_pos_ @@ -1220,152 +1154,130 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllWithDiffTypeByKeyIndex() { TargetBitmap(real_batch_size, false), TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [segment, &elements, &elements_index, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (valid) { - bitset[row_id] = false; - } else { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); - } + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data for ARRAY type (non-shared) + { + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonContainsAllWithDiffTypeExecutor executor( + elements, elements_index); + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); } - auto f = [&](const milvus::Json& json, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - std::set tmp_elements_index(elements_index); - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - for (auto&& it : array) { - int i = -1; - for (auto& element : elements) { - i++; - switch (element.val_case()) { - case proto::plan::GenericValue::kBoolVal: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.bool_val()) { - tmp_elements_index.erase(i); - } - break; + } + + auto shared_executor = [&elements, &elements_index, &res_view]( + milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + std::set tmp_elements_index(elements_index); + auto array = bson.ParseAsArrayAtOffset(value_offset); + if (!array.has_value()) { + res_view[row_offset] = false; + return; + } + + for (const auto& sub_value : array.value()) { + int i = -1; + for (auto& element : elements) { + i++; + switch (element.val_case()) { + case proto::plan::GenericValue::kBoolVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; } - case proto::plan::GenericValue::kInt64Val: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.int64_val()) { - tmp_elements_index.erase(i); - } - break; + if (val.value() == element.bool_val()) { + tmp_elements_index.erase(i); } - case proto::plan::GenericValue::kFloatVal: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.float_val()) { - tmp_elements_index.erase(i); - } - break; - } - case proto::plan::GenericValue::kStringVal: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.string_val()) { - tmp_elements_index.erase(i); - } - break; - } - case proto::plan::GenericValue::kArrayVal: { - auto val = it.get_array(); - if (val.error()) { - continue; - } - if (CompareTwoJsonArray(val, - element.array_val())) { - tmp_elements_index.erase(i); - } - break; - } - default: - ThrowInfo( - DataTypeInvalid, - fmt::format("unsupported data type {}", - element.val_case())); + break; } - if (tmp_elements_index.size() == 0) { - return true; + case proto::plan::GenericValue::kInt64Val: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.int64_val()) { + tmp_elements_index.erase(i); + } + break; } + case proto::plan::GenericValue::kFloatVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.float_val()) { + tmp_elements_index.erase(i); + } + break; + } + case proto::plan::GenericValue::kStringVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + std::string>(sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.string_val()) { + tmp_elements_index.erase(i); + } + break; + } + case proto::plan::GenericValue::kArrayVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (CompareTwoJsonArray(val.value(), + element.array_val())) { + tmp_elements_index.erase(i); + } + break; + } + default: + ThrowInfo(DataTypeInvalid, + fmt::format("unsupported data type {}", + element.val_case())); } if (tmp_elements_index.size() == 0) { - return true; + res_view[row_offset] = true; + return; } } - return tmp_elements_index.size() == 0; - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); + if (tmp_elements_index.size() == 0) { + res_view[row_offset] = true; + return; + } + } + res_view[row_offset] = tmp_elements_index.size() == 0; }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); @@ -1379,8 +1291,8 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllArray(EvalCtx& context) { auto* input = context.get_offset_input(); const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonContainsAllArrayByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonContainsAllArrayByStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -1488,7 +1400,7 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllArray(EvalCtx& context) { } VectorPtr -PhyJsonContainsFilterExpr::ExecJsonContainsAllArrayByKeyIndex() { +PhyJsonContainsFilterExpr::ExecJsonContainsAllArrayByStats() { auto real_batch_size = (current_data_chunk_pos_ + batch_size_ > active_count_) ? active_count_ - current_data_chunk_pos_ @@ -1504,96 +1416,68 @@ PhyJsonContainsFilterExpr::ExecJsonContainsAllArrayByKeyIndex() { TargetBitmap(real_batch_size, false), TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [segment, &elements, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (valid) { - bitset[row_id] = false; - } else { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data for ARRAY type (non-shared) + { + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonContainsAllArrayExecutor executor(elements); + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); + } + } + + auto shared_executor = [&elements, &res_view](milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + auto array = bson.ParseAsArrayAtOffset(value_offset); + if (!array.has_value()) { + res_view[row_offset] = false; + return; + } + + std::set exist_elements_index; + for (const auto& sub_value : array.value()) { + auto sub_array = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + + if (!sub_array.has_value()) + continue; + + for (int index = 0; index < elements.size(); ++index) { + if (CompareTwoJsonArray(sub_array.value(), + elements[index])) { + exist_elements_index.insert(index); + } + } + if (exist_elements_index.size() == elements.size()) { + res_view[row_offset] = true; + return; } } - auto f = [&](const milvus::Json& json, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - std::set exist_elements_index; - for (auto&& it : array) { - auto json_array = it.get_array(); - if (json_array.error()) { - continue; - } - for (int index = 0; index < elements.size(); ++index) { - if (CompareTwoJsonArray(json_array, elements[index])) { - exist_elements_index.insert(index); - } - } - if (exist_elements_index.size() == elements.size()) { - return true; - } - } - return exist_elements_index.size() == elements.size(); - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); + res_view[row_offset] = + exist_elements_index.size() == elements.size(); }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); @@ -1607,8 +1491,8 @@ PhyJsonContainsFilterExpr::ExecJsonContainsWithDiffType(EvalCtx& context) { auto* input = context.get_offset_input(); const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonContainsWithDiffTypeByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonContainsWithDiffTypeByStats(); } auto real_batch_size = has_offset_input_ ? input->size() : GetNextBatchSize(); @@ -1759,7 +1643,7 @@ PhyJsonContainsFilterExpr::ExecJsonContainsWithDiffType(EvalCtx& context) { } VectorPtr -PhyJsonContainsFilterExpr::ExecJsonContainsWithDiffTypeByKeyIndex() { +PhyJsonContainsFilterExpr::ExecJsonContainsWithDiffTypeByStats() { auto real_batch_size = (current_data_chunk_pos_ + batch_size_ > active_count_) ? active_count_ - current_data_chunk_pos_ @@ -1772,144 +1656,122 @@ PhyJsonContainsFilterExpr::ExecJsonContainsWithDiffTypeByKeyIndex() { TargetBitmap(real_batch_size, false), TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto* segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [segment, &elements, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (valid) { - bitset[row_id] = false; - } else { - invalid_row_ids.push_back(row_id_array[i]); - invalid_offset.push_back(offset_array[i]); - invalid_type.push_back(type_array[i]); - invalid_size.push_back(size_array[i]); - } + + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data for ARRAY type (non-shared) + { + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonContainsAnyWithDiffTypeExecutor executor( + elements); + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); } - auto f = [&](const milvus::Json& json, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - // Note: array can only be iterated once - for (auto&& it : array) { - for (auto const& element : elements) { - switch (element.val_case()) { - case proto::plan::GenericValue::kBoolVal: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.bool_val()) { - return true; - } - break; + } + + auto shared_executor = [&elements, &res_view](milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + auto array = bson.ParseAsArrayAtOffset(value_offset); + if (!array.has_value()) { + res_view[row_offset] = false; + return; + } + + for (const auto& sub_value : array.value()) { + for (auto const& element : elements) { + switch (element.val_case()) { + case proto::plan::GenericValue::kBoolVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; } - case proto::plan::GenericValue::kInt64Val: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.int64_val()) { - return true; - } - break; + if (val.value() == element.bool_val()) { + res_view[row_offset] = true; + return; } - case proto::plan::GenericValue::kFloatVal: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.float_val()) { - return true; - } - break; - } - case proto::plan::GenericValue::kStringVal: { - auto val = it.template get(); - if (val.error()) { - continue; - } - if (val.value() == element.string_val()) { - return true; - } - break; - } - case proto::plan::GenericValue::kArrayVal: { - auto val = it.get_array(); - if (val.error()) { - continue; - } - if (CompareTwoJsonArray(val, - element.array_val())) { - return true; - } - break; - } - default: - ThrowInfo( - DataTypeInvalid, - fmt::format("unsupported data type {}", - element.val_case())); + break; } + case proto::plan::GenericValue::kInt64Val: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.int64_val()) { + res_view[row_offset] = true; + return; + } + break; + } + case proto::plan::GenericValue::kFloatVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.float_val()) { + res_view[row_offset] = true; + return; + } + break; + } + case proto::plan::GenericValue::kStringVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + std::string>(sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.string_val()) { + res_view[row_offset] = true; + return; + } + break; + } + case proto::plan::GenericValue::kArrayVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (CompareTwoJsonArray(val.value(), + element.array_val())) { + res_view[row_offset] = true; + return; + } + break; + } + default: + ThrowInfo(DataTypeInvalid, + fmt::format("unsupported data type {}", + element.val_case())); } } - return false; - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); + } }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); @@ -2005,6 +1867,5 @@ PhyJsonContainsFilterExpr::ExecArrayContainsForIndexSegmentImpl() { real_batch_size); return res; } - } //namespace exec } // namespace milvus diff --git a/internal/core/src/exec/expression/JsonContainsExpr.h b/internal/core/src/exec/expression/JsonContainsExpr.h index 4565d41235..446f81545c 100644 --- a/internal/core/src/exec/expression/JsonContainsExpr.h +++ b/internal/core/src/exec/expression/JsonContainsExpr.h @@ -24,10 +24,426 @@ #include "exec/expression/Expr.h" #include "exec/expression/Element.h" #include "segcore/SegmentInterface.h" +#include "common/bson_view.h" +#include "exec/expression/Utils.h" namespace milvus { namespace exec { +class ShreddingArrayBsonContainsArrayExecutor { + public: + explicit ShreddingArrayBsonContainsArrayExecutor( + const std::vector& elems) + : elements_(elems) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array_view = bson.ParseAsArrayAtOffset(0); + if (!array_view.has_value()) { + res[i] = false; + continue; + } + bool matched = false; + for (const auto& sub_value : array_view.value()) { + auto sub_array = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + if (!sub_array.has_value()) + continue; + for (const auto& element : elements_) { + if (CompareTwoJsonArray(sub_array.value(), element)) { + matched = true; + break; + } + } + if (matched) + break; + } + res[i] = matched; + } + } + + private: + const std::vector elements_; +}; + +class ShreddingArrayBsonContainsAllArrayExecutor { + public: + explicit ShreddingArrayBsonContainsAllArrayExecutor( + const std::vector& elems) + : elements_(elems) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array_view = bson.ParseAsArrayAtOffset(0); + if (!array_view.has_value()) { + res[i] = false; + continue; + } + std::set exist_elements_index; + for (const auto& sub_value : array_view.value()) { + auto sub_array = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + if (!sub_array.has_value()) + continue; + + for (int idx = 0; idx < static_cast(elements_.size()); + ++idx) { + if (CompareTwoJsonArray(sub_array.value(), + elements_[idx])) { + exist_elements_index.insert(idx); + } + } + if (exist_elements_index.size() == elements_.size()) { + break; + } + } + res[i] = exist_elements_index.size() == elements_.size(); + } + } + + private: + const std::vector elements_; +}; + +template +class ShreddingArrayBsonContainsAnyExecutor { + public: + ShreddingArrayBsonContainsAnyExecutor( + std::shared_ptr arg_set, + std::shared_ptr arg_set_double) + : arg_set_(std::move(arg_set)), + arg_set_double_(std::move(arg_set_double)) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array_view = bson.ParseAsArrayAtOffset(0); + if (!array_view.has_value()) { + res[i] = false; + continue; + } + bool matched = false; + for (const auto& element : array_view.value()) { + if constexpr (std::is_same_v || + std::is_same_v) { + auto value = milvus::BsonView::GetValueFromBsonView( + element.get_value()); + if (value.has_value() && + arg_set_double_->In(value.value())) { + matched = true; + break; + } + } else { + auto value = + milvus::BsonView::GetValueFromBsonView( + element.get_value()); + if (value.has_value() && arg_set_->In(value.value())) { + matched = true; + break; + } + } + } + res[i] = matched; + } + } + + private: + std::shared_ptr arg_set_; + std::shared_ptr arg_set_double_; +}; + +template +class ShreddingArrayBsonContainsAllExecutor { + public: + explicit ShreddingArrayBsonContainsAllExecutor( + const std::set& elements) + : elements_(elements) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array_view = bson.ParseAsArrayAtOffset(0); + if (!array_view.has_value()) { + res[i] = false; + continue; + } + std::set tmp_elements(elements_); + for (const auto& element : array_view.value()) { + auto value = milvus::BsonView::GetValueFromBsonView( + element.get_value()); + if (!value.has_value()) { + continue; + } + tmp_elements.erase(value.value()); + if (tmp_elements.empty()) { + break; + } + } + res[i] = tmp_elements.empty(); + } + } + + private: + std::set elements_; +}; + +class ShreddingArrayBsonContainsAllWithDiffTypeExecutor { + public: + ShreddingArrayBsonContainsAllWithDiffTypeExecutor( + std::vector elements, + std::set elements_index) + : elements_(std::move(elements)), + elements_index_(std::move(elements_index)) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array = bson.ParseAsArrayAtOffset(0); + if (!array.has_value()) { + res[i] = false; + continue; + } + std::set tmp_elements_index(elements_index_); + for (const auto& sub_value : array.value()) { + int idx = -1; + for (auto& element : elements_) { + idx++; + switch (element.val_case()) { + case proto::plan::GenericValue::kBoolVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.bool_val()) { + tmp_elements_index.erase(idx); + } + break; + } + case proto::plan::GenericValue::kInt64Val: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.int64_val()) { + tmp_elements_index.erase(idx); + } + break; + } + case proto::plan::GenericValue::kFloatVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.float_val()) { + tmp_elements_index.erase(idx); + } + break; + } + case proto::plan::GenericValue::kStringVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + std::string>(sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (val.value() == element.string_val()) { + tmp_elements_index.erase(idx); + } + break; + } + case proto::plan::GenericValue::kArrayVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + if (!val.has_value()) { + continue; + } + if (CompareTwoJsonArray(val.value(), + element.array_val())) { + tmp_elements_index.erase(idx); + } + break; + } + default: + ThrowInfo(DataTypeInvalid, + fmt::format("unsupported data type {}", + element.val_case())); + } + if (tmp_elements_index.size() == 0) { + break; + } + } + if (tmp_elements_index.size() == 0) { + break; + } + } + res[i] = tmp_elements_index.size() == 0; + } + } + + private: + std::vector elements_; + std::set elements_index_; +}; + +class ShreddingArrayBsonContainsAnyWithDiffTypeExecutor { + public: + explicit ShreddingArrayBsonContainsAnyWithDiffTypeExecutor( + std::vector elements) + : elements_(std::move(elements)) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array = bson.ParseAsArrayAtOffset(0); + if (!array.has_value()) { + res[i] = false; + continue; + } + bool matched = false; + for (const auto& sub_value : array.value()) { + for (auto const& element : elements_) { + switch (element.val_case()) { + case proto::plan::GenericValue::kBoolVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (val.has_value() && + val.value() == element.bool_val()) { + matched = true; + } + break; + } + case proto::plan::GenericValue::kInt64Val: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (val.has_value() && + val.value() == element.int64_val()) { + matched = true; + } + break; + } + case proto::plan::GenericValue::kFloatVal: { + auto val = + milvus::BsonView::GetValueFromBsonView( + sub_value.get_value()); + if (val.has_value() && + val.value() == element.float_val()) { + matched = true; + } + break; + } + case proto::plan::GenericValue::kStringVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + std::string>(sub_value.get_value()); + if (val.has_value() && + val.value() == element.string_val()) { + matched = true; + } + break; + } + case proto::plan::GenericValue::kArrayVal: { + auto val = milvus::BsonView::GetValueFromBsonView< + bsoncxx::array::view>(sub_value.get_value()); + if (val.has_value() && + CompareTwoJsonArray(val.value(), + element.array_val())) { + matched = true; + } + break; + } + default: + ThrowInfo(DataTypeInvalid, + fmt::format("unsupported data type {}", + element.val_case())); + } + if (matched) + break; + } + if (matched) + break; + } + res[i] = matched; + } + } + + private: + std::vector elements_; +}; + class PhyJsonContainsFilterExpr : public SegmentExpr { public: PhyJsonContainsFilterExpr( @@ -82,7 +498,7 @@ class PhyJsonContainsFilterExpr : public SegmentExpr { template VectorPtr - ExecJsonContainsByKeyIndex(); + ExecJsonContainsByStats(); template VectorPtr @@ -94,7 +510,7 @@ class PhyJsonContainsFilterExpr : public SegmentExpr { template VectorPtr - ExecJsonContainsAllByKeyIndex(); + ExecJsonContainsAllByStats(); template VectorPtr @@ -104,25 +520,25 @@ class PhyJsonContainsFilterExpr : public SegmentExpr { ExecJsonContainsArray(EvalCtx& context); VectorPtr - ExecJsonContainsArrayByKeyIndex(); + ExecJsonContainsArrayByStats(); VectorPtr ExecJsonContainsAllArray(EvalCtx& context); VectorPtr - ExecJsonContainsAllArrayByKeyIndex(); + ExecJsonContainsAllArrayByStats(); VectorPtr ExecJsonContainsAllWithDiffType(EvalCtx& context); VectorPtr - ExecJsonContainsAllWithDiffTypeByKeyIndex(); + ExecJsonContainsAllWithDiffTypeByStats(); VectorPtr ExecJsonContainsWithDiffType(EvalCtx& context); VectorPtr - ExecJsonContainsWithDiffTypeByKeyIndex(); + ExecJsonContainsWithDiffTypeByStats(); VectorPtr EvalArrayContainsForIndexSegment(DataType data_type); @@ -135,6 +551,7 @@ class PhyJsonContainsFilterExpr : public SegmentExpr { std::shared_ptr expr_; bool arg_inited_{false}; std::shared_ptr arg_set_; + std::shared_ptr arg_set_double_; }; } //namespace exec } // namespace milvus diff --git a/internal/core/src/exec/expression/TermExpr.cpp b/internal/core/src/exec/expression/TermExpr.cpp index f35c564cd0..f5d40209cf 100644 --- a/internal/core/src/exec/expression/TermExpr.cpp +++ b/internal/core/src/exec/expression/TermExpr.cpp @@ -529,17 +529,26 @@ PhyTermFilterExpr::ExecTermJsonVariableInField(EvalCtx& context) { template VectorPtr -PhyTermFilterExpr::ExecJsonInVariableByKeyIndex() { +PhyTermFilterExpr::ExecJsonInVariableByStats() { using GetType = std::conditional_t, std::string_view, ValueType>; auto real_batch_size = GetNextBatchSize(); - auto pointer = milvus::Json::pointer(expr_->column_.nested_path_); + auto pointer = milvus::index::JsonPointer(expr_->column_.nested_path_); if (!arg_inited_) { arg_set_ = std::make_shared>(expr_->vals_); - if constexpr (std::is_same_v) { - arg_set_float_ = std::make_shared>(expr_->vals_); + if constexpr (std::is_same_v) { + // for int64_t, we need to a double vector to store the values + auto int_arg_set = + std::static_pointer_cast>(arg_set_); + std::vector double_vals; + for (const auto& val : int_arg_set->GetElements()) { + double_vals.emplace_back(static_cast(val)); + } + arg_set_double_ = std::make_shared>(double_vals); + } else if constexpr (std::is_same_v) { + arg_set_double_ = arg_set_; } arg_inited_ = true; } @@ -551,154 +560,132 @@ PhyTermFilterExpr::ExecJsonInVariableByKeyIndex() { TargetBitmap(real_batch_size, true)); } - if (cached_index_chunk_id_ != 0) { - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto segment = dynamic_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); auto vals = expr_->vals_; - + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - auto filter_func = [this, segment, &field_id]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (!valid) { - invalid_row_ids.push_back(row_id); - invalid_offset.push_back(offset); - invalid_type.push_back(type); - invalid_size.push_back(size); - continue; - } - auto f = [&]() { - if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::INT32) && - type != uint8_t(milvus::index::JSONType::INT64) && - type != uint8_t(milvus::index::JSONType::FLOAT) && - type != uint8_t(milvus::index::JSONType::DOUBLE)) { - return false; + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); + + // process shredding data + auto try_execute = [&](milvus::index::JSONType json_type, + TargetBitmapView& res_view, + TargetBitmapView& valid_res_view, + auto GetType) { + auto target_field = index->GetShreddingField(pointer, json_type); + if (!target_field.empty()) { + using ColType = decltype(GetType); + auto shredding_executor = [this](const ColType* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; } - } else if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::STRING) && - type != - uint8_t( - milvus::index::JSONType::STRING_ESCAPE)) { - return false; + if constexpr (std::is_same_v) { + res[i] = this->arg_set_double_->In(src[i]); + } else { + res[i] = this->arg_set_->In(src[i]); } - } else if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::INT32) && - type != uint8_t(milvus::index::JSONType::INT64) && - type != uint8_t(milvus::index::JSONType::FLOAT) && - type != uint8_t(milvus::index::JSONType::DOUBLE)) { - return false; - } - } else if constexpr (std::is_same_v) { - if (type != uint8_t(milvus::index::JSONType::BOOL)) { - return false; - } - } - if constexpr (std::is_same_v) { - return this->arg_set_->In(value); - } else if constexpr (std::is_same_v) { - float restoredValue = *reinterpret_cast(&value); - return this->arg_set_float_->In(restoredValue); - } else if constexpr (std::is_same_v) { - bool restoredValue = *reinterpret_cast(&value); - return this->arg_set_->In(restoredValue); } }; - bitset[row_id] = f(); + index->ExecutorForShreddingData(target_field, + shredding_executor, + nullptr, + res_view, + valid_res_view); + LOG_DEBUG("using shredding data's field: {} count {}", + target_field, + res_view.count()); } - - auto f = [&](const milvus::Json& json, - uint8_t type, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - if (type == uint8_t(milvus::index::JSONType::STRING) || - type == uint8_t(milvus::index::JSONType::DOUBLE) || - type == uint8_t(milvus::index::JSONType::INT64)) { - if (type == uint8_t(milvus::index::JSONType::STRING)) { - if constexpr (std::is_same_v) { - auto val = json.at_string(offset, size); - return this->arg_set_->In(ValueType(val)); - } else { - return false; - } - } else if (type == - uint8_t(milvus::index::JSONType::DOUBLE)) { - if constexpr (std::is_same_v) { - auto val = std::stod( - std::string(json.at_string(offset, size))); - return this->arg_set_->In(ValueType(val)); - } else { - return false; - } - } else if (type == - uint8_t(milvus::index::JSONType::INT64)) { - if constexpr (std::is_same_v) { - auto val = std::stoll( - std::string(json.at_string(offset, size))); - return this->arg_set_->In(ValueType(val)); - } else { - return false; - } - } - } else { - auto val = json.at(offset, size); - if (val.error()) { - return false; - } - return this->arg_set_->In(ValueType(val.value())); - } - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, type, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + + if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::BOOL, + res_view, + valid_res_view, + bool{}); + } else if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::INT64, + res_view, + valid_res_view, + int64_t{}); + // and double compare + TargetBitmap res_double(active_count_, false); + TargetBitmapView res_double_view(res_double); + TargetBitmap res_double_valid(active_count_, true); + TargetBitmapView valid_res_double_view(res_double_valid); + try_execute(milvus::index::JSONType::DOUBLE, + res_double_view, + valid_res_double_view, + double{}); + res_view.inplace_or_with_count(res_double_view, active_count_); + valid_res_view.inplace_or_with_count(valid_res_double_view, + active_count_); + + } else if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::DOUBLE, + res_view, + valid_res_view, + double{}); + // and int64 compare + TargetBitmap res_int64(active_count_, false); + TargetBitmapView res_int64_view(res_int64); + TargetBitmap res_int64_valid(active_count_, true); + TargetBitmapView valid_res_int64_view(res_int64_valid); + try_execute(milvus::index::JSONType::INT64, + res_int64_view, + valid_res_int64_view, + int64_t{}); + res_view.inplace_or_with_count(res_int64_view, active_count_); + valid_res_view.inplace_or_with_count(valid_res_int64_view, + active_count_); + } else if constexpr (std::is_same_v || + std::is_same_v) { + try_execute(milvus::index::JSONType::STRING, + res_view, + valid_res_view, + std::string_view{}); + } + + // process shared data + auto shared_executor = [this, &res_view](milvus::BsonView bson, + uint32_t row_offset, + uint32_t value_offset) { + auto get_value = bson.ParseAsValueAtOffset(value_offset); + + if constexpr (std::is_same_v || + std::is_same_v) { + auto get_value = + bson.ParseAsValueAtOffset(value_offset); + if (get_value.has_value()) { + res_view[row_offset] = + this->arg_set_double_->In(get_value.value()); + } + return; + } else { + auto get_value = + bson.ParseAsValueAtOffset(value_offset); + if (get_value.has_value()) { + res_view[row_offset] = + this->arg_set_->In(get_value.value()); + } + return; + } + }; + if (!index->CanSkipShared(pointer)) { + index->ExecuteForSharedData(pointer, shared_executor); + } cached_index_chunk_id_ = 0; } @@ -719,8 +706,8 @@ PhyTermFilterExpr::ExecTermJsonFieldInVariable(EvalCtx& context) { auto* input = context.get_offset_input(); const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecJsonInVariableByKeyIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecJsonInVariableByStats(); } auto real_batch_size = diff --git a/internal/core/src/exec/expression/TermExpr.h b/internal/core/src/exec/expression/TermExpr.h index 2fc749f0fe..7a67c64106 100644 --- a/internal/core/src/exec/expression/TermExpr.h +++ b/internal/core/src/exec/expression/TermExpr.h @@ -141,7 +141,7 @@ class PhyTermFilterExpr : public SegmentExpr { template VectorPtr - ExecJsonInVariableByKeyIndex(); + ExecJsonInVariableByStats(); private: std::shared_ptr expr_; @@ -150,7 +150,7 @@ class PhyTermFilterExpr : public SegmentExpr { TargetBitmap cached_bits_; bool arg_inited_{false}; std::shared_ptr arg_set_; - std::shared_ptr arg_set_float_; + std::shared_ptr arg_set_double_; SingleElement arg_val_; int32_t consistency_level_ = 0; }; diff --git a/internal/core/src/exec/expression/UnaryExpr.cpp b/internal/core/src/exec/expression/UnaryExpr.cpp index 6f5f3295a6..685af02af6 100644 --- a/internal/core/src/exec/expression/UnaryExpr.cpp +++ b/internal/core/src/exec/expression/UnaryExpr.cpp @@ -16,14 +16,16 @@ #include "UnaryExpr.h" #include +#include #include "common/EasyAssert.h" #include "common/Json.h" #include "common/Types.h" #include "exec/expression/ExprCache.h" #include "common/type_c.h" #include "log/Log.h" +#include "monitor/Monitor.h" +#include "common/ScopedTimer.h" -#include namespace milvus { namespace exec { template @@ -663,8 +665,8 @@ PhyUnaryRangeFilterExpr::ExecRangeVisitorImplJson(EvalCtx& context) { const auto& bitmap_input = context.get_bitmap_input(); FieldId field_id = expr_->column_.field_id_; - if (CanUseJsonKeyIndex(field_id) && !has_offset_input_) { - return ExecRangeVisitorImplJsonForIndex(); + if (!has_offset_input_ && CanUseJsonStats(context, field_id)) { + return ExecRangeVisitorImplJsonByStats(); } auto real_batch_size = @@ -965,7 +967,7 @@ PhyUnaryRangeFilterExpr::SplitAtFirstSlashDigit(std::string input) { template VectorPtr -PhyUnaryRangeFilterExpr::ExecRangeVisitorImplJsonForIndex() { +PhyUnaryRangeFilterExpr::ExecRangeVisitorImplJsonByStats() { using GetType = std::conditional_t, std::string_view, @@ -974,509 +976,261 @@ PhyUnaryRangeFilterExpr::ExecRangeVisitorImplJsonForIndex() { if (real_batch_size == 0) { return nullptr; } - auto pointerpath = milvus::Json::pointer(expr_->column_.nested_path_); - auto pointerpair = SplitAtFirstSlashDigit(pointerpath); - std::string pointer = pointerpair.first; - std::string arrayIndex = pointerpair.second; -#define UnaryRangeJSONIndexCompare(cmp) \ - do { \ - auto x = json.at(offset, size); \ - if (x.error()) { \ - if constexpr (std::is_same_v) { \ - auto x = json.at(offset, size); \ - return !x.error() && (cmp); \ - } \ - return false; \ - } \ - return (cmp); \ - } while (false) + if (cached_index_chunk_id_ != 0 && + segment_->type() == SegmentType::Sealed) { + auto pointerpath = milvus::Json::pointer(expr_->column_.nested_path_); + auto pointerpair = SplitAtFirstSlashDigit(pointerpath); + std::string pointer = pointerpair.first; + size_t array_index = pointerpair.second.empty() + ? INVALID_ARRAY_INDEX + : std::stoi(pointerpair.second); -#define UnaryJSONTypeCompare(cmp) \ - do { \ - if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::STRING)) { \ - auto x = json.at_string(offset, size); \ - return (cmp); \ - } else { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::INT64)) { \ - auto x = \ - std::stoll(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else if (type == uint8_t(milvus::index::JSONType::DOUBLE)) { \ - auto x = std::stod(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::INT64)) { \ - auto x = \ - std::stoll(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else if (type == uint8_t(milvus::index::JSONType::DOUBLE)) { \ - auto x = std::stod(std::string(json.at_string(offset, size))); \ - return (cmp); \ - } else { \ - return false; \ - } \ - } \ - } while (false) + ExprValueType val = GetValueFromProto(expr_->val_); + auto op_type = expr_->op_type_; -#define UnaryJSONTypeCompareWithValue(cmp) \ - do { \ - if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - float x = *reinterpret_cast(&value); \ - return (cmp); \ - } else { \ - int64_t x = value; \ - return (cmp); \ - } \ - } else if constexpr (std::is_same_v) { \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - float x = *reinterpret_cast(&value); \ - return (cmp); \ - } else { \ - int64_t x = value; \ - return (cmp); \ - } \ - } else if constexpr (std::is_same_v) { \ - bool x = *reinterpret_cast(&value); \ - return (cmp); \ - } \ - } while (false) - -#define CompareValueWithOpType(type, value, val, op_type) \ - switch (op_type) { \ - case proto::plan::GreaterThan: \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - UnaryJSONTypeCompareWithValue(x > static_cast(val)); \ - } else { \ - UnaryJSONTypeCompareWithValue(x > val); \ - } \ - break; \ - case proto::plan::GreaterEqual: \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - UnaryJSONTypeCompareWithValue(x >= static_cast(val)); \ - } else { \ - UnaryJSONTypeCompareWithValue(x >= val); \ - } \ - break; \ - case proto::plan::LessThan: \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - UnaryJSONTypeCompareWithValue(x < static_cast(val)); \ - } else { \ - UnaryJSONTypeCompareWithValue(x < val); \ - } \ - break; \ - case proto::plan::LessEqual: \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - UnaryJSONTypeCompareWithValue(x <= static_cast(val)); \ - } else { \ - UnaryJSONTypeCompareWithValue(x <= val); \ - } \ - break; \ - case proto::plan::Equal: \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - UnaryJSONTypeCompareWithValue(x == static_cast(val)); \ - } else { \ - UnaryJSONTypeCompareWithValue(x == val); \ - } \ - break; \ - case proto::plan::NotEqual: \ - if (type == uint8_t(milvus::index::JSONType::FLOAT)) { \ - UnaryJSONTypeCompareWithValue(x != static_cast(val)); \ - } else { \ - UnaryJSONTypeCompareWithValue(x != val); \ - } \ - break; \ - default: \ - return false; \ - } - -#define UnaryRangeJSONIndexCompareWithArrayIndex(cmp) \ - do { \ - if (type != uint8_t(milvus::index::JSONType::UNKNOWN)) { \ - return false; \ - } \ - auto array = json.array_at(offset, size); \ - if (array.error()) { \ - return false; \ - } \ - auto value = array.at_pointer(arrayIndex); \ - if (value.error()) { \ - return false; \ - } \ - if constexpr (std::is_same_v || \ - std::is_same_v) { \ - if (!value.is_number()) { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (!value.is_string()) { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (!value.is_bool()) { \ - return false; \ - } \ - } \ - auto x = value.get(); \ - if (x.error()) { \ - if constexpr (std::is_same_v) { \ - auto x = value.get(); \ - return !x.error() && (cmp); \ - } \ - } \ - return (cmp); \ - } while (false) - -#define UnaryRangeJSONIndexCompareNotEqual(cmp) \ - do { \ - auto x = json.at(offset, size); \ - if (x.error()) { \ - if constexpr (std::is_same_v) { \ - auto x = json.at(offset, size); \ - return x.error() || (cmp); \ - } \ - return true; \ - } \ - return (cmp); \ - } while (false) -#define UnaryRangeJSONIndexCompareNotEqualWithArrayIndex(cmp) \ - do { \ - auto array = json.array_at(offset, size); \ - if (array.error()) { \ - return false; \ - } \ - auto value = array.at_pointer(arrayIndex); \ - if (value.error()) { \ - return false; \ - } \ - if constexpr (std::is_same_v || \ - std::is_same_v) { \ - if (!value.is_number()) { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (!value.is_string()) { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - if (!value.is_bool()) { \ - return false; \ - } \ - } \ - auto x = value.get(); \ - if (x.error()) { \ - if constexpr (std::is_same_v) { \ - auto x = value.get(); \ - return x.error() || (cmp); \ - } \ - } \ - return (cmp); \ - } while (false) - -#define CHECKISJSONTYPEWITHOFFSET(type) \ - (type == uint8_t(milvus::index::JSONType::STRING) || \ - type == uint8_t(milvus::index::JSONType::DOUBLE) || \ - type == uint8_t(milvus::index::JSONType::INT64)) - -#define CHECKJSONTYPEISNUMBER(type) \ - if ((type != uint8_t(milvus::index::JSONType::INT32)) && \ - (type != uint8_t(milvus::index::JSONType::INT64)) && \ - (type != uint8_t(milvus::index::JSONType::FLOAT)) && \ - (type != uint8_t(milvus::index::JSONType::DOUBLE))) { \ - return false; \ - } - -#define ISVALIDJSONTYPE(type, GetType) \ - if constexpr (std::is_same_v) { \ - CHECKJSONTYPEISNUMBER(type) \ - } else if constexpr (std::is_same_v) { \ - if ((type != uint8_t(milvus::index::JSONType::STRING)) && \ - (type != uint8_t(milvus::index::JSONType::STRING_ESCAPE))) { \ - return false; \ - } \ - } else if constexpr (std::is_same_v) { \ - CHECKJSONTYPEISNUMBER(type) \ - } else if constexpr (std::is_same_v) { \ - if (type != uint8_t(milvus::index::JSONType::BOOL)) { \ - return false; \ - } \ - } - - ExprValueType val = GetValueFromProto(expr_->val_); - auto op_type = expr_->op_type_; - - if (cached_index_chunk_id_ != 0) { - cached_index_chunk_id_ = 0; - const segcore::SegmentInternalInterface* segment = nullptr; - if (segment_->type() == SegmentType::Growing) { - segment = - dynamic_cast(segment_); - } else if (segment_->type() == SegmentType::Sealed) { - segment = dynamic_cast(segment_); - } + auto segment = static_cast(segment_); auto field_id = expr_->column_.field_id_; - auto* index = segment->GetJsonKeyIndex(field_id); + auto* index = segment->GetJsonStats(field_id); Assert(index != nullptr); - Assert(segment != nullptr); - auto filter_func = [segment, - field_id, - op_type, - val, - arrayIndex, - pointer](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - std::vector invalid_row_ids; - std::vector invalid_offset; - std::vector invalid_type; - std::vector invalid_size; - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - auto type = type_array[i]; - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto value = value_array[i]; - if (!valid) { - invalid_row_ids.push_back(row_id); - invalid_offset.push_back(offset); - invalid_type.push_back(type); - invalid_size.push_back(size); - continue; - } - auto f = [&]() { - if (type == uint8_t(milvus::index::JSONType::UNKNOWN) || - !arrayIndex.empty()) { - return false; - } - ISVALIDJSONTYPE(type, GetType); - switch (op_type) { - case proto::plan::GreaterThan: - CompareValueWithOpType(type, value, val, op_type); - case proto::plan::GreaterEqual: - CompareValueWithOpType(type, value, val, op_type); - case proto::plan::LessThan: - CompareValueWithOpType(type, value, val, op_type); - case proto::plan::LessEqual: - CompareValueWithOpType(type, value, val, op_type); - case proto::plan::Equal: - CompareValueWithOpType(type, value, val, op_type); - case proto::plan::NotEqual: - CompareValueWithOpType(type, value, val, op_type); - default: - return false; - } - }; - bitset[row_id] = f(); - } - auto f = [&](const milvus::Json& json, - uint8_t type, - uint16_t offset, - uint16_t size, - bool is_valid) { - if (!is_valid) { - return false; - } - switch (op_type) { - case proto::plan::GreaterThan: - if constexpr (std::is_same_v) { - return false; - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - ExprValueType(x.value()) > val); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare(x > val); - } else { - UnaryRangeJSONIndexCompare( - ExprValueType(x.value()) > val); - } - } - } - case proto::plan::GreaterEqual: - if constexpr (std::is_same_v) { - return false; - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - ExprValueType(x.value()) >= val); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare(x >= val); - } else { - UnaryRangeJSONIndexCompare( - ExprValueType(x.value()) >= val); - } - } - } - case proto::plan::LessThan: - if constexpr (std::is_same_v) { - return false; - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - ExprValueType(x.value()) < val); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare(x < val); - } else { - UnaryRangeJSONIndexCompare( - ExprValueType(x.value()) < val); - } - } - } - case proto::plan::LessEqual: - if constexpr (std::is_same_v) { - return false; - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - ExprValueType(x.value()) <= val); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare(x <= val); - } else { - UnaryRangeJSONIndexCompare( - ExprValueType(x.value()) <= val); - } - } - } + cached_index_chunk_res_ = std::make_shared(active_count_); + cached_index_chunk_valid_res_ = + std::make_shared(active_count_, true); + TargetBitmapView res_view(*cached_index_chunk_res_); + TargetBitmapView valid_res_view(*cached_index_chunk_valid_res_); - case proto::plan::Equal: - if constexpr (std::is_same_v) { - if (type != - uint8_t(milvus::index::JSONType::UNKNOWN)) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - return CompareTwoJsonArray(array.value(), val); - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - ExprValueType(x.value()) == val); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare(x == val); - } else { - UnaryRangeJSONIndexCompare( - ExprValueType(x.value()) == val); - } - } - } - case proto::plan::NotEqual: - if constexpr (std::is_same_v) { - if (type != - uint8_t(milvus::index::JSONType::UNKNOWN)) { - return false; - } - auto array = json.array_at(offset, size); - if (array.error()) { - return false; - } - return !CompareTwoJsonArray(array.value(), val); - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareNotEqualWithArrayIndex( - ExprValueType(x.value()) != val); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare(x != val); - } else { - UnaryRangeJSONIndexCompareNotEqual( - ExprValueType(x.value()) != val); - } - } - } - case proto::plan::InnerMatch: - case proto::plan::PostfixMatch: - case proto::plan::PrefixMatch: - if constexpr (std::is_same_v) { - return false; - } else { - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - milvus::query::Match( - ExprValueType(x.value()), - val, - op_type)); - } else { - if (CHECKISJSONTYPEWITHOFFSET(type)) { - UnaryJSONTypeCompare( - milvus::query::Match(x, val, op_type)); - } else { - UnaryRangeJSONIndexCompare( - milvus::query::Match( - ExprValueType(x.value()), - val, - op_type)); - } - } - } - case proto::plan::Match: - if constexpr (std::is_same_v) { - return false; - } else { - PatternMatchTranslator translator; - auto regex_pattern = translator(val); - RegexMatcher matcher(regex_pattern); - if (!arrayIndex.empty()) { - UnaryRangeJSONIndexCompareWithArrayIndex( - matcher(ExprValueType(x.value()))); - } else { - UnaryRangeJSONIndexCompare( - matcher(ExprValueType(x.value()))); - } - } - default: - return false; - } - }; - segment->BulkGetJsonData( - field_id, - [&](const milvus::Json& json, size_t i, bool is_valid) { - auto row_id = invalid_row_ids[i]; - auto type = invalid_type[i]; - auto offset = invalid_offset[i]; - auto size = invalid_size[i]; - bitset[row_id] = f(json, type, offset, size, is_valid); - }, - invalid_row_ids.data(), - invalid_row_ids.size()); + // process shredding data + auto try_execute = [&](milvus::index::JSONType json_type, + TargetBitmapView& res_view, + TargetBitmapView& valid_res_view, + auto GetType, + auto ValType) { + auto target_field = index->GetShreddingField(pointer, json_type); + if (!target_field.empty()) { + using ColType = decltype(GetType); + using ValType = decltype(ValType); + ShreddingExecutor executor( + op_type, pointer, val); + index->ExecutorForShreddingData( + target_field, executor, nullptr, res_view, valid_res_view); + LOG_DEBUG( + "using shredding data's field: {} with value {}, count {}", + target_field, + val, + res_view.count()); + } }; - bool is_growing = segment_->type() == SegmentType::Growing; - bool is_strong_consistency = consistency_level_ == 0; - cached_index_chunk_res_ = std::make_shared( - std::move(index->FilterByPath(pointer, - active_count_, - is_growing, - is_strong_consistency, - filter_func))); + + { + milvus::ScopedTimer timer( + "unary_json_stats_shredding_data", [](double ms) { + milvus::monitor::internal_json_stats_latency_shredding + .Observe(ms); + }); + + if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::BOOL, + res_view, + valid_res_view, + bool{}, + bool{}); + } else if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::INT64, + res_view, + valid_res_view, + int64_t{}, + int64_t{}); + + // and double compare + TargetBitmap res_double(active_count_, false); + TargetBitmapView res_double_view(res_double); + TargetBitmap res_double_valid(active_count_, true); + TargetBitmapView valid_res_double_view(res_double_valid); + try_execute(milvus::index::JSONType::DOUBLE, + res_double_view, + valid_res_double_view, + double{}, + int64_t{}); + res_view.inplace_or_with_count(res_double_view, active_count_); + valid_res_view.inplace_or_with_count(valid_res_double_view, + active_count_); + } else if constexpr (std::is_same_v) { + try_execute(milvus::index::JSONType::DOUBLE, + res_view, + valid_res_view, + double{}, + double{}); + + // add int64 compare + TargetBitmap res_int64(active_count_, false); + TargetBitmapView res_int64_view(res_int64); + TargetBitmap res_int64_valid(active_count_, true); + TargetBitmapView valid_res_int64_view(res_int64_valid); + try_execute(milvus::index::JSONType::INT64, + res_int64_view, + valid_res_int64_view, + int64_t{}, + double{}); + res_view.inplace_or_with_count(res_int64_view, active_count_); + valid_res_view.inplace_or_with_count(valid_res_int64_view, + active_count_); + } else if constexpr (std::is_same_v || + std::is_same_v) { + try_execute(milvus::index::JSONType::STRING, + res_view, + valid_res_view, + GetType{}, + GetType{}); + } else if constexpr (std::is_same_v) { + // ARRAY shredding data: stored as BSON binary in binary column + auto target_field = index->GetShreddingField( + pointer, milvus::index::JSONType::ARRAY); + if (!target_field.empty()) { + ShreddingArrayBsonExecutor executor(op_type, pointer, val); + index->ExecutorForShreddingData( + target_field, + executor, + nullptr, + res_view, + valid_res_view); + LOG_DEBUG("using shredding array field: {}, count {}", + target_field, + res_view.count()); + } + } + } + + // process shared data + auto shared_executor = [op_type, val, array_index, &res_view]( + milvus::BsonView bson, + uint32_t row_id, + uint32_t value_offset) { + if constexpr (std::is_same_v) { + Assert(op_type == proto::plan::OpType::Equal || + op_type == proto::plan::OpType::NotEqual); + if (array_index != INVALID_ARRAY_INDEX) { + auto array_value = bson.ParseAsArrayAtOffset(value_offset); + if (!array_value.has_value()) { + res_view[row_id] = false; + return; + } + auto sub_array = milvus::BsonView::GetNthElementInArray< + bsoncxx::array::view>(array_value.value().data(), + array_index); + if (!sub_array.has_value()) { + res_view[row_id] = false; + return; + } + res_view[row_id] = + op_type == proto::plan::OpType::Equal + ? CompareTwoJsonArray(sub_array.value(), val) + : !CompareTwoJsonArray(sub_array.value(), val); + } else { + auto array_value = bson.ParseAsArrayAtOffset(value_offset); + if (!array_value.has_value()) { + res_view[row_id] = false; + return; + } + res_view[row_id] = + op_type == proto::plan::OpType::Equal + ? CompareTwoJsonArray(array_value.value(), val) + : !CompareTwoJsonArray(array_value.value(), val); + } + } else { + std::optional get_value; + if (array_index != INVALID_ARRAY_INDEX) { + auto array_value = bson.ParseAsArrayAtOffset(value_offset); + if (!array_value.has_value()) { + res_view[row_id] = false; + return; + } + get_value = milvus::BsonView::GetNthElementInArray( + array_value.value().data(), array_index); + // If GetType is int and value is not found, try double + if constexpr (std::is_same_v) { + if (!get_value.has_value()) { + auto get_value = + milvus::BsonView::GetNthElementInArray( + array_value.value().data(), array_index); + if (get_value.has_value()) { + res_view[row_id] = UnaryCompare( + get_value.value(), val, op_type); + } + return; + } + } else if constexpr (std::is_same_v) { + if (!get_value.has_value()) { + auto get_value = + milvus::BsonView::GetNthElementInArray( + array_value.value().data(), array_index); + if (get_value.has_value()) { + res_view[row_id] = UnaryCompare( + get_value.value(), val, op_type); + } + return; + } + } + } else { + get_value = + bson.ParseAsValueAtOffset(value_offset); + // If GetType is int and value is not found, try double + if constexpr (std::is_same_v) { + if (!get_value.has_value()) { + auto get_value = + bson.ParseAsValueAtOffset(value_offset); + if (get_value.has_value()) { + res_view[row_id] = UnaryCompare( + get_value.value(), val, op_type); + } + return; + } + } else if constexpr (std::is_same_v) { + if (!get_value.has_value()) { + auto get_value = bson.ParseAsValueAtOffset( + value_offset); + if (get_value.has_value()) { + res_view[row_id] = UnaryCompare( + get_value.value(), val, op_type); + } + return; + } + } + } + if (!get_value.has_value()) { + res_view[row_id] = false; + return; + } + res_view[row_id] = + UnaryCompare(get_value.value(), val, op_type); + } + }; + + std::set target_types; + if constexpr (std::is_same_v) { + target_types.insert(milvus::index::JSONType::STRING); + } else if constexpr (std::is_same_v || + std::is_same_v) { + target_types.insert(milvus::index::JSONType::INT64); + target_types.insert(milvus::index::JSONType::DOUBLE); + } else if constexpr (std::is_same_v) { + target_types.insert(milvus::index::JSONType::BOOL); + } + + { + milvus::ScopedTimer timer( + "unary_json_stats_shared_data", [](double ms) { + milvus::monitor::internal_json_stats_latency_shared.Observe( + ms); + }); + + if (!index->CanSkipShared(pointer, target_types)) { + index->ExecuteForSharedData(pointer, shared_executor); + } + } + + cached_index_chunk_id_ = 0; } + TargetBitmap result; result.append( *cached_index_chunk_res_, current_data_global_pos_, real_batch_size); diff --git a/internal/core/src/exec/expression/UnaryExpr.h b/internal/core/src/exec/expression/UnaryExpr.h index 1c5cf3d864..c19b9939ba 100644 --- a/internal/core/src/exec/expression/UnaryExpr.h +++ b/internal/core/src/exec/expression/UnaryExpr.h @@ -31,15 +31,76 @@ #include "segcore/SegmentInterface.h" #include "query/Utils.h" #include "common/RegexQuery.h" +#include "exec/expression/Utils.h" +#include "common/bson_view.h" namespace milvus { namespace exec { -template +template +bool +UnaryCompare(const T& get_value, const U& val, proto::plan::OpType op_type) { + switch (op_type) { + case proto::plan::GreaterThan: + return get_value > val; + case proto::plan::GreaterEqual: + return get_value >= val; + case proto::plan::LessThan: + return get_value < val; + case proto::plan::LessEqual: + return get_value <= val; + case proto::plan::Equal: + return get_value == val; + case proto::plan::NotEqual: + return get_value != val; + case proto::plan::InnerMatch: + case proto::plan::PostfixMatch: + case proto::plan::PrefixMatch: + if constexpr (std::is_same_v || + std::is_same_v) { + return milvus::query::Match(get_value, val, op_type); + } else { + return false; + } + case proto::plan::Match: + if constexpr (std::is_same_v || + std::is_same_v) { + PatternMatchTranslator translator; + auto regex_pattern = translator(val); + RegexMatcher matcher(regex_pattern); + return matcher(get_value); + } else { + return false; + } + default: + return false; + } +} + +template struct UnaryElementFuncForMatch { using IndexInnerType = std::conditional_t, std::string, T>; + void + operator()(const T* src, + size_t size, + IndexInnerType val, + TargetBitmapView res) { + static_assert( + filter_type == FilterType::sequential, + "this override operator() of UnaryElementFuncForMatch does " + "not support FilterType::random"); + + PatternMatchTranslator translator; + auto regex_pattern = translator(val); + RegexMatcher matcher(regex_pattern); + + for (int i = 0; i < size; ++i) { + res[i] = matcher(src[i]); + } + } + void operator()(const T* src, size_t size, @@ -65,11 +126,81 @@ struct UnaryElementFuncForMatch { } }; -template +template struct UnaryElementFunc { using IndexInnerType = std::conditional_t, std::string, T>; + void + operator()(const T* src, + size_t size, + TargetBitmapView res, + IndexInnerType val) { + static_assert(filter_type == FilterType::sequential, + "this override operator() of UnaryElementFunc does not " + "support FilterType::random"); + if constexpr (op == proto::plan::OpType::Match) { + UnaryElementFuncForMatch func; + func(src, size, val, res); + return; + } + + if constexpr (std::is_same_v || + std::is_same_v) { + for (int i = 0; i < size; ++i) { + if constexpr (op == proto::plan::OpType::Equal) { + res[i] = src[i] == val; + } else if constexpr (op == proto::plan::OpType::NotEqual) { + res[i] = src[i] != val; + } else if constexpr (op == proto::plan::OpType::GreaterThan) { + res[i] = src[i] > val; + } else if constexpr (op == proto::plan::OpType::LessThan) { + res[i] = src[i] < val; + } else if constexpr (op == proto::plan::OpType::GreaterEqual) { + res[i] = src[i] >= val; + } else if constexpr (op == proto::plan::OpType::LessEqual) { + res[i] = src[i] <= val; + } else if constexpr (op == proto::plan::OpType::PrefixMatch || + op == proto::plan::OpType::PostfixMatch || + op == proto::plan::OpType::InnerMatch) { + res[i] = milvus::query::Match(src[i], val, op); + } else { + ThrowInfo( + OpTypeInvalid, + fmt::format( + "unsupported op_type:{} for UnaryElementFunc", op)); + } + } + return; + } + + if constexpr (op == proto::plan::OpType::Equal) { + res.inplace_compare_val( + src, size, val); + } else if constexpr (op == proto::plan::OpType::NotEqual) { + res.inplace_compare_val( + src, size, val); + } else if constexpr (op == proto::plan::OpType::GreaterThan) { + res.inplace_compare_val( + src, size, val); + } else if constexpr (op == proto::plan::OpType::LessThan) { + res.inplace_compare_val( + src, size, val); + } else if constexpr (op == proto::plan::OpType::GreaterEqual) { + res.inplace_compare_val( + src, size, val); + } else if constexpr (op == proto::plan::OpType::LessEqual) { + res.inplace_compare_val( + src, size, val); + } else { + ThrowInfo( + OpTypeInvalid, + fmt::format("unsupported op_type:{} for UnaryElementFunc", op)); + } + } + void operator()(const T* src, size_t size, @@ -385,6 +516,222 @@ struct UnaryIndexFunc { } }; +template +void +BatchUnaryCompare(const T* src, + size_t size, + U& val, + proto::plan::OpType op_type, + TargetBitmapView res) { + if constexpr (std::is_integral_v || std::is_floating_point_v) { + using milvus::bitset::CompareOpType; + switch (op_type) { + case proto::plan::GreaterThan: { + res.inplace_compare_val( + src, size, static_cast(val), CompareOpType::GT); + return; + } + case proto::plan::GreaterEqual: { + res.inplace_compare_val( + src, size, static_cast(val), CompareOpType::GE); + return; + } + case proto::plan::LessThan: { + res.inplace_compare_val( + src, size, static_cast(val), CompareOpType::LT); + return; + } + case proto::plan::LessEqual: { + res.inplace_compare_val( + src, size, static_cast(val), CompareOpType::LE); + return; + } + case proto::plan::Equal: { + res.inplace_compare_val( + src, size, static_cast(val), CompareOpType::EQ); + return; + } + case proto::plan::NotEqual: { + res.inplace_compare_val( + src, size, static_cast(val), CompareOpType::NE); + return; + } + default: + break; + } + } + switch (op_type) { + case proto::plan::GreaterThan: { + for (int i = 0; i < size; ++i) { + res[i] = src[i] > val; + } + break; + } + case proto::plan::GreaterEqual: { + for (int i = 0; i < size; ++i) { + res[i] = src[i] >= val; + } + break; + } + case proto::plan::LessThan: { + for (int i = 0; i < size; ++i) { + res[i] = src[i] < val; + } + break; + } + case proto::plan::LessEqual: { + for (int i = 0; i < size; ++i) { + res[i] = src[i] <= val; + } + break; + } + case proto::plan::Equal: { + for (int i = 0; i < size; ++i) { + res[i] = src[i] == val; + } + break; + } + case proto::plan::NotEqual: { + for (int i = 0; i < size; ++i) { + res[i] = src[i] != val; + } + break; + } + case proto::plan::InnerMatch: + case proto::plan::PostfixMatch: + case proto::plan::PrefixMatch: { + for (int i = 0; i < size; ++i) { + res[i] = milvus::query::Match(src[i], val, op_type); + } + break; + } + case proto::plan::Match: { + if constexpr (std::is_same_v || + std::is_same_v) { + PatternMatchTranslator translator; + auto regex_pattern = translator(val); + RegexMatcher matcher(regex_pattern); + for (int i = 0; i < size; ++i) { + res[i] = matcher(src[i]); + } + break; + } + } + default: { + ThrowInfo( + OpTypeInvalid, + fmt::format("unsupported op_type:{} for BatchUnaryCompare", + op_type)); + } + } +} + +template +class ShreddingExecutor { + using IndexInnerType = + std::conditional_t, + std::string, + GetType>; + + public: + ShreddingExecutor(proto::plan::OpType op_type, + const std::string& pointer, + ValType val) + : op_type_(op_type), val_(val), pointer_(pointer) { + } + + void + operator()(const GetType* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + if constexpr (std::is_same_v) { + ThrowInfo(ErrorCode::UnexpectedError, + "need using ShreddingArrayBsonExecutor for array type in " + "shredding data"); + } else { + ExecuteOperation(src, size, res); + HandleValidData(valid, size, res, valid_res); + } + } + + private: + void + ExecuteOperation(const GetType* src, size_t size, TargetBitmapView res) { + BatchUnaryCompare(src, size, val_, op_type_, res); + } + + void + HandleValidData(const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + if (valid != nullptr) { + for (int i = 0; i < size; ++i) { + if (!valid[i]) { + res[i] = valid_res[i] = false; + } + } + } + } + + proto::plan::OpType op_type_; + ValType val_; + std::string pointer_; +}; + +// Executor for shredding ARRAY type stored as BSON binary in variable-length +// columns (std::string_view). Only supports Equal/NotEqual. +class ShreddingArrayBsonExecutor { + public: + ShreddingArrayBsonExecutor(proto::plan::OpType op_type, + const std::string& pointer, + const proto::plan::Array& val) + : op_type_(op_type), val_(val), pointer_(pointer) { + } + + void + operator()(const std::string_view* src, + const bool* valid, + size_t size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (size_t i = 0; i < size; ++i) { + if (valid != nullptr && !valid[i]) { + res[i] = valid_res[i] = false; + continue; + } + milvus::BsonView bson( + reinterpret_cast(src[i].data()), src[i].size()); + auto array_view = bson.ParseAsArrayAtOffset(0); + if (!array_view.has_value()) { + res[i] = false; + continue; + } + bool equal = CompareTwoJsonArray(array_view.value(), val_); + switch (op_type_) { + case proto::plan::Equal: + res[i] = equal; + break; + case proto::plan::NotEqual: + res[i] = !equal; + break; + default: + ThrowInfo(OpTypeInvalid, + fmt::format("unsupported op_type:{} for ARRAY in " + "ShreddingArrayBsonExecutor", + op_type_)); + } + } + } + + private: + proto::plan::OpType op_type_; + const proto::plan::Array& val_; + std::string pointer_; +}; + class PhyUnaryRangeFilterExpr : public SegmentExpr { public: PhyUnaryRangeFilterExpr( @@ -473,7 +820,7 @@ class PhyUnaryRangeFilterExpr : public SegmentExpr { template VectorPtr - ExecRangeVisitorImplJsonForIndex(); + ExecRangeVisitorImplJsonByStats(); template VectorPtr diff --git a/internal/core/src/exec/expression/Utils.h b/internal/core/src/exec/expression/Utils.h index 8af1edbd42..8eeb735f09 100644 --- a/internal/core/src/exec/expression/Utils.h +++ b/internal/core/src/exec/expression/Utils.h @@ -24,7 +24,7 @@ #include "exec/expression/Expr.h" #include "segcore/SegmentInterface.h" #include "query/Utils.h" - +#include "common/bson_view.h" namespace milvus { namespace exec { @@ -128,6 +128,94 @@ CompareTwoJsonArray(T arr1, const proto::plan::Array& arr2) { return true; } +template <> +inline bool +CompareTwoJsonArray(bsoncxx::array::view arr1, + const proto::plan::Array& arr2) { + size_t bson_array_length = std::distance(arr1.begin(), arr1.end()); + + if (arr2.array_size() != bson_array_length) { + return false; + } + + auto bson_it = arr1.begin(); + for (int i = 0; i < arr2.array_size(); ++i, ++bson_it) { + if (bson_it == arr1.end()) { + return false; + } + + const auto& bson_elem = *bson_it; + const auto& proto_elem = arr2.array(i); + + switch (proto_elem.val_case()) { + case proto::plan::GenericValue::kBoolVal: { + if (bson_elem.type() != bsoncxx::type::k_bool) { + return false; + } + if (bson_elem.get_bool().value != proto_elem.bool_val()) { + return false; + } + break; + } + case proto::plan::GenericValue::kInt64Val: { + if (bson_elem.type() == bsoncxx::type::k_int32) { + const int32_t val = bson_elem.get_int32().value; + if (val != proto_elem.int64_val()) { + return false; + } + } else if (bson_elem.type() == bsoncxx::type::k_int64) { + const int64_t val = bson_elem.get_int64().value; + if (val != proto_elem.int64_val()) { + return false; + } + } else { + return false; + } + break; + } + case proto::plan::GenericValue::kFloatVal: { + double bson_val; + switch (bson_elem.type()) { + case bsoncxx::type::k_int32: + bson_val = bson_elem.get_int32().value; + break; + case bsoncxx::type::k_int64: + bson_val = bson_elem.get_int64().value; + break; + case bsoncxx::type::k_double: + bson_val = bson_elem.get_double().value; + break; + default: + return false; + } + if (bson_val != proto_elem.float_val()) { + return false; + } + break; + } + case proto::plan::GenericValue::kStringVal: { + if (bson_elem.type() != bsoncxx::type::k_string) { + return false; + } + auto bson_str_view = bson_elem.get_string().value; + if (std::string(bson_str_view.data(), bson_str_view.size()) != + proto_elem.string_val()) { + return false; + } + break; + } + default: + return false; + } + } + + if (bson_it != arr1.end()) { + return false; + } + + return true; +} + template T GetValueFromProtoInternal(const milvus::proto::plan::GenericValue& value_proto, diff --git a/internal/core/src/index/IndexStats.h b/internal/core/src/index/IndexStats.h index 4f1f116231..6b14a637d9 100644 --- a/internal/core/src/index/IndexStats.h +++ b/internal/core/src/index/IndexStats.h @@ -70,6 +70,11 @@ class IndexStats { int64_t GetSerializedSize() const; + const std::vector& + GetSerializedIndexFileInfo() const { + return serialized_index_infos_; + } + private: IndexStats(int64_t mem_size, std::vector&& serialized_index_infos); diff --git a/internal/core/src/index/InvertedIndexTantivy.h b/internal/core/src/index/InvertedIndexTantivy.h index 68fc3fb4e6..f1f56d24cf 100644 --- a/internal/core/src/index/InvertedIndexTantivy.h +++ b/internal/core/src/index/InvertedIndexTantivy.h @@ -320,7 +320,7 @@ class InvertedIndexTantivy : public ScalarIndex { // Therefore, we should provide a way to allow higher version of milvus to build tantivy index with low version. uint32_t tantivy_index_version_{0}; - // for now, only TextMatchIndex and JsonKeyStatsInvertedIndex can be built for growing segment, + // for now, only TextMatchIndex can be built for growing segment, // and can read and insert concurrently. bool is_growing_{false}; }; diff --git a/internal/core/src/index/JsonKeyStatsInvertedIndex.cpp b/internal/core/src/index/JsonKeyStatsInvertedIndex.cpp deleted file mode 100644 index ff3ed44139..0000000000 --- a/internal/core/src/index/JsonKeyStatsInvertedIndex.cpp +++ /dev/null @@ -1,539 +0,0 @@ -// Copyright (C) 2019-2020 Zilliz. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software distributed under the License -// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express -// or implied. See the License for the specific language governing permissions and limitations under the License - -#include -#include - -#include "index/JsonKeyStatsInvertedIndex.h" -#include "index/InvertedIndexUtil.h" -#include "index/Utils.h" -#include "storage/MmapManager.h" - -namespace milvus::index { -constexpr const char* TMP_JSON_INVERTED_LOG_PREFIX = - "/tmp/milvus/json-key-inverted-index-log/"; -constexpr size_t MEMORY_THRESHOLD = 128 * 1024 * 1024; -constexpr size_t VECTOR_ELEMENT_SIZE = 8; -constexpr size_t KEY_OVERHEAD = 2; -size_t current_batch_size_ = 0; - -size_t -calculateMemoryUsage(const std::map>& mp) { - size_t total_memory = 0; - for (const auto& [key, vec] : mp) { - total_memory += (key.length()); - total_memory += (vec.size() * VECTOR_ELEMENT_SIZE); - } - return total_memory * KEY_OVERHEAD; -} - -void -JsonKeyStatsInvertedIndex::AddJSONEncodeValue( - const std::vector& paths, - uint8_t flag, - uint8_t type, - uint32_t row_id, - uint16_t offset, - uint16_t length, - int32_t value, - std::map>& mp) { - std::string key = milvus::Json::pointer(paths); - LOG_DEBUG( - "insert inverted key: {}, flag: {}, type: {}, row_id: {}, offset: " - "{}, length:{}, value:{}", - key, - flag, - type, - row_id, - offset, - length, - value); - int64_t combine_id = 0; - - if (flag) { - combine_id = EncodeValue(flag, type, row_id, value); - } else { - combine_id = EncodeOffset(flag, type, row_id, offset, length); - } - - mp[key].push_back(combine_id); - - if (calculateMemoryUsage(mp) >= MEMORY_THRESHOLD) { - AddInvertedRecord(mp); - } -} - -void -JsonKeyStatsInvertedIndex::AddInvertedRecord( - std::map>& mp) { - std::vector json_offsets_lens; - std::vector keys; - std::vector json_offsets; - if (mp.empty()) { - return; - } - for (auto& iter : mp) { - keys.push_back(iter.first.c_str()); - json_offsets.push_back(iter.second.data()); - json_offsets_lens.push_back(iter.second.size()); - } - wrapper_->add_json_key_stats_data_by_batch(keys.data(), - json_offsets.data(), - json_offsets_lens.data(), - keys.size()); - mp.clear(); - current_batch_size_ = 0; -} - -void -JsonKeyStatsInvertedIndex::TravelJson( - const char* json, - jsmntok* tokens, - int& index, - std::vector& path, - int32_t offset, - std::map>& mp) { - jsmntok current = tokens[0]; - Assert(current.type != JSMN_UNDEFINED); - if (current.type == JSMN_OBJECT) { - if (!path.empty()) { - AddJSONEncodeValue(path, - 0, - 0, - offset, - current.start, - current.end - current.start, - 0, - mp); - } - int j = 1; - for (int i = 0; i < current.size; i++) { - Assert(tokens[j].type == JSMN_STRING && tokens[j].size != 0); - std::string key(json + tokens[j].start, - tokens[j].end - tokens[j].start); - path.push_back(key); - j++; - int consumed = 0; - TravelJson(json, tokens + j, consumed, path, offset, mp); - path.pop_back(); - j += consumed; - } - index = j; - } else if (current.type == JSMN_PRIMITIVE) { - std::string value(json + current.start, current.end - current.start); - auto type = getType(value); - - if (type == JSONType::INT32) { - AddJSONEncodeValue(path, - 1, - static_cast(JSONType::INT32), - offset, - current.start, - current.end - current.start, - stoi(value), - mp); - } else if (type == JSONType::INT64) { - AddJSONEncodeValue(path, - 0, - static_cast(JSONType::INT64), - offset, - current.start, - current.end - current.start, - 0, - mp); - } else if (type == JSONType::FLOAT) { - auto fvalue = stof(value); - int32_t valueBits = *reinterpret_cast(&fvalue); - AddJSONEncodeValue(path, - 1, - static_cast(JSONType::FLOAT), - offset, - current.start, - current.end - current.start, - valueBits, - mp); - } else if (type == JSONType::DOUBLE) { - AddJSONEncodeValue(path, - 0, - static_cast(JSONType::DOUBLE), - offset, - current.start, - current.end - current.start, - 0, - mp); - } else if (type == JSONType::BOOL) { - AddJSONEncodeValue(path, - 1, - static_cast(JSONType::BOOL), - offset, - current.start, - current.end - current.start, - value == "true" ? 1 : 0, - mp); - } - - index++; - } else if (current.type == JSMN_ARRAY) { - AddJSONEncodeValue(path, - 0, - static_cast(JSONType::UNKNOWN), - offset, - current.start, - current.end - current.start, - 0, - mp); - // skip array parse - int count = current.size; - int j = 1; - while (count > 0) { - count--; - if (tokens[j].size != 0) { - count += tokens[j].size; - } - j++; - } - index = j; - } else if (current.type == JSMN_STRING) { - Assert(current.size == 0); - std::string value(json + current.start, current.end - current.start); - if (has_escape_sequence(value)) { - AddJSONEncodeValue(path, - 0, - static_cast(JSONType::STRING_ESCAPE), - offset, - current.start - 1, - current.end - current.start + 2, - 0, - mp); - } else { - AddJSONEncodeValue(path, - 0, - static_cast(JSONType::STRING), - offset, - current.start, - current.end - current.start, - 0, - mp); - } - index++; - } -} - -void -JsonKeyStatsInvertedIndex::AddJson( - const char* json, - int64_t offset, - std::map>& mp) { - jsmn_parser parser; - jsmntok_t* tokens = (jsmntok_t*)malloc(16 * sizeof(jsmntok_t)); - if (!tokens) { - ThrowInfo(ErrorCode::UnexpectedError, "alloc jsmn token failed"); - return; - } - int num_tokens = 0; - int token_capacity = 16; - - jsmn_init(&parser); - - while (1) { - int r = jsmn_parse(&parser, json, strlen(json), tokens, token_capacity); - if (r < 0) { - if (r == JSMN_ERROR_NOMEM) { - // Reallocate tokens array if not enough space - token_capacity *= 2; - tokens = (jsmntok_t*)realloc( - tokens, token_capacity * sizeof(jsmntok_t)); - if (!tokens) { - ThrowInfo(ErrorCode::UnexpectedError, "realloc failed"); - } - continue; - } else { - free(tokens); - ThrowInfo(ErrorCode::UnexpectedError, - "Failed to parse Json: {}, error: {}", - json, - int(r)); - } - } - num_tokens = r; - break; - } - - int index = 0; - std::vector paths; - TravelJson(json, tokens, index, paths, offset, mp); - free(tokens); -} - -JsonKeyStatsInvertedIndex::JsonKeyStatsInvertedIndex( - const storage::FileManagerContext& ctx, - bool is_load, - int64_t json_stats_tantivy_memory_budget, - uint32_t tantivy_index_version) - : commit_interval_in_ms_(std::numeric_limits::max()), - last_commit_time_(stdclock::now()) { - LOG_INFO("json_stats_tantivy_memory_budget:{}", - json_stats_tantivy_memory_budget); - schema_ = ctx.fieldDataMeta.field_schema; - field_id_ = ctx.fieldDataMeta.field_id; - mem_file_manager_ = std::make_shared(ctx); - disk_file_manager_ = std::make_shared(ctx); - if (is_load) { - path_ = disk_file_manager_->GetLocalJsonKeyIndexPrefix(); - } else { - path_ = disk_file_manager_->GetLocalTempJsonKeyIndexPrefix(); - boost::filesystem::create_directories(path_); - std::string field_name = - std::to_string(disk_file_manager_->GetFieldDataMeta().field_id); - wrapper_ = std::make_shared( - field_name.c_str(), - path_.c_str(), - tantivy_index_version, - false, /* in_ram */ - 1, - json_stats_tantivy_memory_budget); - } -} - -JsonKeyStatsInvertedIndex::JsonKeyStatsInvertedIndex( - int64_t commit_interval_in_ms, const char* unique_id) - : commit_interval_in_ms_(commit_interval_in_ms), - last_commit_time_(stdclock::now()) { - wrapper_ = std::make_shared( - unique_id, "", TANTIVY_INDEX_LATEST_VERSION, true /* in_ram */); - set_is_growing(true); -} - -JsonKeyStatsInvertedIndex::JsonKeyStatsInvertedIndex( - int64_t commit_interval_in_ms, - const char* unique_id, - const std::string& path) - : commit_interval_in_ms_(commit_interval_in_ms), - last_commit_time_(stdclock::now()) { - boost::filesystem::path prefix = path; - boost::filesystem::path sub_path = unique_id; - path_ = (prefix / sub_path).string(); - boost::filesystem::create_directories(path_); - wrapper_ = std::make_shared( - unique_id, path_.c_str(), TANTIVY_INDEX_LATEST_VERSION); - set_is_growing(true); -} - -IndexStatsPtr -JsonKeyStatsInvertedIndex::Upload(const Config& config) { - finish(); - - index_build_timestamps_.index_build_done_ = - std::chrono::system_clock::now(); - LOG_INFO( - "index build done for json key index, field id:{}, json parse " - "duration: {}s, " - "tantivy document add schedule duration : {}s, " - "tantivy total duration : {}s, " - "total duration : {}s", - field_id_, - index_build_timestamps_.getJsonParsingDuration(), - index_build_timestamps_.getTantivyAddSchedulingDuration(), - index_build_timestamps_.getTantivyTotalDuration(), - index_build_timestamps_.getIndexBuildTotalDuration()); - - boost::filesystem::path p(path_); - boost::filesystem::directory_iterator end_iter; - - for (boost::filesystem::directory_iterator iter(p); iter != end_iter; - iter++) { - if (boost::filesystem::is_directory(*iter)) { - LOG_WARN("{} is a directory", iter->path().string()); - } else { - LOG_INFO("trying to add json key inverted index log: {}", - iter->path().string()); - AssertInfo( - disk_file_manager_->AddJsonKeyIndexLog(iter->path().string()), - "failed to add json key inverted index log: {}", - iter->path().string()); - LOG_INFO("json key inverted index log: {} added", - iter->path().string()); - } - } - - auto remote_paths_to_size = disk_file_manager_->GetRemotePathsToFileSize(); - - auto binary_set = Serialize(config); - mem_file_manager_->AddFile(binary_set); - auto remote_mem_path_to_size = - mem_file_manager_->GetRemotePathsToFileSize(); - - std::vector index_files; - index_files.reserve(remote_paths_to_size.size() + - remote_mem_path_to_size.size()); - for (auto& file : remote_paths_to_size) { - index_files.emplace_back(disk_file_manager_->GetFileName(file.first), - file.second); - } - for (auto& file : remote_mem_path_to_size) { - index_files.emplace_back(file.first, file.second); - } - return IndexStats::New(mem_file_manager_->GetAddedTotalMemSize() + - disk_file_manager_->GetAddedTotalFileSize(), - std::move(index_files)); -} - -void -JsonKeyStatsInvertedIndex::Load(milvus::tracer::TraceContext ctx, - const Config& config) { - auto index_files = - GetValueFromConfig>(config, INDEX_FILES); - AssertInfo(index_files.has_value(), - "index file paths is empty when load json key index"); - for (auto& index_file : index_files.value()) { - boost::filesystem::path p(index_file); - if (!p.has_parent_path()) { - auto remote_prefix = - disk_file_manager_->GetRemoteJsonKeyLogPrefix(); - index_file = remote_prefix + "/" + index_file; - } - } - auto load_priority = - GetValueFromConfig( - config, milvus::LOAD_PRIORITY) - .value_or(milvus::proto::common::LoadPriority::HIGH); - disk_file_manager_->CacheJsonKeyIndexToDisk(index_files.value(), - load_priority); - AssertInfo( - tantivy_index_exist(path_.c_str()), "index not exist: {}", path_); - - auto load_in_mmap = - GetValueFromConfig(config, ENABLE_MMAP).value_or(true); - wrapper_ = std::make_shared( - path_.c_str(), load_in_mmap, milvus::index::SetBitsetSealed); - - if (!load_in_mmap) { - // the index is loaded in ram, so we can remove files in advance - disk_file_manager_->RemoveJsonKeyIndexFiles(); - } - - LOG_INFO( - "load json key index done for field id:{} with dir:{}, load_in_mmap:{}", - field_id_, - path_, - load_in_mmap); -} - -void -JsonKeyStatsInvertedIndex::BuildWithFieldData( - const std::vector& field_datas) { - AssertInfo(schema_.data_type() == proto::schema::DataType::JSON, - "schema data type is {}", - schema_.data_type()); - BuildWithFieldData(field_datas, schema_.nullable()); -} - -void -JsonKeyStatsInvertedIndex::BuildWithFieldData( - const std::vector& field_datas, bool nullable) { - int64_t offset = 0; - std::map> mp; - index_build_timestamps_.index_build_begin_ = - std::chrono::system_clock::now(); - if (nullable) { - for (const auto& data : field_datas) { - auto n = data->get_num_rows(); - for (int i = 0; i < n; i++) { - if (!data->is_valid(i)) { - offset++; - continue; - } - AddJson(static_cast(data->RawValue(i)) - ->data() - .data(), - offset++, - mp); - } - } - } else { - for (const auto& data : field_datas) { - auto n = data->get_num_rows(); - for (int i = 0; i < n; i++) { - AddJson(static_cast(data->RawValue(i)) - ->data() - .data(), - offset++, - mp); - } - } - } - index_build_timestamps_.tantivy_build_begin_ = - std::chrono::system_clock::now(); - - // Schedule all document add operations to tantivy. - AddInvertedRecord(mp); - index_build_timestamps_.tantivy_add_schedule_end_ = - std::chrono::system_clock::now(); -} - -void -JsonKeyStatsInvertedIndex::AddJSONDatas(size_t n, - const std::string* jsonDatas, - const bool* valids, - int64_t offset_begin) { - std::map> mp; - for (int i = 0; i < n; i++) { - auto offset = i + offset_begin; - if (valids != nullptr && !valids[i]) { - continue; - } - AddJson(jsonDatas[i].c_str(), offset, mp); - } - AddInvertedRecord(mp); - is_data_uncommitted_ = true; - LOG_INFO("build json key index done for AddJSONDatas"); - if (shouldTriggerCommit()) { - Commit(); - } -} - -void -JsonKeyStatsInvertedIndex::Finish() { - finish(); -} - -bool -JsonKeyStatsInvertedIndex::shouldTriggerCommit() { - auto span = (std::chrono::duration( - stdclock::now() - last_commit_time_.load())) - .count(); - return span > commit_interval_in_ms_; -} - -void -JsonKeyStatsInvertedIndex::Commit() { - std::unique_lock lck(mtx_, std::defer_lock); - if (lck.try_lock()) { - is_data_uncommitted_ = false; - wrapper_->commit(); - last_commit_time_.store(stdclock::now()); - } -} - -void -JsonKeyStatsInvertedIndex::Reload() { - std::unique_lock lck(mtx_, std::defer_lock); - if (lck.try_lock()) { - wrapper_->reload(); - } -} - -void -JsonKeyStatsInvertedIndex::CreateReader(SetBitsetFn set_bitset) { - wrapper_->create_reader(set_bitset); -} - -} // namespace milvus::index diff --git a/internal/core/src/index/JsonKeyStatsInvertedIndex.h b/internal/core/src/index/JsonKeyStatsInvertedIndex.h deleted file mode 100644 index b9458b36e2..0000000000 --- a/internal/core/src/index/JsonKeyStatsInvertedIndex.h +++ /dev/null @@ -1,353 +0,0 @@ -// Copyright (C) 2019-2020 Zilliz. All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software distributed under the License -// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express -// or implied. See the License for the specific language governing permissions and limitations under the License - -#pragma once - -#include -#include - -#include "index/InvertedIndexTantivy.h" -#include "common/jsmn.h" -namespace milvus::index { -enum class JSONType { - UNKNOWN, - BOOL, - INT32, - INT64, - FLOAT, - DOUBLE, - STRING, - STRING_ESCAPE -}; -using stdclock = std::chrono::high_resolution_clock; -class JsonKeyStatsInvertedIndex : public InvertedIndexTantivy { - public: - explicit JsonKeyStatsInvertedIndex( - const storage::FileManagerContext& ctx, - bool is_load, - int64_t json_stats_tantivy_memory_budget = 16777216, - uint32_t tantivy_index_version = TANTIVY_INDEX_LATEST_VERSION); - - explicit JsonKeyStatsInvertedIndex(int64_t commit_interval_in_ms, - const char* unique_id); - - explicit JsonKeyStatsInvertedIndex(int64_t commit_interval_in_ms, - const char* unique_id, - const std::string& path); - - ~JsonKeyStatsInvertedIndex() override{}; - - public: - IndexStatsPtr - Upload(const Config& config) override; - - void - Load(milvus::tracer::TraceContext ctx, const Config& config) override; - - void - BuildWithFieldData(const std::vector& datas) override; - - void - BuildWithFieldData(const std::vector& datas, bool nullable); - - TargetBitmap - FilterByPath(const std::string& path, - int32_t row, - bool is_growing, - bool is_strong_consistency, - std::function filter) { - auto processArray = [this, &path, row, &filter]() { - TargetBitmap bitset(row); - auto array = wrapper_->term_query_i64(path); - LOG_INFO("json key filter size:{}", array.array_.len); - folly::fbvector valid_array(array.array_.len); - std::vector type_array(array.array_.len); - std::vector row_id_array(array.array_.len); - std::vector offset_array(array.array_.len); - std::vector size_array(array.array_.len); - std::vector value_array(array.array_.len); - - for (size_t j = 0; j < array.array_.len; j++) { - auto the_offset = array.array_.array[j]; - - if (DecodeValid(the_offset)) { - auto tuple = DecodeValue(the_offset); - auto row_id = std::get<1>(tuple); - if (row_id >= row) { - continue; - } - - valid_array[j] = true; - type_array[j] = std::get<0>(tuple); - row_id_array[j] = std::get<1>(tuple); - offset_array[j] = 0; - size_array[j] = 0; - value_array[j] = std::get<2>(tuple); - } else { - auto tuple = DecodeOffset(the_offset); - auto row_id = std::get<1>(tuple); - if (row_id >= row) { - continue; - } - valid_array[j] = false; - type_array[j] = std::get<0>(tuple); - row_id_array[j] = std::get<1>(tuple); - offset_array[j] = std::get<2>(tuple); - size_array[j] = std::get<3>(tuple); - value_array[j] = 0; - } - } - - filter(valid_array.data(), - type_array.data(), - row_id_array.data(), - offset_array.data(), - size_array.data(), - value_array.data(), - bitset, - array.array_.len); - - return bitset; - }; - - if (is_growing && (shouldTriggerCommit() || is_strong_consistency)) { - if (is_data_uncommitted_) { - Commit(); - } - Reload(); - } - return processArray(); - } - - void - AddJSONDatas(size_t n, - const std::string* jsonDatas, - const bool* valids, - int64_t offset_begin); - - void - Finish(); - - void - Commit(); - - void - Reload(); - - void - CreateReader(SetBitsetFn set_bitset); - - bool - has_escape_sequence(const std::string& str) { - for (size_t i = 0; i < str.size(); ++i) { - if (str[i] == '\\' && i + 1 < str.size()) { - char next = str[i + 1]; - if (next == 'n' || next == 't' || next == 'r' || next == 'b' || - next == 'f' || next == 'v' || next == '\\' || - next == '\"' || next == '\'' || next == '0' || - next == 'u' || next == '/') { - return true; - } - } - } - return false; - } - - private: - void - AddJson(const char* json, - int64_t offset, - std::map>& mp); - - void - TravelJson(const char* json, - jsmntok* tokens, - int& index, - std::vector& path, - int32_t offset, - std::map>& mp); - - void - AddJSONEncodeValue(const std::vector& paths, - uint8_t flag, - uint8_t type, - uint32_t row_id, - uint16_t offset, - uint16_t length, - int32_t value, - std::map>& mp); - - int64_t - EncodeOffset(uint8_t flag, - uint8_t type, - uint32_t row_id, - uint16_t row_offset, - uint16_t size) { - row_id &= 0x0FFFFFFF; - return static_cast(flag) << 63 | - static_cast(type) << 60 | - static_cast(row_id) << 32 | - static_cast(row_offset) << 16 | - static_cast(size); - } - - int64_t - EncodeValue(uint8_t flag, uint8_t type, uint32_t row_id, int32_t value) { - row_id &= 0x0FFFFFFF; - return static_cast(flag) << 63 | - static_cast(type) << 60 | - static_cast(row_id) << 32 | - static_cast(value); - } - - bool - DecodeValid(int64_t encode_offset) { - return (encode_offset >> 63) & 1; - } - - std::tuple - DecodeValue(int64_t encode_offset) { - uint8_t type = (encode_offset >> 60) & 0x7; - uint32_t row_id = (encode_offset >> 32) & 0x0FFFFFFF; - int32_t value = static_cast(encode_offset & 0xFFFFFFFF); - return std::make_tuple(type, row_id, value); - } - - std::tuple - DecodeOffset(int64_t encode_offset) { - uint8_t type = (encode_offset >> 60) & 0x7; - uint32_t row_id = (encode_offset >> 32) & 0x0FFFFFFF; - uint16_t row_offset = (encode_offset >> 16) & 0xFFFF; - uint16_t size = encode_offset & 0xFFFF; - return std::make_tuple(type, row_id, row_offset, size); - } - - bool - shouldTriggerCommit(); - - bool - isBoolean(const std::string& str) { - return str == "true" || str == "false"; - } - - bool - isInt32(const std::string& str) { - std::istringstream iss(str); - int64_t num; - iss >> num; - - return !iss.fail() && iss.eof() && - num >= std::numeric_limits::min() && - num <= std::numeric_limits::max(); - } - - bool - isInt64(const std::string& str) { - std::istringstream iss(str); - int64_t num; - iss >> num; - - return !iss.fail() && iss.eof(); - } - - bool - isFloat(const std::string& str) { - try { - float d = std::stof(str); - return true; - } catch (...) { - return false; - } - } - - bool - isDouble(const std::string& str) { - try { - double d = std::stod(str); - return true; - } catch (...) { - return false; - } - } - - JSONType - getType(const std::string& str) { - if (isBoolean(str)) { - return JSONType::BOOL; - } else if (isInt32(str)) { - return JSONType::INT32; - } else if (isInt64(str)) { - return JSONType::INT64; - } else if (isFloat(str)) { - return JSONType::FLOAT; - } else if (isDouble(str)) { - return JSONType::DOUBLE; - } - return JSONType::UNKNOWN; - } - - void - AddInvertedRecord(std::map>& mp); - - private: - int64_t field_id_; - mutable std::mutex mtx_; - std::atomic last_commit_time_; - int64_t commit_interval_in_ms_; - std::atomic is_data_uncommitted_ = false; - - struct IndexBuildTimestamps { - std::chrono::time_point index_build_begin_; - std::chrono::time_point tantivy_build_begin_; - // The time that we have finished push add operations to tantivy, which will be - // executed asynchronously - std::chrono::time_point - tantivy_add_schedule_end_; - std::chrono::time_point index_build_done_; - - auto - getJsonParsingDuration() const { - return std::chrono::duration(tantivy_build_begin_ - - index_build_begin_) - .count(); - } - - auto - getTantivyAddSchedulingDuration() const { - return std::chrono::duration(tantivy_add_schedule_end_ - - tantivy_build_begin_) - .count(); - } - - auto - getTantivyTotalDuration() const { - return std::chrono::duration(index_build_done_ - - tantivy_build_begin_) - .count(); - } - - auto - getIndexBuildTotalDuration() const { - return std::chrono::duration(index_build_done_ - - index_build_begin_) - .count(); - } - }; - IndexBuildTimestamps index_build_timestamps_; -}; -} // namespace milvus::index diff --git a/internal/core/src/index/Meta.h b/internal/core/src/index/Meta.h index c79405c3ae..4bddf992b2 100644 --- a/internal/core/src/index/Meta.h +++ b/internal/core/src/index/Meta.h @@ -56,6 +56,7 @@ constexpr const char* NGRAM_INDEX_TYPE = "NGRAM"; constexpr const char* MIN_GRAM = "min_gram"; constexpr const char* MAX_GRAM = "max_gram"; +constexpr const char* JSON_KEY_STATS_INDEX_TYPE = "JsonKeyStats"; // index meta constexpr const char* COLLECTION_ID = "collection_id"; constexpr const char* PARTITION_ID = "partition_id"; diff --git a/internal/core/src/index/ScalarIndex.h b/internal/core/src/index/ScalarIndex.h index d3fdd8dcb6..92d18a3975 100644 --- a/internal/core/src/index/ScalarIndex.h +++ b/internal/core/src/index/ScalarIndex.h @@ -36,6 +36,7 @@ enum class ScalarIndexType { MARISA, INVERTED, HYBRID, + JSONSTATS, }; inline std::string diff --git a/internal/core/src/index/Utils.h b/internal/core/src/index/Utils.h index 5c3be6006f..f6d95455f2 100644 --- a/internal/core/src/index/Utils.h +++ b/internal/core/src/index/Utils.h @@ -201,6 +201,11 @@ CheckAndUpdateKnowhereRangeSearchParam(const SearchInfo& search_info, const MetricType& metric_type, knowhere::Json& search_config); +// for unused +void inline SetBitsetUnused(void* bitset, const uint32_t* doc_id, uintptr_t n) { + ThrowInfo(ErrorCode::UnexpectedError, "SetBitsetUnused is not supported"); +} + // For sealed segment, the doc_id is guaranteed to be less than bitset size which equals to the doc count of tantivy before querying. void inline SetBitsetSealed(void* bitset, const uint32_t* doc_id, uintptr_t n) { TargetBitmap* bitmap = static_cast(bitset); diff --git a/internal/core/src/index/json_stats/JsonKeyStats.cpp b/internal/core/src/index/json_stats/JsonKeyStats.cpp new file mode 100644 index 0000000000..2bb74d28d6 --- /dev/null +++ b/internal/core/src/index/json_stats/JsonKeyStats.cpp @@ -0,0 +1,1015 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include + +#include +#include "index/json_stats/JsonKeyStats.h" +#include "index/json_stats/bson_builder.h" +#include "index/InvertedIndexUtil.h" +#include "index/Utils.h" +#include "storage/MmapManager.h" +#include "storage/Util.h" +#include "common/bson_view.h" +#include "mmap/ChunkedColumnGroup.h" +#include "milvus-storage/format/parquet/file_reader.h" +#include "milvus-storage/common/constants.h" +#include "segcore/storagev1translator/ChunkTranslator.h" +#include "segcore/storagev1translator/DefaultValueChunkTranslator.h" +#include "segcore/storagev2translator/GroupChunkTranslator.h" + +namespace milvus::index { + +JsonKeyStats::JsonKeyStats(const storage::FileManagerContext& ctx, + bool is_load, + int64_t json_stats_max_shredding_columns, + double json_stats_shredding_ratio_threshold, + int64_t json_stats_write_batch_size, + uint32_t tantivy_index_version) + : ScalarIndex(JSON_KEY_STATS_INDEX_TYPE) { + schema_ = ctx.fieldDataMeta.field_schema; + field_id_ = ctx.fieldDataMeta.field_id; + segment_id_ = ctx.fieldDataMeta.segment_id; + rcm_ = ctx.chunkManagerPtr; + mem_file_manager_ = + std::make_shared(ctx); + disk_file_manager_ = + std::make_shared(ctx); + write_batch_size_ = json_stats_write_batch_size; + max_shredding_columns_ = json_stats_max_shredding_columns; + shredding_ratio_threshold_ = json_stats_shredding_ratio_threshold; + LOG_INFO( + "init json key stats with write_batch_size : {}, " + "max_shredding_columns: {}, shredding_ratio_threshold: {} for segment " + "{}", + write_batch_size_, + max_shredding_columns_, + shredding_ratio_threshold_, + segment_id_); + + if (is_load) { + auto prefix = disk_file_manager_->GetLocalJsonStatsPrefix(); + path_ = prefix; + bson_inverted_index_ = std::make_shared( + path_, field_id_, true, ctx, tantivy_index_version); + } else { + auto prefix = disk_file_manager_->GetLocalTempJsonStatsPrefix(); + path_ = prefix; + LOG_INFO("init json key stats with path: {} for segment {}", + path_, + segment_id_); + + // TODO: add params to modify batch size and max file size + auto conf = milvus_storage::StorageConfig(); + conf.part_size = DEFAULT_PART_UPLOAD_SIZE; + auto trueFs = milvus_storage::ArrowFileSystemSingleton::GetInstance() + .GetArrowFileSystem(); + if (!trueFs) { + ThrowInfo(ErrorCode::UnexpectedError, "Failed to get filesystem"); + } + parquet_writer_ = std::make_shared( + trueFs, conf, DEFAULT_BUFFER_SIZE, write_batch_size_); + + // build bson index for shared key + auto shared_key_index_path = GetSharedKeyIndexDir(); + LOG_INFO("init local shared bson index with path: {} for segment {}", + shared_key_index_path, + segment_id_); + boost::filesystem::create_directories(shared_key_index_path); + bson_inverted_index_ = + std::make_shared(shared_key_index_path, + field_id_, + false, + ctx, + tantivy_index_version); + } +} + +JsonKeyStats::~JsonKeyStats() { + boost::filesystem::remove_all(path_); +} + +void +JsonKeyStats::AddKeyStatsInfo(const std::vector& paths, + JSONType type, + uint8_t* value, + std::map& infos) { + std::string key = ""; + if (!paths.empty()) { + key = JsonPointer(paths); + } + JsonKey json_key; + json_key.key_ = key; + json_key.type_ = type; + + if (infos.find(json_key) == infos.end()) { + infos[json_key] = KeyStatsInfo(); + } + infos[json_key].hit_row_num_++; + // TODO: update min and max value +} + +void +JsonKeyStats::TraverseJsonForStats(const char* json, + jsmntok* tokens, + int& index, + std::vector& path, + std::map& infos) { + jsmntok current = tokens[0]; + Assert(current.type != JSMN_UNDEFINED); + if (current.type == JSMN_OBJECT) { + if (!path.empty()) { + AddKeyStatsInfo(path, JSONType::OBJECT, nullptr, infos); + } + int j = 1; + for (int i = 0; i < current.size; i++) { + Assert(tokens[j].type == JSMN_STRING && tokens[j].size != 0); + std::string key(json + tokens[j].start, + tokens[j].end - tokens[j].start); + path.push_back(key); + j++; + int consumed = 0; + TraverseJsonForStats(json, tokens + j, consumed, path, infos); + path.pop_back(); + j += consumed; + } + index = j; + } else if (current.type == JSMN_PRIMITIVE) { + std::string value(json + current.start, current.end - current.start); + auto type = getType(value); + + if (type == JSONType::INT64) { + AddKeyStatsInfo(path, JSONType::INT64, nullptr, infos); + } else if (type == JSONType::FLOAT || type == JSONType::DOUBLE) { + AddKeyStatsInfo(path, JSONType::DOUBLE, nullptr, infos); + } else if (type == JSONType::BOOL) { + AddKeyStatsInfo(path, JSONType::BOOL, nullptr, infos); + } else if (type == JSONType::NONE) { + AddKeyStatsInfo(path, JSONType::NONE, nullptr, infos); + } else { + ThrowInfo(ErrorCode::UnexpectedError, + "unsupported json type: {} for build json stats", + type); + } + index++; + } else if (current.type == JSMN_ARRAY) { + AddKeyStatsInfo(path, JSONType::ARRAY, nullptr, infos); + // skip array parse + int count = current.size; + int j = 1; + while (count > 0) { + count--; + if (tokens[j].size != 0) { + count += tokens[j].size; + } + j++; + } + index = j; + } else if (current.type == JSMN_STRING) { + Assert(current.size == 0); + AddKeyStatsInfo(path, JSONType::STRING, nullptr, infos); + index++; + } +} + +void +JsonKeyStats::CollectSingleJsonStatsInfo( + const char* json_str, std::map& infos) { + jsmn_parser parser; + jsmn_init(&parser); + + int num_tokens = 0; + int token_capacity = 16; + std::vector tokens(token_capacity); + + while (1) { + int r = jsmn_parse( + &parser, json_str, strlen(json_str), tokens.data(), token_capacity); + if (r < 0) { + if (r == JSMN_ERROR_NOMEM) { + // Reallocate tokens array if not enough space + token_capacity *= 2; + tokens.resize(token_capacity); + continue; + } else { + ThrowInfo(ErrorCode::UnexpectedError, + "Failed to parse Json: {}, error: {}", + json_str, + int(r)); + } + } + num_tokens = r; + break; + } + + int index = 0; + std::vector paths; + TraverseJsonForStats(json_str, tokens.data(), index, paths, infos); +} + +std::map +JsonKeyStats::CollectKeyInfo(const std::vector& field_datas, + bool nullable) { + std::map infos; + int64_t num_rows = 0; + for (const auto& data : field_datas) { + auto n = data->get_num_rows(); + for (int i = 0; i < n; i++) { + if (nullable && !data->is_valid(i)) { + continue; + } + auto json_str = static_cast(data->RawValue(i)) + ->data() + .data(); + CollectSingleJsonStatsInfo(json_str, infos); + } + num_rows += n; + } + num_rows_ = num_rows; + return infos; +} + +std::map +JsonKeyStats::ClassifyJsonKeyLayoutType( + const std::map& infos) { + std::map types; + std::unordered_map>> + grouped; + std::unordered_map group_hit_rows; + for (const auto& [json_key, key_stats_info] : infos) { + grouped[json_key.key_].emplace_back(json_key, key_stats_info); + group_hit_rows[json_key.key_] += key_stats_info.hit_row_num_; + } + + auto ClassifyKey = [&](const JsonKey& key, + const KeyStatsInfo& info) -> JsonKeyLayoutType { + // for null/object, must be classified as shared + if (key.type_ == JSONType::OBJECT || key.type_ == JSONType::NONE) { + return JsonKeyLayoutType::SHARED; + } + + float hit_ratio = float(info.hit_row_num_) / num_rows_; + if (info.hit_row_num_ == num_rows_) { + return JsonKeyLayoutType::TYPED; + } else if (hit_ratio >= shredding_ratio_threshold_) { + return JsonKeyLayoutType::DYNAMIC; + } else { + return JsonKeyLayoutType::SHARED; + } + }; + + size_t column_path_num = 0; + for (const auto& [key, infos] : grouped) { + if (infos.size() == 1) { + auto stat_type = ClassifyKey(infos[0].first, infos[0].second); + stat_type = + // for key with only one type and is primitive type but not all rows hit, + // can be classified as TYPED_NOT_ALL + IsPrimitiveJsonType(infos[0].first.type_) && + stat_type == JsonKeyLayoutType::DYNAMIC + ? JsonKeyLayoutType::TYPED_NOT_ALL + : stat_type; + + if (stat_type == JsonKeyLayoutType::TYPED || + stat_type == JsonKeyLayoutType::TYPED_NOT_ALL) { + column_path_num++; + } + + types[infos[0].first] = stat_type; + } else { + size_t dynamic_path_num = 0; + for (const auto& [json_key, info] : infos) { + auto stat_type = ClassifyKey(json_key, info); + types[json_key] = stat_type; + + if (stat_type == JsonKeyLayoutType::DYNAMIC) { + column_path_num++; + dynamic_path_num++; + } + } + + // if all paths are dynamic, set all paths type to DYNAMIC_ONLY + if (dynamic_path_num == infos.size()) { + for (const auto& [json_key, info] : infos) { + types[json_key] = JsonKeyLayoutType::DYNAMIC_ONLY; + } + } + } + } + + if (column_path_num > max_shredding_columns_) { + // sort by hit rows in descending order to find the least hit rows + // move them to shared column + std::vector> key_hit_rows; + for (const auto& [json_key, key_stats_info] : infos) { + auto it = types.find(json_key); + if (it != types.end() && + (it->second == JsonKeyLayoutType::TYPED || + it->second == JsonKeyLayoutType::TYPED_NOT_ALL || + it->second == JsonKeyLayoutType::DYNAMIC_ONLY || + it->second == JsonKeyLayoutType::DYNAMIC)) { + key_hit_rows.emplace_back(json_key, + key_stats_info.hit_row_num_); + } + } + + std::sort( + key_hit_rows.begin(), + key_hit_rows.end(), + [](const auto& a, const auto& b) { return a.second < b.second; }); + + size_t idx = 0; + while (column_path_num > max_shredding_columns_ && + idx < key_hit_rows.size()) { + const auto& [json_key, _] = key_hit_rows[idx++]; + types[json_key] = JsonKeyLayoutType::SHARED; + column_path_num--; + } + } + + return types; +} + +void +JsonKeyStats::AddKeyStats(const std::vector& path, + JSONType type, + const std::string& value, + std::map& values) { + auto path_str = JsonPointer(path); + auto key = JsonKey(path_str, type); + values[key] = value; +} + +void +JsonKeyStats::TraverseJsonForBuildStats( + const char* json, + jsmntok* tokens, + int& index, + std::vector& path, + std::map& values) { + jsmntok current = tokens[0]; + Assert(current.type != JSMN_UNDEFINED); + if (current.type == JSMN_OBJECT) { + if (!path.empty() && current.size == 0) { + AddKeyStats( + path, + JSONType::OBJECT, + std::string(json + current.start, current.end - current.start), + values); + return; + } + int j = 1; + for (int i = 0; i < current.size; i++) { + Assert(tokens[j].type == JSMN_STRING && tokens[j].size != 0); + std::string key(json + tokens[j].start, + tokens[j].end - tokens[j].start); + path.push_back(key); + j++; + int consumed = 0; + TraverseJsonForBuildStats(json, tokens + j, consumed, path, values); + path.pop_back(); + j += consumed; + } + index = j; + } else if (current.type == JSMN_PRIMITIVE) { + std::string value(json + current.start, current.end - current.start); + JSONType type; + try { + type = getType(value); + } catch (const std::exception& e) { + ThrowInfo(ErrorCode::UnexpectedError, + "failed to get json type for value: {} with error: {}", + value, + e.what()); + } + + if (type == JSONType::INT64) { + AddKeyStats(path, JSONType::INT64, value, values); + } else if (type == JSONType::FLOAT || type == JSONType::DOUBLE) { + AddKeyStats(path, JSONType::DOUBLE, value, values); + } else if (type == JSONType::BOOL) { + AddKeyStats(path, JSONType::BOOL, value, values); + } else if (type == JSONType::NONE) { + AddKeyStats(path, JSONType::NONE, value, values); + } else { + ThrowInfo(ErrorCode::UnexpectedError, + "unsupported json type: {} for build json stats", + type); + } + index++; + } else if (current.type == JSMN_ARRAY) { + // Collect array as raw JSON string so it can be shredded into a dedicated column + AddKeyStats( + path, + JSONType::ARRAY, + std::string(json + current.start, current.end - current.start), + values); + // Skip array subtree + int count = current.size; + int j = 1; + while (count > 0) { + count--; + if (tokens[j].size != 0) { + count += tokens[j].size; + } + j++; + } + index = j; + } else if (current.type == JSMN_STRING) { + Assert(current.size == 0); + AddKeyStats( + path, + JSONType::STRING, + std::string(json + current.start, current.end - current.start), + values); + index++; + } +} + +void +JsonKeyStats::BuildKeyStatsForNullRow() { + // add empty value for column keys that not hit + for (const auto& key : column_keys_) { + parquet_writer_->AppendValue(key.ToColumnName(), ""); + } + + // add null bson to shared column + bsoncxx::builder::basic::document null_doc; + auto null_bson = null_doc.extract(); + parquet_writer_->AppendSharedRow(null_bson.view().data(), + null_bson.view().length()); + + parquet_writer_->AddCurrentRow(); +} + +void +JsonKeyStats::BuildKeyStatsForRow(const char* json_str, uint32_t row_id) { + LOG_TRACE("build key stats for row {} with json {} for segment {}", + row_id, + json_str, + segment_id_); + jsmn_parser parser; + jsmn_init(&parser); + + int num_tokens = 0; + int token_capacity = 16; + std::vector tokens(token_capacity); + + while (1) { + int r = jsmn_parse( + &parser, json_str, strlen(json_str), tokens.data(), token_capacity); + if (r < 0) { + if (r == JSMN_ERROR_NOMEM) { + // Reallocate tokens array if not enough space + token_capacity *= 2; + tokens.resize(token_capacity); + continue; + } else { + ThrowInfo(ErrorCode::UnexpectedError, + "Failed to parse Json: {}, error: {}", + json_str, + int(r)); + } + } + num_tokens = r; + break; + } + + int index = 0; + std::vector paths; + std::map values; + TraverseJsonForBuildStats(json_str, tokens.data(), index, paths, values); + DomNode root; + std::set hit_keys; + for (const auto& [key, value] : values) { + AssertInfo(key_types_.find(key) != key_types_.end(), + "key {} not found in key types", + key.key_); + if (key_types_[key] == JsonKeyLayoutType::SHARED) { + auto path_vec = ParseJsonPointerPath(key.key_); + BsonBuilder::AppendToDom(root, path_vec, value, key.type_); + } else { + if (key.type_ == JSONType::ARRAY) { + auto bson_bytes = BuildBsonArrayBytesFromJsonString(value); + parquet_writer_->AppendValue( + key.ToColumnName(), + std::string( + reinterpret_cast(bson_bytes.data()), + bson_bytes.size())); + } else { + parquet_writer_->AppendValue(key.ToColumnName(), value); + } + } + hit_keys.insert(key); + } + // add empty value for column keys that not hit + for (const auto& key : column_keys_) { + if (hit_keys.find(key) == hit_keys.end()) { + parquet_writer_->AppendValue(key.ToColumnName(), ""); + } + } + + bsoncxx::builder::basic::document final_doc; + BsonBuilder::ConvertDomToBson(root, final_doc); + // build inverted index for shared key + // cache pairs of (key, row_id/offset) into memory + // when all rows processed, build it into disk + auto key_offsets = BsonBuilder::ExtractBsonKeyOffsets(final_doc.view()); + for (const auto& [key, offset] : key_offsets) { + LOG_TRACE( + "add record to bson inverted index: {} with row_id: {} and offset: " + "{} for segment {} for field {}", + key, + row_id, + offset, + segment_id_, + field_id_); + bson_inverted_index_->AddRecord(key, row_id, offset); + } + auto bson = final_doc.extract(); + parquet_writer_->AppendSharedRow(bson.view().data(), bson.view().length()); + + parquet_writer_->AddCurrentRow(); +} + +void +JsonKeyStats::BuildKeyStats(const std::vector& field_datas, + bool nullable) { + uint32_t row_id = 0; + for (const auto& data : field_datas) { + auto n = data->get_num_rows(); + for (uint32_t i = 0; i < n; i++) { + if (nullable && !data->is_valid(i)) { + BuildKeyStatsForNullRow(); + } else { + auto json_str = + static_cast(data->RawValue(i)) + ->data() + .data(); + BuildKeyStatsForRow(json_str, row_id); + } + row_id++; + } + } +} + +std::string +JsonKeyStats::GetShreddingDir() { + std::filesystem::path json_stats_dir = path_; + std::filesystem::path shredding_path = + json_stats_dir / JSON_STATS_SHREDDING_DATA_PATH; + return shredding_path.string(); +} + +std::string +JsonKeyStats::GetSharedKeyIndexDir() { + std::filesystem::path json_stats_dir = path_; + std::filesystem::path shared_key_index_path = + json_stats_dir / JSON_STATS_SHARED_INDEX_PATH; + return shared_key_index_path.string(); +} + +BinarySet +JsonKeyStats::Serialize(const Config& config) { + return BinarySet(); +} + +void +JsonKeyStats::Build(const Config& config) { + if (is_built_) + return; + auto start_time = std::chrono::steady_clock::now(); + auto field_datas = mem_file_manager_->CacheRawDataToMemory(config); + + auto lack_binlog_rows = + GetValueFromConfig(config, "lack_binlog_rows"); + if (lack_binlog_rows.has_value()) { + auto field_schema = mem_file_manager_->GetFieldDataMeta().field_schema; + auto default_value = [&]() -> std::optional { + if (!field_schema.has_default_value()) { + return std::nullopt; + } + return field_schema.default_value(); + }(); + auto field_data = storage::CreateFieldData( + static_cast(field_schema.data_type()), + true, + 1, + lack_binlog_rows.value()); + field_data->FillFieldData(default_value, lack_binlog_rows.value()); + field_datas.insert(field_datas.begin(), field_data); + } + + BuildWithFieldData(field_datas, schema_.nullable()); + auto end_time = std::chrono::steady_clock::now(); + auto duration = std::chrono::duration_cast( + end_time - start_time) + .count(); + LOG_INFO( + "build json stats for segment {} cost {} ms", segment_id_, duration); + is_built_ = true; +} + +std::string +JsonKeyStats::AddBucketName(const std::string& remote_prefix) { + std::filesystem::path bucket_name = rcm_->GetBucketName(); + std::filesystem::path remote_prefix_path = remote_prefix; + return (bucket_name / remote_prefix_path).string(); +} + +void +JsonKeyStats::BuildWithFieldData(const std::vector& field_datas, + bool nullable) { + // collect key stats info and classify key type + auto infos = CollectKeyInfo(field_datas, nullable); + LOG_INFO("collect key infos: {} for segment {} for field {}", + PrintKeyInfo(infos), + segment_id_, + field_id_); + key_types_ = ClassifyJsonKeyLayoutType(infos); + LOG_INFO("key types infos: {} for segment {} for field {}", + PrintJsonKeyLayoutType(key_types_), + segment_id_, + field_id_); + for (const auto& [json_key, type] : key_types_) { + if (type == JsonKeyLayoutType::SHARED) { + shared_keys_.insert(json_key); + } else { + column_keys_.insert(json_key); + } + } + + // for storage v2, we need to add bucket name to remote prefix + auto remote_prefix = + AddBucketName(disk_file_manager_->GetRemoteJsonStatsShreddingPrefix()); + LOG_INFO( + "init parquet writer with shredding remote prefix: {} for segment {}", + remote_prefix, + segment_id_); + + auto writer_context = + ParquetWriterFactory::CreateContext(key_types_, remote_prefix); + parquet_writer_->Init(writer_context); + BuildKeyStats(field_datas, nullable); + parquet_writer_->Close(); + bson_inverted_index_->BuildIndex(); +} + +void +JsonKeyStats::GetColumnSchemaFromParquet(int64_t column_group_id, + const std::string& file) { + auto fs = milvus_storage::ArrowFileSystemSingleton::GetInstance() + .GetArrowFileSystem(); + auto file_reader = + std::make_shared(fs, file); + std::shared_ptr file_schema = file_reader->schema(); + LOG_DEBUG("get column schema: [{}] for segment {}", + file_schema->ToString(true), + segment_id_); + column_group_schemas_[column_group_id] = file_schema; + + for (const auto& field : file_schema->fields()) { + auto field_name = field->name(); + field_names_.emplace_back(field_name); + + const auto& metadata = field->metadata(); + if (metadata == nullptr) { + LOG_ERROR("metadata is nullptr for field: {} for segment {}", + field_name, + segment_id_); + continue; + } + + auto result = metadata->Get(milvus_storage::ARROW_FIELD_ID_KEY); + AssertInfo(result.ok(), + "failed to get field id from metadata for field {}: {} " + "for segment {}", + field_name, + result.status().ToString(), + segment_id_); + auto field_id_str = result.ValueOrDie(); + auto field_id = std::stoll(field_id_str); + field_name_to_id_map_[field_name] = field_id; + field_id_to_name_map_[field_id] = field_name; + + JSONType field_type; + if (EndWith(field_name, JSON_KEY_STATS_SHARED_FIELD_NAME)) { + // for shared key, we use string type instead of real binary type + field_type = JSONType::STRING; + shared_column_field_name_ = field_name; + } else if (EndWith(field_name, "_ARRAY")) { + field_type = JSONType::ARRAY; + } else { + field_type = GetPrimitiveJsonType(field->type()); + } + shred_field_data_type_map_[field_name] = field_type; + + LOG_INFO( + "parse field_name: {}, field_id: {}, " + "field_type: {} for segment {}", + field_name, + field_id, + field_type, + segment_id_); + } +} + +void +JsonKeyStats::GetCommonMetaFromParquet(const std::string& file) { + LOG_INFO("get common metadata from parquet file: {} for segment {}", + file, + segment_id_); + + auto fs = milvus_storage::ArrowFileSystemSingleton::GetInstance() + .GetArrowFileSystem(); + auto file_reader = + std::make_shared(fs, file); + + // get key value metadata from parquet file + std::shared_ptr metadata = + file_reader->file_metadata(); + auto kv_metadata = metadata->GetParquetMetadata()->key_value_metadata(); + if (kv_metadata == nullptr) { + LOG_WARN( + "no key value metadata found in parquet file: {} for segment {} " + "for field {}", + file, + segment_id_, + field_id_); + return; + } + + // Deserialize key field map from metadata + for (int i = 0; i < kv_metadata->size(); ++i) { + const auto& key = kv_metadata->key(i); + const auto& value = kv_metadata->value(i); + LOG_TRACE("parquet metadata entry: {} = {} for segment {} for field {}", + key, + value, + segment_id_, + field_id_); + + if (key == JSON_STATS_META_KEY_LAYOUT_TYPE_MAP) { + try { + auto layout_type_json = nlohmann::json::parse(value); + for (const auto& [k, v] : layout_type_json.items()) { + field_layout_type_map_[k] = JsonKeyLayoutTypeFromString(v); + key_data_type_map_[k] = GetJsonTypeFromKeyName(k); + key_field_map_[GetKeyFromColumnName(k)].insert(k); + } + } catch (const std::exception& e) { + ThrowInfo( + ErrorCode::UnexpectedError, + "Failed to parse JSON_STATS_META_KEY_LAYOUT_TYPE_MAP from " + "metadata: {} in file: {} for segment {}", + e.what(), + file, + segment_id_); + } + } + } +} + +void +JsonKeyStats::LoadShreddingMeta( + std::vector>> sorted_files) { + if (sorted_files.empty()) { + return; + } + + auto remote_prefix = + AddBucketName(disk_file_manager_->GetRemoteJsonStatsShreddingPrefix()); + + // load common meta from parquet, all parquet files have the same meta + // just need to read one file + auto file = CreateColumnGroupParquetPath( + remote_prefix, sorted_files[0].first, sorted_files[0].second[0]); + GetCommonMetaFromParquet(file); + + // load distinct meta from parquet, distinct meta is different for each parquet file + // main purpose is to get column schema + for (const auto& [column_group_id, file_ids] : sorted_files) { + auto file = CreateColumnGroupParquetPath( + remote_prefix, column_group_id, file_ids[0]); + GetColumnSchemaFromParquet(column_group_id, file); + } +} + +void +JsonKeyStats::LoadColumnGroup(int64_t column_group_id, + const std::vector& file_ids) { + if (file_ids.empty()) { + return; + } + int64_t num_rows = 0; + + auto remote_prefix = + AddBucketName(disk_file_manager_->GetRemoteJsonStatsShreddingPrefix()); + + std::vector files; + for (const auto& file_id : file_ids) { + files.emplace_back(CreateColumnGroupParquetPath( + remote_prefix, column_group_id, file_id)); + } + + auto fs = milvus_storage::ArrowFileSystemSingleton::GetInstance() + .GetArrowFileSystem(); + auto file_reader = + std::make_shared(fs, files[0]); + std::shared_ptr metadata = + file_reader->file_metadata(); + milvus_storage::FieldIDList field_id_list = + metadata->GetGroupFieldIDList().GetFieldIDList(column_group_id); + std::vector milvus_field_ids; + for (int i = 0; i < field_id_list.size(); ++i) { + milvus_field_ids.push_back(FieldId(field_id_list.Get(i))); + } + + for (const auto& file : files) { + auto reader = + std::make_shared(fs, file); + auto row_group_meta_vector = + reader->file_metadata()->GetRowGroupMetadataVector(); + num_rows += row_group_meta_vector.row_num(); + } + + if (num_rows_ == 0) { + num_rows_ = num_rows; + } + AssertInfo(num_rows_ == num_rows, + "num_rows is not equal to num_rows_ for segment {}", + segment_id_); + + auto enable_mmap = !mmap_filepath_.empty(); + auto column_group_info = + FieldDataInfo(column_group_id, num_rows, mmap_filepath_); + LOG_INFO( + "segment {} loads column group {} with num_rows {} for segment " + "{}", + segment_id_, + column_group_id, + num_rows, + segment_id_); + + std::unordered_map field_meta_map; + for (const auto& field_id : milvus_field_ids) { + auto field_name = field_id_to_name_map_[field_id.get()]; + FieldMeta field_meta( + FieldName(field_name), + field_id, + GetPrimitiveDataType(shred_field_data_type_map_[field_name]), + true, + std::nullopt); + field_meta_map.insert( + std::make_pair(FieldId(field_id.get()), std::move(field_meta))); + } + + auto translator = std::make_unique< + milvus::segcore::storagev2translator::GroupChunkTranslator>( + segment_id_, + field_meta_map, + column_group_info, + files, + enable_mmap, + milvus_field_ids.size(), + load_priority_); + + auto chunked_column_group = + std::make_shared(std::move(translator)); + + // Create ProxyChunkColumn for each field in this column group + for (const auto& field_id : milvus_field_ids) { + auto field_meta = field_meta_map.at(field_id); + auto column = std::make_shared( + chunked_column_group, field_id, field_meta); + + LOG_DEBUG("add shredding column: {}, field_id:{}, for segment {}", + field_meta.get_name().get(), + field_id.get(), + segment_id_); + shredding_columns_[field_meta.get_name().get()] = column; + } + shared_column_ = shredding_columns_.at(shared_column_field_name_); +} + +void +JsonKeyStats::LoadShreddingData(const std::vector& index_files) { + // sort files by column group id and file id + auto sorted_files = SortByParquetPath(index_files); + + // load shredding meta + LoadShreddingMeta(sorted_files); + + // load shredding data + for (const auto& [column_group_id, file_ids] : sorted_files) { + LoadColumnGroup(column_group_id, file_ids); + } +} + +void +JsonKeyStats::Load(milvus::tracer::TraceContext ctx, const Config& config) { + if (config.contains(MMAP_FILE_PATH)) { + mmap_filepath_ = GetValueFromConfig(config, MMAP_FILE_PATH) + .value_or(""); + LOG_INFO("load json stats for segment {} with mmap local file path: {}", + segment_id_, + mmap_filepath_); + } + load_priority_ = config[milvus::LOAD_PRIORITY]; + LOG_INFO("load json stats for segment {} with load priority: {}", + segment_id_, + load_priority_); + + auto index_files = + GetValueFromConfig>(config, "index_files"); + AssertInfo(index_files.has_value(), + "index file paths is empty when load json stats for segment {}", + segment_id_); + // split index_files into shared_key_index and shredding_data + std::vector shared_key_index_files; + std::vector shredding_data_files; + for (const auto& file : index_files.value()) { + if (file.find(JSON_STATS_SHARED_INDEX_PATH) != std::string::npos) { + shared_key_index_files.emplace_back(file); + } else if (file.find(JSON_STATS_SHREDDING_DATA_PATH) != + std::string::npos) { + shredding_data_files.emplace_back(file); + } else { + ThrowInfo(ErrorCode::UnexpectedError, + "unknown file path: {} for segment {}", + file, + segment_id_); + } + } + + // load shredding data + LoadShreddingData(shredding_data_files); + + // load shared key index + bson_inverted_index_->LoadIndex(shared_key_index_files, load_priority_); +} + +IndexStatsPtr +JsonKeyStats::Upload(const Config& config) { + // upload inverted index + auto bson_index_stats = bson_inverted_index_->UploadIndex(); + + // upload parquet file, parquet writer has already upload file to remote + auto shredding_remote_paths_to_size = parquet_writer_->GetPathsToSize(); + auto shared_key_index_remote_paths_to_size = + bson_index_stats->GetSerializedIndexFileInfo(); + + // get all index files for meta + std::vector index_files; + index_files.reserve(shredding_remote_paths_to_size.size() + + shared_key_index_remote_paths_to_size.size()); + // only store shared_key_index/... and shredding_data/... to meta + // for saving meta space + for (const auto& file_info : shared_key_index_remote_paths_to_size) { + auto file_path = file_info.file_name.substr( + file_info.file_name.find(JSON_STATS_SHARED_INDEX_PATH)); + index_files.emplace_back(file_path, file_info.file_size); + LOG_INFO("upload shared_key_index file: {} for segment {}", + file_path, + segment_id_); + } + + for (auto& file : shredding_remote_paths_to_size) { + auto file_path = + file.first.substr(file.first.find(JSON_STATS_SHREDDING_DATA_PATH)); + index_files.emplace_back(file_path, file.second); + LOG_INFO("upload shredding_data file: {} for segment {}", + file_path, + segment_id_); + } + + LOG_INFO( + "upload json key stats for segment {} with bson mem size: {} " + "and " + "shredding data mem size: {} and index files size: {}", + segment_id_, + bson_index_stats->GetMemSize(), + parquet_writer_->GetTotalSize(), + index_files.size()); + + return IndexStats::New( + bson_index_stats->GetMemSize() + parquet_writer_->GetTotalSize(), + std::move(index_files)); +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/src/index/json_stats/JsonKeyStats.h b/internal/core/src/index/json_stats/JsonKeyStats.h new file mode 100644 index 0000000000..68365b06aa --- /dev/null +++ b/internal/core/src/index/json_stats/JsonKeyStats.h @@ -0,0 +1,672 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include +#include + +#include "index/InvertedIndexTantivy.h" +#include "common/jsmn.h" +#include "mmap/ChunkedColumnInterface.h" +#include "arrow/api.h" +#include "index/json_stats/utils.h" +#include "index/json_stats/bson_inverted.h" +#include "index/json_stats/parquet_writer.h" +#include "index/json_stats/bson_builder.h" +#include "common/bson_view.h" +#include "index/SkipIndex.h" + +namespace milvus::index { +class JsonKeyStats : public ScalarIndex { + public: + explicit JsonKeyStats( + const storage::FileManagerContext& ctx, + bool is_load, + int64_t json_stats_max_shredding_columns = 1024, + double json_stats_shredding_ratio_threshold = 0.3, + int64_t json_stats_write_batch_size = 81920, + uint32_t tantivy_index_version = TANTIVY_INDEX_LATEST_VERSION); + + ~JsonKeyStats() override; + + public: + void + BuildWithFieldData(const std::vector& datas, bool nullable); + + void + Load(milvus::tracer::TraceContext ctx, const Config& config = {}) override; + + void + Load(const BinarySet& binary_set, const Config& config) override { + ThrowInfo(ErrorCode::NotImplemented, + "Load not supported for JsonKeyStats"); + } + + /* + * deprecated. + * TODO: why not remove this? + */ + void + BuildWithDataset(const DatasetPtr& dataset, + const Config& config = {}) override { + ThrowInfo(ErrorCode::NotImplemented, + "BuildWithDataset should be deprecated"); + } + + ScalarIndexType + GetIndexType() const override { + return ScalarIndexType::JSONSTATS; + } + + void + Build(const Config& config = {}) override; + + int64_t + Count() override { + return num_rows_; + } + + BinarySet + Serialize(const Config& config) override; + + IndexStatsPtr + Upload(const Config& config = {}) override; + + const bool + HasRawData() const override { + return false; + } + + int64_t + Size() override { + return Count(); + } + + void + BuildWithRawDataForUT(size_t n, + const void* values, + const Config& config) override { + ThrowInfo(ErrorCode::NotImplemented, + "BuildWithRawDataForUT Not supported for JsonKeyStats"); + } + + void + Build(size_t n, + const std::string* values, + const bool* valid_data = nullptr) override { + ThrowInfo(ErrorCode::NotImplemented, + "Build not supported for JsonKeyStats"); + } + + const TargetBitmap + In(size_t n, const std::string* values) override { + ThrowInfo(ErrorCode::NotImplemented, + "In not supported for JsonKeyStats"); + } + + const TargetBitmap + IsNull() override { + ThrowInfo(ErrorCode::NotImplemented, + "IsNull not supported for JsonKeyStats"); + } + + TargetBitmap + IsNotNull() override { + ThrowInfo(ErrorCode::NotImplemented, + "IsNotNull not supported for JsonKeyStats"); + } + + const TargetBitmap + NotIn(size_t n, const std::string* values) override { + ThrowInfo(ErrorCode::NotImplemented, + "NotIn not supported for JsonKeyStats"); + } + + const TargetBitmap + Range(std::string value, OpType op) override { + ThrowInfo(ErrorCode::NotImplemented, + "Range not supported for JsonKeyStats"); + } + + const TargetBitmap + Range(std::string lower_bound_value, + bool lb_inclusive, + std::string upper_bound_value, + bool ub_inclusive) override { + ThrowInfo(ErrorCode::NotImplemented, + "Range not supported for JsonKeyStats"); + } + + std::optional + Reverse_Lookup(size_t offset) const override { + ThrowInfo(ErrorCode::NotImplemented, + "Reverse_Lookup not supported for JsonKeyStats"); + } + + public: + void + ExecuteForSharedData( + const std::string& path, + std::function + func) { + bson_inverted_index_->TermQuery( + path, + [this, &func](const uint32_t* row_id_array, + const uint32_t* offset_array, + const int64_t array_len) { + shared_column_->BulkRawBsonAt( + func, row_id_array, offset_array, array_len); + }); + } + + void + ExecuteExistsPathForSharedData(const std::string& path, + TargetBitmapView bitset) { + bson_inverted_index_->TermQueryEach( + path, [&bitset](uint32_t row_id, uint32_t offset) { + bitset[row_id] = true; + }); + } + + int64_t + ExecutorForGettingValid(const std::string& path, + TargetBitmapView valid_res) { + size_t processed_size = 0; + // if path is not in shredding_columns_, return 0 + if (shredding_columns_.find(path) == shredding_columns_.end()) { + return processed_size; + } + auto column = shredding_columns_[path]; + auto num_data_chunk = column->num_chunks(); + + for (size_t i = 0; i < num_data_chunk; i++) { + auto chunk_size = column->chunk_row_nums(i); + const bool* valid_data; + if (GetShreddingJsonType(path) == JSONType::STRING || + GetShreddingJsonType(path) == JSONType::ARRAY) { + auto pw = column->StringViews(i); + valid_data = pw.get().second.data(); + ApplyOnlyValidData( + valid_data, valid_res + processed_size, chunk_size); + } else { + auto pw = column->Span(i); + auto chunk = pw.get(); + valid_data = chunk.valid_data(); + ApplyOnlyValidData( + valid_data, valid_res + processed_size, chunk_size); + } + processed_size += chunk_size; + } + AssertInfo(processed_size == valid_res.size(), + "Processed size {} is not equal to num_rows {}", + processed_size, + valid_res.size()); + return processed_size; + } + + template + int64_t + ExecutorForShreddingData( + // path is field_name in shredding_columns_ + const std::string& path, + FUNC func, + std::function + skip_func, + TargetBitmapView res, + TargetBitmapView valid_res, + ValTypes... values) { + int64_t processed_size = 0; + // if path is not in shredding_columns_, return 0 + if (shredding_columns_.find(path) == shredding_columns_.end()) { + return processed_size; + } + auto column = shredding_columns_[path]; + auto num_data_chunk = column->num_chunks(); + auto num_rows = column->NumRows(); + + for (size_t i = 0; i < num_data_chunk; i++) { + auto chunk_size = column->chunk_row_nums(i); + + if (!skip_func || !skip_func(skip_index_, path, i)) { + if constexpr (std::is_same_v) { + // first is the raw data, second is valid_data + // use valid_data to see if raw data is null + auto pw = column->StringViews(i); + auto [data_vec, valid_data] = pw.get(); + + func(data_vec.data(), + valid_data.data(), + chunk_size, + res + processed_size, + valid_res + processed_size, + values...); + } else { + auto pw = column->Span(i); + auto chunk = pw.get(); + const T* data = static_cast(chunk.data()); + const bool* valid_data = chunk.valid_data(); + func(data, + valid_data, + chunk_size, + res + processed_size, + valid_res + processed_size, + values...); + } + } else { + const bool* valid_data; + if constexpr (std::is_same_v) { + auto pw = column->StringViews(i); + valid_data = pw.get().second.data(); + ApplyValidData(valid_data, + res + processed_size, + valid_res + processed_size, + chunk_size); + } else { + auto pw = column->Span(i); + auto chunk = pw.get(); + valid_data = chunk.valid_data(); + ApplyValidData(valid_data, + res + processed_size, + valid_res + processed_size, + chunk_size); + } + } + + processed_size += chunk_size; + } + AssertInfo(processed_size == num_rows, + "Processed size {} is not equal to num_rows {}", + processed_size, + num_rows); + return processed_size; + } + + // Whether shared columns can be skipped for this path (type-agnostic) + bool + CanSkipShared(const std::string& path) { + auto it = key_field_map_.find(path); + if (it == key_field_map_.end()) { + return true; + } + + const auto& field_names = it->second; + for (const auto& field_name : field_names) { + if (field_layout_type_map_[field_name] == + JsonKeyLayoutType::SHARED) { + return false; + } + } + + return true; + } + + // Whether shared columns can be skipped for this path with type filter + bool + CanSkipShared(const std::string& path, + const std::set& target_types) { + auto it = key_field_map_.find(path); + if (it == key_field_map_.end()) { + return true; + } + + const auto& field_names = it->second; + for (const auto& field_name : field_names) { + if (field_layout_type_map_[field_name] != + JsonKeyLayoutType::SHARED) { + continue; + } + + if (!target_types.empty() && + target_types.find(key_data_type_map_[field_name]) == + target_types.end()) { + continue; + } + + return false; + } + + return true; + } + + std::set + GetShreddingFields(const std::string& pointer) { + std::set fields; + if (key_field_map_.find(pointer) != key_field_map_.end()) { + for (const auto& field : key_field_map_[pointer]) { + if (shred_field_data_type_map_.find(field) != + shred_field_data_type_map_.end()) { + fields.insert(field); + } + } + } + return fields; + } + + std::string + GetShreddingField(const std::string& pointer, JSONType type) { + if (key_field_map_.find(pointer) == key_field_map_.end()) { + return ""; + } + for (const auto& field : key_field_map_[pointer]) { + if (shred_field_data_type_map_.find(field) != + shred_field_data_type_map_.end() && + shred_field_data_type_map_[field] == type) { + return field; + } + } + return ""; + } + + std::set + GetShreddingFields(const std::string& pointer, + std::vector types) { + std::set fields; + if (key_field_map_.find(pointer) == key_field_map_.end()) { + return fields; + } + for (const auto& field : key_field_map_[pointer]) { + if (shred_field_data_type_map_.find(field) != + shred_field_data_type_map_.end() && + std::find(types.begin(), + types.end(), + shred_field_data_type_map_[field]) != types.end()) { + fields.insert(field); + } + } + return fields; + } + + JSONType + GetShreddingJsonType(const std::string& field_name) { + if (shred_field_data_type_map_.find(field_name) != + shred_field_data_type_map_.end()) { + return shred_field_data_type_map_[field_name]; + } + return JSONType::UNKNOWN; + } + + private: + void + CollectSingleJsonStatsInfo(const char* json_str, + std::map& infos); + + std::string + PrintKeyInfo(const std::map& infos) { + std::stringstream ss; + for (const auto& [key, info] : infos) { + ss << key.ToString() << " -> " << info.ToString() << "\t"; + } + return ss.str(); + } + + std::map + CollectKeyInfo(const std::vector& field_datas, bool nullable); + + void + TraverseJsonForStats(const char* json, + jsmntok* tokens, + int& index, + std::vector& path, + std::map& infos); + + void + AddKeyStatsInfo(const std::vector& paths, + JSONType type, + uint8_t* value, + std::map& infos); + + std::string + PrintJsonKeyLayoutType(const std::map& infos) { + std::stringstream ss; + std::unordered_map> + type_to_keys; + for (const auto& [key, type] : infos) { + type_to_keys[type].push_back(key.ToString()); + } + for (const auto& [type, keys] : type_to_keys) { + ss << ToString(type) << " -> [" << Join(keys, ", ") << "]\n"; + } + return ss.str(); + } + + std::map + ClassifyJsonKeyLayoutType(const std::map& infos); + + void + BuildKeyStats(const std::vector& field_datas, bool nullable); + + void + BuildKeyStatsForRow(const char* json_str, uint32_t row_id); + + void + BuildKeyStatsForNullRow(); + + std::string + GetShreddingDir(); + + std::string + GetSharedKeyIndexDir(); + + void + AddKeyStats(const std::vector& path, + JSONType type, + const std::string& value, + std::map& values); + + void + TraverseJsonForBuildStats(const char* json, + jsmntok* tokens, + int& index, + std::vector& path, + std::map& values); + + bool + IsBoolean(const std::string& str) { + return str == "true" || str == "false"; + } + + bool + IsInt8(const std::string& str) { + std::istringstream iss(str); + int8_t num; + iss >> num; + + return !iss.fail() && iss.eof() && + num >= std::numeric_limits::min() && + num <= std::numeric_limits::max(); + } + + bool + IsInt16(const std::string& str) { + std::istringstream iss(str); + int16_t num; + iss >> num; + + return !iss.fail() && iss.eof() && + num >= std::numeric_limits::min() && + num <= std::numeric_limits::max(); + } + + bool + IsInt32(const std::string& str) { + std::istringstream iss(str); + int64_t num; + iss >> num; + + return !iss.fail() && iss.eof() && + num >= std::numeric_limits::min() && + num <= std::numeric_limits::max(); + } + + bool + IsInt64(const std::string& str) { + std::istringstream iss(str); + int64_t num; + iss >> num; + + return !iss.fail() && iss.eof(); + } + + bool + IsFloat(const std::string& str) { + try { + float d = std::stof(str); + return true; + } catch (...) { + return false; + } + } + + bool + IsDouble(const std::string& str) { + try { + double d = std::stod(str); + return true; + } catch (...) { + return false; + } + } + + bool + IsNull(const std::string& str) { + return str == "null"; + } + + JSONType + getType(const std::string& str) { + if (IsBoolean(str)) { + return JSONType::BOOL; + // TODO: add int8, int16, int32 support + // now we only support int64 for build performance + // } else if (IsInt8(str)) { + // return JSONType::INT8; + // } else if (IsInt16(str)) { + // return JSONType::INT16; + // } else if (IsInt32(str)) { + // return JSONType::INT32; + } else if (IsInt64(str)) { + return JSONType::INT64; + } else if (IsFloat(str)) { + return JSONType::FLOAT; + } else if (IsDouble(str)) { + return JSONType::DOUBLE; + } else if (IsNull(str)) { + return JSONType::NONE; + } + LOG_DEBUG("unknown json type for string: {}", str); + return JSONType::UNKNOWN; + } + + void + LoadShreddingData(const std::vector& index_files); + + void + ApplyValidData(const bool* valid_data, + TargetBitmapView res, + TargetBitmapView valid_res, + const int size) { + if (valid_data != nullptr) { + for (int i = 0; i < size; i++) { + if (!valid_data[i]) { + res[i] = valid_res[i] = false; + } + } + } + } + + void + ApplyOnlyValidData(const bool* valid_data, + TargetBitmapView valid_res, + const int size) { + if (valid_data != nullptr) { + for (int i = 0; i < size; i++) { + if (!valid_data[i]) { + valid_res[i] = false; + } + } + } + } + + void + GetColumnSchemaFromParquet(int64_t column_group_id, + const std::string& file); + + void + GetCommonMetaFromParquet(const std::string& file); + + void + LoadColumnGroup(int64_t column_group_id, + const std::vector& file_ids); + + void + LoadShreddingMeta( + std::vector>> sorted_files); + + std::string + AddBucketName(const std::string& remote_prefix); + + private: + proto::schema::FieldSchema schema_; + int64_t segment_id_; + int64_t field_id_; + mutable std::mutex mtx_; + int64_t num_rows_{0}; + bool is_built_ = false; + std::string path_; + milvus::storage::ChunkManagerPtr rcm_; + std::shared_ptr mem_file_manager_; + std::shared_ptr disk_file_manager_; + int64_t max_shredding_columns_; + double shredding_ratio_threshold_; + int64_t write_batch_size_; + + std::map key_types_; + std::set shared_keys_; + std::set column_keys_; + std::shared_ptr parquet_writer_; + std::shared_ptr bson_inverted_index_; + + milvus::proto::common::LoadPriority load_priority_; + // some meta cache for searching + // json_path -> [json_path_int, json_path_array, json_path_object, ...], only for all keys + std::unordered_map> key_field_map_; + // field_name -> data_type, such as json_path_int -> JSONType::INT64, only for real shredding columns + std::unordered_map shred_field_data_type_map_; + // key_name -> data_type, such as json_path_int -> JSONType::INT64, for all keys + std::unordered_map key_data_type_map_; + // field_name -> key_type, such as json_path_int -> JsonKeyLayoutType::TYPED, for all keys + std::unordered_map field_layout_type_map_; + // field_name -> field_id, such as json_path_int -> 1001 + std::unordered_map field_name_to_id_map_; + // field_id -> field_name, such as 1001 -> json_path_int + std::unordered_map field_id_to_name_map_; + // field_name vector, the sequece is the same as the order of files + std::vector field_names_; + // column_group_id -> schema, the sequence of schemas is the same as the order of files + std::map> column_group_schemas_; + // field_name -> column + mutable std::unordered_map> + shredding_columns_; + std::string mmap_filepath_; + + std::string shared_column_field_name_; + std::shared_ptr shared_column_; + SkipIndex skip_index_; +}; + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/src/index/json_stats/bson_builder.cpp b/internal/core/src/index/json_stats/bson_builder.cpp new file mode 100644 index 0000000000..a707769b7a --- /dev/null +++ b/internal/core/src/index/json_stats/bson_builder.cpp @@ -0,0 +1,328 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include +#include + +#include "index/json_stats/bson_builder.h" + +namespace milvus::index { + +namespace { + +using bsoncxx::builder::basic::kvp; + +void +AppendDomElementToBsonArray(simdjson::dom::element elem, + bsoncxx::builder::basic::array& out); + +void +AppendDomElementToBsonDocument(simdjson::dom::element elem, + std::string_view key, + bsoncxx::builder::basic::document& out) { + using simdjson::dom::element_type; + + auto type = elem.type(); + if (type == element_type::STRING) { + std::string s(std::string_view(elem.get_string())); + out.append(kvp(std::string(key), std::move(s))); + } else if (type == element_type::INT64) { + out.append(kvp(std::string(key), int64_t(elem.get_int64()))); + } else if (type == element_type::UINT64) { + out.append(kvp(std::string(key), int64_t(elem.get_uint64()))); + } else if (type == element_type::DOUBLE) { + out.append(kvp(std::string(key), elem.get_double())); + } else if (type == element_type::BOOL) { + out.append(kvp(std::string(key), bool(elem.get_bool()))); + } else if (type == element_type::NULL_VALUE) { + out.append(kvp(std::string(key), bsoncxx::types::b_null{})); + } else if (type == element_type::OBJECT) { + bsoncxx::builder::basic::document sub; + for (auto [k, v] : elem.get_object()) { + AppendDomElementToBsonDocument(v, k, sub); + } + out.append(kvp(std::string(key), sub.extract())); + } else if (type == element_type::ARRAY) { + bsoncxx::builder::basic::array subarr; + for (simdjson::dom::element v : elem.get_array()) { + AppendDomElementToBsonArray(v, subarr); + } + out.append(kvp(std::string(key), subarr.extract())); + } else { + out.append(kvp(std::string(key), bsoncxx::types::b_null{})); + } +} + +void +AppendDomElementToBsonArray(simdjson::dom::element elem, + bsoncxx::builder::basic::array& out) { + using simdjson::dom::element_type; + + auto type = elem.type(); + if (type == element_type::STRING) { + out.append(std::string(std::string_view(elem.get_string()))); + } else if (type == element_type::INT64) { + out.append(int64_t(elem.get_int64())); + } else if (type == element_type::UINT64) { + out.append(int64_t(elem.get_uint64())); + } else if (type == element_type::DOUBLE) { + out.append(elem.get_double()); + } else if (type == element_type::BOOL) { + out.append(bool(elem.get_bool())); + } else if (type == element_type::NULL_VALUE) { + out.append(bsoncxx::types::b_null{}); + } else if (type == element_type::OBJECT) { + bsoncxx::builder::basic::document sub; + for (auto [k, v] : elem.get_object()) { + AppendDomElementToBsonDocument(v, k, sub); + } + out.append(sub.extract()); + } else if (type == element_type::ARRAY) { + bsoncxx::builder::basic::array subarr; + for (simdjson::dom::element v : elem.get_array()) { + AppendDomElementToBsonArray(v, subarr); + } + out.append(subarr.extract()); + } else { + out.append(bsoncxx::types::b_null{}); + } +} +} // namespace + +// Parse a JSON array string with simdjson and build an owning BSON array value +bsoncxx::array::value +BuildBsonArrayFromJsonString(const std::string& json_array) { + simdjson::dom::parser parser; + simdjson::dom::element root = parser.parse(json_array); + if (root.type() != simdjson::dom::element_type::ARRAY) { + ThrowInfo(ErrorCode::UnexpectedError, + "input is not a JSON array: {}", + json_array); + } + + bsoncxx::builder::basic::array out; + for (simdjson::dom::element elem : root.get_array()) { + AppendDomElementToBsonArray(elem, out); + } + return out.extract(); +} + +std::vector +BuildBsonArrayBytesFromJsonString(const std::string& json_array) { + auto arr_value = BuildBsonArrayFromJsonString(json_array); + auto view = arr_value.view(); + return std::vector(view.data(), view.data() + view.length()); +} + +void +BsonBuilder::AppendToDom(DomNode& root, + const std::vector& keys, + const std::string& value, + const JSONType& type) { + LOG_TRACE("append to dom: {} with value {} and type {}", + Join(keys, "."), + value, + ToString(type)); + DomNode* current = &root; + for (size_t i = 0; i < keys.size(); ++i) { + const std::string& key = keys[i]; + if (i == keys.size() - 1) { + current->document_children[key] = CreateValueNode(value, type); + } else { + auto& children = current->document_children; + auto it = children.find(key); + if (it != children.end()) { + if (it->second.type != DomNode::Type::DOCUMENT) { + it->second = DomNode(DomNode::Type::DOCUMENT); + } + current = &it->second; + } else { + children[key] = DomNode(DomNode::Type::DOCUMENT); + current = &children[key]; + } + } + } +} + +DomNode +BsonBuilder::CreateValueNode(const std::string& value, JSONType type) { + switch (type) { + case JSONType::NONE: { + return DomNode(bsoncxx::types::b_null{}); + } + case JSONType::BOOL: { + bool b = (value == "true" || value == "1"); + return DomNode(bsoncxx::types::b_bool{b}); + } + case JSONType::INT32: { + int32_t i = std::stoi(value); + return DomNode(bsoncxx::types::b_int32{i}); + } + case JSONType::INT64: { + int64_t l = std::stoll(value); + return DomNode(bsoncxx::types::b_int64{l}); + } + case JSONType::DOUBLE: { + double d = std::stod(value); + return DomNode(bsoncxx::types::b_double{d}); + } + case JSONType::STRING: { + return DomNode(bsoncxx::types::b_string{value}); + } + case JSONType::ARRAY: { + try { + auto arr_value = BuildBsonArrayFromJsonString(value); + return DomNode(bsoncxx::types::b_array{arr_value.view()}); + } catch (const simdjson::simdjson_error& e) { + ThrowInfo( + ErrorCode::UnexpectedError, + "Failed to build bson array (simdjson) from string: {}, {}", + value, + e.what()); + } catch (const std::exception& e) { + ThrowInfo( + ErrorCode::UnexpectedError, + "Failed to build bson array (generic) from string: {}, {}", + value, + e.what()); + } + } + case JSONType::OBJECT: { + AssertInfo(value == "{}", + "object value should be empty but got {}", + value); + // return an empty json object as a document node + return DomNode(DomNode::Type::DOCUMENT); + } + default: + ThrowInfo(ErrorCode::Unsupported, "Unsupported JSON type {}", type); + } +} + +void +BsonBuilder::ConvertDomToBson(const DomNode& node, + bsoncxx::builder::basic::document& builder) { + for (const auto& [key, child] : node.document_children) { + switch (child.type) { + case DomNode::Type::VALUE: { + builder.append(bsoncxx::builder::basic::kvp( + key, child.bson_value.value())); + break; + } + case DomNode::Type::DOCUMENT: { + bsoncxx::builder::basic::document sub_doc; + ConvertDomToBson(child, sub_doc); + builder.append(bsoncxx::builder::basic::kvp(key, sub_doc)); + break; + } + default: { + ThrowInfo(ErrorCode::Unsupported, + "Unsupported DOM node type {}", + static_cast(child.type)); + } + } + } +} + +void +BsonBuilder::ExtractOffsetsRecursive( + const uint8_t* root_base_ptr, + const uint8_t* current_base_ptr, + const std::string& current_path, + std::vector>& result) { + uint32_t length; + memcpy(&length, current_base_ptr, 4); + + const uint8_t* end_ptr = current_base_ptr + length - 1; + AssertInfo(*(end_ptr) == 0x00, "miss bson document terminator"); + + const uint8_t* ptr = current_base_ptr + 4; + + while (ptr <= end_ptr && *ptr != 0x00) { + // record key offset + size_t key_offset = ptr - root_base_ptr; + + // read key type + auto type = static_cast(*ptr++); + + // read key + auto key_name = reinterpret_cast(ptr); + ptr += strlen(key_name) + 1; + + // construct key path + std::string key_path = AppendJsonPointer(current_path, key_name); + + // do not record key offset pair for null value + // because null value is not a valid key + if (type != bsoncxx::type::k_null) { + result.emplace_back(key_path, key_offset); + } + + // handle value + switch (type) { + case bsoncxx::type::k_document: { + ExtractOffsetsRecursive(root_base_ptr, ptr, key_path, result); + // skip sub doc + uint32_t child_len; + memcpy(&child_len, ptr, 4); + ptr += child_len; + break; + } + case bsoncxx::type::k_array: { + // not parse array + // skip sub doc + uint32_t child_len; + memcpy(&child_len, ptr, 4); + ptr += child_len; + break; + } + case bsoncxx::type::k_string: { + uint32_t str_len; + memcpy(&str_len, ptr, 4); + ptr += 4 + str_len; + break; + } + case bsoncxx::type::k_int32: { + ptr += 4; + break; + } + case bsoncxx::type::k_int64: { + ptr += 8; + break; + } + case bsoncxx::type::k_double: { + ptr += 8; + break; + } + case bsoncxx::type::k_bool: { + ptr += 1; + break; + } + case bsoncxx::type::k_null: { + break; + } + default: { + ThrowInfo(ErrorCode::Unsupported, + "Unsupported BSON type {}", + static_cast(type)); + } + } + } +} + +} // namespace milvus::index diff --git a/internal/core/src/index/json_stats/bson_builder.h b/internal/core/src/index/json_stats/bson_builder.h new file mode 100644 index 0000000000..327e5ea3c9 --- /dev/null +++ b/internal/core/src/index/json_stats/bson_builder.h @@ -0,0 +1,97 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "index/json_stats/utils.h" +#include "common/EasyAssert.h" +namespace milvus::index { + +class DomNode { + public: + enum class Type { DOCUMENT, VALUE }; + Type type; + + std::map document_children; + std::optional bson_value; + + DomNode(Type t = Type::DOCUMENT) : type(t) { + } + DomNode(bsoncxx::types::bson_value::value v) + : type(Type::VALUE), bson_value(std::move(v)) { + } +}; + +// Parse a JSON array string and return a self-owned buffer containing the +// BSON array bytes (length-prefixed, including terminator). The returned +// vector's data() can be used directly with bson_view. +std::vector +BuildBsonArrayBytesFromJsonString(const std::string& json_array); + +class BsonBuilder { + public: + static void + AppendToDom(DomNode& root, + const std::vector& keys, + const std::string& value, + const JSONType& type); + + static DomNode + CreateValueNode(const std::string& value, JSONType type); + + static void + ConvertDomToBson(const DomNode& node, + bsoncxx::builder::basic::document& builder); + + // helper function to recursively extract keys with offset + static void + ExtractOffsetsRecursive( + const uint8_t* base_ptr, + const uint8_t* current_base_ptr, + const std::string& current_path, + std::vector>& result); + + static std::vector> + ExtractBsonKeyOffsets(const bsoncxx::document::view& view) { + std::vector> result; + const uint8_t* raw_data = view.data(); + size_t raw_len = view.length(); + + ExtractOffsetsRecursive(raw_data, raw_data, "", result); + return result; + } + + static std::vector> + ExtractBsonKeyOffsets(const uint8_t* data, size_t size) { + std::vector> result; + ExtractOffsetsRecursive(data, data, "", result); + return result; + } +}; +} // namespace milvus::index diff --git a/internal/core/src/index/json_stats/bson_inverted.cpp b/internal/core/src/index/json_stats/bson_inverted.cpp new file mode 100644 index 0000000000..aaba5808f1 --- /dev/null +++ b/internal/core/src/index/json_stats/bson_inverted.cpp @@ -0,0 +1,222 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include +#include +#include +#include +#include + +#include "common/ScopedTimer.h" +#include "monitor/Monitor.h" +#include "index/json_stats/bson_inverted.h" +#include "storage/LocalChunkManagerSingleton.h" +namespace milvus::index { + +BsonInvertedIndex::BsonInvertedIndex(const std::string& path, + int64_t field_id, + bool is_load, + const storage::FileManagerContext& ctx, + int64_t tantivy_index_version) + : is_load_(is_load), + field_id_(field_id), + tantivy_index_version_(tantivy_index_version) { + disk_file_manager_ = + std::make_shared(ctx); + if (is_load_) { + auto prefix = disk_file_manager_->GetLocalJsonStatsSharedIndexPrefix(); + path_ = prefix; + LOG_INFO("bson inverted index load path:{}", path_); + } else { + path_ = path; + LOG_INFO("bson inverted index build path:{}", path_); + } +} + +BsonInvertedIndex::~BsonInvertedIndex() { + if (wrapper_) { + wrapper_->free(); + } + if (!is_load_) { + auto local_chunk_manager = + milvus::storage::LocalChunkManagerSingleton::GetInstance() + .GetChunkManager(); + auto prefix = path_; + LOG_INFO("bson inverted index remove path:{}", path_); + local_chunk_manager->RemoveDir(prefix); + } +} + +void +BsonInvertedIndex::AddRecord(const std::string& key, + uint32_t row_id, + uint32_t offset) { + if (inverted_index_map_.find(key) == inverted_index_map_.end()) { + inverted_index_map_[key] = {EncodeInvertedIndexValue(row_id, offset)}; + } else { + inverted_index_map_[key].push_back( + EncodeInvertedIndexValue(row_id, offset)); + } +} + +void +BsonInvertedIndex::BuildIndex() { + if (wrapper_ == nullptr) { + if (tantivy_index_exist(path_.c_str())) { + ThrowInfo(IndexBuildError, + "build inverted index temp dir:{} not empty", + path_); + } + auto field_name = std::to_string(field_id_) + "_" + "shared"; + wrapper_ = std::make_shared( + field_name.c_str(), path_.c_str(), tantivy_index_version_); + LOG_INFO("build bson inverted index for field id:{} with dir:{}", + field_id_, + path_); + } + std::vector keys; + std::vector json_offsets; + std::vector json_offsets_lens; + for (const auto& [key, offsets] : inverted_index_map_) { + keys.push_back(key.c_str()); + json_offsets.push_back(offsets.data()); + json_offsets_lens.push_back(offsets.size()); + } + wrapper_->add_json_key_stats_data_by_batch(keys.data(), + json_offsets.data(), + json_offsets_lens.data(), + keys.size()); +} + +void +BsonInvertedIndex::LoadIndex(const std::vector& index_files, + milvus::proto::common::LoadPriority priority) { + if (is_load_) { + // convert shared_key_index/... to remote_prefix/shared_key_index/... + std::vector remote_files; + for (auto& file : index_files) { + auto remote_prefix = + disk_file_manager_->GetRemoteJsonStatsLogPrefix(); + remote_files.emplace_back(remote_prefix + "/" + file); + } + // cache shared_key_index/... to disk + disk_file_manager_->CacheJsonStatsSharedIndexToDisk(remote_files, + priority); + AssertInfo(tantivy_index_exist(path_.c_str()), + "index dir not exist: {}", + path_); + wrapper_ = std::make_shared( + path_.c_str(), false, milvus::index::SetBitsetUnused); + LOG_INFO("load json shared key index done for field id:{} with dir:{}", + field_id_, + path_); + } +} + +IndexStatsPtr +BsonInvertedIndex::UploadIndex() { + AssertInfo(!is_load_, "upload index is not supported for load index"); + AssertInfo(wrapper_ != nullptr, + "bson inverted index wrapper is not initialized"); + wrapper_->finish(); + + boost::filesystem::path p(path_); + boost::filesystem::directory_iterator end_iter; + + for (boost::filesystem::directory_iterator iter(p); iter != end_iter; + iter++) { + if (boost::filesystem::is_directory(*iter)) { + LOG_WARN("{} is a directory", iter->path().string()); + } else { + LOG_INFO("trying to add bson inverted index file: {}", + iter->path().string()); + AssertInfo(disk_file_manager_->AddJsonSharedIndexLog( + iter->path().string()), + "failed to add bson inverted index file: {}", + iter->path().string()); + LOG_INFO("bson inverted index file: {} added", + iter->path().string()); + } + } + + auto remote_paths_to_size = disk_file_manager_->GetRemotePathsToFileSize(); + + std::vector index_files; + index_files.reserve(remote_paths_to_size.size()); + for (auto& file : remote_paths_to_size) { + index_files.emplace_back(file.first, file.second); + } + return IndexStats::New(disk_file_manager_->GetAddedTotalFileSize(), + std::move(index_files)); +} + +void +BsonInvertedIndex::TermQuery( + const std::string& path, + const std::function& visitor) { + AssertInfo(wrapper_ != nullptr, + "bson inverted index wrapper is not initialized"); + auto start = std::chrono::steady_clock::now(); + auto array = wrapper_->term_query_i64(path); + auto end = std::chrono::steady_clock::now(); + LOG_TRACE("term query time:{}", + std::chrono::duration_cast(end - start) + .count()); + auto array_len = array.array_.len; + LOG_DEBUG("json stats shared column filter size:{} with path:{}", + array_len, + path); + + std::vector row_id_array(array_len); + std::vector offset_array(array_len); + + for (int64_t i = 0; i < array_len; i++) { + auto value = array.array_.array[i]; + auto [row_id, offset] = DecodeInvertedIndexValue(value); + row_id_array[i] = row_id; + offset_array[i] = offset; + } + + visitor(row_id_array.data(), offset_array.data(), array_len); +} + +void +BsonInvertedIndex::TermQueryEach( + const std::string& path, + const std::function& each) { + AssertInfo(wrapper_ != nullptr, + "bson inverted index wrapper is not initialized"); + auto start = std::chrono::steady_clock::now(); + auto array = wrapper_->term_query_i64(path); + auto end = std::chrono::steady_clock::now(); + LOG_TRACE("term query time:{}", + std::chrono::duration_cast(end - start) + .count()); + auto array_len = array.array_.len; + LOG_TRACE("json stats shared column filter size:{} with path:{}", + array_len, + path); + + for (int64_t i = 0; i < array_len; i++) { + auto value = array.array_.array[i]; + auto [row_id, offset] = DecodeInvertedIndexValue(value); + each(row_id, offset); + } +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/src/index/json_stats/bson_inverted.h b/internal/core/src/index/json_stats/bson_inverted.h new file mode 100644 index 0000000000..c532feb34e --- /dev/null +++ b/internal/core/src/index/json_stats/bson_inverted.h @@ -0,0 +1,95 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include +#include +#include +#include +#include + +#include "index/json_stats/utils.h" +#include "common/EasyAssert.h" +#include "index/IndexStats.h" + +namespace milvus::index { + +inline int64_t +EncodeInvertedIndexValue(uint32_t row_id, uint32_t offset) { + return (static_cast(row_id) << 32) | offset; +} + +inline std::pair +DecodeInvertedIndexValue(uint64_t value) { + return std::make_pair(static_cast(value >> 32), + static_cast(value & 0xFFFFFFFF)); +} + +class BsonInvertedIndex { + public: + BsonInvertedIndex(const std::string& path, + int64_t field_id, + bool is_load, + const storage::FileManagerContext& ctx, + int64_t tantivy_index_version); + + ~BsonInvertedIndex(); + + void + AddRecord(const std::string& key, uint32_t row_id, uint32_t offset); + + void + BuildIndex(); + + void + LoadIndex(const std::vector& index_files, + milvus::proto::common::LoadPriority priority); + + IndexStatsPtr + UploadIndex(); + + void + TermQuery(const std::string& path, + const std::function& visitor); + + void + TermQueryEach( + const std::string& path, + const std::function& each); + + bool + KeyExists(const std::string& key) { + auto array = wrapper_->term_query_i64(key); + return !array.array_.len == 0; + } + + private: + std::string path_; + bool is_load_; + // json field id that this inverted index belongs to + int64_t field_id_; + int64_t tantivy_index_version_; + // key -> encoded([row_id, offset]) map cache for building index + std::map> inverted_index_map_; + // tantivy index wrapper + std::shared_ptr wrapper_; + std::shared_ptr disk_file_manager_; +}; + +} // namespace milvus::index diff --git a/internal/core/src/index/json_stats/parquet_writer.cpp b/internal/core/src/index/json_stats/parquet_writer.cpp new file mode 100644 index 0000000000..b1743155d0 --- /dev/null +++ b/internal/core/src/index/json_stats/parquet_writer.cpp @@ -0,0 +1,260 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "index/json_stats/parquet_writer.h" +#include +#include +#include +#include +#include +#include +#include + +namespace milvus::index { + +JsonStatsParquetWriter::JsonStatsParquetWriter( + std::shared_ptr fs, + milvus_storage::StorageConfig& storage_config, + size_t buffer_size, + size_t batch_size, + std::shared_ptr writer_props) + : fs_(fs), + storage_config_(storage_config), + buffer_size_(buffer_size), + batch_size_(batch_size), + writer_props_(writer_props), + unflushed_row_count_(0), + all_row_count_(0) { +} + +JsonStatsParquetWriter::~JsonStatsParquetWriter() { + Close(); +} + +void +JsonStatsParquetWriter::Close() { + Flush(); + packed_writer_->Close(); +} + +void +JsonStatsParquetWriter::Flush() { + WriteCurrentBatch(); +} + +void +JsonStatsParquetWriter::UpdatePathSizeMap( + const std::vector>& arrays) { + auto index = 0; + for (const auto& group : column_groups_) { + auto path = file_paths_[index]; + for (const auto& column_index : group) { + size_t size = GetArrowArrayMemorySize(arrays[column_index]); + path_size_map_[path] += size; + total_size_ += size; + } + index++; + } +} + +size_t +JsonStatsParquetWriter::WriteCurrentBatch() { + if (unflushed_row_count_ == 0) { + return 0; + } + + std::vector> arrays; + for (auto& builder : builders_) { + std::shared_ptr array; + auto status = builder->Finish(&array); + AssertInfo( + status.ok(), "failed to finish builder: {}", status.ToString()); + arrays.push_back(array); + builder->Reset(); + } + + UpdatePathSizeMap(arrays); + + auto batch = + arrow::RecordBatch::Make(schema_, unflushed_row_count_, arrays); + auto status = packed_writer_->Write(batch); + AssertInfo( + status.ok(), "failed to write batch, error: {}", status.ToString()); + + auto res = unflushed_row_count_; + unflushed_row_count_ = 0; + return res; +} + +void +JsonStatsParquetWriter::Init(const ParquetWriteContext& context) { + schema_ = context.schema; + builders_ = context.builders; + builders_map_ = context.builders_map; + kv_metadata_ = std::move(context.kv_metadata); + column_groups_ = context.column_groups; + file_paths_ = context.file_paths; + packed_writer_ = std::make_unique( + fs_, + file_paths_, + schema_, + storage_config_, + column_groups_, + buffer_size_); + for (const auto& [key, value] : kv_metadata_) { + packed_writer_->AddUserMetadata(key, value); + } +} + +size_t +JsonStatsParquetWriter::AddCurrentRow() { + unflushed_row_count_++; + all_row_count_++; + if (unflushed_row_count_ >= batch_size_) { + WriteCurrentBatch(); + } + return all_row_count_; +} + +void +JsonStatsParquetWriter::AppendSharedRow(const uint8_t* data, size_t length) { + auto builder = builders_.at(builders_.size() - 1); + auto shared_builder = + std::static_pointer_cast(builder); + + if (length == 0) { + auto status = shared_builder->AppendNull(); + AssertInfo(status.ok(), "failed to append null data"); + } else { + auto status = shared_builder->Append(data, length); + AssertInfo(status.ok(), "failed to append binary data"); + } +} + +void +JsonStatsParquetWriter::AppendValue(const std::string& key, + const std::string& value) { + auto it = builders_map_.find(key); + if (it == builders_map_.end()) { + ThrowInfo( + ErrorCode::UnexpectedError, "builder for key {} not found", key); + } + + auto builder = it->second; + auto ast = AppendDataToBuilder(value, builder); + AssertInfo(ast.ok(), "failed to append data to builder"); +} + +void +JsonStatsParquetWriter::AppendRow( + const std::map& row_data) { + for (const auto& [key, value] : row_data) { + auto it = builders_map_.find(key); + if (it == builders_map_.end()) { + ThrowInfo(ErrorCode::UnexpectedError, + "builder for key {} not found", + key); + } + + auto builder = it->second; + auto status = AppendDataToBuilder(value, builder); + AssertInfo(status.ok(), "failed to append data to builder"); + } + + AddCurrentRow(); +} + +arrow::Status +JsonStatsParquetWriter::AppendDataToBuilder( + const std::string& value, std::shared_ptr builder) { + auto type_id = builder->type()->id(); + + if (value.empty()) { + return builder->AppendNull(); + } + + arrow::Status ast; + try { + switch (type_id) { + case arrow::Type::INT8: { + auto int8_builder = + std::static_pointer_cast(builder); + ast = int8_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::INT16: { + auto int16_builder = + std::static_pointer_cast(builder); + ast = int16_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::INT32: { + auto int32_builder = + std::static_pointer_cast(builder); + ast = int32_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::INT64: { + auto int64_builder = + std::static_pointer_cast(builder); + ast = int64_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::FLOAT: { + auto float_builder = + std::static_pointer_cast(builder); + ast = float_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::DOUBLE: { + auto double_builder = + std::static_pointer_cast(builder); + ast = double_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::BOOL: { + auto bool_builder = + std::static_pointer_cast(builder); + ast = bool_builder->Append(ConvertValue(value)); + break; + } + case arrow::Type::STRING: { + auto string_builder = + std::static_pointer_cast(builder); + ast = string_builder->Append(value); + break; + } + case arrow::Type::BINARY: { + auto binary_builder = + std::static_pointer_cast(builder); + ast = binary_builder->Append(value.data(), value.size()); + break; + } + default: + ThrowInfo(ErrorCode::Unsupported, + "Unsupported JSON type: {} for value {}", + type_id, + value); + } + } catch (const std::exception& e) { + ThrowInfo(ErrorCode::UnexpectedError, + "failed to append data to builder: {}", + e.what()); + } + return ast; +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/src/index/json_stats/parquet_writer.h b/internal/core/src/index/json_stats/parquet_writer.h new file mode 100644 index 0000000000..9ef6781ff2 --- /dev/null +++ b/internal/core/src/index/json_stats/parquet_writer.h @@ -0,0 +1,244 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include +#include +#include +#include +#include "arrow/api.h" +#include "arrow/io/api.h" +#include "parquet/arrow/writer.h" +#include "index/json_stats/utils.h" +#include "milvus-storage/packed/writer.h" +#include "milvus-storage/common/config.h" + +namespace milvus::index { + +template +inline T +ConvertValue(const std::string& value); + +template <> +inline int8_t +ConvertValue(const std::string& value) { + return static_cast(std::stoi(value)); +} +template <> +inline int16_t +ConvertValue(const std::string& value) { + return static_cast(std::stoi(value)); +} +template <> +inline int32_t +ConvertValue(const std::string& value) { + return std::stoi(value); +} +template <> +inline int64_t +ConvertValue(const std::string& value) { + return std::stoll(value); +} +template <> +inline float +ConvertValue(const std::string& value) { + return std::stof(value); +} +template <> +inline double +ConvertValue(const std::string& value) { + return std::stod(value); +} +template <> +inline bool +ConvertValue(const std::string& value) { + return value == "true"; +} + +template +inline arrow::Status +AppendValueImpl(std::shared_ptr builder, + const std::string& value) { + return builder->Append(ConvertValue(value)); +} + +struct ParquetWriteContext { + std::shared_ptr schema; + std::vector> builders; + std::map> builders_map; + std::vector> kv_metadata; + std::vector file_paths; + std::vector> column_groups; +}; + +struct TableStatsInfo { + std::shared_ptr schema; + std::map column_map; +}; + +class ColumnGroupingStrategy { + public: + virtual ~ColumnGroupingStrategy() = default; + + virtual std::vector> + CreateGroups(const TableStatsInfo& table_info) const = 0; +}; + +class DefaultColumnGroupingStrategy : public ColumnGroupingStrategy { + public: + std::vector> + CreateGroups(const TableStatsInfo& table_info) const override { + // put all columns into one group + std::vector> column_groups; + std::vector group; + for (size_t i = 0; i < table_info.schema->num_fields(); ++i) { + group.push_back(i); + } + column_groups.push_back(group); + return column_groups; + } +}; + +enum class ColumnGroupingStrategyType { + DEFAULT, +}; + +class ColumnGroupingStrategyFactory { + public: + static std::unique_ptr + CreateStrategy(ColumnGroupingStrategyType type) { + switch (type) { + case ColumnGroupingStrategyType::DEFAULT: + return std::make_unique(); + default: + ThrowInfo(ErrorCode::UnexpectedError, + "Unknown ColumnGroupingStrategyType"); + } + } +}; + +struct ParquetWriterFactory { + static ParquetWriteContext + CreateContext(const std::map& column_map, + const std::string& path_prefix) { + ParquetWriteContext context; + context.schema = CreateArrowSchema(column_map); + auto builders = CreateArrowBuilders(column_map); + context.builders = std::move(builders.first); + context.builders_map = std::move(builders.second); + context.kv_metadata = CreateParquetKVMetadata(column_map); + context.column_groups = + std::move(ColumnGroupingStrategyFactory::CreateStrategy( + ColumnGroupingStrategyType::DEFAULT) + ->CreateGroups(TableStatsInfo{ + context.schema, + column_map, + })); + auto column_group_id = 0; + for (const auto& group : context.column_groups) { + auto file_log_id = 0; + context.file_paths.push_back(CreateColumnGroupParquetPath( + path_prefix, column_group_id, file_log_id)); + LOG_INFO("create column group parquet path: {} for column group {}", + context.file_paths.back(), + column_group_id); + column_group_id++; + } + return context; + } +}; + +class JsonStatsParquetWriter { + public: + JsonStatsParquetWriter( + std::shared_ptr fs, + milvus_storage::StorageConfig& storage_config, + size_t buffer_size, + size_t batch_size, + std::shared_ptr writer_props = + parquet::default_writer_properties()); + + ~JsonStatsParquetWriter(); + + void + Init(const ParquetWriteContext& context); + + void + AppendValue(const std::string& key, const std::string& value); + + void + AppendRow(const std::map& row_data); + + void + AppendSharedRow(const uint8_t* data, size_t length); + + void + Flush(); + + void + Close(); + + size_t + WriteCurrentBatch(); + + size_t + AddCurrentRow(); + + std::map + GetPathsToSize() const { + return path_size_map_; + } + + int64_t + GetTotalSize() const { + return total_size_; + } + + void + UpdatePathSizeMap(const std::vector>& arrays); + + private: + arrow::Status + AppendDataToBuilder(const std::string& value, + std::shared_ptr builder); + + // init info + std::shared_ptr schema_{nullptr}; + + // for column groups + std::vector file_paths_; + std::vector> column_groups_; + std::map path_size_map_; + size_t total_size_{0}; + std::shared_ptr writer_props_; + size_t buffer_size_; + size_t batch_size_; + std::shared_ptr fs_; + milvus_storage::StorageConfig storage_config_; + std::unique_ptr packed_writer_; + std::vector> kv_metadata_; + + // cache for builders + std::vector> builders_; + std::map> builders_map_; + size_t unflushed_row_count_{0}; + size_t all_row_count_{0}; + size_t current_row_count_{0}; +}; + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/src/index/json_stats/utils.cpp b/internal/core/src/index/json_stats/utils.cpp new file mode 100644 index 0000000000..10bc157a1e --- /dev/null +++ b/internal/core/src/index/json_stats/utils.cpp @@ -0,0 +1,221 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "index/json_stats/utils.h" +#include +#include +#include +#include "milvus-storage/common/constants.h" + +namespace milvus::index { + +std::shared_ptr +CreateSharedArrowBuilder() { + return std::make_shared(); +} + +std::shared_ptr +CreateArrowBuilder(JSONType type) { + std::shared_ptr builder; + switch (type) { + case JSONType::INT8: + builder = std::make_shared(); + break; + case JSONType::INT16: + builder = std::make_shared(); + break; + case JSONType::INT32: + builder = std::make_shared(); + break; + case JSONType::INT64: + builder = std::make_shared(); + break; + case JSONType::FLOAT: + builder = std::make_shared(); + break; + case JSONType::DOUBLE: + builder = std::make_shared(); + break; + case JSONType::BOOL: + builder = std::make_shared(); + break; + case JSONType::STRING: + builder = std::make_shared(); + break; + case JSONType::ARRAY: + // Store array as bson binary in a dedicated column + builder = std::make_shared(); + break; + default: + ThrowInfo(ErrorCode::Unsupported, + "Unsupported JSON type:{} ", + ToString(type)); + } + return builder; +} + +std::shared_ptr +CreateSharedArrowField(const std::string& field_name, int64_t field_id) { + auto metadata = std::make_shared(); + metadata->Append(milvus_storage::ARROW_FIELD_ID_KEY, + std::to_string(field_id)); + metadata->Append(JSON_STATS_META_KEY_LAYOUT_TYPE_MAP, + ToString(JsonKeyLayoutType::SHARED)); + return arrow::field(field_name, arrow::binary(), true, metadata); +} + +std::shared_ptr +CreateArrowField(const JsonKey& key, + const JsonKeyLayoutType& key_type, + int64_t field_id) { + if (key_type == JsonKeyLayoutType::SHARED) { + ThrowInfo(ErrorCode::Unsupported, + "Shared field is not supported in CreateArrowField"); + } + + std::string field_name = key.ToColumnName(); + auto metadata = std::make_shared(); + // metadata->Append(JSON_STATS_META_SHREDDING_COLUMN_KEY_MAP, key.key_); + // metadata->Append(JSON_STATS_META_KEY_LAYOUT_TYPE_MAP, ToString(key_type)); + metadata->Append(milvus_storage::ARROW_FIELD_ID_KEY, + std::to_string(field_id)); + + std::shared_ptr field; + switch (key.type_) { + case JSONType::INT8: + field = arrow::field(field_name, arrow::int8(), true, metadata); + break; + case JSONType::INT16: + field = arrow::field(field_name, arrow::int16(), true, metadata); + break; + case JSONType::INT32: + field = arrow::field(field_name, arrow::int32(), true, metadata); + break; + case JSONType::INT64: + field = arrow::field(field_name, arrow::int64(), true, metadata); + break; + case JSONType::DOUBLE: + field = arrow::field(field_name, arrow::float64(), true, metadata); + break; + case JSONType::FLOAT: + field = arrow::field(field_name, arrow::float32(), true, metadata); + break; + case JSONType::BOOL: + field = arrow::field(field_name, arrow::boolean(), true, metadata); + break; + case JSONType::STRING: + field = arrow::field(field_name, arrow::utf8(), true, metadata); + break; + case JSONType::ARRAY: + // Store array payload as binary column (bson format) + field = arrow::field(field_name, arrow::binary(), true, metadata); + break; + default: + ThrowInfo(ErrorCode::Unsupported, + "Unsupported JSON type: {} ", + ToString(key.type_)); + } + return field; +} + +std::pair>, + std::map>> +CreateArrowBuilders(std::map column_map) { + std::shared_ptr shared_builder = + CreateSharedArrowBuilder(); + std::vector> builders; + std::map> builders_map; + for (const auto& [key, type] : column_map) { + switch (type) { + case JsonKeyLayoutType::SHARED: + builders_map[key.ToColumnName()] = shared_builder; + break; + case JsonKeyLayoutType::TYPED: + case JsonKeyLayoutType::TYPED_NOT_ALL: + case JsonKeyLayoutType::DYNAMIC: + case JsonKeyLayoutType::DYNAMIC_ONLY: { + auto builder = CreateArrowBuilder(key.type_); + builders.push_back(builder); + builders_map[key.ToColumnName()] = builder; + break; + } + default: + ThrowInfo(ErrorCode::Unsupported, + "Unsupported JSON key type: {}", + ToString(type)); + } + } + builders.push_back(shared_builder); + return std::make_pair(builders, builders_map); +} + +std::shared_ptr +CreateArrowSchema(std::map column_map) { + std::vector> fields; + std::shared_ptr shared_field = nullptr; + bool shared_field_name_conflict = false; + std::vector may_conflict_shared_field_names; + auto field_id = START_JSON_STATS_FIELD_ID; + for (const auto& [key, type] : column_map) { + switch (type) { + case JsonKeyLayoutType::TYPED: + case JsonKeyLayoutType::TYPED_NOT_ALL: + case JsonKeyLayoutType::DYNAMIC: + case JsonKeyLayoutType::DYNAMIC_ONLY: + fields.push_back(CreateArrowField(key, type, field_id++)); + if (field_id > END_JSON_STATS_FIELD_ID) { + ThrowInfo(ErrorCode::UnexpectedError, + "Field ID exceeds the limit: {}, field_id: {}", + END_JSON_STATS_FIELD_ID, + field_id); + } + if (key.key_ == JSON_KEY_STATS_SHARED_FIELD_NAME) { + shared_field_name_conflict = true; + } + break; + case JsonKeyLayoutType::SHARED: + break; + default: + ThrowInfo(ErrorCode::Unsupported, + "Unsupported JSON key type: {}", + ToString(type)); + } + } + std::string field_name = JSON_KEY_STATS_SHARED_FIELD_NAME; + if (shared_field_name_conflict) { + boost::uuids::random_generator generator; + auto uuid = generator(); + auto suffix = boost::uuids::to_string(uuid).substr(0, 5); + field_name = suffix + "_" + field_name; + } + fields.push_back(CreateSharedArrowField(field_name, field_id++)); + return arrow::schema(fields); +} + +std::vector> +CreateParquetKVMetadata(std::map column_map) { + nlohmann::json key_type; + for (const auto& [key, type] : column_map) { + key_type[key.ToColumnName()] = ToString(type); + } + // for shared field, not need to store in metadata + std::vector> res; + res.push_back( + std::make_pair(JSON_STATS_META_KEY_LAYOUT_TYPE_MAP, key_type.dump())); + return res; +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/src/index/json_stats/utils.h b/internal/core/src/index/json_stats/utils.h new file mode 100644 index 0000000000..a899f99ba5 --- /dev/null +++ b/internal/core/src/index/json_stats/utils.h @@ -0,0 +1,520 @@ +// Licensed to the LF AI & Data foundation under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#pragma once + +#include +#include + +#include +#include + +#include "index/InvertedIndexTantivy.h" +#include "common/jsmn.h" +#include "arrow/api.h" +#include "common/EasyAssert.h" + +namespace milvus::index { + +constexpr int64_t DEFAULT_BATCH_SIZE = 8192 * 10; +constexpr int64_t DEFAULT_BUFFER_SIZE = 16 * 1024 * 1024; +constexpr int64_t DEFAULT_PART_UPLOAD_SIZE = 10 * 1024 * 1024; + +enum class JSONType { + UNKNOWN, + NONE, + BOOL, + INT8, + INT16, + INT32, + INT64, + FLOAT, + DOUBLE, + STRING, + STRING_ESCAPE, + ARRAY, + OBJECT +}; + +inline std::string +ToString(JSONType type) { + switch (type) { + case JSONType::NONE: + return "NONE"; + case JSONType::BOOL: + return "BOOL"; + case JSONType::INT8: + return "INT8"; + case JSONType::INT16: + return "INT16"; + case JSONType::INT32: + return "INT32"; + case JSONType::INT64: + return "INT64"; + case JSONType::FLOAT: + return "FLOAT"; + case JSONType::DOUBLE: + return "DOUBLE"; + case JSONType::STRING: + return "STRING"; + case JSONType::STRING_ESCAPE: + return "STRING_ESCAPE"; + case JSONType::ARRAY: + return "ARRAY"; + case JSONType::OBJECT: + return "OBJECT"; + default: + return "UNKNOWN"; + } +} + +inline milvus::DataType +GetPrimitiveDataType(JSONType type) { + switch (type) { + case JSONType::NONE: + return milvus::DataType::NONE; + case JSONType::BOOL: + return milvus::DataType::BOOL; + case JSONType::INT8: + return milvus::DataType::INT8; + case JSONType::INT16: + return milvus::DataType::INT16; + case JSONType::INT32: + return milvus::DataType::INT32; + case JSONType::INT64: + return milvus::DataType::INT64; + case JSONType::FLOAT: + return milvus::DataType::FLOAT; + case JSONType::DOUBLE: + return milvus::DataType::DOUBLE; + case JSONType::STRING: + return milvus::DataType::STRING; + // for array type(bson format), we use string type instead of real binary type + case JSONType::ARRAY: + return milvus::DataType::STRING; + default: + return milvus::DataType::NONE; + } +} + +inline JSONType +GetPrimitiveJsonType(std::shared_ptr type) { + if (type->id() == arrow::Type::BOOL) { + return JSONType::BOOL; + } else if (type->id() == arrow::Type::INT8) { + return JSONType::INT8; + } else if (type->id() == arrow::Type::INT16) { + return JSONType::INT16; + } else if (type->id() == arrow::Type::INT32) { + return JSONType::INT32; + } else if (type->id() == arrow::Type::INT64) { + return JSONType::INT64; + } else if (type->id() == arrow::Type::FLOAT) { + return JSONType::FLOAT; + } else if (type->id() == arrow::Type::DOUBLE) { + return JSONType::DOUBLE; + } else if (type->id() == arrow::Type::STRING) { + return JSONType::STRING; + } else { + return JSONType::UNKNOWN; + } +} + +inline bool +IsPrimitiveJsonType(JSONType type) { + return type == JSONType::NONE || type == JSONType::BOOL || + type == JSONType::INT8 || type == JSONType::INT16 || + type == JSONType::INT32 || type == JSONType::INT64 || + type == JSONType::FLOAT || type == JSONType::DOUBLE || + type == JSONType::STRING || type == JSONType::STRING_ESCAPE; +} + +inline bool +IsIntegerJsonType(JSONType type) { + return type == JSONType::INT8 || type == JSONType::INT16 || + type == JSONType::INT32 || type == JSONType::INT64; +} + +inline bool +IsFloatJsonType(JSONType type) { + return type == JSONType::FLOAT || type == JSONType::DOUBLE; +} + +inline bool +IsStringJsonType(JSONType type) { + return type == JSONType::STRING || type == JSONType::STRING_ESCAPE; +} + +inline bool +IsComplexJsonType(JSONType type) { + return type == JSONType::ARRAY || type == JSONType::OBJECT; +} + +inline bool +IsNullJsonType(JSONType type) { + return type == JSONType::NONE; +} + +inline bool +IsShreddingJsonType(JSONType type) { + return IsPrimitiveJsonType(type) || type == JSONType::ARRAY; +} + +enum class JsonKeyLayoutType { + UNKNOWN = 0, + TYPED = 1, + TYPED_NOT_ALL = 2, + DYNAMIC = 3, + DYNAMIC_ONLY = 4, + SHARED = 5, +}; + +inline std::string +ToString(JsonKeyLayoutType type) { + switch (type) { + case JsonKeyLayoutType::TYPED: + return "TYPED"; + case JsonKeyLayoutType::TYPED_NOT_ALL: + return "TYPED_NOT_ALL"; + case JsonKeyLayoutType::DYNAMIC: + return "DYNAMIC"; + case JsonKeyLayoutType::DYNAMIC_ONLY: + return "DYNAMIC_ONLY"; + case JsonKeyLayoutType::SHARED: + return "SHARED"; + default: + return "UNKNOWN"; + } +} + +inline JsonKeyLayoutType +JsonKeyLayoutTypeFromString(const std::string& str) { + if (str == "TYPED") { + return JsonKeyLayoutType::TYPED; + } else if (str == "TYPED_NOT_ALL") { + return JsonKeyLayoutType::TYPED_NOT_ALL; + } else if (str == "DYNAMIC") { + return JsonKeyLayoutType::DYNAMIC; + } else if (str == "DYNAMIC_ONLY") { + return JsonKeyLayoutType::DYNAMIC_ONLY; + } else if (str == "SHARED") { + return JsonKeyLayoutType::SHARED; + } + return JsonKeyLayoutType::UNKNOWN; +} + +inline bool +EndWith(std::string_view str, std::string_view suffix) { + return str.size() >= suffix.size() && + str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0; +} + +inline JSONType +GetJsonTypeFromKeyName(const std::string& key_name) { + if (EndWith(key_name, "_INT64")) { + return JSONType::INT64; + } else if (EndWith(key_name, "_DOUBLE")) { + return JSONType::DOUBLE; + } else if (EndWith(key_name, "_STRING")) { + return JSONType::STRING; + } else if (EndWith(key_name, "_BOOL")) { + return JSONType::BOOL; + } else if (EndWith(key_name, "_NULL")) { + return JSONType::NONE; + } else if (EndWith(key_name, "_ARRAY")) { + return JSONType::ARRAY; + } else if (EndWith(key_name, "_OBJECT")) { + return JSONType::OBJECT; + } else { + return JSONType::UNKNOWN; + } +} + +inline std::string +GetKeyFromColumnName(const std::string& column_name) { + if (EndWith(column_name, "_INT64")) { + return column_name.substr(0, column_name.size() - 6); + } else if (EndWith(column_name, "_DOUBLE")) { + return column_name.substr(0, column_name.size() - 7); + } else if (EndWith(column_name, "_STRING")) { + return column_name.substr(0, column_name.size() - 7); + } else if (EndWith(column_name, "_BOOL")) { + return column_name.substr(0, column_name.size() - 5); + } else if (EndWith(column_name, "_NULL")) { + return column_name.substr(0, column_name.size() - 5); + } else if (EndWith(column_name, "_ARRAY")) { + return column_name.substr(0, column_name.size() - 6); + } else if (EndWith(column_name, "_OBJECT")) { + return column_name.substr(0, column_name.size() - 7); + } else { + return column_name; + } +} + +// construct json pointer with nested path vector +inline std::string +JsonPointer(std::vector nested_path) { + if (nested_path.empty()) { + return ""; + } + + std::for_each(nested_path.begin(), nested_path.end(), [](std::string& key) { + boost::replace_all(key, "~", "~0"); + boost::replace_all(key, "/", "~1"); + }); + + auto pointer = "/" + boost::algorithm::join(nested_path, "/"); + return pointer; +} + +inline std::string +AppendJsonPointer(std::string pointer, std::string key) { + boost::replace_all(key, "~", "~0"); + boost::replace_all(key, "/", "~1"); + return pointer + "/" + key; +} + +// parse json pointer to nested path vector +inline std::vector +ParseJsonPointerPath(const std::string& pointer) { + if (pointer.empty()) { + return {}; + } + if (pointer[0] != '/') { + ThrowInfo(ErrorCode::PathInvalid, + "Invalid JSON pointer: must start with '/'"); + } + + std::vector tokens; + boost::split(tokens, pointer.substr(1), boost::is_any_of("/")); + + for (auto& token : tokens) { + if (token.find('~') != std::string::npos) { + boost::replace_all(token, "~1", "/"); + boost::replace_all(token, "~0", "~"); + } + } + + return tokens; +} + +struct JsonKey { + std::string key_; + JSONType type_; + + JsonKey(const std::string& key, JSONType type) : key_(key), type_(type) { + } + + JsonKey() { + } + + bool + operator<(const JsonKey& other) const { + return std::tie(key_, type_) < std::tie(other.key_, other.type_); + } + + bool + operator==(const JsonKey& other) const { + return key_ == other.key_ && type_ == other.type_; + } + + bool + operator!=(const JsonKey& other) const { + return !(*this == other); + } + + std::string + ToString() const { + return key_ + ":" + milvus::index::ToString(type_); + } + + std::string + ToColumnName() const { + return key_ + "_" + milvus::index::ToString(type_); + } +}; + +struct KeyStatsInfo { + int32_t hit_row_num_ = 0; + // TODO: add min/max value for stats info + uint8_t min_value_[8] = {0}; + uint8_t max_value_[8] = {0}; + + std::string + ToString() const { + return "row_num: " + std::to_string(hit_row_num_); + } +}; +struct PathWriter { + JsonKeyLayoutType type_; + JsonKey key_; +}; + +std::shared_ptr +CreateSharedArrowBuilder(); + +std::shared_ptr +CreateArrowBuilder(JSONType type); + +std::shared_ptr +CreateSharedArrowField(const std::string& field_name, int64_t field_id); + +std::shared_ptr +CreateArrowField(const JsonKey& key, const JsonKeyLayoutType& key_type); + +std::pair>, + std::map>> +CreateArrowBuilders(std::map column_map); + +std::shared_ptr +CreateArrowSchema(std::map column_map); + +std::vector> +CreateParquetKVMetadata(std::map column_map); + +inline size_t +GetArrowArrayMemorySize(const std::shared_ptr& array) { + if (!array || !array->data()) { + return 0; + } + size_t total_size = 0; + for (const auto& buffer : array->data()->buffers) { + if (buffer) { + total_size += buffer->size(); + } + } + return total_size; +} + +inline std::string +CreateColumnGroupParquetPath(const std::string& path_prefix, + size_t column_group_id, + size_t file_log_id) { + return path_prefix + "/" + std::to_string(column_group_id) + "/" + + std::to_string(file_log_id); +} + +// parse from parquet path +inline std::pair +ParseParquetPath(const std::string& path) { + const auto last_slash = path.find_last_of('/'); + const auto second_last_slash = path.find_last_of('/', last_slash - 1); + const size_t column_group_id = std::stoll( + path.substr(second_last_slash + 1, last_slash - second_last_slash - 1)); + const size_t file_id = std::stoll(path.substr(last_slash + 1)); + return {column_group_id, file_id}; +} + +// sort parquet paths by column_group_id and file_id +// return vector of > +inline std::vector>> +SortByParquetPath(const std::vector& paths) { + // preprocess stage: parse all path info + std::vector> parsed_info; + parsed_info.reserve(paths.size()); + for (const auto& path : paths) { + parsed_info.emplace_back(ParseParquetPath(path)); + } + + // sort stage: directly compare parsed values + std::sort(parsed_info.begin(), + parsed_info.end(), + [](const auto& a, const auto& b) { + return std::tie(a.first, a.second) < + std::tie(b.first, b.second); + }); + + // group stage: single traversal to complete grouping + std::vector>> result; + for (const auto& [col, file] : parsed_info) { + if (result.empty() || result.back().first != col) { + result.emplace_back(col, std::vector()); + } + result.back().second.push_back(file); + } + + return result; +} + +} // namespace milvus::index + +template <> +struct fmt::formatter : fmt::formatter { + template + auto + format(const milvus::index::JSONType& jt, FormatContext& ctx) { + switch (jt) { + case milvus::index::JSONType::UNKNOWN: + return fmt::format_to(ctx.out(), "UNKNOWN"); + case milvus::index::JSONType::NONE: + return fmt::format_to(ctx.out(), "NULL"); + case milvus::index::JSONType::BOOL: + return fmt::format_to(ctx.out(), "BOOL"); + case milvus::index::JSONType::INT8: + return fmt::format_to(ctx.out(), "INT8"); + case milvus::index::JSONType::INT16: + return fmt::format_to(ctx.out(), "INT16"); + case milvus::index::JSONType::INT32: + return fmt::format_to(ctx.out(), "INT32"); + case milvus::index::JSONType::INT64: + return fmt::format_to(ctx.out(), "INT64"); + case milvus::index::JSONType::FLOAT: + return fmt::format_to(ctx.out(), "FLOAT"); + case milvus::index::JSONType::DOUBLE: + return fmt::format_to(ctx.out(), "DOUBLE"); + case milvus::index::JSONType::STRING: + return fmt::format_to(ctx.out(), "STRING"); + case milvus::index::JSONType::STRING_ESCAPE: + return fmt::format_to(ctx.out(), "STRING_ESCAPE"); + case milvus::index::JSONType::ARRAY: + return fmt::format_to(ctx.out(), "ARRAY"); + case milvus::index::JSONType::OBJECT: + return fmt::format_to(ctx.out(), "OBJECT"); + default: + return fmt::format_to(ctx.out(), "UNKNOWN"); + } + } +}; + +template <> +struct fmt::formatter + : fmt::formatter { + auto + format(milvus::index::JsonKeyLayoutType type, fmt::format_context& ctx) { + std::string name; + switch (type) { + case milvus::index::JsonKeyLayoutType::TYPED: + name = "TYPED"; + break; + case milvus::index::JsonKeyLayoutType::DYNAMIC: + name = "DYNAMIC"; + break; + case milvus::index::JsonKeyLayoutType::SHARED: + name = "SHARED"; + break; + case milvus::index::JsonKeyLayoutType::TYPED_NOT_ALL: + name = "TYPED_NOT_ALL"; + break; + case milvus::index::JsonKeyLayoutType::DYNAMIC_ONLY: + name = "DYNAMIC_ONLY"; + break; + default: + name = "UNKNOWN"; + break; + } + return fmt::formatter::format(name, ctx); + } +}; diff --git a/internal/core/src/indexbuilder/index_c.cpp b/internal/core/src/indexbuilder/index_c.cpp index d69e1fff7b..f0a6fc30fe 100644 --- a/internal/core/src/indexbuilder/index_c.cpp +++ b/internal/core/src/indexbuilder/index_c.cpp @@ -36,7 +36,7 @@ #include "pb/index_cgo_msg.pb.h" #include "storage/Util.h" #include "index/Meta.h" -#include "index/JsonKeyStatsInvertedIndex.h" +#include "index/json_stats/JsonKeyStats.h" #include "milvus-storage/filesystem/fs.h" #include "monitor/scope_metric.h" @@ -298,8 +298,8 @@ BuildJsonKeyIndex(ProtoLayoutInterface result, build_index_info->ParseFromArray(serialized_build_index_info, len); AssertInfo(res, "Unmarshall build index info failed"); - auto field_type = - static_cast(build_index_info->field_schema().data_type()); + auto field_type = static_cast( + build_index_info->field_schema().data_type()); auto storage_config = get_storage_config(build_index_info->storage_config()); @@ -353,10 +353,12 @@ BuildJsonKeyIndex(ProtoLayoutInterface result, auto field_schema = FieldMeta::ParseFrom(build_index_info->field_schema()); - auto index = std::make_unique( + auto index = std::make_unique( fileManagerContext, false, - build_index_info->json_key_stats_tantivy_memory(), + build_index_info->json_stats_max_shredding_columns(), + build_index_info->json_stats_shredding_ratio_threshold(), + build_index_info->json_stats_write_batch_size(), tantivy_index_version); index->Build(config); auto create_index_result = index->Upload(config); @@ -392,8 +394,8 @@ BuildTextIndex(ProtoLayoutInterface result, build_index_info->ParseFromArray(serialized_build_index_info, len); AssertInfo(res, "Unmarshal build index info failed"); - auto field_type = - static_cast(build_index_info->field_schema().data_type()); + auto field_type = static_cast( + build_index_info->field_schema().data_type()); auto storage_config = get_storage_config(build_index_info->storage_config()); diff --git a/internal/core/src/mmap/ChunkedColumn.h b/internal/core/src/mmap/ChunkedColumn.h index 670c8f362f..396e70ca3f 100644 --- a/internal/core/src/mmap/ChunkedColumn.h +++ b/internal/core/src/mmap/ChunkedColumn.h @@ -554,6 +554,30 @@ class ChunkedVariableColumn : public ChunkedColumnBase { fn(Json(str_view.data(), str_view.size()), i, valid); } } + + void + BulkRawBsonAt(std::function fn, + const uint32_t* row_offsets, + const uint32_t* value_offsets, + int64_t count) const override { + if (count == 0) { + return; + } + AssertInfo(row_offsets != nullptr && value_offsets != nullptr, + "row_offsets and value_offsets must be provided"); + + auto [cids, offsets_in_chunk] = ToChunkIdAndOffset(row_offsets, count); + auto ca = SemiInlineGet(slot_->PinCells(cids)); + for (int64_t i = 0; i < count; i++) { + auto chunk = ca->get_cell_of(cids[i]); + auto str_view = static_cast(chunk)->operator[]( + offsets_in_chunk[i]); + fn(BsonView(reinterpret_cast(str_view.data()), + str_view.size()), + row_offsets[i], + value_offsets[i]); + } + } }; class ChunkedArrayColumn : public ChunkedColumnBase { diff --git a/internal/core/src/mmap/ChunkedColumnGroup.h b/internal/core/src/mmap/ChunkedColumnGroup.h index 5e874d268f..0681550623 100644 --- a/internal/core/src/mmap/ChunkedColumnGroup.h +++ b/internal/core/src/mmap/ChunkedColumnGroup.h @@ -556,6 +556,37 @@ class ProxyChunkColumn : public ChunkedColumnInterface { } } + void + BulkRawBsonAt(std::function fn, + const uint32_t* row_offsets, + const uint32_t* value_offsets, + int64_t count) const override { + if (data_type_ != DataType::STRING) { + ThrowInfo(ErrorCode::Unsupported, + "BulkRawBsonAt only supported for ProxyChunkColumn of " + "Bson type"); + } + if (count == 0) { + return; + } + + AssertInfo(row_offsets != nullptr, "row_offsets is nullptr"); + auto [cids, offsets_in_chunk] = ToChunkIdAndOffset(row_offsets, count); + auto ca = group_->GetGroupChunks(cids); + + for (int64_t i = 0; i < count; i++) { + auto* group_chunk = ca->get_cell_of(cids[i]); + auto chunk = group_chunk->GetChunk(field_id_); + auto str_view = static_cast(chunk.get()) + -> + operator[](offsets_in_chunk[i]); + fn(BsonView(reinterpret_cast(str_view.data()), + str_view.size()), + row_offsets[i], + value_offsets[i]); + } + } + void BulkArrayAt(std::function fn, const int64_t* offsets, diff --git a/internal/core/src/mmap/ChunkedColumnInterface.h b/internal/core/src/mmap/ChunkedColumnInterface.h index 8391217907..d58860b573 100644 --- a/internal/core/src/mmap/ChunkedColumnInterface.h +++ b/internal/core/src/mmap/ChunkedColumnInterface.h @@ -17,7 +17,7 @@ #include "cachinglayer/CacheSlot.h" #include "common/Chunk.h" - +#include "common/bson_view.h" namespace milvus { using namespace milvus::cachinglayer; @@ -157,6 +157,16 @@ class ChunkedColumnInterface { "RawJsonAt only supported for ChunkColumnInterface of Json type"); } + virtual void + BulkRawBsonAt(std::function fn, + const uint32_t* row_offsets, + const uint32_t* value_offsets, + int64_t count) const { + ThrowInfo(ErrorCode::Unsupported, + "BulkRawBsonAt only supported for ChunkColumnInterface of " + "Bson type"); + } + virtual void BulkArrayAt(std::function fn, const int64_t* offsets, @@ -221,6 +231,22 @@ class ChunkedColumnInterface { } return GetChunkIDsByOffsets(offsets, count); } + + std::pair, std::vector> + ToChunkIdAndOffset(const uint32_t* offsets, int64_t count) const { + AssertInfo(offsets != nullptr, "Offsets cannot be nullptr"); + std::vector cids; + cids.reserve(count); + std::vector offsets_in_chunk; + offsets_in_chunk.reserve(count); + + for (int64_t i = 0; i < count; i++) { + auto [chunk_id, offset_in_chunk] = GetChunkIDByOffset(offsets[i]); + cids.push_back(chunk_id); + offsets_in_chunk.push_back(offset_in_chunk); + } + return std::make_pair(std::move(cids), std::move(offsets_in_chunk)); + } }; } // namespace milvus diff --git a/internal/core/src/monitor/Monitor.cpp b/internal/core/src/monitor/Monitor.cpp index 4fe1b8f846..d75a9d21c7 100644 --- a/internal/core/src/monitor/Monitor.cpp +++ b/internal/core/src/monitor/Monitor.cpp @@ -130,6 +130,30 @@ DEFINE_PROMETHEUS_HISTOGRAM(internal_storage_deserialize_duration, internal_storage_load_duration, deserializeDurationLabels) +// json stats metrics +std::map invertedIndexLatencyLabels{ + {"type", "inverted_index_latency"}}; +std::map shreddingLatencyLabels{ + {"type", "shredding_latency"}}; +std::map sharedLatencyLabels{ + {"type", "shared_latency"}}; +std::map loadLatencyLabels{{"type", "load_latency"}}; + +DEFINE_PROMETHEUS_HISTOGRAM_FAMILY(internal_json_stats_latency, + "[cpp]durations of json stats") +DEFINE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_term_query, + internal_json_stats_latency, + invertedIndexLatencyLabels) +DEFINE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_shredding, + internal_json_stats_latency, + shreddingLatencyLabels) +DEFINE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_shared, + internal_json_stats_latency, + sharedLatencyLabels) +DEFINE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_load, + internal_json_stats_latency, + loadLatencyLabels) + // search latency metrics std::map scalarLatencyLabels{ {"type", "scalar_latency"}}; diff --git a/internal/core/src/monitor/Monitor.h b/internal/core/src/monitor/Monitor.h index f183d62678..1655ed631d 100644 --- a/internal/core/src/monitor/Monitor.h +++ b/internal/core/src/monitor/Monitor.h @@ -94,6 +94,13 @@ DECLARE_PROMETHEUS_GAUGE(internal_cgo_inflight_task_total_all); DECLARE_PROMETHEUS_GAUGE_FAMILY(internal_cgo_executing_task_total); DECLARE_PROMETHEUS_GAUGE(internal_cgo_executing_task_total_all); +// json stats metrics +DECLARE_PROMETHEUS_HISTOGRAM_FAMILY(internal_json_stats_latency); +DECLARE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_term_query); +DECLARE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_shredding); +DECLARE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_shared); +DECLARE_PROMETHEUS_HISTOGRAM(internal_json_stats_latency_load); + // --- file writer metrics --- DECLARE_PROMETHEUS_COUNTER_FAMILY(disk_write_total_bytes); diff --git a/internal/core/src/plan/PlanNode.h b/internal/core/src/plan/PlanNode.h index 8ee1336aa2..7a8bbeeac5 100644 --- a/internal/core/src/plan/PlanNode.h +++ b/internal/core/src/plan/PlanNode.h @@ -431,8 +431,7 @@ class CountNode : public PlanNode { std::string ToString() const override { - return fmt::format("VectorSearchNode:\n\t[source node:{}]", - SourceToString()); + return fmt::format("CountNode:\n\t[source node:{}]", SourceToString()); } private: diff --git a/internal/core/src/query/ExecPlanNodeVisitor.cpp b/internal/core/src/query/ExecPlanNodeVisitor.cpp index 40bddc1130..c275a8ddda 100644 --- a/internal/core/src/query/ExecPlanNodeVisitor.cpp +++ b/internal/core/src/query/ExecPlanNodeVisitor.cpp @@ -138,7 +138,9 @@ ExecPlanNodeVisitor::VectorVisitorImpl(VectorPlanNode& node) { active_count, timestamp_, collection_ttl_timestamp_, - consystency_level_); + consystency_level_, + node.plan_options_); + query_context->set_search_info(node.search_info_); query_context->set_placeholder_group(placeholder_group_); @@ -194,7 +196,8 @@ ExecPlanNodeVisitor::visit(RetrievePlanNode& node) { active_count, timestamp_, collection_ttl_timestamp_, - consystency_level_); + consystency_level_, + node.plan_options_); // Do task execution auto bitset_holder = ExecuteTask(plan, query_context); diff --git a/internal/core/src/query/PlanNode.h b/internal/core/src/query/PlanNode.h index c6b9e53b52..0bad95331e 100644 --- a/internal/core/src/query/PlanNode.h +++ b/internal/core/src/query/PlanNode.h @@ -25,12 +25,19 @@ class PlanNode; namespace milvus::query { class PlanNodeVisitor; + +struct PlanOptions { + bool expr_use_json_stats = true; +}; + // Base of all Nodes struct PlanNode { public: virtual ~PlanNode() = default; virtual void accept(PlanNodeVisitor&) = 0; + + PlanOptions plan_options_; }; using PlanNodePtr = std::unique_ptr; diff --git a/internal/core/src/query/PlanProto.cpp b/internal/core/src/query/PlanProto.cpp index c537de1b5e..0642f64145 100644 --- a/internal/core/src/query/PlanProto.cpp +++ b/internal/core/src/query/PlanProto.cpp @@ -29,6 +29,15 @@ namespace milvus::query { namespace planpb = milvus::proto::plan; +void +ProtoParser::PlanOptionsFromProto( + const proto::plan::PlanOption& plan_option_proto, + PlanOptions& plan_options) { + plan_options.expr_use_json_stats = plan_option_proto.expr_use_json_stats(); + LOG_INFO("plan_options.expr_use_json_stats: {}", + plan_options.expr_use_json_stats); +} + std::unique_ptr ProtoParser::PlanNodeFromProto(const planpb::PlanNode& plan_node_proto) { // TODO: add more buffs @@ -224,6 +233,9 @@ ProtoParser::PlanNodeFromProto(const planpb::PlanNode& plan_node_proto) { plan_node->plannodes_ = plannode; + PlanOptionsFromProto(plan_node_proto.plan_options(), + plan_node->plan_options_); + return plan_node; } @@ -306,6 +318,9 @@ ProtoParser::RetrievePlanNodeFromProto( return node; }(); + PlanOptionsFromProto(plan_node_proto.plan_options(), + plan_node->plan_options_); + return plan_node; } diff --git a/internal/core/src/query/PlanProto.h b/internal/core/src/query/PlanProto.h index 3cba38e16d..e401a43442 100644 --- a/internal/core/src/query/PlanProto.h +++ b/internal/core/src/query/PlanProto.h @@ -101,6 +101,10 @@ class ProtoParser { expr::TypedExprPtr ParseValueExprs(const proto::plan::ValueExpr& expr_pb); + void + PlanOptionsFromProto(const proto::plan::PlanOption& plan_option_proto, + PlanOptions& plan_options); + private: const SchemaPtr schema; }; diff --git a/internal/core/src/segcore/ChunkedSegmentSealedImpl.h b/internal/core/src/segcore/ChunkedSegmentSealedImpl.h index 0a495c7a86..459a05dff3 100644 --- a/internal/core/src/segcore/ChunkedSegmentSealedImpl.h +++ b/internal/core/src/segcore/ChunkedSegmentSealedImpl.h @@ -102,20 +102,25 @@ class ChunkedSegmentSealedImpl : public SegmentSealed { void LoadTextIndex(FieldId field_id, std::unique_ptr index) override; + void - LoadJsonKeyIndex( - FieldId field_id, - std::unique_ptr index) override { + RemoveJsonStats(FieldId field_id) override { std::unique_lock lck(mutex_); - const auto& field_meta = schema_->operator[](field_id); - json_key_indexes_[field_id] = std::move(index); + json_stats_.erase(field_id); } - index::JsonKeyStatsInvertedIndex* - GetJsonKeyIndex(FieldId field_id) const override { + void + LoadJsonStats(FieldId field_id, + std::shared_ptr stats) override { + std::unique_lock lck(mutex_); + json_stats_[field_id] = stats; + } + + index::JsonKeyStats* + GetJsonStats(FieldId field_id) const override { std::shared_lock lck(mutex_); - auto iter = json_key_indexes_.find(field_id); - if (iter == json_key_indexes_.end()) { + auto iter = json_stats_.find(field_id); + if (iter == json_stats_.end()) { return nullptr; } return iter->second.get(); @@ -536,10 +541,6 @@ class ChunkedSegmentSealedImpl : public SegmentSealed { // whether the segment is sorted by the pk // 1. will skip index loading for primary key field bool is_sorted_by_pk_ = false; - // used for json expr optimization - std::unordered_map> - json_key_indexes_; }; inline SegmentSealedUPtr diff --git a/internal/core/src/segcore/SegmentGrowingImpl.cpp b/internal/core/src/segcore/SegmentGrowingImpl.cpp index 41fa9784fd..88fef5b040 100644 --- a/internal/core/src/segcore/SegmentGrowingImpl.cpp +++ b/internal/core/src/segcore/SegmentGrowingImpl.cpp @@ -215,33 +215,6 @@ SegmentGrowingImpl::Insert(int64_t reserved_offset, reserved_offset); } - // index json. - if (field_meta.enable_growing_jsonStats()) { - std::vector jsonDatas( - insert_record_proto->fields_data(data_offset) - .scalars() - .json_data() - .data() - .begin(), - insert_record_proto->fields_data(data_offset) - .scalars() - .json_data() - .data() - .end()); - FixedVector jsonDatas_valid_data( - insert_record_proto->fields_data(data_offset) - .valid_data() - .begin(), - insert_record_proto->fields_data(data_offset) - .valid_data() - .end()); - AddJSONDatas(field_id, - jsonDatas.data(), - jsonDatas_valid_data.data(), - num_rows, - reserved_offset); - } - // update average row data size auto field_data_size = GetRawDataSizeOfDataArray( &insert_record_proto->fields_data(data_offset), @@ -410,15 +383,6 @@ SegmentGrowingImpl::load_field_data_common( index->Reload(); } - // build json match index - if (field_meta.enable_growing_jsonStats()) { - auto index = GetJsonKeyIndex(field_id); - index->BuildWithFieldData(field_data, field_meta.is_nullable()); - index->Commit(); - // Reload reader so that the index can be read immediately - index->Reload(); - } - // update the mem size stats_.mem_size += storage::GetByteSizeOfFieldDatas(field_data); @@ -1241,44 +1205,6 @@ SegmentGrowingImpl::AddTexts(milvus::FieldId field_id, iter->second->AddTextsGrowing(n, texts, texts_valid_data, offset_begin); } -void -SegmentGrowingImpl::AddJSONDatas(FieldId field_id, - const std::string* jsondatas, - const bool* jsondatas_valid_data, - size_t n, - int64_t offset_begin) { - std::unique_lock lock(mutex_); - auto iter = json_indexes_.find(field_id); - AssertInfo(iter != json_indexes_.end(), "json index not found"); - iter->second->AddJSONDatas( - n, jsondatas, jsondatas_valid_data, offset_begin); -} - -void -SegmentGrowingImpl::CreateJSONIndexes() { - for (auto [field_id, field_meta] : schema_->get_fields()) { - if (field_meta.enable_growing_jsonStats()) { - CreateJSONIndex(FieldId(field_id)); - } - } -} - -void -SegmentGrowingImpl::CreateJSONIndex(FieldId field_id) { - std::unique_lock lock(mutex_); - const auto& field_meta = schema_->operator[](field_id); - AssertInfo(IsJsonDataType(field_meta.get_data_type()), - "cannot create json index on non-json type"); - std::string unique_id = GetUniqueFieldId(field_meta.get_id().get()); - auto index = std::make_unique( - JSON_KEY_STATS_COMMIT_INTERVAL, unique_id.c_str()); - - index->Commit(); - index->CreateReader(milvus::index::SetBitsetGrowing); - - json_indexes_[field_id] = std::move(index); -} - void SegmentGrowingImpl::BulkGetJsonData( FieldId field_id, diff --git a/internal/core/src/segcore/SegmentGrowingImpl.h b/internal/core/src/segcore/SegmentGrowingImpl.h index 85d1b7fa17..08865f90fb 100644 --- a/internal/core/src/segcore/SegmentGrowingImpl.h +++ b/internal/core/src/segcore/SegmentGrowingImpl.h @@ -307,7 +307,6 @@ class SegmentGrowingImpl : public SegmentGrowing { }, segment_id) { this->CreateTextIndexes(); - this->CreateJSONIndexes(); } ~SegmentGrowingImpl() { @@ -479,19 +478,6 @@ class SegmentGrowingImpl : public SegmentGrowing { void CreateTextIndexes(); - void - AddJSONDatas(FieldId field_id, - const std::string* jsondatas, - const bool* jsondatas_valid_data, - size_t n, - int64_t offset_begin); - - void - CreateJSONIndexes(); - - void - CreateJSONIndex(FieldId field_id); - private: storage::MmapChunkDescriptorPtr mmap_descriptor_ = nullptr; SegcoreConfig segcore_config_; diff --git a/internal/core/src/segcore/SegmentInterface.cpp b/internal/core/src/segcore/SegmentInterface.cpp index a9c5c7f329..a23d0140ea 100644 --- a/internal/core/src/segcore/SegmentInterface.cpp +++ b/internal/core/src/segcore/SegmentInterface.cpp @@ -538,16 +538,6 @@ SegmentInternalInterface::bulk_subscript_not_exist_field( return result; } -index::JsonKeyStatsInvertedIndex* -SegmentInternalInterface::GetJsonKeyIndex(FieldId field_id) const { - std::shared_lock lock(mutex_); - auto iter = json_indexes_.find(field_id); - if (iter == json_indexes_.end()) { - return nullptr; - } - return iter->second.get(); -} - // Only sealed segment has ngram index PinWrapper SegmentInternalInterface::GetNgramIndex(FieldId field_id) const { @@ -571,4 +561,14 @@ SegmentInternalInterface::HasNgramIndexForJson( return false; } +index::JsonKeyStats* +SegmentInternalInterface::GetJsonStats(FieldId field_id) const { + std::shared_lock lock(mutex_); + auto iter = json_stats_.find(field_id); + if (iter == json_stats_.end()) { + return nullptr; + } + return iter->second.get(); +} + } // namespace milvus::segcore diff --git a/internal/core/src/segcore/SegmentInterface.h b/internal/core/src/segcore/SegmentInterface.h index 5686880a36..155e8130d9 100644 --- a/internal/core/src/segcore/SegmentInterface.h +++ b/internal/core/src/segcore/SegmentInterface.h @@ -40,10 +40,10 @@ #include "pb/segcore.pb.h" #include "index/SkipIndex.h" #include "index/TextMatchIndex.h" -#include "index/JsonKeyStatsInvertedIndex.h" #include "segcore/ConcurrentVector.h" #include "segcore/InsertRecord.h" #include "index/NgramInvertedIndex.h" +#include "index/json_stats/JsonKeyStats.h" namespace milvus::segcore { @@ -145,8 +145,6 @@ class SegmentInterface { GetJsonIndex(FieldId field_id, std::string path) const { return nullptr; } - virtual index::JsonKeyStatsInvertedIndex* - GetJsonKeyIndex(FieldId field_id) const = 0; virtual void BulkGetJsonData(FieldId field_id, @@ -168,6 +166,9 @@ class SegmentInterface { HasNgramIndexForJson(FieldId field_id, const std::string& nested_path) const = 0; + virtual index::JsonKeyStats* + GetJsonStats(FieldId field_id) const = 0; + virtual void LazyCheckSchema(SchemaPtr sch) = 0; @@ -379,9 +380,6 @@ class SegmentInternalInterface : public SegmentInterface { index::TextMatchIndex* GetTextIndex(FieldId field_id) const override; - virtual index::JsonKeyStatsInvertedIndex* - GetJsonKeyIndex(FieldId field_id) const override; - virtual PinWrapper GetNgramIndex(FieldId field_id) const override; @@ -396,6 +394,9 @@ class SegmentInternalInterface : public SegmentInterface { HasNgramIndexForJson(FieldId field_id, const std::string& nested_path) const override; + virtual index::JsonKeyStats* + GetJsonStats(FieldId field_id) const override; + public: // `query_lims` is not null only for vector array (embedding list) search // where it denotes the number of vectors in each embedding list. The length @@ -618,9 +619,8 @@ class SegmentInternalInterface : public SegmentInterface { std::unordered_map> text_indexes_; - std::unordered_map> - json_indexes_; + std::unordered_map> + json_stats_; }; } // namespace milvus::segcore diff --git a/internal/core/src/segcore/SegmentSealed.h b/internal/core/src/segcore/SegmentSealed.h index b7f9bbd574..42383559ce 100644 --- a/internal/core/src/segcore/SegmentSealed.h +++ b/internal/core/src/segcore/SegmentSealed.h @@ -99,11 +99,6 @@ class SegmentSealed : public SegmentInternalInterface { return PinWrapper(ca, index); } - virtual void - LoadJsonKeyIndex( - FieldId field_id, - std::unique_ptr index) = 0; - virtual bool HasNgramIndex(FieldId field_id) const = 0; @@ -117,6 +112,12 @@ class SegmentSealed : public SegmentInternalInterface { virtual PinWrapper GetNgramIndexForJson(FieldId field_id, const std::string& nested_path) const override = 0; + virtual void + LoadJsonStats(FieldId field_id, + std::shared_ptr stats) = 0; + + virtual void + RemoveJsonStats(FieldId field_id) = 0; SegmentType type() const override { diff --git a/internal/core/src/segcore/Utils.cpp b/internal/core/src/segcore/Utils.cpp index e9afef6c8b..87a1bde70e 100644 --- a/internal/core/src/segcore/Utils.cpp +++ b/internal/core/src/segcore/Utils.cpp @@ -988,6 +988,60 @@ ReverseDataFromIndex(const index::IndexBase* index, return data_array; } +void +LoadArrowReaderForJsonStatsFromRemote( + const std::vector& remote_files, + std::shared_ptr channel) { + try { + auto rcm = storage::RemoteChunkManagerSingleton::GetInstance() + .GetRemoteChunkManager(); + auto& pool = ThreadPools::GetThreadPool(ThreadPoolPriority::HIGH); + + std::vector>> + futures; + futures.reserve(remote_files.size()); + for (const auto& file : remote_files) { + auto future = pool.Submit([rcm, file]() { + auto fileSize = rcm->Size(file); + auto buf = std::shared_ptr(new uint8_t[fileSize]); + rcm->Read(file, buf.get(), fileSize); + + auto arrow_buf = + std::make_shared(buf.get(), fileSize); + auto buffer_reader = + std::make_shared(arrow_buf); + + std::unique_ptr arrow_reader; + auto status = parquet::arrow::OpenFile( + buffer_reader, arrow::default_memory_pool(), &arrow_reader); + AssertInfo(status.ok(), + "failed to open parquet file: {}", + status.message()); + + std::shared_ptr batch_reader; + status = arrow_reader->GetRecordBatchReader(&batch_reader); + AssertInfo(status.ok(), + "failed to get record batch reader: {}", + status.message()); + + return std::make_shared( + std::move(batch_reader), std::move(arrow_reader), buf); + }); + futures.emplace_back(std::move(future)); + } + + for (auto& future : futures) { + auto field_data = future.get(); + channel->push(field_data); + } + + channel->close(); + } catch (std::exception& e) { + LOG_INFO("failed to load data from remote: {}", e.what()); + channel->close(std::current_exception()); + } +} + // init segcore storage config first, and create default remote chunk manager // segcore use default remote chunk manager to load data from minio/s3 void diff --git a/internal/core/src/segcore/Utils.h b/internal/core/src/segcore/Utils.h index f527d686d3..fe8d0fdb0d 100644 --- a/internal/core/src/segcore/Utils.h +++ b/internal/core/src/segcore/Utils.h @@ -106,6 +106,10 @@ ReverseDataFromIndex(const index::IndexBase* index, const int64_t* seg_offsets, int64_t count, const FieldMeta& field_meta); +void +LoadArrowReaderForJsonStatsFromRemote( + const std::vector& remote_files, + std::shared_ptr channel); void LoadArrowReaderFromRemote(const std::vector& remote_files, diff --git a/internal/core/src/segcore/segment_c.cpp b/internal/core/src/segcore/segment_c.cpp index 729debacb6..d97591da2a 100644 --- a/internal/core/src/segcore/segment_c.cpp +++ b/internal/core/src/segcore/segment_c.cpp @@ -22,6 +22,7 @@ #include "common/Types.h" #include "common/Tracer.h" #include "common/type_c.h" +#include "common/ScopedTimer.h" #include "google/protobuf/text_format.h" #include "log/Log.h" #include "mmap/Types.h" @@ -39,6 +40,7 @@ #include "mmap/Types.h" #include "storage/RemoteChunkManagerSingleton.h" #include "exec/expression/ExprCache.h" +#include "monitor/Monitor.h" ////////////////////////////// common interfaces ////////////////////////////// CStatus @@ -529,15 +531,32 @@ LoadJsonKeyIndex(CTraceContext c_trace, config[milvus::index::INDEX_FILES] = files; config[milvus::LOAD_PRIORITY] = info_proto->load_priority(); config[milvus::index::ENABLE_MMAP] = info_proto->enable_mmap(); + if (info_proto->enable_mmap()) { + config[milvus::index::MMAP_FILE_PATH] = info_proto->mmap_dir_path(); + } + milvus::storage::FileManagerContext file_ctx( field_meta, index_meta, remote_chunk_manager); - auto index = std::make_unique( - file_ctx, true); - index->Load(ctx, config); + auto index = + std::make_shared(file_ctx, true); + { + milvus::ScopedTimer timer( + "json_stats_load", + [](double ms) { + milvus::monitor::internal_json_stats_latency_load.Observe( + ms); + }, + milvus::ScopedTimer::LogLevel::Info); + index->Load(ctx, config); + } - segment->LoadJsonKeyIndex(milvus::FieldId(info_proto->fieldid()), - std::move(index)); + segment->LoadJsonStats(milvus::FieldId(info_proto->fieldid()), + std::move(index)); + + LOG_INFO("load json stats success for field:{} of segment:{}", + info_proto->fieldid(), + segment->get_segment_id()); return milvus::SuccessCStatus(); } catch (std::exception& e) { diff --git a/internal/core/src/segcore/storagev2translator/GroupChunkTranslator.cpp b/internal/core/src/segcore/storagev2translator/GroupChunkTranslator.cpp index 02ec0e4690..596038b242 100644 --- a/internal/core/src/segcore/storagev2translator/GroupChunkTranslator.cpp +++ b/internal/core/src/segcore/storagev2translator/GroupChunkTranslator.cpp @@ -271,6 +271,7 @@ std::unique_ptr GroupChunkTranslator::load_group_chunk( const std::shared_ptr& table, const milvus::cachinglayer::cid_t cid) { + AssertInfo(table != nullptr, "arrow table is nullptr"); // Create chunks for each field in this batch std::unordered_map> chunks; // Iterate through field_id_list to get field_id and create chunk diff --git a/internal/core/src/storage/DiskFileManagerImpl.cpp b/internal/core/src/storage/DiskFileManagerImpl.cpp index d4456a2106..4f1d2bfac2 100644 --- a/internal/core/src/storage/DiskFileManagerImpl.cpp +++ b/internal/core/src/storage/DiskFileManagerImpl.cpp @@ -63,7 +63,7 @@ DiskFileManagerImpl::DiskFileManagerImpl( DiskFileManagerImpl::~DiskFileManagerImpl() { RemoveIndexFiles(); RemoveTextLogFiles(); - RemoveJsonKeyIndexFiles(); + RemoveJsonStatsFiles(); RemoveNgramIndexFiles(); } @@ -94,10 +94,21 @@ DiskFileManagerImpl::GetRemoteTextLogPath(const std::string& file_name, } std::string -DiskFileManagerImpl::GetRemoteJsonKeyIndexPath(const std::string& file_name, - int64_t slice_num) { - auto remote_prefix = GetRemoteJsonKeyLogPrefix(); - return remote_prefix + "/" + file_name + "_" + std::to_string(slice_num); +DiskFileManagerImpl::GetRemoteJsonStatsSharedIndexPath( + const std::string& file_name, int64_t slice_num) { + namespace fs = std::filesystem; + fs::path prefix = GetRemoteJsonStatsLogPrefix(); + fs::path suffix = JSON_STATS_SHARED_INDEX_PATH; + fs::path file = file_name + "_" + std::to_string(slice_num); + return (prefix / suffix / file).string(); +} + +std::string +DiskFileManagerImpl::GetRemoteJsonStatsShreddingPrefix() { + namespace fs = std::filesystem; + fs::path prefix = GetRemoteJsonStatsLogPrefix(); + fs::path suffix = JSON_STATS_SHREDDING_DATA_PATH; + return (prefix / suffix).string(); } bool @@ -205,10 +216,10 @@ DiskFileManagerImpl::AddFileMeta(const FileMeta& file_meta) { } bool -DiskFileManagerImpl::AddJsonKeyIndexLog(const std::string& file) noexcept { +DiskFileManagerImpl::AddJsonSharedIndexLog(const std::string& file) noexcept { return AddFileInternal( file, [this](const std::string& file_name, int slice_num) { - return GetRemoteJsonKeyIndexPath(file_name, slice_num); + return GetRemoteJsonStatsSharedIndexPath(file_name, slice_num); }); } @@ -364,14 +375,6 @@ DiskFileManagerImpl::CacheTextLogToDisk( remote_files, GetLocalTextIndexPrefix(), priority); } -void -DiskFileManagerImpl::CacheJsonKeyIndexToDisk( - const std::vector& remote_files, - milvus::proto::common::LoadPriority priority) { - return CacheIndexToDiskInternal( - remote_files, GetLocalJsonKeyIndexPrefix(), priority); -} - void DiskFileManagerImpl::CacheNgramIndexToDisk( const std::vector& remote_files, @@ -380,6 +383,14 @@ DiskFileManagerImpl::CacheNgramIndexToDisk( remote_files, GetLocalNgramIndexPrefix(), priority); } +void +DiskFileManagerImpl::CacheJsonStatsSharedIndexToDisk( + const std::vector& remote_files, + milvus::proto::common::LoadPriority priority) { + return CacheIndexToDiskInternal( + remote_files, GetLocalJsonStatsSharedIndexPrefix(), priority); +} + template std::string DiskFileManagerImpl::CacheRawDataToDisk(const Config& config) { @@ -587,10 +598,10 @@ DiskFileManagerImpl::RemoveTextLogFiles() { } void -DiskFileManagerImpl::RemoveJsonKeyIndexFiles() { +DiskFileManagerImpl::RemoveJsonStatsFiles() { auto local_chunk_manager = LocalChunkManagerSingleton::GetInstance().GetChunkManager(); - local_chunk_manager->RemoveDir(GetLocalJsonKeyIndexPrefix()); + local_chunk_manager->RemoveDir(GetLocalJsonStatsPrefix()); } void @@ -872,41 +883,58 @@ DiskFileManagerImpl::GetLocalTempTextIndexPrefix() { true); } -// path to store pre-built index contents downloaded from remote storage std::string -DiskFileManagerImpl::GetLocalJsonKeyIndexPrefix() { +DiskFileManagerImpl::GetLocalJsonStatsPrefix() { auto local_chunk_manager = LocalChunkManagerSingleton::GetInstance().GetChunkManager(); - return GenJsonKeyIndexPathPrefix(local_chunk_manager, - index_meta_.build_id, - index_meta_.index_version, - field_meta_.segment_id, - field_meta_.field_id, - false); -} - -// temporary path used during index building -std::string -DiskFileManagerImpl::GetLocalTempJsonKeyIndexPrefix() { - auto local_chunk_manager = - LocalChunkManagerSingleton::GetInstance().GetChunkManager(); - return GenJsonKeyIndexPathPrefix(local_chunk_manager, - index_meta_.build_id, - index_meta_.index_version, - field_meta_.segment_id, - field_meta_.field_id, - true); + return GenJsonStatsPathPrefix(local_chunk_manager, + index_meta_.build_id, + index_meta_.index_version, + field_meta_.segment_id, + field_meta_.field_id, + false); } std::string -DiskFileManagerImpl::GetRemoteJsonKeyLogPrefix() { - return GenRemoteJsonKeyIndexPathPrefix(rcm_, - index_meta_.build_id, - index_meta_.index_version, - field_meta_.collection_id, - field_meta_.partition_id, - field_meta_.segment_id, - field_meta_.field_id); +DiskFileManagerImpl::GetLocalTempJsonStatsPrefix() { + auto local_chunk_manager = + LocalChunkManagerSingleton::GetInstance().GetChunkManager(); + return GenJsonStatsPathPrefix(local_chunk_manager, + index_meta_.build_id, + index_meta_.index_version, + field_meta_.segment_id, + field_meta_.field_id, + true); +} + +std::string +DiskFileManagerImpl::GetLocalJsonStatsShreddingPrefix() { + namespace fs = std::filesystem; + fs::path prefix = GetLocalJsonStatsPrefix(); + fs::path suffix = JSON_STATS_SHREDDING_DATA_PATH; + return (prefix / suffix).string(); +} + +std::string +DiskFileManagerImpl::GetLocalJsonStatsSharedIndexPrefix() { + // make sure the path end with '/' + namespace fs = std::filesystem; + fs::path prefix = GetLocalJsonStatsPrefix(); + fs::path suffix = JSON_STATS_SHARED_INDEX_PATH; + auto result = (prefix / suffix).string(); + if (!result.empty() && result.back() != fs::path::preferred_separator) { + result += fs::path::preferred_separator; + } + return result; +} + +std::string +DiskFileManagerImpl::GetLocalJsonStatsShreddingPath( + const std::string& file_name) { + namespace fs = std::filesystem; + fs::path prefix = GetLocalJsonStatsShreddingPrefix(); + fs::path file = file_name; + return (prefix / file).string(); } std::string @@ -933,6 +961,17 @@ DiskFileManagerImpl::GetLocalTempNgramIndexPrefix() { true); } +std::string +DiskFileManagerImpl::GetRemoteJsonStatsLogPrefix() { + return GenRemoteJsonStatsPathPrefix(rcm_, + index_meta_.build_id, + index_meta_.index_version, + field_meta_.collection_id, + field_meta_.partition_id, + field_meta_.segment_id, + field_meta_.field_id); +} + std::string DiskFileManagerImpl::GetLocalRawDataObjectPrefix() { auto local_chunk_manager = diff --git a/internal/core/src/storage/DiskFileManagerImpl.h b/internal/core/src/storage/DiskFileManagerImpl.h index 34554cad64..6586e0d2ad 100644 --- a/internal/core/src/storage/DiskFileManagerImpl.h +++ b/internal/core/src/storage/DiskFileManagerImpl.h @@ -63,7 +63,7 @@ class DiskFileManagerImpl : public FileManagerImpl { AddTextLog(const std::string& filename) noexcept; bool - AddJsonKeyIndexLog(const std::string& filename) noexcept; + AddJsonSharedIndexLog(const std::string& filename) noexcept; public: std::string @@ -87,16 +87,20 @@ class DiskFileManagerImpl : public FileManagerImpl { std::string GetLocalTempTextIndexPrefix(); - // Used for loading index, using this index prefix dir to store index. std::string - GetLocalJsonKeyIndexPrefix(); + GetLocalJsonStatsPrefix(); std::string - GetLocalTempJsonKeyIndexPrefix(); + GetLocalTempJsonStatsPrefix(); - // Used for upload index to remote storage, using this index prefix dir as remote storage directory std::string - GetRemoteJsonKeyLogPrefix(); + GetLocalJsonStatsShreddingPrefix(); + + std::string + GetLocalJsonStatsSharedIndexPrefix(); + + std::string + GetLocalJsonStatsShreddingPath(const std::string& file_name); // Used for upload index to remote storage, using this index prefix dir as remote storage directory std::string @@ -106,6 +110,16 @@ class DiskFileManagerImpl : public FileManagerImpl { std::string GetLocalTempNgramIndexPrefix(); + std::string + GetRemoteJsonStatsLogPrefix(); + + std::string + GetRemoteJsonStatsShreddingPrefix(); + + std::string + GetRemoteJsonStatsSharedIndexPath(const std::string& file_name, + int64_t slice_num); + std::string GetLocalRawDataObjectPrefix(); @@ -127,10 +141,6 @@ class DiskFileManagerImpl : public FileManagerImpl { CacheTextLogToDisk(const std::vector& remote_files, milvus::proto::common::LoadPriority priority); - void - CacheJsonKeyIndexToDisk(const std::vector& remote_files, - milvus::proto::common::LoadPriority priority); - void CacheNgramIndexToDisk(const std::vector& remote_files, milvus::proto::common::LoadPriority priority); @@ -142,7 +152,12 @@ class DiskFileManagerImpl : public FileManagerImpl { RemoveTextLogFiles(); void - RemoveJsonKeyIndexFiles(); + RemoveJsonStatsFiles(); + + void + CacheJsonStatsSharedIndexToDisk( + const std::vector& remote_files, + milvus::proto::common::LoadPriority priority); void RemoveNgramIndexFiles(); @@ -196,9 +211,6 @@ class DiskFileManagerImpl : public FileManagerImpl { std::string GetRemoteTextLogPath(const std::string& file_name, int64_t slice_num) const; - std::string - GetRemoteJsonKeyIndexPath(const std::string& file_name, int64_t slice_num); - bool AddFileInternal(const std::string& file_name, const std::function& diff --git a/internal/core/src/storage/LocalChunkManager.h b/internal/core/src/storage/LocalChunkManager.h index 649bdb8013..f84ddd63a5 100644 --- a/internal/core/src/storage/LocalChunkManager.h +++ b/internal/core/src/storage/LocalChunkManager.h @@ -106,6 +106,11 @@ class LocalChunkManager : public ChunkManager { return path_prefix_; } + virtual std::string + GetBucketName() const { + return ""; + } + bool CreateFile(const std::string& filepath); @@ -133,11 +138,6 @@ class LocalChunkManager : public ChunkManager { int64_t GetSizeOfDir(const std::string& dir); - virtual std::string - GetBucketName() const { - return ""; - } - private: std::string path_prefix_; }; diff --git a/internal/core/src/storage/MinioChunkManager.h b/internal/core/src/storage/MinioChunkManager.h index 223e4b6aaf..a49ff04e1c 100644 --- a/internal/core/src/storage/MinioChunkManager.h +++ b/internal/core/src/storage/MinioChunkManager.h @@ -200,6 +200,7 @@ class MinioChunkManager : public ChunkManager { const std::string& object_name, void* buf, uint64_t size); + uint64_t GetObjectBuffer(const std::string& bucket_name, const std::string& object_name, diff --git a/internal/core/src/storage/Util.cpp b/internal/core/src/storage/Util.cpp index f5db1a35e7..f94db23c6d 100644 --- a/internal/core/src/storage/Util.cpp +++ b/internal/core/src/storage/Util.cpp @@ -644,50 +644,58 @@ GenTextIndexPathPrefix(ChunkManagerPtr cm, } std::string -GenJsonKeyIndexPathPrefix(ChunkManagerPtr cm, - int64_t build_id, - int64_t index_version, - int64_t segment_id, - int64_t field_id, - bool is_temp) { - return GenIndexPathPrefixByType(cm, - build_id, +GenJsonStatsPathPrefix(ChunkManagerPtr cm, + int64_t build_id, + int64_t index_version, + int64_t segment_id, + int64_t field_id, + bool is_temp) { + boost::filesystem::path prefix = cm->GetRootPath(); + + if (is_temp) { + prefix = prefix / TEMP; + } + + boost::filesystem::path path = std::string(JSON_STATS_ROOT_PATH); + boost::filesystem::path path1 = + GenIndexPathIdentifier(build_id, index_version, segment_id, field_id); + + return (prefix / path / path1).string(); +} + +std::string +GenJsonStatsPathIdentifier(int64_t build_id, + int64_t index_version, + int64_t collection_id, + int64_t partition_id, + int64_t segment_id, + int64_t field_id) { + boost::filesystem::path p = + boost::filesystem::path(std::to_string(build_id)) / + std::to_string(index_version) / std::to_string(collection_id) / + std::to_string(partition_id) / std::to_string(segment_id) / + std::to_string(field_id); + return p.string() + "/"; +} + +std::string +GenRemoteJsonStatsPathPrefix(ChunkManagerPtr cm, + int64_t build_id, + int64_t index_version, + int64_t collection_id, + int64_t partition_id, + int64_t segment_id, + int64_t field_id) { + boost::filesystem::path p = cm->GetRootPath(); + p /= std::string(JSON_STATS_ROOT_PATH); + p /= std::string(JSON_STATS_DATA_FORMAT_VERSION); + p /= GenJsonStatsPathIdentifier(build_id, index_version, + collection_id, + partition_id, segment_id, - field_id, - JSON_KEY_INDEX_LOG_ROOT_PATH, - is_temp); -} - -std::string -GenJsonKeyIndexPathIdentifier(int64_t build_id, - int64_t index_version, - int64_t collection_id, - int64_t partition_id, - int64_t segment_id, - int64_t field_id) { - return std::to_string(build_id) + "/" + std::to_string(index_version) + - "/" + std::to_string(collection_id) + "/" + - std::to_string(partition_id) + "/" + std::to_string(segment_id) + - "/" + std::to_string(field_id) + "/"; -} - -std::string -GenRemoteJsonKeyIndexPathPrefix(ChunkManagerPtr cm, - int64_t build_id, - int64_t index_version, - int64_t collection_id, - int64_t partition_id, - int64_t segment_id, - int64_t field_id) { - return cm->GetRootPath() + "/" + std::string(JSON_KEY_INDEX_LOG_ROOT_PATH) + - "/" + - GenJsonKeyIndexPathIdentifier(build_id, - index_version, - collection_id, - partition_id, - segment_id, - field_id); + field_id); + return p.string(); } std::string diff --git a/internal/core/src/storage/Util.h b/internal/core/src/storage/Util.h index c86b07db32..611d967070 100644 --- a/internal/core/src/storage/Util.h +++ b/internal/core/src/storage/Util.h @@ -125,24 +125,31 @@ GenTextIndexPathPrefix(ChunkManagerPtr cm, int64_t field_id, bool is_temp); -// is_temp: true for temporary path used during index building, -// false for path to store pre-built index contents downloaded from remote storage std::string -GenJsonKeyIndexPathPrefix(ChunkManagerPtr cm, - int64_t build_id, - int64_t index_version, - int64_t segment_id, - int64_t field_id, - bool is_temp); +GenJsonStatsPathPrefix(ChunkManagerPtr cm, + int64_t build_id, + int64_t index_version, + int64_t segment_id, + int64_t field_id, + bool is_temp); std::string -GenRemoteJsonKeyIndexPathPrefix(ChunkManagerPtr cm, - int64_t build_id, - int64_t index_version, - int64_t collection_id, - int64_t partition_id, - int64_t segment_id, - int64_t field_id); +GenJsonStatsPathIdentifier(int64_t build_id, + int64_t index_version, + int64_t collection_id, + int64_t partition_id, + int64_t segment_id, + int64_t field_id); + +std::string +GenRemoteJsonStatsPathPrefix(ChunkManagerPtr cm, + int64_t build_id, + int64_t index_version, + int64_t collection_id, + int64_t partition_id, + int64_t segment_id, + int64_t field_id); + std::string GenNgramIndexPrefix(ChunkManagerPtr cm, int64_t build_id, diff --git a/internal/core/src/storage/gcp-native-storage/GcpNativeChunkManager.h b/internal/core/src/storage/gcp-native-storage/GcpNativeChunkManager.h index 6689bc84b5..c45fc9c0f0 100644 --- a/internal/core/src/storage/gcp-native-storage/GcpNativeChunkManager.h +++ b/internal/core/src/storage/gcp-native-storage/GcpNativeChunkManager.h @@ -107,12 +107,12 @@ class GcpNativeChunkManager : public ChunkManager { return path_prefix_; } - public: virtual std::string GetBucketName() const { return default_bucket_name_; } + public: inline void SetBucketName(const std::string& bucket_name) { default_bucket_name_ = bucket_name; diff --git a/internal/core/src/storage/opendal/OpenDALChunkManager.h b/internal/core/src/storage/opendal/OpenDALChunkManager.h index 84059dfe1c..a42c0d3763 100644 --- a/internal/core/src/storage/opendal/OpenDALChunkManager.h +++ b/internal/core/src/storage/opendal/OpenDALChunkManager.h @@ -79,8 +79,8 @@ class OpenDALChunkManager : public ChunkManager { return remote_root_path_; } - virtual std::string - GetBucketName() const { + std::string + GetBucketName() const override { return default_bucket_name_; } diff --git a/internal/core/unittest/CMakeLists.txt b/internal/core/unittest/CMakeLists.txt index f225fe1fa1..7982ade2ac 100644 --- a/internal/core/unittest/CMakeLists.txt +++ b/internal/core/unittest/CMakeLists.txt @@ -97,7 +97,6 @@ set(MILVUS_TEST_FILES test_cached_search_iterator.cpp test_random_sample.cpp test_json_index.cpp - test_json_key_stats_index.cpp test_types.cpp test_growing_storage_v2.cpp test_memory_planner.cpp @@ -202,6 +201,7 @@ target_link_libraries(all_tests install(TARGETS all_tests DESTINATION unittest) add_subdirectory(bench) +add_subdirectory(test_json_stats) # if (USE_DYNAMIC_SIMD) # add_executable(dynamic_simd_test diff --git a/internal/core/unittest/test_c_api.cpp b/internal/core/unittest/test_c_api.cpp index 44cd860650..1180b6601d 100644 --- a/internal/core/unittest/test_c_api.cpp +++ b/internal/core/unittest/test_c_api.cpp @@ -51,6 +51,7 @@ #include "test_utils/DataGen.h" #include "segcore/vector_index_c.h" #include "common/jsmn.h" +#include "exec/expression/Element.h" using namespace milvus; using namespace milvus::test; @@ -1050,6 +1051,40 @@ TEST(CApiTest, InsertSamePkAfterDeleteOnGrowingSegment) { DeleteSegment(segment); } +TEST(CApiTest, TestMultiElement) { + std::vector params; + for (int i = 0; i < 100; i++) { + params.push_back(std::to_string(i)); + } + auto multi_element = + std::make_shared>(params); + std::string target = "50"; + auto res = multi_element->In(target); + ASSERT_EQ(res, true); + target = "30"; + res = multi_element->In(target); + ASSERT_EQ(res, true); + target = "40"; + res = multi_element->In(target); + ASSERT_EQ(res, true); + target = "100"; + res = multi_element->In(target); + ASSERT_EQ(res, false); + target = "1000"; + res = multi_element->In(target); + ASSERT_EQ(res, false); + + std::string_view target_view = "30"; + res = multi_element->In(target_view); + ASSERT_EQ(res, true); + target_view = "40"; + res = multi_element->In(target_view); + ASSERT_EQ(res, true); + target_view = "50"; + res = multi_element->In(target_view); + ASSERT_EQ(res, true); +} + TEST(CApiTest, InsertSamePkAfterDeleteOnSealedSegment) { auto collection = NewCollection(get_default_schema_config().c_str()); CSegmentInterface segment; diff --git a/internal/core/unittest/test_disk_file_manager_test.cpp b/internal/core/unittest/test_disk_file_manager_test.cpp index 3004f15b58..68d99ba9d2 100644 --- a/internal/core/unittest/test_disk_file_manager_test.cpp +++ b/internal/core/unittest/test_disk_file_manager_test.cpp @@ -514,7 +514,7 @@ TEST_F(DiskAnnFileManagerTest, CacheOptFieldToDiskOnlyOneCategory) { TEST_F(DiskAnnFileManagerTest, FileCleanup) { std::string local_index_file_path; std::string local_text_index_file_path; - std::string local_json_key_index_file_path; + std::string local_json_stats_file_path; auto local_chunk_manager = LocalChunkManagerSingleton::GetInstance().GetChunkManager(); @@ -525,25 +525,25 @@ TEST_F(DiskAnnFileManagerTest, FileCleanup) { auto random_file_suffix = std::to_string(rand()); local_text_index_file_path = file_manager->GetLocalTextIndexPrefix() + random_file_suffix; - local_json_key_index_file_path = - file_manager->GetLocalJsonKeyIndexPrefix() + random_file_suffix; local_index_file_path = file_manager->GetLocalIndexObjectPrefix() + random_file_suffix; + local_json_stats_file_path = + file_manager->GetLocalJsonStatsPrefix() + random_file_suffix; local_chunk_manager->CreateFile(local_text_index_file_path); - local_chunk_manager->CreateFile(local_json_key_index_file_path); local_chunk_manager->CreateFile(local_index_file_path); + local_chunk_manager->CreateFile(local_json_stats_file_path); // verify these files exist EXPECT_TRUE( file_manager->IsExisted(local_text_index_file_path).value()); - EXPECT_TRUE( - file_manager->IsExisted(local_json_key_index_file_path).value()); EXPECT_TRUE(file_manager->IsExisted(local_index_file_path).value()); + EXPECT_TRUE( + file_manager->IsExisted(local_json_stats_file_path).value()); } // verify these files not exist EXPECT_FALSE(local_chunk_manager->Exist(local_text_index_file_path)); - EXPECT_FALSE(local_chunk_manager->Exist(local_json_key_index_file_path)); EXPECT_FALSE(local_chunk_manager->Exist(local_index_file_path)); + EXPECT_FALSE(local_chunk_manager->Exist(local_json_stats_file_path)); } \ No newline at end of file diff --git a/internal/core/unittest/test_exec.cpp b/internal/core/unittest/test_exec.cpp index 660b471bca..d2506d3638 100644 --- a/internal/core/unittest/test_exec.cpp +++ b/internal/core/unittest/test_exec.cpp @@ -145,6 +145,7 @@ TEST_P(TaskTest, CallExprEmpty) { MAX_TIMESTAMP, 0, 0, + query::PlanOptions{false}, std::make_shared( std::unordered_map{})); @@ -184,6 +185,7 @@ TEST_P(TaskTest, UnaryExpr) { MAX_TIMESTAMP, 0, 0, + query::PlanOptions{false}, std::make_shared( std::unordered_map{})); @@ -232,6 +234,7 @@ TEST_P(TaskTest, LogicalExpr) { MAX_TIMESTAMP, 0, 0, + query::PlanOptions{false}, std::make_shared( std::unordered_map{})); diff --git a/internal/core/unittest/test_json_key_stats_index.cpp b/internal/core/unittest/test_json_key_stats_index.cpp deleted file mode 100644 index 0c2aa42f0a..0000000000 --- a/internal/core/unittest/test_json_key_stats_index.cpp +++ /dev/null @@ -1,640 +0,0 @@ -// Copyright(C) 2019 - 2020 Zilliz.All rights reserved. -// -// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance -// with the License. You may obtain a copy of the License at -// -// http://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software distributed under the License -// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express -// or implied. See the License for the specific language governing permissions and limitations under the License - -#include -#include -#include -#include -#include - -#include "common/Tracer.h" -#include "index/BitmapIndex.h" -#include "storage/Util.h" -#include "storage/InsertData.h" -#include "indexbuilder/IndexFactory.h" -#include "index/IndexFactory.h" -#include "test_utils/indexbuilder_test_utils.h" -#include "index/Meta.h" -#include "index/JsonKeyStatsInvertedIndex.h" -#include "common/Json.h" -#include "common/Types.h" -using namespace milvus::index; -using namespace milvus::indexbuilder; -using namespace milvus; -using namespace milvus::index; - -static std::vector -GenerateJsons(int size) { - std::vector jsons; - std::default_random_engine random(42); - std::normal_distribution<> distr(0, 1); - for (int i = 0; i < size; i++) { - auto str = R"({"int":)" + std::to_string(random()) + R"(,"double":)" + - std::to_string(static_cast(random())) + - R"(,"string":")" + std::to_string(random()) + - R"(","bool": true)" + R"(, "array": [1,2,3])" + "}"; - jsons.push_back(milvus::Json(simdjson::padded_string(str))); - } - return jsons; -} - -class JsonKeyStatsIndexTest : public ::testing::TestWithParam { - protected: - void - Init(int64_t collection_id, - int64_t partition_id, - int64_t segment_id, - int64_t field_id, - int64_t index_build_id, - int64_t index_version, - int64_t size) { - proto::schema::FieldSchema field_schema; - field_schema.set_data_type(proto::schema::DataType::JSON); - field_schema.set_nullable(nullable_); - auto field_meta = storage::FieldDataMeta{ - collection_id, partition_id, segment_id, field_id, field_schema}; - auto index_meta = storage::IndexMeta{ - segment_id, field_id, index_build_id, index_version}; - - data_ = std::move(GenerateJsons(size)); - auto field_data = storage::CreateFieldData(DataType::JSON, nullable_); - if (nullable_) { - valid_data.reserve(size_); - for (size_t i = 0; i < size_; i++) { - valid_data.push_back(false); - } - } - if (nullable_) { - int byteSize = (size_ + 7) / 8; - uint8_t* valid_data_ = new uint8_t[byteSize]; - for (int i = 0; i < size_; i++) { - bool value = valid_data[i]; - int byteIndex = i / 8; - int bitIndex = i % 8; - if (value) { - valid_data_[byteIndex] |= (1 << bitIndex); - } else { - valid_data_[byteIndex] &= ~(1 << bitIndex); - } - } - field_data->FillFieldData( - data_.data(), valid_data_, data_.size(), 0); - delete[] valid_data_; - } else { - field_data->FillFieldData(data_.data(), data_.size()); - } - - auto payload_reader = - std::make_shared(field_data); - storage::InsertData insert_data(payload_reader); - insert_data.SetFieldDataMeta(field_meta); - insert_data.SetTimestamps(0, 100); - - auto serialized_bytes = insert_data.Serialize(storage::Remote); - - auto log_path = fmt::format("/{}/{}/{}/{}/{}/{}", - "/tmp/test-jsonkey-index/", - collection_id, - partition_id, - segment_id, - field_id, - 0); - chunk_manager_->Write( - log_path, serialized_bytes.data(), serialized_bytes.size()); - - storage::FileManagerContext ctx(field_meta, index_meta, chunk_manager_); - std::vector index_files; - - Config config; - config[INSERT_FILES_KEY] = std::vector{log_path}; - - auto build_index = - std::make_shared(ctx, false); - build_index->Build(config); - - auto create_index_result = build_index->Upload(config); - auto memSize = create_index_result->GetMemSize(); - auto serializedSize = create_index_result->GetSerializedSize(); - ASSERT_GT(memSize, 0); - ASSERT_GT(serializedSize, 0); - index_files = create_index_result->GetIndexFiles(); - - index::CreateIndexInfo index_info{}; - config["index_files"] = index_files; - config[milvus::LOAD_PRIORITY] = - milvus::proto::common::LoadPriority::HIGH; - index_ = std::make_shared(ctx, true); - index_->Load(milvus::tracer::TraceContext{}, config); - } - - void - SetUp() override { - nullable_ = GetParam(); - type_ = DataType::JSON; - int64_t collection_id = 1; - int64_t partition_id = 2; - int64_t segment_id = 3; - int64_t field_id = 101; - int64_t index_build_id = 1000; - int64_t index_version = 10000; - size_ = 1; - std::string root_path = "/tmp/test-jsonkey-index/"; - - storage::StorageConfig storage_config; - storage_config.storage_type = "local"; - storage_config.root_path = root_path; - chunk_manager_ = storage::CreateChunkManager(storage_config); - - Init(collection_id, - partition_id, - segment_id, - field_id, - index_build_id, - index_version, - size_); - } - - virtual ~JsonKeyStatsIndexTest() override { - boost::filesystem::remove_all(chunk_manager_->GetRootPath()); - } - - public: - std::shared_ptr index_; - DataType type_; - bool nullable_; - size_t size_; - FixedVector valid_data; - std::vector data_; - std::vector json_col; - std::shared_ptr chunk_manager_; -}; - -INSTANTIATE_TEST_SUITE_P(JsonKeyStatsIndexTestSuite, - JsonKeyStatsIndexTest, - ::testing::Values(true, false)); - -TEST_P(JsonKeyStatsIndexTest, HasEscapeSequence) { - EXPECT_TRUE(index_->has_escape_sequence("Hello\\nWorld")); - EXPECT_TRUE(index_->has_escape_sequence("Tab\\tCharacter")); - EXPECT_TRUE(index_->has_escape_sequence("Carriage\\rReturn")); - EXPECT_TRUE(index_->has_escape_sequence("Backspace\\bTest")); - EXPECT_TRUE(index_->has_escape_sequence("FormFeed\\fTest")); - EXPECT_TRUE(index_->has_escape_sequence("Vertical\\vTab")); - EXPECT_TRUE(index_->has_escape_sequence("Backslash\\\\Test")); - EXPECT_TRUE(index_->has_escape_sequence("Quote\\\"Test")); - EXPECT_TRUE(index_->has_escape_sequence("SingleQuote\\'Test")); - - EXPECT_FALSE(index_->has_escape_sequence("No escape sequence here")); - EXPECT_FALSE(index_->has_escape_sequence("Just a backslash \\")); - EXPECT_FALSE(index_->has_escape_sequence("")); -} - -TEST_P(JsonKeyStatsIndexTest, TestTermInFunc) { - struct Testcase { - std::vector term; - std::vector nested_path; - }; - std::vector testcases{ - {{1, 2, 3, 4}, {"int"}}, - {{10, 100, 1000, 10000}, {"int"}}, - {{100, 10000, 9999, 444}, {"int"}}, - {{23, 42, 66, 17, 25}, {"int"}}, - }; - for (auto testcase : testcases) { - auto check = [&](int64_t value) { - std::unordered_set term_set(testcase.term.begin(), - testcase.term.end()); - return term_set.find(value) != term_set.end(); - }; - std::unordered_set term_set(testcase.term.begin(), - testcase.term.end()); - auto filter_func = [&term_set, this](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto value = value_array[i]; - bitset[row_id_array[i]] = - term_set.find(int64_t(value)) != term_set.end(); - } - }; - auto pointer = milvus::Json::pointer(testcase.nested_path); - auto bitset = - index_->FilterByPath(pointer, size_, false, true, filter_func); - ASSERT_EQ(bitset.size(), size_); - for (int i = 0; i < bitset.size(); ++i) { - if (nullable_ && !valid_data[i]) { - ASSERT_EQ(bitset[i], false); - } else { - auto val = data_[i].template at(pointer).value(); - auto ans = bitset[i]; - auto ref = check(val); - ASSERT_EQ(ans, ref); - } - } - } -} - -TEST_P(JsonKeyStatsIndexTest, TestUnaryRangeInFunc) { - struct Testcase { - int64_t val; - std::vector nested_path; - }; - std::vector testcases{ - {10, {"int"}}, - {20, {"int"}}, - {30, {"int"}}, - {40, {"int"}}, - }; - std::vector ops{ - OpType::Equal, - OpType::NotEqual, - OpType::GreaterThan, - OpType::GreaterEqual, - OpType::LessThan, - OpType::LessEqual, - }; - for (const auto& testcase : testcases) { - auto check = [&](int64_t value) { return value == testcase.val; }; - std::function f = check; - for (auto& op : ops) { - switch (op) { - case OpType::Equal: { - f = [&](int64_t value) { return value == testcase.val; }; - break; - } - case OpType::NotEqual: { - f = [&](int64_t value) { return value != testcase.val; }; - break; - } - case OpType::GreaterEqual: { - f = [&](int64_t value) { return value >= testcase.val; }; - break; - } - case OpType::GreaterThan: { - f = [&](int64_t value) { return value > testcase.val; }; - break; - } - case OpType::LessEqual: { - f = [&](int64_t value) { return value <= testcase.val; }; - break; - } - case OpType::LessThan: { - f = [&](int64_t value) { return value < testcase.val; }; - break; - } - default: { - ThrowInfo(Unsupported, "unsupported range node"); - } - } - - auto filter_func = [&op, &testcase, this]( - const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto value = value_array[i]; - auto row_id = row_id_array[i]; - switch (op) { - case OpType::GreaterThan: - bitset[row_id] = value > testcase.val; - break; - case OpType::GreaterEqual: - bitset[row_id] = value >= testcase.val; - break; - case OpType::LessThan: - bitset[row_id] = value < testcase.val; - break; - case OpType::LessEqual: - bitset[row_id] = value <= testcase.val; - break; - case OpType::Equal: - bitset[row_id] = value == testcase.val; - break; - case OpType::NotEqual: - bitset[row_id] = value != testcase.val; - break; - default: - bitset[row_id] = false; - break; - } - } - }; - auto pointer = milvus::Json::pointer(testcase.nested_path); - auto bitset = - index_->FilterByPath(pointer, size_, false, true, filter_func); - ASSERT_EQ(bitset.size(), size_); - for (int i = 0; i < bitset.size(); ++i) { - if (nullable_ && !valid_data[i]) { - ASSERT_EQ(bitset[i], false); - } else { - auto ans = bitset[i]; - if (testcase.nested_path[0] == "int") { - auto val = - data_[i].template at(pointer).value(); - auto ref = f(val); - ASSERT_EQ(ans, ref); - } else { - auto val = - data_[i].template at(pointer).value(); - auto ref = f(val); - ASSERT_EQ(ans, ref); - } - } - } - } - } -} - -TEST_P(JsonKeyStatsIndexTest, TestBinaryRangeInFunc) { - struct Testcase { - bool lower_inclusive; - bool upper_inclusive; - int64_t lower; - int64_t upper; - std::vector nested_path; - }; - std::vector testcases{ - {true, false, 10, 20, {"int"}}, - {true, true, 20, 30, {"int"}}, - {false, true, 30, 40, {"int"}}, - {false, false, 40, 50, {"int"}}, - {true, false, 10, 20, {"double"}}, - {true, true, 20, 30, {"double"}}, - {false, true, 30, 40, {"double"}}, - {false, false, 40, 50, {"double"}}, - }; - for (const auto& testcase : testcases) { - auto check = [&](int64_t value) { - if (testcase.lower_inclusive && testcase.upper_inclusive) { - return testcase.lower <= value && value <= testcase.upper; - } else if (testcase.lower_inclusive && !testcase.upper_inclusive) { - return testcase.lower <= value && value < testcase.upper; - } else if (!testcase.lower_inclusive && testcase.upper_inclusive) { - return testcase.lower < value && value <= testcase.upper; - } else { - return testcase.lower < value && value < testcase.upper; - } - }; - - auto filter_func = [&testcase, this](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto valid = valid_array[i]; - if (valid) { - auto value = value_array[i]; - auto row_id = row_id_array[i]; - if (testcase.lower_inclusive && testcase.upper_inclusive) { - bitset[row_id] = - testcase.lower <= value && value <= testcase.upper; - } else if (testcase.lower_inclusive && - !testcase.upper_inclusive) { - bitset[row_id] = - testcase.lower <= value && value < testcase.upper; - } else if (!testcase.lower_inclusive && - testcase.upper_inclusive) { - bitset[row_id] = - testcase.lower < value && value <= testcase.upper; - } else { - bitset[row_id] = - testcase.lower < value && value < testcase.upper; - } - } else { - auto offset = offset_array[i]; - auto size = size_array[i]; - auto row_id = row_id_array[i]; - auto val = - this->data_[row_id].template at(offset, size); - if (val.error()) { - bitset[row_id] = false; - } - if (testcase.lower_inclusive && testcase.upper_inclusive) { - bitset[row_id] = - testcase.lower <= int64_t(val.value()) && - int64_t(val.value()) <= testcase.upper; - } else if (testcase.lower_inclusive && - !testcase.upper_inclusive) { - bitset[row_id] = - testcase.lower <= int64_t(val.value()) && - int64_t(val.value()) < testcase.upper; - } else if (!testcase.lower_inclusive && - testcase.upper_inclusive) { - bitset[row_id] = - testcase.lower < int64_t(val.value()) && - int64_t(val.value()) <= testcase.upper; - } else { - bitset[row_id] = - testcase.lower < int64_t(val.value()) && - int64_t(val.value()) < testcase.upper; - } - } - } - }; - auto pointer = milvus::Json::pointer(testcase.nested_path); - auto bitset = - index_->FilterByPath(pointer, size_, false, true, filter_func); - ASSERT_EQ(bitset.size(), size_); - for (int i = 0; i < bitset.size(); ++i) { - if (nullable_ && !valid_data[i]) { - ASSERT_EQ(bitset[i], false); - } else { - auto ans = bitset[i]; - if (testcase.nested_path[0] == "int") { - auto val = data_[i].template at(pointer).value(); - auto ref = check(val); - ASSERT_EQ(ans, ref); - } else { - auto val = data_[i].template at(pointer).value(); - auto ref = check(val); - ASSERT_EQ(ans, ref); - } - } - } - } -} - -TEST_P(JsonKeyStatsIndexTest, TestExistInFunc) { - struct Testcase { - std::vector nested_path; - }; - std::vector testcases{ - {{"A"}}, - {{"int"}}, - {{"double"}}, - {{"B"}}, - }; - for (const auto& testcase : testcases) { - auto pointer = milvus::Json::pointer(testcase.nested_path); - auto filter_func = [&pointer, this](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto row_id = row_id_array[i]; - bitset[row_id] = this->data_[row_id].exist(pointer); - } - }; - - auto bitset = - index_->FilterByPath(pointer, size_, false, true, filter_func); - ASSERT_EQ(bitset.size(), size_); - for (int i = 0; i < bitset.size(); ++i) { - if (nullable_ && !valid_data[i]) { - ASSERT_EQ(bitset[i], false); - } else { - auto ans = bitset[i]; - auto val = data_[i].exist(pointer); - ASSERT_EQ(ans, val); - } - } - } -} -TEST_P(JsonKeyStatsIndexTest, TestJsonContainsAllFunc) { - struct Testcase { - std::vector term; - std::vector nested_path; - }; - { - std::vector testcases{ - {{1, 2, 3}, {"array"}}, - {{10, 100}, {"array"}}, - {{100, 1000}, {"array"}}, - }; - for (const auto& testcase : testcases) { - auto check = [&](const std::vector& values) { - for (auto const& e : testcase.term) { - if (std::find(values.begin(), values.end(), e) == - values.end()) { - return false; - } - } - return true; - }; - auto pointer = milvus::Json::pointer(testcase.nested_path); - std::unordered_set elements; - for (auto const& element : testcase.term) { - elements.insert(element); - } - auto filter_func = [&elements, this](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto row_id = row_id_array[i]; - auto offset = offset_array[i]; - auto size = size_array[i]; - auto array = this->data_[row_id].array_at(offset, size); - std::unordered_set tmp_elements(elements); - for (auto&& it : array) { - auto val = it.template get(); - if (val.error()) { - continue; - } - tmp_elements.erase(val.value()); - } - if (tmp_elements.size() == 0) { - bitset[row_id] = true; - } - bitset[row_id] = tmp_elements.empty(); - } - }; - - auto bitset = - index_->FilterByPath(pointer, size_, false, true, filter_func); - ASSERT_EQ(bitset.size(), size_); - for (int i = 0; i < bitset.size(); ++i) { - if (nullable_ && !valid_data[i]) { - ASSERT_EQ(bitset[i], false); - } else { - auto ans = bitset[i]; - auto array = data_[i].array_at(pointer); - std::vector res; - for (const auto& element : array) { - res.push_back(element.template get()); - } - ASSERT_EQ(ans, check(res)); - } - } - } - } -} - -TEST(GrowingJsonKeyStatsIndexTest, GrowingIndex) { - using Index = index::JsonKeyStatsInvertedIndex; - auto index = std::make_unique(std::numeric_limits::max(), - "json", - "/tmp/test-jsonkey-index/"); - auto str = R"({"int":)" + std::to_string(1) + R"(,"double":)" + - std::to_string(static_cast(1)) + R"(,"string":")" + - std::to_string(1) + R"(","bool": true)" + - R"(, "array": [1,2,3])" + "}"; - auto str1 = R"({"int":)" + std::to_string(2) + "}"; - auto str2 = R"({"int":)" + std::to_string(3) + "}"; - std::vector jsonDatas; - jsonDatas.push_back(str); - jsonDatas.push_back(str1); - jsonDatas.push_back(str2); - std::vector jsons; - for (const auto& jsonData : jsonDatas) { - jsons.push_back(milvus::Json(simdjson::padded_string(jsonData))); - } - index->CreateReader(milvus::index::SetBitsetSealed); - index->AddJSONDatas(jsonDatas.size(), jsonDatas.data(), nullptr, 0); - index->Commit(); - index->Reload(); - int64_t checkVal = 1; - auto filter_func = [jsons, checkVal](const bool* valid_array, - const uint8_t* type_array, - const uint32_t* row_id_array, - const uint16_t* offset_array, - const uint16_t* size_array, - const int32_t* value_array, - TargetBitmap& bitset, - const size_t n) { - for (size_t i = 0; i < n; i++) { - auto value = value_array[i]; - bitset[row_id_array[i]] = value == checkVal; - } - }; - auto pointer = milvus::Json::pointer({"int"}); - auto bitset = - index->FilterByPath(pointer, jsonDatas.size(), true, true, filter_func); - ASSERT_EQ(bitset.size(), jsonDatas.size()); - for (int i = 0; i < bitset.size(); ++i) { - auto val = jsons[i].template at(pointer).value(); - auto ans = bitset[i]; - auto ref = val == checkVal; - ASSERT_EQ(ans, ref); - } -} \ No newline at end of file diff --git a/internal/core/unittest/test_json_stats/CMakeLists.txt b/internal/core/unittest/test_json_stats/CMakeLists.txt new file mode 100644 index 0000000000..a9957476f1 --- /dev/null +++ b/internal/core/unittest/test_json_stats/CMakeLists.txt @@ -0,0 +1,32 @@ +# Copyright (C) 2019-2020 Zilliz. All rights reserved. +# +# Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software distributed under the License +# is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +# or implied. See the License for the specific language governing permissions and limitations under the License + +set(JSON_STATS_TEST_FILES + ../init_gtest.cpp + test_bson_builder.cpp + test_bson_view.cpp + test_parquet_writer.cpp + test_utils.cpp + test_json_key_stats.cpp +) + +add_executable(json_stats_test + ${JSON_STATS_TEST_FILES} +) + +target_link_libraries(json_stats_test + gtest + gmock + milvus_core + milvus-storage +) + +install(TARGETS json_stats_test DESTINATION unittest) diff --git a/internal/core/unittest/test_json_stats/test_bson_builder.cpp b/internal/core/unittest/test_json_stats/test_bson_builder.cpp new file mode 100644 index 0000000000..86faa5e1cb --- /dev/null +++ b/internal/core/unittest/test_json_stats/test_bson_builder.cpp @@ -0,0 +1,476 @@ +#include +#include "common/bson_view.h" +#include +#include +#include +#include +#include +#include +#include + +#include "index/json_stats/bson_builder.h" + +namespace milvus::index { + +class DomNodeTest : public ::testing::Test { + protected: + void + SetUp() override { + } +}; + +TEST_F(DomNodeTest, DefaultConstructorTest) { + DomNode node; + EXPECT_EQ(node.type, DomNode::Type::DOCUMENT); + EXPECT_TRUE(node.document_children.empty()); + EXPECT_FALSE(node.bson_value.has_value()); +} + +TEST_F(DomNodeTest, TypeConstructorTest) { + // Test DOCUMENT type + DomNode doc_node(DomNode::Type::DOCUMENT); + EXPECT_EQ(doc_node.type, DomNode::Type::DOCUMENT); + EXPECT_TRUE(doc_node.document_children.empty()); + EXPECT_FALSE(doc_node.bson_value.has_value()); + + // Test VALUE type + DomNode value_node(DomNode::Type::VALUE); + EXPECT_EQ(value_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(value_node.document_children.empty()); + EXPECT_FALSE(value_node.bson_value.has_value()); +} + +TEST_F(DomNodeTest, ValueConstructorTest) { + // Test with boolean value + bsoncxx::types::b_bool bool_val{true}; + DomNode bool_node{bsoncxx::types::bson_value::value(bool_val)}; + EXPECT_EQ(bool_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(bool_node.bson_value.has_value()); + EXPECT_TRUE(bool_node.bson_value.value().view().get_bool()); + + // Test with int32 value + bsoncxx::types::b_int32 int_val{42}; + DomNode int_node{bsoncxx::types::bson_value::value(int_val)}; + EXPECT_EQ(int_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(int_node.bson_value.has_value()); + EXPECT_EQ(int_node.bson_value.value().view().get_int32(), 42); + + // Test with string value + bsoncxx::types::b_string str_val{"test"}; + DomNode str_node{bsoncxx::types::bson_value::value(str_val)}; + EXPECT_EQ(str_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(str_node.bson_value.has_value()); + EXPECT_STREQ(str_node.bson_value.value().view().get_string().value.data(), + "test"); +} + +TEST_F(DomNodeTest, DocumentChildrenTest) { + DomNode root; + + // Add child nodes + root.document_children["child1"] = DomNode(DomNode::Type::VALUE); + root.document_children["child2"] = DomNode(DomNode::Type::DOCUMENT); + + EXPECT_EQ(root.document_children.size(), 2); + EXPECT_EQ(root.document_children["child1"].type, DomNode::Type::VALUE); + EXPECT_EQ(root.document_children["child2"].type, DomNode::Type::DOCUMENT); + + // Test nested document + root.document_children["child2"].document_children["nested"] = DomNode( + bsoncxx::types::bson_value::value(bsoncxx::types::b_int32{123})); + + EXPECT_EQ(root.document_children["child2"].document_children["nested"].type, + DomNode::Type::VALUE); + EXPECT_EQ(root.document_children["child2"] + .document_children["nested"] + .bson_value.value() + .view() + .get_int32(), + 123); +} + +class BsonBuilderTest : public ::testing::Test { + protected: + void + SetUp() override { + builder_ = std::make_unique(); + } + + std::unique_ptr builder_; +}; + +TEST_F(BsonBuilderTest, CreateValueNodeTest) { + BsonBuilder builder; + + // Test NONE type + auto none_node = builder.CreateValueNode("", JSONType::NONE); + EXPECT_EQ(none_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(none_node.bson_value.value().view().type() == + bsoncxx::type::k_null); + + // Test BOOL type + auto true_node = builder.CreateValueNode("true", JSONType::BOOL); + EXPECT_EQ(true_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(true_node.bson_value.value().view().type() == + bsoncxx::type::k_bool); + EXPECT_TRUE(true_node.bson_value.value().view().get_bool().value); + + auto false_node = builder.CreateValueNode("false", JSONType::BOOL); + EXPECT_EQ(false_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(false_node.bson_value.value().view().type() == + bsoncxx::type::k_bool); + EXPECT_FALSE(false_node.bson_value.value().view().get_bool().value); + + // Test INT64 type + auto int64_node = + builder.CreateValueNode("9223372036854775807", JSONType::INT64); + EXPECT_EQ(int64_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(int64_node.bson_value.value().view().type() == + bsoncxx::type::k_int64); + EXPECT_EQ(int64_node.bson_value.value().view().get_int64().value, + 9223372036854775807LL); + + // Test DOUBLE type + auto double_node = builder.CreateValueNode("3.14159", JSONType::DOUBLE); + EXPECT_EQ(double_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(double_node.bson_value.value().view().type() == + bsoncxx::type::k_double); + EXPECT_DOUBLE_EQ(double_node.bson_value.value().view().get_double().value, + 3.14159); + + // Test STRING type + auto string_node = builder.CreateValueNode("hello world", JSONType::STRING); + EXPECT_EQ(string_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(string_node.bson_value.value().view().type() == + bsoncxx::type::k_string); + EXPECT_EQ(string_node.bson_value.value().view().get_string().value, + "hello world"); + + // Test ARRAY type + auto array_node = builder.CreateValueNode("[1, 2, 3]", JSONType::ARRAY); + EXPECT_EQ(array_node.type, DomNode::Type::VALUE); + EXPECT_TRUE(array_node.bson_value.value().view().type() == + bsoncxx::type::k_array); + auto array_view = array_node.bson_value.value().view().get_array().value; + EXPECT_EQ(std::distance(array_view.begin(), array_view.end()), 3); + EXPECT_EQ(array_view[0].get_int64().value, 1); + EXPECT_EQ(array_view[1].get_int64().value, 2); + EXPECT_EQ(array_view[2].get_int64().value, 3); + + // Test invalid type + EXPECT_THROW(builder.CreateValueNode("value", static_cast(999)), + std::runtime_error); +} + +TEST_F(BsonBuilderTest, AppendToDomTest) { + BsonBuilder builder; + DomNode root(DomNode::Type::DOCUMENT); + + // Test single level append + builder.AppendToDom(root, {"key1"}, "value1", JSONType::STRING); + EXPECT_TRUE(root.document_children.find("key1") != + root.document_children.end()); + EXPECT_EQ(root.document_children["key1"].type, DomNode::Type::VALUE); + EXPECT_EQ(root.document_children["key1"] + .bson_value.value() + .view() + .get_string() + .value, + "value1"); + + // Test nested document append + builder.AppendToDom( + root, {"level1", "level2", "key2"}, "42", JSONType::INT64); + EXPECT_TRUE(root.document_children.find("level1") != + root.document_children.end()); + EXPECT_EQ(root.document_children["level1"].type, DomNode::Type::DOCUMENT); + EXPECT_TRUE( + root.document_children["level1"].document_children.find("level2") != + root.document_children["level1"].document_children.end()); + EXPECT_EQ(root.document_children["level1"].document_children["level2"].type, + DomNode::Type::DOCUMENT); + EXPECT_EQ(root.document_children["level1"] + .document_children["level2"] + .document_children["key2"] + .type, + DomNode::Type::VALUE); + EXPECT_EQ(root.document_children["level1"] + .document_children["level2"] + .document_children["key2"] + .bson_value.value() + .view() + .get_int64() + .value, + 42); + + // Test overwriting existing value with document + builder.AppendToDom(root, {"key1", "nested"}, "value3", JSONType::STRING); + EXPECT_EQ(root.document_children["key1"].type, DomNode::Type::DOCUMENT); + EXPECT_EQ(root.document_children["key1"].document_children["nested"].type, + DomNode::Type::VALUE); + EXPECT_EQ(root.document_children["key1"] + .document_children["nested"] + .bson_value.value() + .view() + .get_string() + .value, + "value3"); +} + +TEST_F(BsonBuilderTest, ConvertDomToBsonTest) { + BsonBuilder builder; + DomNode root(DomNode::Type::DOCUMENT); + + // Build a complex document structure + builder.AppendToDom(root, {"string_field"}, "hello", JSONType::STRING); + builder.AppendToDom(root, {"int_field"}, "42", JSONType::INT64); + builder.AppendToDom(root, {"double_field"}, "3.14", JSONType::DOUBLE); + builder.AppendToDom(root, {"bool_field"}, "true", JSONType::BOOL); + builder.AppendToDom( + root, {"nested", "field"}, "nested_value", JSONType::STRING); + builder.AppendToDom(root, {"array_field"}, "[1, 2, 3]", JSONType::ARRAY); + + // Convert to BSON + bsoncxx::builder::basic::document bson_doc; + builder.ConvertDomToBson(root, bson_doc); + auto bson_view = bson_doc.view(); + + // Verify the converted BSON document + EXPECT_EQ(bson_view["string_field"].get_string().value, "hello"); + EXPECT_EQ(bson_view["int_field"].get_int64().value, 42); + EXPECT_DOUBLE_EQ(bson_view["double_field"].get_double().value, 3.14); + EXPECT_TRUE(bson_view["bool_field"].get_bool().value); + EXPECT_EQ(bson_view["nested"]["field"].get_string().value, "nested_value"); + + auto array_view = bson_view["array_field"].get_array().value; + EXPECT_EQ(std::distance(array_view.begin(), array_view.end()), 3); + EXPECT_EQ(array_view[0].get_int64().value, 1); + EXPECT_EQ(array_view[1].get_int64().value, 2); + EXPECT_EQ(array_view[2].get_int64().value, 3); +} + +TEST_F(BsonBuilderTest, ComplexDocumentTest) { + BsonBuilder builder; + DomNode root(DomNode::Type::DOCUMENT); + + // Create a complex document with multiple levels and types + builder.AppendToDom(root, {"user", "name"}, "John", JSONType::STRING); + builder.AppendToDom(root, {"user", "age"}, "30", JSONType::INT64); + builder.AppendToDom( + root, {"user", "scores"}, "[85, 90, 95]", JSONType::ARRAY); + builder.AppendToDom( + root, {"user", "address", "city"}, "New York", JSONType::STRING); + builder.AppendToDom( + root, {"user", "address", "zip"}, "10001", JSONType::STRING); + builder.AppendToDom(root, {"user", "active"}, "true", JSONType::BOOL); + builder.AppendToDom(root, {"metadata", "version"}, "1.0", JSONType::STRING); + builder.AppendToDom(root, {"metadata", "count"}, "1000", JSONType::INT64); + + // Convert to BSON + bsoncxx::builder::basic::document bson_doc; + builder.ConvertDomToBson(root, bson_doc); + auto bson_view = bson_doc.view(); + + // Verify the complex document structure + EXPECT_EQ(bson_view["user"]["name"].get_string().value, "John"); + EXPECT_EQ(bson_view["user"]["age"].get_int64().value, 30); + EXPECT_TRUE(bson_view["user"]["active"].get_bool().value); + EXPECT_EQ(bson_view["user"]["address"]["city"].get_string().value, + "New York"); + EXPECT_EQ(bson_view["user"]["address"]["zip"].get_string().value, "10001"); + EXPECT_EQ(bson_view["metadata"]["version"].get_string().value, "1.0"); + EXPECT_EQ(bson_view["metadata"]["count"].get_int64().value, 1000); + + // Verify array + auto scores_array = bson_view["user"]["scores"].get_array().value; + EXPECT_EQ(std::distance(scores_array.begin(), scores_array.end()), 3); + EXPECT_EQ(scores_array[0].get_int64().value, 85); + EXPECT_EQ(scores_array[1].get_int64().value, 90); + EXPECT_EQ(scores_array[2].get_int64().value, 95); +} + +TEST_F(BsonBuilderTest, ExtractBsonKeyOffsetsTest) { + { + auto doc = bsoncxx::from_json(R"({ "age": 30 })"); + auto offsets = BsonBuilder::ExtractBsonKeyOffsets(doc.view()); + EXPECT_EQ(offsets.size(), 1); + EXPECT_EQ(offsets[0].first, "/age"); + EXPECT_EQ(offsets[0].second, 4); + BsonView view(doc.view().data(), doc.view().length()); + auto res = view.ParseAsValueAtOffset(4); + EXPECT_EQ(res.value(), 30); + } + + { + auto doc = bsoncxx::from_json(R"({ "age": "30"})"); + auto offsets = BsonBuilder::ExtractBsonKeyOffsets(doc.view()); + EXPECT_EQ(offsets.size(), 1); + EXPECT_EQ(offsets[0].first, "/age"); + EXPECT_EQ(offsets[0].second, 4); + auto bson_view = BsonView(doc.view().data(), doc.view().length()); + auto res = bson_view.ParseAsValueAtOffset(4); + EXPECT_STREQ(res.value().data(), "30"); + } + + { + auto doc = bsoncxx::from_json( + R"({ "age": 30, "name": "Alice", "active": true })"); + auto offsets = BsonBuilder::ExtractBsonKeyOffsets(doc.view()); + EXPECT_EQ(offsets.size(), 3); + EXPECT_EQ(offsets[0].first, "/age"); + EXPECT_EQ(offsets[1].first, "/name"); + EXPECT_EQ(offsets[2].first, "/active"); + auto view = BsonView(doc.view().data(), doc.view().length()); + auto res1 = view.ParseAsValueAtOffset(offsets[0].second); + EXPECT_EQ(res1.value(), 30); + auto res2 = + view.ParseAsValueAtOffset(offsets[1].second); + EXPECT_STREQ(res2.value().data(), "Alice"); + auto res3 = view.ParseAsValueAtOffset(offsets[2].second); + EXPECT_EQ(res3.value(), true); + } +} + +TEST_F(BsonBuilderTest, ExtractBsonKeyOffsetsTestAllTypes) { + // Create a complex BSON document with nested structures + bsoncxx::builder::basic::document doc; + + // Add simple fields + doc.append(bsoncxx::builder::basic::kvp("string_field", "value1")); + doc.append(bsoncxx::builder::basic::kvp("int_field", 42)); + doc.append(bsoncxx::builder::basic::kvp("double_field", 3.14)); + doc.append(bsoncxx::builder::basic::kvp("bool_field", true)); + + // Add nested document + bsoncxx::builder::basic::document nested_doc; + nested_doc.append( + bsoncxx::builder::basic::kvp("nested_string", "nested_value")); + nested_doc.append(bsoncxx::builder::basic::kvp("nested_int", 123)); + doc.append(bsoncxx::builder::basic::kvp("nested_doc", nested_doc)); + + // Add array + bsoncxx::builder::basic::array arr; + arr.append("array_item1"); + arr.append(456); + arr.append(false); + doc.append(bsoncxx::builder::basic::kvp("array_field", arr)); + + // Add nested array with document + bsoncxx::builder::basic::array nested_arr; + bsoncxx::builder::basic::document arr_doc; + arr_doc.append( + bsoncxx::builder::basic::kvp("arr_doc_field", "arr_doc_value")); + nested_arr.append(arr_doc); + doc.append(bsoncxx::builder::basic::kvp("nested_array", nested_arr)); + + // Extract offsets + auto offsets = BsonBuilder::ExtractBsonKeyOffsets(doc.view()); + + // Verify results + EXPECT_FALSE(offsets.empty()); + + // Create a map for easier lookup + std::map offset_map; + for (const auto& [key, offset] : offsets) { + offset_map[key] = offset; + } + + // Verify all expected fields are present + EXPECT_TRUE(offset_map.find("/string_field") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/int_field") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/double_field") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/bool_field") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/nested_doc") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/nested_doc/nested_string") != + offset_map.end()); + EXPECT_TRUE(offset_map.find("/nested_doc/nested_int") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/array_field") != offset_map.end()); + EXPECT_TRUE(offset_map.find("/nested_array") != offset_map.end()); + + // Verify offsets are within document bounds + size_t doc_size = doc.view().length(); + for (const auto& [key, offset] : offsets) { + EXPECT_LT(offset, doc_size) + << "Offset for key " << key << " is out of bounds"; + } + + // Verify offsets are unique + std::set unique_offsets; + for (const auto& [key, offset] : offsets) { + EXPECT_TRUE(unique_offsets.insert(offset).second) + << "Duplicate offset found for key " << key; + } + + // Verify the total number of fields + // This number should match the total number of fields we added + // 1. string_field + // 2. int_field + // 3. double_field + // 4. bool_field + // 5. nested_doc + // 6. nested_doc/nested_string + // 7. nested_doc/nested_int + // 8. array_field + // 9. nested_array + // 10. nested_array/0/arr_doc_field + EXPECT_EQ(offsets.size(), 9); +} + +TEST_F(BsonBuilderTest, ExtractOffsetsRecursiveTest) { + // Test empty document + bsoncxx::builder::basic::document empty_doc; + std::vector> empty_result; + builder_->ExtractOffsetsRecursive( + empty_doc.view().data(), empty_doc.view().data(), "", empty_result); + EXPECT_TRUE(empty_result.empty()); + + // Test simple document with one field + bsoncxx::builder::basic::document simple_doc; + simple_doc.append(bsoncxx::builder::basic::kvp("field", "value")); + std::vector> simple_result; + builder_->ExtractOffsetsRecursive( + simple_doc.view().data(), simple_doc.view().data(), "", simple_result); + EXPECT_EQ(simple_result.size(), 1); + EXPECT_EQ(simple_result[0].first, "/field"); +} + +TEST_F(BsonBuilderTest, ExtractOffsetsRecursiveWithNestedPathTest) { + bsoncxx::builder::basic::document doc; + bsoncxx::builder::basic::document nested_doc; + nested_doc.append(bsoncxx::builder::basic::kvp("nested_field", "value")); + doc.append(bsoncxx::builder::basic::kvp("parent", nested_doc)); + + std::vector> result; + builder_->ExtractOffsetsRecursive( + doc.view().data(), doc.view().data(), "prefix", result); + + EXPECT_EQ(result.size(), 2); + EXPECT_EQ(result[0].first, "prefix/parent"); + EXPECT_EQ(result[1].first, "prefix/parent/nested_field"); +} + +TEST_F(BsonBuilderTest, ExtractOffsetsRecursiveWithArrayElementsTest) { + bsoncxx::builder::basic::document doc; + bsoncxx::builder::basic::array arr; + + // Add array with mixed types + arr.append("string_item"); + arr.append(42); + arr.append(true); + + // Add nested document in array + bsoncxx::builder::basic::document nested_doc; + nested_doc.append(bsoncxx::builder::basic::kvp("nested_field", "value")); + arr.append(nested_doc); + + doc.append(bsoncxx::builder::basic::kvp("mixed_array", arr)); + + std::vector> result; + builder_->ExtractOffsetsRecursive( + doc.view().data(), doc.view().data(), "", result); + + EXPECT_EQ(result.size(), 1); // mixed_array + EXPECT_EQ(result[0].first, "/mixed_array"); +} + +} // namespace milvus::index diff --git a/internal/core/unittest/test_json_stats/test_bson_view.cpp b/internal/core/unittest/test_json_stats/test_bson_view.cpp new file mode 100644 index 0000000000..1f026b8b88 --- /dev/null +++ b/internal/core/unittest/test_json_stats/test_bson_view.cpp @@ -0,0 +1,313 @@ +#include +#include "common/bson_view.h" +#include +#include +#include +#include +#include +#include +#include +#include "index/json_stats/bson_builder.h" + +namespace milvus::index { + +class BsonViewTest : public ::testing::Test { + protected: + void + SetUp() override { + } +}; + +TEST_F(BsonViewTest, ConstructorTest) { + // Test vector constructor + std::vector data = { + 0x05, 0x00, 0x00, 0x00, 0x00}; // Empty BSON document + BsonView view1(data); + EXPECT_EQ(view1.ToString(), "{ }"); +} + +TEST_F(BsonViewTest, ParseAsValueAtOffsetTest) { + // Create a BSON document with various types + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("int32_field", 42)); + doc.append(bsoncxx::builder::basic::kvp("double_field", 3.14159)); + doc.append(bsoncxx::builder::basic::kvp("bool_field", true)); + doc.append(bsoncxx::builder::basic::kvp("string_field", "test string")); + + BsonView view(doc.view().data(), doc.view().length()); + + auto offsets = BsonBuilder::ExtractBsonKeyOffsets(doc.view()); + for (const auto& offset : offsets) { + std::cout << offset.first << " " << offset.second << std::endl; + } + + // Test int32 parsing + auto int32_val = view.ParseAsValueAtOffset(offsets[0].second); + EXPECT_TRUE(int32_val.has_value()); + EXPECT_EQ(int32_val.value(), 42); + + // Test double parsing + auto double_val = view.ParseAsValueAtOffset(offsets[1].second); + EXPECT_TRUE(double_val.has_value()); + EXPECT_EQ(double_val.value(), 3.14159); + + // Test bool parsing + auto bool_val = view.ParseAsValueAtOffset(offsets[2].second); + EXPECT_TRUE(bool_val.has_value()); + EXPECT_TRUE(bool_val.value()); + + // Test string parsing + auto string_val = view.ParseAsValueAtOffset(offsets[3].second); + EXPECT_TRUE(string_val.has_value()); + EXPECT_EQ(string_val.value(), "test string"); +} + +TEST_F(BsonViewTest, ParseAsArrayAtOffsetTest) { + // Test case 1: offset = 0 (whole array) + { + bsoncxx::builder::basic::array arr; + arr.append("value1"); + arr.append(42); + arr.append(true); + + BsonView view(arr.view().data(), arr.view().length()); + auto array_view = view.ParseAsArrayAtOffset(0); + + // Verify array content + EXPECT_TRUE(array_view.has_value()); + EXPECT_EQ( + std::distance(array_view.value().begin(), array_view.value().end()), + 3); + EXPECT_STREQ(array_view.value()[0].get_string().value.data(), "value1"); + EXPECT_EQ(array_view.value()[1].get_int32(), 42); + EXPECT_TRUE(array_view.value()[2].get_bool()); + } + + // Test case 2: offset != 0 (array in document) + { + bsoncxx::builder::basic::array arr; + arr.append("array_value1"); + arr.append(123); + arr.append(3.14159); + + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("top_field", "top_value")); + doc.append(bsoncxx::builder::basic::kvp("array_field", arr)); + + BsonView view(doc.view().data(), doc.view().length()); + + // Find the offset of the array + auto offsets = BsonBuilder::ExtractBsonKeyOffsets(doc.view()); + size_t array_offset = 0; + for (const auto& offset : offsets) { + if (offset.first == "/array_field") { + array_offset = offset.second; + break; + } + } + auto array_view = view.ParseAsArrayAtOffset(array_offset); + + // Verify array content + EXPECT_TRUE(array_view.has_value()); + EXPECT_EQ( + std::distance(array_view.value().begin(), array_view.value().end()), + 3); + EXPECT_STREQ(array_view.value()[0].get_string().value.data(), + "array_value1"); + EXPECT_EQ(array_view.value()[1].get_int32(), 123); + EXPECT_DOUBLE_EQ(array_view.value()[2].get_double(), 3.14159); + } + + // Test case 4: Error cases + { + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("field", "value")); + BsonView view(doc.view().data(), doc.view().length()); + + // Test invalid offset (out of range) + EXPECT_THROW(view.ParseAsArrayAtOffset(1000), std::runtime_error); + } +} + +TEST_F(BsonViewTest, FindByPathTest) { + // Create a complex nested BSON document + bsoncxx::builder::basic::document nested_doc; + nested_doc.append(bsoncxx::builder::basic::kvp("nested_field", "value")); + + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("level1", nested_doc)); + doc.append(bsoncxx::builder::basic::kvp("simple_field", "simple_value")); + + BsonView view(doc.view().data(), doc.view().length()); + + // Test finding nested field + std::vector path = {"level1", "nested_field"}; + auto value = view.FindByPath(doc.view(), path); + EXPECT_TRUE(value.has_value()); + EXPECT_STREQ(value.value().get_string().value.data(), "value"); + + // Test finding simple field + path = {"simple_field"}; + value = view.FindByPath(doc.view(), path); + EXPECT_TRUE(value.has_value()); + EXPECT_STREQ(value.value().get_string().value.data(), "simple_value"); + + // Test non-existent path + path = {"non_existent"}; + value = view.FindByPath(doc.view(), path); + EXPECT_FALSE(value.has_value()); + + // Test invalid nested path + path = {"level1", "non_existent"}; + value = view.FindByPath(doc.view(), path); + EXPECT_FALSE(value.has_value()); +} + +TEST_F(BsonViewTest, GetNthElementInArrayTest) { + // Create a BSON array with mixed types + bsoncxx::builder::basic::array arr; + arr.append("string_item"); + arr.append(42); + arr.append(true); + arr.append(3.14159); + + // Test string element + auto string_val = + BsonView::GetNthElementInArray(arr.view().data(), 0); + EXPECT_TRUE(string_val.has_value()); + EXPECT_EQ(string_val.value(), "string_item"); + + // Test int32 element + auto int_val = + BsonView::GetNthElementInArray(arr.view().data(), 1); + EXPECT_TRUE(int_val.has_value()); + EXPECT_EQ(int_val.value(), 42); + + // Test bool element + auto bool_val = BsonView::GetNthElementInArray(arr.view().data(), 2); + EXPECT_TRUE(bool_val.has_value()); + EXPECT_TRUE(bool_val.value()); + + // Test double element + auto double_val = + BsonView::GetNthElementInArray(arr.view().data(), 3); + EXPECT_TRUE(double_val.has_value()); + EXPECT_DOUBLE_EQ(double_val.value(), 3.14159); + + // Test out of bounds + auto out_of_bounds = + BsonView::GetNthElementInArray(arr.view().data(), 10); + EXPECT_FALSE(out_of_bounds.has_value()); + + // Test invalid type conversion + auto invalid_type = + BsonView::GetNthElementInArray(arr.view().data(), 1); + EXPECT_FALSE(invalid_type.has_value()); +} + +TEST_F(BsonViewTest, ParseBsonFieldTest) { + // Create a simple BSON document + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("test_field", "test_value")); + + BsonView view(doc.view().data(), doc.view().length()); + + // Test field parsing + auto field = view.ParseBsonField(doc.view().data(), 4); + EXPECT_EQ(field.type, bsoncxx::type::k_string); + EXPECT_EQ(field.key, "test_field"); + EXPECT_NE(field.value_ptr, nullptr); +} + +TEST_F(BsonViewTest, GetValueFromElementTest) { + // Create a BSON document with various types + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("int32_field", 42)); + doc.append(bsoncxx::builder::basic::kvp("double_field", 3.14159)); + doc.append(bsoncxx::builder::basic::kvp("bool_field", true)); + doc.append(bsoncxx::builder::basic::kvp("string_field", "test string")); + + auto view = doc.view(); + + // Test int32 + auto int32_val = + BsonView::GetValueFromElement(view["int32_field"]); + EXPECT_TRUE(int32_val.has_value()); + EXPECT_EQ(int32_val.value(), 42); + + // Test double + auto double_val = + BsonView::GetValueFromElement(view["double_field"]); + EXPECT_TRUE(double_val.has_value()); + EXPECT_DOUBLE_EQ(double_val.value(), 3.14159); + + // Test bool + auto bool_val = BsonView::GetValueFromElement(view["bool_field"]); + EXPECT_TRUE(bool_val.has_value()); + EXPECT_TRUE(bool_val.value()); + + // Test string + auto string_val = + BsonView::GetValueFromElement(view["string_field"]); + EXPECT_TRUE(string_val.has_value()); + EXPECT_EQ(string_val.value(), "test string"); + + // Test string_view + auto string_view_val = + BsonView::GetValueFromElement(view["string_field"]); + EXPECT_TRUE(string_view_val.has_value()); + EXPECT_EQ(string_view_val.value(), "test string"); + + // Test invalid type conversion + auto invalid_val = + BsonView::GetValueFromElement(view["int32_field"]); + EXPECT_FALSE(invalid_val.has_value()); +} + +TEST_F(BsonViewTest, GetValueFromBsonViewTest) { + // Create a BSON document with various types + bsoncxx::builder::basic::document doc; + doc.append(bsoncxx::builder::basic::kvp("int32_field", 42)); + doc.append(bsoncxx::builder::basic::kvp("double_field", 3.14159)); + doc.append(bsoncxx::builder::basic::kvp("bool_field", true)); + doc.append(bsoncxx::builder::basic::kvp("string_field", "test string")); + + auto view = doc.view(); + + // Test int32 + auto int32_val = BsonView::GetValueFromBsonView( + view["int32_field"].get_value()); + EXPECT_TRUE(int32_val.has_value()); + EXPECT_EQ(int32_val.value(), 42); + + // Test double + auto double_val = BsonView::GetValueFromBsonView( + view["double_field"].get_value()); + EXPECT_TRUE(double_val.has_value()); + EXPECT_DOUBLE_EQ(double_val.value(), 3.14159); + + // Test bool + auto bool_val = + BsonView::GetValueFromBsonView(view["bool_field"].get_value()); + EXPECT_TRUE(bool_val.has_value()); + EXPECT_TRUE(bool_val.value()); + + // Test string + auto string_val = BsonView::GetValueFromBsonView( + view["string_field"].get_value()); + EXPECT_TRUE(string_val.has_value()); + EXPECT_EQ(string_val.value(), "test string"); + + // Test string_view + auto string_view_val = BsonView::GetValueFromBsonView( + view["string_field"].get_value()); + EXPECT_TRUE(string_view_val.has_value()); + EXPECT_EQ(string_view_val.value(), "test string"); + + // Test invalid type conversion + auto invalid_val = BsonView::GetValueFromBsonView( + view["int32_field"].get_value()); + EXPECT_FALSE(invalid_val.has_value()); +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/unittest/test_json_stats/test_json_key_stats.cpp b/internal/core/unittest/test_json_stats/test_json_key_stats.cpp new file mode 100644 index 0000000000..81a6b71251 --- /dev/null +++ b/internal/core/unittest/test_json_stats/test_json_key_stats.cpp @@ -0,0 +1,562 @@ +// Copyright(C) 2019 - 2020 Zilliz.All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software distributed under the License +// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +// or implied. See the License for the specific language governing permissions and limitations under the License + +#include +#include +#include +#include +#include +#include + +#include "common/Tracer.h" +#include "index/BitmapIndex.h" +#include "storage/Util.h" +#include "storage/InsertData.h" +#include "indexbuilder/IndexFactory.h" +#include "index/IndexFactory.h" +#include "index/Meta.h" +#include "index/json_stats/JsonKeyStats.h" +#include "common/Json.h" +#include "common/Types.h" + +using namespace milvus::index; +using namespace milvus::indexbuilder; +using namespace milvus; +using namespace milvus::index; + +int64_t +GenerateRandomInt64(int64_t min, int64_t max) { + static std::random_device rd; + static std::mt19937_64 gen(rd()); + + std::uniform_int_distribution dist(min, max); + return dist(gen); +} + +static std::vector +GenerateJsons(int size) { + std::vector jsons; + std::default_random_engine random(42); + std::normal_distribution<> distr(0, 1); + for (int i = 0; i < size; i++) { + std::string str; + if (i % 10 < 2) { + str = R"({"int_shared":)" + std::to_string(random()) + + R"(,"double_shared":)" + + std::to_string(static_cast(random())) + + R"(,"string_shared":")" + std::to_string(random()) + + R"(","bool_shared": true)" + R"(, "array_shared": [1,2,3])" + + "}"; + } else { + str = R"({"int":)" + std::to_string(random()) + R"(,"double":)" + + std::to_string(static_cast(random())) + + R"(,"string":")" + std::to_string(random()) + + R"(","bool": true)" + R"(, "array": [1,2,3])" + "}"; + } + jsons.push_back(milvus::Json(simdjson::padded_string(str))); + } + return jsons; +} + +class JsonKeyStatsTest : public ::testing::TestWithParam { + protected: + void + Init(int64_t collection_id, + int64_t partition_id, + int64_t segment_id, + int64_t field_id, + int64_t index_build_id, + int64_t index_version, + int64_t size) { + proto::schema::FieldSchema field_schema; + field_schema.set_data_type(proto::schema::DataType::JSON); + field_schema.set_nullable(nullable_); + auto field_meta = storage::FieldDataMeta{ + collection_id, partition_id, segment_id, field_id, field_schema}; + auto index_meta = storage::IndexMeta{ + segment_id, field_id, index_build_id, index_version}; + + data_ = std::move(GenerateJsons(size)); + auto field_data = storage::CreateFieldData(DataType::JSON, nullable_); + if (nullable_) { + valid_data.reserve(size_); + for (size_t i = 0; i < size_; i++) { + if (i % 2 == 0) { + valid_data.push_back(true); + } else { + valid_data.push_back(false); + } + } + + int byteSize = (size_ + 7) / 8; + uint8_t* valid_data_ = new uint8_t[byteSize]; + for (int i = 0; i < size_; i++) { + bool value = valid_data[i]; + int byteIndex = i / 8; + int bitIndex = i % 8; + if (value) { + valid_data_[byteIndex] |= (1 << bitIndex); + } else { + valid_data_[byteIndex] &= ~(1 << bitIndex); + } + } + field_data->FillFieldData( + data_.data(), valid_data_, data_.size(), 0); + delete[] valid_data_; + } else { + field_data->FillFieldData(data_.data(), data_.size()); + } + + auto payload_reader = + std::make_shared(field_data); + storage::InsertData insert_data(payload_reader); + insert_data.SetFieldDataMeta(field_meta); + insert_data.SetTimestamps(0, 100); + + auto serialized_bytes = insert_data.Serialize(storage::Remote); + + auto log_path = fmt::format("/{}/{}/{}/{}/{}/{}", + "/tmp/test-jsonkey-stats/", + collection_id, + partition_id, + segment_id, + field_id, + 0); + chunk_manager_->Write( + log_path, serialized_bytes.data(), serialized_bytes.size()); + + storage::FileManagerContext ctx(field_meta, index_meta, chunk_manager_); + std::vector index_files; + + Config config; + config[INSERT_FILES_KEY] = std::vector{log_path}; + + auto build_index = std::make_shared(ctx, false); + build_index->Build(config); + + auto create_index_result = build_index->Upload(config); + auto memSize = create_index_result->GetMemSize(); + auto serializedSize = create_index_result->GetSerializedSize(); + ASSERT_GT(memSize, 0); + ASSERT_GT(serializedSize, 0); + index_files = create_index_result->GetIndexFiles(); + + index::CreateIndexInfo index_info{}; + config["index_files"] = index_files; + config[milvus::LOAD_PRIORITY] = + milvus::proto::common::LoadPriority::HIGH; + config[milvus::index::ENABLE_MMAP] = true; + config[milvus::index::MMAP_FILE_PATH] = + "/tmp/test-jsonkey-stats/mmap-file"; + index_ = std::make_shared(ctx, true); + index_->Load(milvus::tracer::TraceContext{}, config); + } + + void + SetUp() override { + nullable_ = GetParam(); + type_ = DataType::JSON; + int64_t collection_id = 1; + int64_t partition_id = 2; + int64_t segment_id = 3; + int64_t field_id = 101; + int64_t index_build_id = GenerateRandomInt64(1, 100000); + int64_t index_version = 1; + size_ = 1000; // Use a larger size for better testing + std::string root_path = "/tmp/test-jsonkey-stats/"; + + storage::StorageConfig storage_config; + storage_config.storage_type = "local"; + storage_config.root_path = root_path; + chunk_manager_ = storage::CreateChunkManager(storage_config); + + auto conf = milvus_storage::ArrowFileSystemConfig(); + conf.storage_type = "local"; + conf.root_path = "/tmp/test-jsonkey-stats/arrow-fs"; + milvus_storage::ArrowFileSystemSingleton::GetInstance().Init(conf); + + Init(collection_id, + partition_id, + segment_id, + field_id, + index_build_id, + index_version, + size_); + } + + virtual ~JsonKeyStatsTest() override { + boost::filesystem::remove_all(chunk_manager_->GetRootPath()); + } + + public: + std::shared_ptr index_; + DataType type_; + bool nullable_; + size_t size_; + FixedVector valid_data; + std::vector data_; + std::vector json_col; + std::shared_ptr chunk_manager_; +}; + +INSTANTIATE_TEST_SUITE_P(JsonKeyStatsTestSuite, + JsonKeyStatsTest, + ::testing::Values(true, false)); + +TEST_P(JsonKeyStatsTest, TestBasicOperations) { + // Test Count + EXPECT_EQ(index_->Count(), size_); + + // Test Size + EXPECT_EQ(index_->Size(), size_); + + // Test HasRawData + EXPECT_FALSE(index_->HasRawData()); +} + +TEST_P(JsonKeyStatsTest, TestExecuteForSharedData) { + std::string path = "/int_shared"; + int count = 0; + index_->ExecuteForSharedData( + path, + [&](BsonView bson, uint32_t row_id, uint32_t offset) { count++; }); + std::cout << "count: " << count << std::endl; + if (nullable_) { + EXPECT_EQ(count, 100); + } else { + EXPECT_EQ(count, 200); + } +} + +TEST_P(JsonKeyStatsTest, TestExecuteExistsPathForSharedData) { + std::string path = "/int_shared"; + TargetBitmap bitset(size_); + TargetBitmapView bitset_view(bitset); + index_->ExecuteExistsPathForSharedData(path, bitset_view); + std::cout << "bitset.count(): " << bitset.count() << std::endl; + auto count = bitset.count(); + if (nullable_) { + EXPECT_EQ(count, 100); + } else { + EXPECT_EQ(count, 200); + } +} + +TEST_P(JsonKeyStatsTest, TestExecutorForGettingValid) { + std::string path = "/int"; + TargetBitmap valid_res(size_, true); + TargetBitmapView valid_res_view(valid_res); + auto shredding_fields = index_->GetShreddingFields(path); + for (const auto& field : shredding_fields) { + auto processed_size = + index_->ExecutorForGettingValid(field, valid_res_view); + EXPECT_EQ(processed_size, size_); + } + if (!index_->CanSkipShared(path)) { + std::cout << "can not skip shared" << std::endl; + index_->ExecuteExistsPathForSharedData(path, valid_res_view); + } + std::cout << "valid_res.count(): " << valid_res.count() << std::endl; + if (nullable_) { + EXPECT_EQ(valid_res.count(), 400); + } else { + EXPECT_EQ(valid_res.count(), 800); + } +} + +TEST_P(JsonKeyStatsTest, TestExecutorForShreddingData) { + std::string path = "/int"; + TargetBitmap res(size_); + TargetBitmap valid_res(size_, true); + TargetBitmapView res_view(res); + TargetBitmapView valid_res_view(valid_res); + + auto func = [](const int64_t* data, + const bool* valid_data, + const int size, + TargetBitmapView res, + TargetBitmapView valid_res) { + for (int i = 0; i < size; i++) { + if (valid_data[i]) { + res[i] = true; + valid_res[i] = true; + } + } + }; + + auto field_name = *(index_->GetShreddingFields(path).begin()); + std::cout << "field_name: " << field_name << std::endl; + int processed_size = index_->ExecutorForShreddingData( + field_name, func, nullptr, res_view, valid_res_view); + std::cout << "processed_size: " << processed_size << std::endl; + EXPECT_EQ(processed_size, size_); + + if (nullable_) { + EXPECT_EQ(res.count(), 400); + } else { + EXPECT_EQ(res.count(), 800); + } +} + +TEST_P(JsonKeyStatsTest, TestGetShreddingFields) { + std::string pointer = "/int"; + auto fields = index_->GetShreddingFields(pointer); + EXPECT_FALSE(fields.empty()); + + std::vector types = {JSONType::INT64}; + auto typed_fields = index_->GetShreddingFields(pointer, types); + EXPECT_FALSE(typed_fields.empty()); +} + +TEST_P(JsonKeyStatsTest, TestCanSkipShared) { + std::string path = "/int"; + std::set target_types = {JSONType::INT64}; + EXPECT_TRUE(index_->CanSkipShared(path, target_types)); + + target_types = {JSONType::STRING}; + EXPECT_TRUE(index_->CanSkipShared(path, target_types)); +} + +class JsonKeyStatsUploadLoadTest : public ::testing::Test { + protected: + void + SetUp() override { + collection_id_ = 1; + partition_id_ = 2; + segment_id_ = 3; + field_id_ = 101; + index_build_id_ = GenerateRandomInt64(1, 100000); + index_version_ = 10000; + root_path_ = "/tmp/test-jsonkey-stats-upload-load/"; + + storage::StorageConfig storage_config; + storage_config.storage_type = "local"; + storage_config.root_path = root_path_; + chunk_manager_ = storage::CreateChunkManager(storage_config); + + auto conf = milvus_storage::ArrowFileSystemConfig(); + conf.storage_type = "local"; + conf.root_path = "/tmp/test-jsonkey-stats-upload-load/arrow-fs"; + milvus_storage::ArrowFileSystemSingleton::GetInstance().Init(conf); + } + + void + TearDown() override { + boost::filesystem::remove_all(chunk_manager_->GetRootPath()); + } + + void + InitContext() { + proto::schema::FieldSchema field_schema; + field_schema.set_data_type(proto::schema::DataType::JSON); + field_schema.set_nullable(false); + field_meta_ = storage::FieldDataMeta{collection_id_, + partition_id_, + segment_id_, + field_id_, + field_schema}; + index_meta_ = storage::IndexMeta{ + segment_id_, field_id_, index_build_id_, index_version_}; + } + + void + PrepareData(const std::vector& json_strings) { + data_.clear(); + for (const auto& str : json_strings) { + data_.push_back(milvus::Json(simdjson::padded_string(str))); + } + } + + void + BuildAndUpload() { + auto field_data = storage::CreateFieldData(DataType::JSON, false); + field_data->FillFieldData(data_.data(), data_.size()); + + auto payload_reader = + std::make_shared(field_data); + storage::InsertData insert_data(payload_reader); + insert_data.SetFieldDataMeta(field_meta_); + insert_data.SetTimestamps(0, 100); + + auto serialized_bytes = insert_data.Serialize(storage::Remote); + + auto log_path = fmt::format("/{}/{}/{}/{}/{}/{}", + root_path_, + collection_id_, + partition_id_, + segment_id_, + field_id_, + 0); + chunk_manager_->Write( + log_path, serialized_bytes.data(), serialized_bytes.size()); + + storage::FileManagerContext ctx( + field_meta_, index_meta_, chunk_manager_); + + Config config; + config[INSERT_FILES_KEY] = std::vector{log_path}; + + build_index_ = std::make_shared(ctx, false); + build_index_->Build(config); + + auto create_index_result = build_index_->Upload(config); + auto memSize = create_index_result->GetMemSize(); + auto serializedSize = create_index_result->GetSerializedSize(); + ASSERT_GT(memSize, 0); + ASSERT_GT(serializedSize, 0); + index_files_ = create_index_result->GetIndexFiles(); + } + + void + Load() { + storage::FileManagerContext ctx( + field_meta_, index_meta_, chunk_manager_); + Config config; + config["index_files"] = index_files_; + config[milvus::index::ENABLE_MMAP] = true; + config[milvus::index::MMAP_FILE_PATH] = + "/tmp/test-jsonkey-stats-upload-load/mmap-file"; + config[milvus::LOAD_PRIORITY] = + milvus::proto::common::LoadPriority::HIGH; + load_index_ = std::make_shared(ctx, true); + load_index_->Load(milvus::tracer::TraceContext{}, config); + } + + void + VerifyBasicOperations() { + EXPECT_EQ(load_index_->Count(), data_.size()); + EXPECT_EQ(load_index_->Size(), data_.size()); + EXPECT_FALSE(load_index_->HasRawData()); + } + + void + VerifyPathInShared(const std::string& path) { + TargetBitmap bitset(data_.size()); + TargetBitmapView bitset_view(bitset); + load_index_->ExecuteExistsPathForSharedData(path, bitset_view); + EXPECT_GT(bitset.size(), 0); + } + + void + VerifyPathInShredding(const std::string& path) { + auto fields = load_index_->GetShreddingFields(path); + EXPECT_GT(fields.size(), 0); + } + + void + VerifyJsonType(const std::string& path, JSONType expected_type) { + auto type = load_index_->GetShreddingJsonType(path); + EXPECT_EQ(int(type), int(expected_type)); + } + + public: + int64_t collection_id_; + int64_t partition_id_; + int64_t segment_id_; + int64_t field_id_; + int64_t index_build_id_; + int64_t index_version_; + std::string root_path_; + storage::FieldDataMeta field_meta_; + storage::IndexMeta index_meta_; + std::vector data_; + std::shared_ptr chunk_manager_; + std::shared_ptr build_index_; + std::shared_ptr load_index_; + std::vector index_files_; +}; + +TEST_F(JsonKeyStatsUploadLoadTest, TestSimpleJson) { + std::vector json_strings = { + R"({"int": 1, "double": 1.5, "string": "test", "bool": true})", + R"({"int": 2, "double": 2.5, "string": "test2", "bool": false})", + R"({"int": 3, "double": 3.5, "string": "test3", "bool": true})"}; + + InitContext(); + PrepareData(json_strings); + BuildAndUpload(); + Load(); + + VerifyBasicOperations(); + VerifyPathInShredding("/int"); + VerifyPathInShredding("/double"); + VerifyPathInShredding("/string"); + VerifyPathInShredding("/bool"); + VerifyJsonType("/int_INT64", JSONType::INT64); + VerifyJsonType("/double_DOUBLE", JSONType::DOUBLE); + VerifyJsonType("/string_STRING", JSONType::STRING); + VerifyJsonType("/bool_BOOL", JSONType::BOOL); +} + +TEST_F(JsonKeyStatsUploadLoadTest, TestNestedJson) { + std::vector json_strings = { + R"({"nested": {"int": 1, "double": 1.5}, "array": [1, 2, 3]})", + R"({"nested": {"int": 2, "double": 2.5}, "array": [4, 5, 6]})", + R"({"nested": {"int": 3, "double": 3.5}, "array": [7, 8, 9]})"}; + + InitContext(); + PrepareData(json_strings); + BuildAndUpload(); + Load(); + + VerifyBasicOperations(); + VerifyPathInShredding("/nested/int"); + VerifyPathInShredding("/nested/double"); + VerifyPathInShared("/array"); + VerifyJsonType("/nested/int_INT64", JSONType::INT64); + VerifyJsonType("/nested/double_DOUBLE", JSONType::DOUBLE); +} + +TEST_F(JsonKeyStatsUploadLoadTest, TestComplexJson) { + std::vector json_strings = { + R"({ + "user": { + "id": 1, + "name": "John", + "scores": [85, 90, 95], + "address": { + "city": "New York", + "zip": 10001 + } + }, + "timestamp": 1234567890 + })", + R"({ + "user": { + "id": 2, + "name": "Jane", + "scores": [88, 92, 98], + "address": { + "city": "Los Angeles", + "zip": 90001 + } + }, + "timestamp": 1234567891 + })"}; + + InitContext(); + PrepareData(json_strings); + BuildAndUpload(); + Load(); + + VerifyBasicOperations(); + VerifyPathInShredding("/user/id"); + VerifyPathInShredding("/user/name"); + VerifyPathInShared("/user/scores"); + VerifyPathInShredding("/user/address/city"); + VerifyPathInShredding("/user/address/zip"); + VerifyPathInShredding("/timestamp"); + VerifyJsonType("/user/id_INT64", JSONType::INT64); + VerifyJsonType("/user/name_STRING", JSONType::STRING); + VerifyJsonType("/user/address/city_STRING", JSONType::STRING); + VerifyJsonType("/user/address/zip_INT64", JSONType::INT64); + VerifyJsonType("/timestamp_INT64", JSONType::INT64); +} \ No newline at end of file diff --git a/internal/core/unittest/test_json_stats/test_parquet_writer.cpp b/internal/core/unittest/test_json_stats/test_parquet_writer.cpp new file mode 100644 index 0000000000..a408ecfceb --- /dev/null +++ b/internal/core/unittest/test_json_stats/test_parquet_writer.cpp @@ -0,0 +1,108 @@ +#include +#include "index/json_stats/parquet_writer.h" +#include +#include +#include +#include +#include +#include +#include + +namespace milvus::index { +class ParquetWriterFactoryTest : public ::testing::Test { + protected: + void + SetUp() override { + // Setup test column map + column_map_ = { + {JsonKey("int_key", JSONType::INT64), JsonKeyLayoutType::DYNAMIC}, + {JsonKey("string_key", JSONType::STRING), + JsonKeyLayoutType::DYNAMIC}, + {JsonKey("double_key", JSONType::DOUBLE), JsonKeyLayoutType::TYPED}, + {JsonKey("bool_key", JSONType::BOOL), JsonKeyLayoutType::TYPED}, + {JsonKey("shared_key", JSONType::STRING), + JsonKeyLayoutType::SHARED}}; + + path_prefix_ = "test_prefix"; + } + + std::map column_map_; + std::string path_prefix_; +}; + +TEST_F(ParquetWriterFactoryTest, ColumnGroupingStrategyFactoryTest) { + // Test creating default strategy + auto default_strategy = ColumnGroupingStrategyFactory::CreateStrategy( + ColumnGroupingStrategyType::DEFAULT); + EXPECT_NE(default_strategy, nullptr); + + // Test creating with invalid type + EXPECT_THROW(ColumnGroupingStrategyFactory::CreateStrategy( + static_cast(999)), + std::runtime_error); +} + +TEST_F(ParquetWriterFactoryTest, CreateContextBasicTest) { + // Test creating context with basic column map + auto context = + ParquetWriterFactory::CreateContext(column_map_, path_prefix_); + + // Verify schema + EXPECT_NE(context.schema, nullptr); + EXPECT_EQ(context.schema->num_fields(), column_map_.size()); + + // Verify builders + EXPECT_FALSE(context.builders.empty()); + EXPECT_FALSE(context.builders_map.empty()); + EXPECT_EQ(context.builders.size(), column_map_.size()); + EXPECT_EQ(context.builders_map.size(), column_map_.size()); + + // Verify metadata + EXPECT_FALSE(context.kv_metadata.empty()); + + // Verify column groups + EXPECT_FALSE(context.column_groups.empty()); + + // Verify file paths + EXPECT_FALSE(context.file_paths.empty()); + EXPECT_EQ(context.file_paths.size(), context.column_groups.size()); +} + +TEST_F(ParquetWriterFactoryTest, CreateContextWithSharedFields) { + // Test creating context with shared fields + std::map shared_map = { + {JsonKey("shared_key1", JSONType::STRING), JsonKeyLayoutType::SHARED}, + {JsonKey("shared_key2", JSONType::STRING), JsonKeyLayoutType::SHARED}, + {JsonKey("normal_key", JSONType::INT64), JsonKeyLayoutType::TYPED}}; + + auto context = + ParquetWriterFactory::CreateContext(shared_map, path_prefix_); + + // Verify schema includes shared fields + EXPECT_NE(context.schema, nullptr); + EXPECT_EQ(context.schema->num_fields(), 2); + + EXPECT_EQ(context.builders_map.size(), 3); +} + +TEST_F(ParquetWriterFactoryTest, CreateContextWithColumnGroups) { + // Test creating context and verify column grouping + auto context = + ParquetWriterFactory::CreateContext(column_map_, path_prefix_); + + // Verify column groups are created + EXPECT_FALSE(context.column_groups.empty()); + + // Verify each column is assigned to a group + std::set group_ids; + for (const auto& group : context.column_groups) { + for (const auto& col_idx : group) { + group_ids.insert(col_idx); + } + } + + // All columns should be assigned to a group + EXPECT_EQ(group_ids.size(), column_map_.size()); +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/unittest/test_json_stats/test_utils.cpp b/internal/core/unittest/test_json_stats/test_utils.cpp new file mode 100644 index 0000000000..ef90d83efb --- /dev/null +++ b/internal/core/unittest/test_json_stats/test_utils.cpp @@ -0,0 +1,70 @@ +#include +#include "index/json_stats/utils.h" +#include +#include +#include +#include + +namespace milvus::index { + +class UtilsTest : public ::testing::Test { + protected: + void + SetUp() override { + } +}; + +TEST_F(UtilsTest, CreateSharedArrowBuilderTest) { + auto builder = CreateSharedArrowBuilder(); + EXPECT_NE(builder, nullptr); + EXPECT_EQ(builder->type()->id(), arrow::Type::BINARY); +} + +TEST_F(UtilsTest, CreateSharedArrowFieldTest) { + auto field = CreateSharedArrowField("test_field", 1); + EXPECT_NE(field, nullptr); + EXPECT_EQ(field->name(), "test_field"); + EXPECT_EQ(field->type()->id(), arrow::Type::BINARY); + EXPECT_TRUE(field->nullable()); + EXPECT_TRUE(field->HasMetadata()); +} + +TEST_F(UtilsTest, CreateArrowBuildersTest) { + std::map column_map = { + {JsonKey("int_key", JSONType::INT64), JsonKeyLayoutType::TYPED}, + {JsonKey("string_key", JSONType::STRING), JsonKeyLayoutType::DYNAMIC}, + {JsonKey("double_key", JSONType::DOUBLE), JsonKeyLayoutType::TYPED}, + {JsonKey("bool_key", JSONType::BOOL), JsonKeyLayoutType::TYPED}, + {JsonKey("shared_key", JSONType::STRING), JsonKeyLayoutType::SHARED}}; + + auto [builders, builders_map] = CreateArrowBuilders(column_map); + EXPECT_EQ(builders.size(), column_map.size()); + EXPECT_EQ(builders_map.size(), column_map.size()); + + auto schema = CreateArrowSchema(column_map); + EXPECT_NE(schema, nullptr); + EXPECT_EQ(schema->num_fields(), column_map.size()); +} + +TEST_F(UtilsTest, CreateParquetKVMetadataTest) { + std::map column_map = { + {JsonKey("int_key", JSONType::INT64), JsonKeyLayoutType::TYPED}, + {JsonKey("string_key", JSONType::STRING), JsonKeyLayoutType::DYNAMIC}, + {JsonKey("double_key", JSONType::DOUBLE), JsonKeyLayoutType::TYPED}, + {JsonKey("bool_key", JSONType::BOOL), JsonKeyLayoutType::TYPED}, + {JsonKey("shared_key", JSONType::STRING), JsonKeyLayoutType::SHARED}}; + + auto metadata = CreateParquetKVMetadata(column_map); + EXPECT_FALSE(metadata.empty()); + EXPECT_EQ(metadata.size(), 1); // layout_type + + // Parse and verify layout_type + auto layout_type_json = nlohmann::json::parse(metadata[0].second); + for (const auto& [key, type] : column_map) { + std::string key_with_type = key.key_ + "_" + ToString(key.type_); + EXPECT_TRUE(layout_type_json.contains(key_with_type)); + EXPECT_EQ(layout_type_json[key_with_type], ToString(type)); + } +} + +} // namespace milvus::index \ No newline at end of file diff --git a/internal/core/unittest/test_string_chunk_writer.cpp b/internal/core/unittest/test_string_chunk_writer.cpp new file mode 100644 index 0000000000..cb4b3da4ec --- /dev/null +++ b/internal/core/unittest/test_string_chunk_writer.cpp @@ -0,0 +1,125 @@ +// Copyright (C) 2019-2025 Zilliz. All rights reserved. +// Licensed under the Apache License, Version 2.0 + +#include +#include +#include +#include +#include +#include + +#include "arrow/api.h" +#include "arrow/array/array_binary.h" + +#include "common/Chunk.h" +#include "common/ChunkWriter.h" + +using milvus::StringChunk; +using milvus::StringChunkWriter; + +namespace { + +std::shared_ptr +BuildBinaryArray(const std::vector>& values) { + arrow::BinaryBuilder builder; + for (const auto& v : values) { + if (v.has_value()) { + auto st = + builder.Append(v->data(), static_cast(v->size())); + ASSERT_TRUE(st.ok()); + } else { + auto st = builder.AppendNull(); + ASSERT_TRUE(st.ok()); + } + } + std::shared_ptr arr; + auto st = builder.Finish(&arr); + EXPECT_TRUE(st.ok()); + return std::static_pointer_cast(arr); +} + +} // namespace + +TEST(StringChunkWriterTest, NoNullsMultiBatches) { + // Prepare two batches without nulls + std::vector> b1 = {std::string("a"), + std::string(""), + std::string("hello"), + std::string("world"), + std::string("foobar")}; + std::vector> b2; + for (int i = 0; i < 100; ++i) { + b2.emplace_back(std::string(1 + (i % 7), 'x' + (i % 3))); + } + + auto a1 = BuildBinaryArray(b1); + auto a2 = BuildBinaryArray(b2); + + arrow::ArrayVector vec{a1, a2}; + + StringChunkWriter writer(/*nullable=*/false); + writer.write(vec); + auto chunk_up = writer.finish(); + + auto* chunk = dynamic_cast(chunk_up.get()); + ASSERT_NE(chunk, nullptr); + + // Verify rows and content + int64_t total_rows = static_cast(b1.size() + b2.size()); + EXPECT_EQ(chunk->RowNums(), total_rows); + + for (int64_t i = 0; i < static_cast(b1.size()); ++i) { + auto sv = (*chunk)[static_cast(i)]; + ASSERT_TRUE(chunk->isValid(static_cast(i))); + EXPECT_EQ(sv, b1[static_cast(i)].value()); + } + for (int64_t i = 0; i < static_cast(b2.size()); ++i) { + auto idx = static_cast(b1.size() + i); + auto sv = (*chunk)[idx]; + ASSERT_TRUE(chunk->isValid(idx)); + EXPECT_EQ(sv, b2[static_cast(i)].value()); + } +} + +TEST(StringChunkWriterTest, WithNullsMergedBitmap) { + // Prepare batches with nulls; only verify validity for nulls + std::vector> b1 = { + std::nullopt, + std::string("alpha"), + std::nullopt, + std::string("beta"), + std::string("gamma"), + }; + std::vector> b2 = { + std::string("one"), + std::nullopt, + std::string("two"), + std::string(""), + }; + + auto a1 = BuildBinaryArray(b1); + auto a2 = BuildBinaryArray(b2); + + arrow::ArrayVector vec{a1, a2}; + + StringChunkWriter writer(/*nullable=*/true); + writer.write(vec); + auto chunk_up = writer.finish(); + + auto* chunk = dynamic_cast(chunk_up.get()); + ASSERT_NE(chunk, nullptr); + + // Verify validity and content for non-null entries only + std::vector> all; + all.reserve(b1.size() + b2.size()); + all.insert(all.end(), b1.begin(), b1.end()); + all.insert(all.end(), b2.begin(), b2.end()); + + for (int i = 0; i < static_cast(all.size()); ++i) { + bool expect_valid = all[static_cast(i)].has_value(); + EXPECT_EQ(chunk->isValid(i), expect_valid); + if (expect_valid) { + EXPECT_EQ((*chunk)[i], all[static_cast(i)].value()); + } + } +} diff --git a/internal/datacoord/garbage_collector.go b/internal/datacoord/garbage_collector.go index 98c2df3fbe..a5ebf978cc 100644 --- a/internal/datacoord/garbage_collector.go +++ b/internal/datacoord/garbage_collector.go @@ -196,6 +196,7 @@ func (gc *garbageCollector) work(ctx context.Context) { gc.recycleUnusedAnalyzeFiles(ctx) gc.recycleUnusedTextIndexFiles(ctx) gc.recycleUnusedJSONIndexFiles(ctx) + gc.recycleUnusedJSONStatsFiles(ctx) }) }() go func() { @@ -989,8 +990,106 @@ func (gc *garbageCollector) recycleUnusedTextIndexFiles(ctx context.Context) { metrics.GarbageCollectorRunCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID())).Add(1) } -// recycleUnusedJSONIndexFiles load meta file info and compares OSS keys +// recycleUnusedJSONStatsFiles load meta file info and compares OSS keys // if missing found, performs gc cleanup +func (gc *garbageCollector) recycleUnusedJSONStatsFiles(ctx context.Context) { + start := time.Now() + log := log.Ctx(ctx).With(zap.String("gcName", "recycleUnusedJSONStatsFiles"), zap.Time("startAt", start)) + log.Info("start recycleUnusedJSONStatsFiles...") + defer func() { log.Info("recycleUnusedJSONStatsFiles done", zap.Duration("timeCost", time.Since(start))) }() + + hasJSONStatsSegments := gc.meta.SelectSegments(ctx, SegmentFilterFunc(func(info *SegmentInfo) bool { + return len(info.GetJsonKeyStats()) != 0 + })) + fileNum := 0 + deletedFilesNum := atomic.NewInt32(0) + + for _, seg := range hasJSONStatsSegments { + for _, fieldStats := range seg.GetJsonKeyStats() { + log := log.With(zap.Int64("segmentID", seg.GetID()), zap.Int64("fieldID", fieldStats.GetFieldID())) + // clear low version task + for i := int64(1); i < fieldStats.GetVersion(); i++ { + prefix := fmt.Sprintf("%s/%s/%d/%d/%d/%d/%d/%d/%d", gc.option.cli.RootPath(), common.JSONStatsPath, fieldStats.GetJsonKeyStatsDataFormat(), + fieldStats.GetBuildID(), i, seg.GetCollectionID(), seg.GetPartitionID(), seg.GetID(), fieldStats.GetFieldID()) + futures := make([]*conc.Future[struct{}], 0) + + err := gc.option.cli.WalkWithPrefix(ctx, prefix, true, func(files *storage.ChunkObjectInfo) bool { + file := files.FilePath + + future := gc.option.removeObjectPool.Submit(func() (struct{}, error) { + log := log.With(zap.String("file", file)) + log.Info("garbageCollector recycleUnusedJSONStatsFiles remove file...") + + if err := gc.option.cli.Remove(ctx, file); err != nil { + log.Warn("garbageCollector recycleUnusedJSONStatsFiles remove file failed", zap.Error(err)) + return struct{}{}, err + } + deletedFilesNum.Inc() + log.Info("garbageCollector recycleUnusedJSONStatsFiles remove file success") + return struct{}{}, nil + }) + futures = append(futures, future) + return true + }) + + // Wait for all remove tasks done. + if err := conc.BlockOnAll(futures...); err != nil { + // error is logged, and can be ignored here. + log.Warn("some task failure in remove object pool", zap.Error(err)) + } + + log = log.With(zap.Int("deleteJSONStatsNum", int(deletedFilesNum.Load())), zap.Int("walkFileNum", fileNum)) + if err != nil { + log.Warn("json stats files recycle failed when walk with prefix", zap.Error(err)) + return + } + } + + // clear low data format version stats file + // for upgrade from old version to new version, we need to clear the old data format version stats file + for i := int64(1); i < fieldStats.GetJsonKeyStatsDataFormat(); i++ { + prefix := fmt.Sprintf("%s/%s/%d", gc.option.cli.RootPath(), common.JSONStatsPath, i) + futures := make([]*conc.Future[struct{}], 0) + + err := gc.option.cli.WalkWithPrefix(ctx, prefix, true, func(files *storage.ChunkObjectInfo) bool { + file := files.FilePath + + future := gc.option.removeObjectPool.Submit(func() (struct{}, error) { + log := log.With(zap.String("file", file)) + log.Info("garbageCollector recycleUnusedJSONStatsFiles remove file...") + + if err := gc.option.cli.Remove(ctx, file); err != nil { + log.Warn("garbageCollector recycleUnusedJSONStatsFiles remove file failed", zap.Error(err)) + return struct{}{}, err + } + deletedFilesNum.Inc() + log.Info("garbageCollector recycleUnusedJSONStatsFiles remove file success") + return struct{}{}, nil + }) + futures = append(futures, future) + return true + }) + + // Wait for all remove tasks done. + if err := conc.BlockOnAll(futures...); err != nil { + // error is logged, and can be ignored here. + log.Warn("some task failure in remove object pool", zap.Error(err)) + } + + log = log.With(zap.Int("deleteJSONStatsLowerDataFormatNum", int(deletedFilesNum.Load())), zap.Int("walkFileNum", fileNum)) + if err != nil { + log.Warn("json stats lower data format files recycle failed when walk with prefix", zap.Error(err)) + return + } + } + } + } + log.Info("json stats files recycle done") + + metrics.GarbageCollectorRunCount.WithLabelValues(fmt.Sprint(paramtable.GetNodeID())).Add(1) +} + +// recycleUnusedJSONIndexFiles load meta file info and compares OSS keys func (gc *garbageCollector) recycleUnusedJSONIndexFiles(ctx context.Context) { start := time.Now() log := log.Ctx(ctx).With(zap.String("gcName", "recycleUnusedJSONIndexFiles"), zap.Time("startAt", start)) diff --git a/internal/datacoord/stats_inspector.go b/internal/datacoord/stats_inspector.go index 8a7a632347..098d54b22b 100644 --- a/internal/datacoord/stats_inspector.go +++ b/internal/datacoord/stats_inspector.go @@ -27,6 +27,7 @@ import ( "github.com/milvus-io/milvus/internal/datacoord/allocator" "github.com/milvus-io/milvus/internal/datacoord/task" + "github.com/milvus-io/milvus/pkg/v2/common" "github.com/milvus-io/milvus/pkg/v2/log" "github.com/milvus-io/milvus/pkg/v2/proto/datapb" "github.com/milvus-io/milvus/pkg/v2/proto/indexpb" @@ -173,6 +174,11 @@ func needDoJsonKeyIndex(segment *SegmentInfo, fieldIDs []UniqueID) bool { if segment.GetJsonKeyStats()[fieldID] == nil { return true } + // if the data format version is less than the current version, we need to do the stats task again + // because the data format is updated, the old data format need to be converted to the new data format + if segment.GetJsonKeyStats()[fieldID].GetJsonKeyStatsDataFormat() < common.JSONStatsDataFormatVersion { + return true + } } return false } diff --git a/internal/datacoord/task_stats.go b/internal/datacoord/task_stats.go index b53eb03b5c..8762d6180b 100644 --- a/internal/datacoord/task_stats.go +++ b/internal/datacoord/task_stats.go @@ -27,6 +27,7 @@ import ( "github.com/milvus-io/milvus/internal/datacoord/allocator" "github.com/milvus-io/milvus/internal/datacoord/session" globalTask "github.com/milvus-io/milvus/internal/datacoord/task" + "github.com/milvus-io/milvus/pkg/v2/common" "github.com/milvus-io/milvus/pkg/v2/log" "github.com/milvus-io/milvus/pkg/v2/proto/indexpb" "github.com/milvus-io/milvus/pkg/v2/proto/workerpb" @@ -330,13 +331,15 @@ func (st *statsTask) prepareJobRequest(ctx context.Context, segment *SegmentInfo EndLogID: end, NumRows: segment.GetNumOfRows(), // update version after check - TaskVersion: st.GetVersion(), - EnableJsonKeyStats: Params.CommonCfg.EnabledJSONKeyStats.GetAsBool(), - JsonKeyStatsTantivyMemory: Params.DataCoordCfg.JSONKeyStatsMemoryBudgetInTantivy.GetAsInt64(), - JsonKeyStatsDataFormat: 1, - TaskSlot: st.taskSlot, - StorageVersion: segment.StorageVersion, - CurrentScalarIndexVersion: st.ievm.GetCurrentScalarIndexEngineVersion(), + TaskVersion: st.GetVersion(), + EnableJsonKeyStats: Params.CommonCfg.EnabledJSONKeyStats.GetAsBool(), + JsonKeyStatsDataFormat: common.JSONStatsDataFormatVersion, + TaskSlot: st.taskSlot, + StorageVersion: segment.StorageVersion, + CurrentScalarIndexVersion: st.ievm.GetCurrentScalarIndexEngineVersion(), + JsonStatsMaxShreddingColumns: Params.DataCoordCfg.JSONStatsMaxShreddingColumns.GetAsInt64(), + JsonStatsShreddingRatioThreshold: Params.DataCoordCfg.JSONStatsShreddingRatioThreshold.GetAsFloat(), + JsonStatsWriteBatchSize: Params.DataCoordCfg.JSONStatsWriteBatchSize.GetAsInt64(), } WrapPluginContext(segment.GetCollectionID(), collInfo.Schema.GetProperties(), req) diff --git a/internal/datanode/index/task_manager_test.go b/internal/datanode/index/task_manager_test.go index 4771eed25c..5150117553 100644 --- a/internal/datanode/index/task_manager_test.go +++ b/internal/datanode/index/task_manager_test.go @@ -22,6 +22,7 @@ import ( "github.com/stretchr/testify/suite" + "github.com/milvus-io/milvus/pkg/v2/common" "github.com/milvus-io/milvus/pkg/v2/proto/datapb" "github.com/milvus-io/milvus/pkg/v2/proto/indexpb" ) @@ -102,7 +103,7 @@ func (s *statsTaskInfoSuite) Test_Methods() { Files: []string{"file1"}, LogSize: 1024, MemorySize: 1024, - JsonKeyStatsDataFormat: 1, + JsonKeyStatsDataFormat: common.JSONStatsDataFormatVersion, }, }) }) diff --git a/internal/datanode/index/task_stats.go b/internal/datanode/index/task_stats.go index f0068e4db5..8d895aa8c2 100644 --- a/internal/datanode/index/task_stats.go +++ b/internal/datanode/index/task_stats.go @@ -73,6 +73,13 @@ type statsTask struct { currentTime time.Time } +type BuildIndexOptions struct { + TantivyMemory int64 + JsonStatsMaxShreddingColumns int64 + JsonStatsShreddingRatio float64 + JsonStatsWriteBatchSize int64 +} + func NewStatsTask(ctx context.Context, cancel context.CancelFunc, req *workerpb.CreateStatsRequest, @@ -337,9 +344,11 @@ func (st *statsTask) Execute(ctx context.Context) error { st.req.GetTargetSegmentID(), st.req.GetTaskVersion(), st.req.GetTaskID(), - st.req.GetJsonKeyStatsTantivyMemory(), st.req.GetJsonKeyStatsDataFormat(), - insertLogs) + insertLogs, + st.req.GetJsonStatsMaxShreddingColumns(), + st.req.GetJsonStatsShreddingRatioThreshold(), + st.req.GetJsonStatsWriteBatchSize()) if err != nil { log.Warn("stats wrong, failed to create json index", zap.Error(err)) return err @@ -467,7 +476,7 @@ func (st *statsTask) createTextIndex(ctx context.Context, req := proto.Clone(st.req).(*workerpb.CreateStatsRequest) req.InsertLogs = insertBinlogs - buildIndexParams := buildIndexParams(req, files, field, newStorageConfig, 0) + buildIndexParams := buildIndexParams(req, files, field, newStorageConfig, nil) uploaded, err := indexcgowrapper.CreateTextIndex(ctx, buildIndexParams) if err != nil { @@ -505,20 +514,27 @@ func (st *statsTask) createJSONKeyStats(ctx context.Context, segmentID int64, version int64, taskID int64, - tantivyMemory int64, jsonKeyStatsDataFormat int64, insertBinlogs []*datapb.FieldBinlog, + jsonStatsMaxShreddingColumns int64, + jsonStatsShreddingRatioThreshold float64, + jsonStatsWriteBatchSize int64, ) error { log := log.Ctx(ctx).With( zap.String("clusterID", st.req.GetClusterID()), zap.Int64("taskID", st.req.GetTaskID()), + zap.Int64("version", version), zap.Int64("collectionID", st.req.GetCollectionID()), zap.Int64("partitionID", st.req.GetPartitionID()), zap.Int64("segmentID", st.req.GetSegmentID()), zap.Any("statsJobType", st.req.GetSubJobType()), zap.Int64("jsonKeyStatsDataFormat", jsonKeyStatsDataFormat), + zap.Int64("jsonStatsMaxShreddingColumns", jsonStatsMaxShreddingColumns), + zap.Float64("jsonStatsShreddingRatioThreshold", jsonStatsShreddingRatioThreshold), + zap.Int64("jsonStatsWriteBatchSize", jsonStatsWriteBatchSize), ) - if jsonKeyStatsDataFormat != 1 { + + if jsonKeyStatsDataFormat != common.JSONStatsDataFormatVersion { log.Info("create json key index failed dataformat invalid") return nil } @@ -562,18 +578,29 @@ func (st *statsTask) createJSONKeyStats(ctx context.Context, req := proto.Clone(st.req).(*workerpb.CreateStatsRequest) req.InsertLogs = insertBinlogs - buildIndexParams := buildIndexParams(req, files, field, newStorageConfig, tantivyMemory) + options := &BuildIndexOptions{ + JsonStatsMaxShreddingColumns: jsonStatsMaxShreddingColumns, + JsonStatsShreddingRatio: jsonStatsShreddingRatioThreshold, + JsonStatsWriteBatchSize: jsonStatsWriteBatchSize, + } + buildIndexParams := buildIndexParams(req, files, field, newStorageConfig, options) uploaded, err := indexcgowrapper.CreateJSONKeyStats(ctx, buildIndexParams) if err != nil { return err } + memorySize := int64(0) + for _, file := range uploaded { + memorySize += file + } + jsonKeyIndexStats[field.GetFieldID()] = &datapb.JsonKeyStats{ FieldID: field.GetFieldID(), Version: version, BuildID: taskID, Files: lo.Keys(uploaded), JsonKeyStatsDataFormat: jsonKeyStatsDataFormat, + MemorySize: memorySize, } log.Info("field enable json key index, create json key index done", zap.Int64("field id", field.GetFieldID()), @@ -603,20 +630,26 @@ func buildIndexParams( files []string, field *schemapb.FieldSchema, storageConfig *indexcgopb.StorageConfig, - tantivyMemory int64, + options *BuildIndexOptions, ) *indexcgopb.BuildIndexInfo { + if options == nil { + options = &BuildIndexOptions{} + } + params := &indexcgopb.BuildIndexInfo{ - BuildID: req.GetTaskID(), - CollectionID: req.GetCollectionID(), - PartitionID: req.GetPartitionID(), - SegmentID: req.GetTargetSegmentID(), - IndexVersion: req.GetTaskVersion(), - InsertFiles: files, - FieldSchema: field, - StorageConfig: storageConfig, - CurrentScalarIndexVersion: req.GetCurrentScalarIndexVersion(), - StorageVersion: req.GetStorageVersion(), - JsonKeyStatsTantivyMemory: tantivyMemory, + BuildID: req.GetTaskID(), + CollectionID: req.GetCollectionID(), + PartitionID: req.GetPartitionID(), + SegmentID: req.GetTargetSegmentID(), + IndexVersion: req.GetTaskVersion(), + InsertFiles: files, + FieldSchema: field, + StorageConfig: storageConfig, + CurrentScalarIndexVersion: req.GetCurrentScalarIndexVersion(), + StorageVersion: req.GetStorageVersion(), + JsonStatsMaxShreddingColumns: options.JsonStatsMaxShreddingColumns, + JsonStatsShreddingRatioThreshold: options.JsonStatsShreddingRatio, + JsonStatsWriteBatchSize: options.JsonStatsWriteBatchSize, } if req.GetStorageVersion() == storage.StorageV2 { diff --git a/internal/datanode/index/task_stats_test.go b/internal/datanode/index/task_stats_test.go index b891f72695..9e327ac023 100644 --- a/internal/datanode/index/task_stats_test.go +++ b/internal/datanode/index/task_stats_test.go @@ -191,7 +191,13 @@ func (s *TaskStatsSuite) TestBuildIndexParams() { StorageConfig: &indexpb.StorageConfig{RootPath: "/test/path"}, } - params := buildIndexParams(req, []string{"file1", "file2"}, nil, &indexcgopb.StorageConfig{}, 0) + options := &BuildIndexOptions{ + TantivyMemory: 0, + JsonStatsMaxShreddingColumns: 256, + JsonStatsShreddingRatio: 0.3, + JsonStatsWriteBatchSize: 81920, + } + params := buildIndexParams(req, []string{"file1", "file2"}, nil, &indexcgopb.StorageConfig{}, options) s.Equal(storage.StorageV2, params.StorageVersion) s.NotNil(params.SegmentInsertFiles) diff --git a/internal/parser/planparserv2/plan_parser_v2.go b/internal/parser/planparserv2/plan_parser_v2.go index b6ae5d45af..eaae3c11aa 100644 --- a/internal/parser/planparserv2/plan_parser_v2.go +++ b/internal/parser/planparserv2/plan_parser_v2.go @@ -13,9 +13,11 @@ import ( "github.com/milvus-io/milvus-proto/go-api/v2/schemapb" planparserv2 "github.com/milvus-io/milvus/internal/parser/planparserv2/generated" "github.com/milvus-io/milvus/internal/util/function/rerank" + "github.com/milvus-io/milvus/pkg/v2/common" "github.com/milvus-io/milvus/pkg/v2/log" "github.com/milvus-io/milvus/pkg/v2/proto/planpb" "github.com/milvus-io/milvus/pkg/v2/util/funcutil" + "github.com/milvus-io/milvus/pkg/v2/util/paramtable" "github.com/milvus-io/milvus/pkg/v2/util/typeutil" ) @@ -27,6 +29,23 @@ var ( } ) +type ExprParams struct { + UseJSONStats bool +} + +func ParseExprParams(vals map[string]*schemapb.TemplateValue) *ExprParams { + ep := &ExprParams{ + UseJSONStats: paramtable.Get().CommonCfg.UsingJSONStatsForQuery.GetAsBool(), + } + + if vals != nil { + if v, ok := vals[common.ExprUseJSONStatsKey]; ok && v != nil { + ep.UseJSONStats = v.GetBoolVal() + } + } + return ep +} + func handleInternal(exprStr string) (ast planparserv2.IExprContext, err error) { val, ok := exprCache.Get(exprStr) if ok { @@ -149,12 +168,17 @@ func CreateRetrievePlan(schema *typeutil.SchemaHelper, exprStr string, exprTempl return nil, err } + exprParams := ParseExprParams(exprTemplateValues) + planNode := &planpb.PlanNode{ Node: &planpb.PlanNode_Query{ Query: &planpb.QueryPlanNode{ Predicates: expr, }, }, + PlanOptions: &planpb.PlanOption{ + ExprUseJsonStats: exprParams.UseJSONStats, + }, } return planNode, nil } @@ -222,6 +246,8 @@ func CreateSearchPlan(schema *typeutil.SchemaHelper, exprStr string, vectorField return nil, fmt.Errorf("don't support use segment scorer with group_by or search_iterator") } + exprParams := ParseExprParams(exprTemplateValues) + planNode := &planpb.PlanNode{ Node: &planpb.PlanNode_VectorAnns{ VectorAnns: &planpb.VectorANNS{ @@ -233,6 +259,9 @@ func CreateSearchPlan(schema *typeutil.SchemaHelper, exprStr string, vectorField }, }, Scorers: scorers, + PlanOptions: &planpb.PlanOption{ + ExprUseJsonStats: exprParams.UseJSONStats, + }, } return planNode, nil } diff --git a/internal/querycoordv2/checkers/index_checker.go b/internal/querycoordv2/checkers/index_checker.go index 8eb8fd84b9..83227588a4 100644 --- a/internal/querycoordv2/checkers/index_checker.go +++ b/internal/querycoordv2/checkers/index_checker.go @@ -29,6 +29,7 @@ import ( "github.com/milvus-io/milvus/internal/querycoordv2/session" "github.com/milvus-io/milvus/internal/querycoordv2/task" "github.com/milvus-io/milvus/internal/querycoordv2/utils" + "github.com/milvus-io/milvus/pkg/v2/common" "github.com/milvus-io/milvus/pkg/v2/log" "github.com/milvus-io/milvus/pkg/v2/proto/indexpb" "github.com/milvus-io/milvus/pkg/v2/proto/querypb" @@ -247,17 +248,15 @@ func (c *IndexChecker) checkSegmentStats(segment *meta.Segment, schema *schemapb for _, v := range loadField { loadFieldMap[v] = struct{}{} } - jsonStatsFieldMap := make(map[int64]struct{}) - for _, v := range segment.JSONIndexField { - jsonStatsFieldMap[v] = struct{}{} - } + for _, field := range schema.GetFields() { // Check if the field exists in both loadFieldMap and jsonStatsFieldMap h := typeutil.CreateFieldSchemaHelper(field) + fieldID := field.GetFieldID() if h.EnableJSONKeyStatsIndex() { - if _, ok := loadFieldMap[field.FieldID]; ok { - if _, ok := jsonStatsFieldMap[field.FieldID]; !ok { - result = append(result, field.FieldID) + if _, ok := loadFieldMap[fieldID]; ok { + if info, ok := segment.JSONStatsField[fieldID]; !ok || info.GetDataFormatVersion() < common.JSONStatsDataFormatVersion { + result = append(result, fieldID) } } } diff --git a/internal/querycoordv2/dist/dist_handler.go b/internal/querycoordv2/dist/dist_handler.go index 29db5160c1..d2ea4f9bf4 100644 --- a/internal/querycoordv2/dist/dist_handler.go +++ b/internal/querycoordv2/dist/dist_handler.go @@ -205,7 +205,7 @@ func (dh *distHandler) updateSegmentsDistribution(ctx context.Context, resp *que Version: s.GetVersion(), LastDeltaTimestamp: s.GetLastDeltaTimestamp(), IndexInfo: s.GetIndexInfo(), - JSONIndexField: s.GetFieldJsonIndexStats(), + JSONStatsField: s.GetJsonStatsInfo(), }) } diff --git a/internal/querycoordv2/meta/segment_dist_manager.go b/internal/querycoordv2/meta/segment_dist_manager.go index bf6c1dffd2..5899fd5882 100644 --- a/internal/querycoordv2/meta/segment_dist_manager.go +++ b/internal/querycoordv2/meta/segment_dist_manager.go @@ -125,7 +125,7 @@ type Segment struct { Version int64 // Version is the timestamp of loading segment LastDeltaTimestamp uint64 // The timestamp of the last delta record IndexInfo map[int64]*querypb.FieldIndexInfo // index info of loaded segment, indexID -> FieldIndexInfo - JSONIndexField []int64 // json index info of loaded segment + JSONStatsField map[int64]*querypb.JsonStatsInfo // json index info of loaded segment } func SegmentFromInfo(info *datapb.SegmentInfo) *Segment { diff --git a/internal/querynodev2/segments/load_index_info.go b/internal/querynodev2/segments/load_index_info.go index a055c22fd5..ebe2023c09 100644 --- a/internal/querynodev2/segments/load_index_info.go +++ b/internal/querynodev2/segments/load_index_info.go @@ -124,26 +124,6 @@ func (li *LoadIndexInfo) appendStorageInfo(uri string, version int64) { }).Await() } -// appendIndexData appends index path to cLoadIndexInfo and create index -func (li *LoadIndexInfo) appendIndexData(ctx context.Context, indexKeys []string) error { - for _, indexPath := range indexKeys { - err := li.appendIndexFile(ctx, indexPath) - if err != nil { - return err - } - } - - var status C.CStatus - GetLoadPool().Submit(func() (any, error) { - traceCtx := ParseCTraceContext(ctx) - status = C.AppendIndexV2(traceCtx.ctx, li.cLoadIndexInfo) - runtime.KeepAlive(traceCtx) - return nil, nil - }).Await() - - return HandleCStatus(ctx, &status, "AppendIndex failed") -} - func (li *LoadIndexInfo) appendIndexEngineVersion(ctx context.Context, indexEngineVersion int32) error { cIndexEngineVersion := C.int32_t(indexEngineVersion) diff --git a/internal/querynodev2/segments/mock_segment.go b/internal/querynodev2/segments/mock_segment.go index b6c08bc38f..1bcd6e5903 100644 --- a/internal/querynodev2/segments/mock_segment.go +++ b/internal/querynodev2/segments/mock_segment.go @@ -409,19 +409,19 @@ func (_c *MockSegment_GetBM25Stats_Call) RunAndReturn(run func() map[int64]*stor } // GetFieldJSONIndexStats provides a mock function with no fields -func (_m *MockSegment) GetFieldJSONIndexStats() []int64 { +func (_m *MockSegment) GetFieldJSONIndexStats() map[int64]*querypb.JsonStatsInfo { ret := _m.Called() if len(ret) == 0 { panic("no return value specified for GetFieldJSONIndexStats") } - var r0 []int64 - if rf, ok := ret.Get(0).(func() []int64); ok { + var r0 map[int64]*querypb.JsonStatsInfo + if rf, ok := ret.Get(0).(func() map[int64]*querypb.JsonStatsInfo); ok { r0 = rf() } else { if ret.Get(0) != nil { - r0 = ret.Get(0).([]int64) + r0 = ret.Get(0).(map[int64]*querypb.JsonStatsInfo) } } diff --git a/internal/querynodev2/segments/segment.go b/internal/querynodev2/segments/segment.go index a54d13b8b6..73ad771d24 100644 --- a/internal/querynodev2/segments/segment.go +++ b/internal/querynodev2/segments/segment.go @@ -295,7 +295,7 @@ type LocalSegment struct { lastDeltaTimestamp *atomic.Uint64 fields *typeutil.ConcurrentMap[int64, *FieldInfo] fieldIndexes *typeutil.ConcurrentMap[int64, *IndexedFieldInfo] // indexID -> IndexedFieldInfo - fieldJSONStats []int64 + fieldJSONStats map[int64]*querypb.JsonStatsInfo } func NewSegment(ctx context.Context, @@ -362,6 +362,7 @@ func NewSegment(ctx context.Context, lastDeltaTimestamp: atomic.NewUint64(0), fields: typeutil.NewConcurrentMap[int64, *FieldInfo](), fieldIndexes: typeutil.NewConcurrentMap[int64, *IndexedFieldInfo](), + fieldJSONStats: make(map[int64]*querypb.JsonStatsInfo), memSize: atomic.NewInt64(-1), rowNum: atomic.NewInt64(-1), @@ -1132,29 +1133,27 @@ func (s *LocalSegment) LoadJSONKeyIndex(ctx context.Context, jsonKeyStats *datap } defer s.ptrLock.Unpin() - if jsonKeyStats.GetJsonKeyStatsDataFormat() == 0 { + if !paramtable.Get().CommonCfg.EnabledJSONKeyStats.GetAsBool() { + log.Ctx(ctx).Warn("load json key index failed, json key stats is not enabled") + return nil + } + + if jsonKeyStats.GetJsonKeyStatsDataFormat() != common.JSONStatsDataFormatVersion { log.Ctx(ctx).Info("load json key index failed dataformat invalid", zap.Int64("dataformat", jsonKeyStats.GetJsonKeyStatsDataFormat()), zap.Int64("field id", jsonKeyStats.GetFieldID()), zap.Any("json key logs", jsonKeyStats)) return nil } + log.Ctx(ctx).Info("load json key index", zap.Int64("field id", jsonKeyStats.GetFieldID()), zap.Any("json key logs", jsonKeyStats)) - exists := false - for _, field := range s.fieldJSONStats { - if field == jsonKeyStats.GetFieldID() { - exists = true - break - } - } - if exists { - log.Warn("JsonKeyIndexStats already loaded") + if info, ok := s.fieldJSONStats[jsonKeyStats.GetFieldID()]; ok && info.GetDataFormatVersion() >= common.JSONStatsDataFormatVersion { + log.Warn("JsonKeyIndexStats already loaded", zap.Int64("field id", jsonKeyStats.GetFieldID()), zap.Any("json key logs", jsonKeyStats)) return nil } + f, err := schemaHelper.GetFieldFromID(jsonKeyStats.GetFieldID()) if err != nil { return err } - // Json key stats index mmap config is based on the raw data mmap. - enableMmap := isDataMmapEnable(f) cgoProto := &indexcgopb.LoadJsonKeyIndexInfo{ FieldID: jsonKeyStats.GetFieldID(), Version: jsonKeyStats.GetVersion(), @@ -1164,7 +1163,8 @@ func (s *LocalSegment) LoadJSONKeyIndex(ctx context.Context, jsonKeyStats *datap CollectionID: s.Collection(), PartitionID: s.Partition(), LoadPriority: s.loadInfo.Load().GetPriority(), - EnableMmap: enableMmap, + EnableMmap: paramtable.Get().QueryNodeCfg.MmapJSONStats.GetAsBool(), + MmapDirPath: paramtable.Get().QueryNodeCfg.MmapDirPath.GetValue(), } marshaled, err := proto.Marshal(cgoProto) @@ -1178,7 +1178,13 @@ func (s *LocalSegment) LoadJSONKeyIndex(ctx context.Context, jsonKeyStats *datap status = C.LoadJsonKeyIndex(traceCtx.ctx, s.ptr, (*C.uint8_t)(unsafe.Pointer(&marshaled[0])), (C.uint64_t)(len(marshaled))) return nil, nil }).Await() - s.fieldJSONStats = append(s.fieldJSONStats, jsonKeyStats.GetFieldID()) + + s.fieldJSONStats[jsonKeyStats.GetFieldID()] = &querypb.JsonStatsInfo{ + FieldID: jsonKeyStats.GetFieldID(), + DataFormatVersion: jsonKeyStats.GetJsonKeyStatsDataFormat(), + BuildID: jsonKeyStats.GetBuildID(), + VersionID: jsonKeyStats.GetVersion(), + } return HandleCStatus(ctx, &status, "Load JsonKeyStats failed") } @@ -1395,6 +1401,6 @@ func (s *LocalSegment) indexNeedLoadRawData(schema *schemapb.CollectionSchema, i return !typeutil.IsVectorType(fieldSchema.DataType) && s.HasRawData(indexInfo.IndexInfo.FieldID), nil } -func (s *LocalSegment) GetFieldJSONIndexStats() []int64 { +func (s *LocalSegment) GetFieldJSONIndexStats() map[int64]*querypb.JsonStatsInfo { return s.fieldJSONStats } diff --git a/internal/querynodev2/segments/segment_interface.go b/internal/querynodev2/segments/segment_interface.go index 802f2ca70b..6a6b6ba135 100644 --- a/internal/querynodev2/segments/segment_interface.go +++ b/internal/querynodev2/segments/segment_interface.go @@ -106,5 +106,5 @@ type Segment interface { NeedUpdatedVersion() int64 RemoveUnusedFieldFiles() error - GetFieldJSONIndexStats() []int64 + GetFieldJSONIndexStats() map[int64]*querypb.JsonStatsInfo } diff --git a/internal/querynodev2/segments/segment_l0.go b/internal/querynodev2/segments/segment_l0.go index c34ecccd48..4ee9a0f0c9 100644 --- a/internal/querynodev2/segments/segment_l0.go +++ b/internal/querynodev2/segments/segment_l0.go @@ -197,6 +197,6 @@ func (s *L0Segment) RemoveUnusedFieldFiles() error { panic("not implemented") } -func (s *L0Segment) GetFieldJSONIndexStats() []int64 { +func (s *L0Segment) GetFieldJSONIndexStats() map[int64]*querypb.JsonStatsInfo { return nil } diff --git a/internal/querynodev2/server.go b/internal/querynodev2/server.go index 61e12b7b15..93787f212d 100644 --- a/internal/querynodev2/server.go +++ b/internal/querynodev2/server.go @@ -303,11 +303,9 @@ func (node *QueryNode) InitSegcore() error { cOptimizeExprEnabled := C.bool(paramtable.Get().CommonCfg.EnabledOptimizeExpr.GetAsBool()) C.SetDefaultOptimizeExprEnable(cOptimizeExprEnabled) - cJSONKeyStatsCommitInterval := C.int64_t(paramtable.Get().QueryNodeCfg.JSONKeyStatsCommitInterval.GetAsInt64()) - C.SetDefaultJSONKeyStatsCommitInterval(cJSONKeyStatsCommitInterval) - cGrowingJSONKeyStatsEnabled := C.bool(paramtable.Get().CommonCfg.EnabledGrowingSegmentJSONKeyStats.GetAsBool()) C.SetDefaultGrowingJSONKeyStatsEnable(cGrowingJSONKeyStatsEnabled) + cGpuMemoryPoolInitSize := C.uint32_t(paramtable.Get().GpuConfig.InitSize.GetAsUint32()) cGpuMemoryPoolMaxSize := C.uint32_t(paramtable.Get().GpuConfig.MaxSize.GetAsUint32()) C.SegcoreSetKnowhereGpuMemoryPoolSize(cGpuMemoryPoolInitSize, cGpuMemoryPoolMaxSize) diff --git a/internal/querynodev2/services.go b/internal/querynodev2/services.go index 2649d8d529..aa96a274b1 100644 --- a/internal/querynodev2/services.go +++ b/internal/querynodev2/services.go @@ -1264,7 +1264,7 @@ func (node *QueryNode) GetDataDistribution(ctx context.Context, req *querypb.Get IndexInfo: lo.SliceToMap(s.Indexes(), func(info *segments.IndexedFieldInfo) (int64, *querypb.FieldIndexInfo) { return info.IndexInfo.IndexID, info.IndexInfo }), - FieldJsonIndexStats: s.GetFieldJSONIndexStats(), + JsonStatsInfo: s.GetFieldJSONIndexStats(), }) } diff --git a/internal/util/initcore/init_core.go b/internal/util/initcore/init_core.go index 2cd4dac040..4abee5b12e 100644 --- a/internal/util/initcore/init_core.go +++ b/internal/util/initcore/init_core.go @@ -493,15 +493,6 @@ func SetupCoreConfigChangelCallback() { return nil }) - paramtable.Get().QueryNodeCfg.JSONKeyStatsCommitInterval.RegisterCallback(func(ctx context.Context, key, oldValue, newValue string) error { - interval, err := strconv.Atoi(newValue) - if err != nil { - return err - } - UpdateDefaultJSONKeyStatsCommitInterval(interval) - return nil - }) - paramtable.Get().QueryNodeCfg.ExprResCacheEnabled.RegisterCallback(func(ctx context.Context, key, oldValue, newValue string) error { enable, err := strconv.ParseBool(newValue) if err != nil { diff --git a/internal/util/initcore/util.go b/internal/util/initcore/util.go index 810dd734ea..877c0933d7 100644 --- a/internal/util/initcore/util.go +++ b/internal/util/initcore/util.go @@ -72,10 +72,6 @@ func UpdateExprResCacheCapacityBytes(capacity int) { C.SetExprResCacheCapacityBytes(C.int64_t(capacity)) } -func UpdateDefaultJSONKeyStatsCommitInterval(interval int) { - C.SetDefaultJSONKeyStatsCommitInterval(C.int64_t(interval)) -} - func UpdateDefaultGrowingJSONKeyStatsEnable(enable bool) { C.SetDefaultGrowingJSONKeyStatsEnable(C.bool(enable)) } diff --git a/pkg/common/common.go b/pkg/common/common.go index 99bd6d92e8..26afaa3947 100644 --- a/pkg/common/common.go +++ b/pkg/common/common.go @@ -121,6 +121,13 @@ const ( // JSONIndexPath storage path const for json index JSONIndexPath = "json_key_index_log" + + // JSONStatsPath storage path const for json stats + JSONStatsPath = "json_stats" +) + +const ( + JSONStatsDataFormatVersion = 2 ) // Search, Index parameter keys @@ -156,6 +163,11 @@ const ( JSONCastFunctionKey = "json_cast_function" ) +// expr query params +const ( + ExprUseJSONStatsKey = "expr_use_json_stats" +) + // Doc-in-doc-out const ( EnableAnalyzerKey = `enable_analyzer` diff --git a/pkg/proto/index_cgo_msg.proto b/pkg/proto/index_cgo_msg.proto index 5aa1c77ad1..dd08b25143 100644 --- a/pkg/proto/index_cgo_msg.proto +++ b/pkg/proto/index_cgo_msg.proto @@ -96,6 +96,9 @@ message BuildIndexInfo { int64 storage_version = 24; SegmentInsertFiles segment_insert_files = 25; StoragePluginContext storage_plugin_context = 26; + int64 json_stats_max_shredding_columns = 27; + double json_stats_shredding_ratio_threshold = 28; + int64 json_stats_write_batch_size = 29; } message StoragePluginContext { @@ -126,4 +129,5 @@ message LoadJsonKeyIndexInfo { int64 partitionID = 7; common.LoadPriority load_priority = 8; bool enable_mmap = 9; + string mmap_dir_path = 10; } diff --git a/pkg/proto/indexcgopb/index_cgo_msg.pb.go b/pkg/proto/indexcgopb/index_cgo_msg.pb.go index 0730a2f4d8..29ebd1a422 100644 --- a/pkg/proto/indexcgopb/index_cgo_msg.pb.go +++ b/pkg/proto/indexcgopb/index_cgo_msg.pb.go @@ -657,21 +657,24 @@ type BuildIndexInfo struct { IndexFilePrefix string `protobuf:"bytes,10,opt,name=index_file_prefix,json=indexFilePrefix,proto3" json:"index_file_prefix,omitempty"` InsertFiles []string `protobuf:"bytes,11,rep,name=insert_files,json=insertFiles,proto3" json:"insert_files,omitempty"` // repeated int64 data_ids = 12; - FieldSchema *schemapb.FieldSchema `protobuf:"bytes,12,opt,name=field_schema,json=fieldSchema,proto3" json:"field_schema,omitempty"` - StorageConfig *StorageConfig `protobuf:"bytes,13,opt,name=storage_config,json=storageConfig,proto3" json:"storage_config,omitempty"` - IndexParams []*commonpb.KeyValuePair `protobuf:"bytes,14,rep,name=index_params,json=indexParams,proto3" json:"index_params,omitempty"` - TypeParams []*commonpb.KeyValuePair `protobuf:"bytes,15,rep,name=type_params,json=typeParams,proto3" json:"type_params,omitempty"` - StorePath string `protobuf:"bytes,16,opt,name=store_path,json=storePath,proto3" json:"store_path,omitempty"` - StoreVersion int64 `protobuf:"varint,17,opt,name=store_version,json=storeVersion,proto3" json:"store_version,omitempty"` - IndexStorePath string `protobuf:"bytes,18,opt,name=index_store_path,json=indexStorePath,proto3" json:"index_store_path,omitempty"` - OptFields []*OptionalFieldInfo `protobuf:"bytes,19,rep,name=opt_fields,json=optFields,proto3" json:"opt_fields,omitempty"` - PartitionKeyIsolation bool `protobuf:"varint,20,opt,name=partition_key_isolation,json=partitionKeyIsolation,proto3" json:"partition_key_isolation,omitempty"` - CurrentScalarIndexVersion int32 `protobuf:"varint,21,opt,name=current_scalar_index_version,json=currentScalarIndexVersion,proto3" json:"current_scalar_index_version,omitempty"` - JsonKeyStatsTantivyMemory int64 `protobuf:"varint,22,opt,name=json_key_stats_tantivy_memory,json=jsonKeyStatsTantivyMemory,proto3" json:"json_key_stats_tantivy_memory,omitempty"` - LackBinlogRows int64 `protobuf:"varint,23,opt,name=lack_binlog_rows,json=lackBinlogRows,proto3" json:"lack_binlog_rows,omitempty"` - StorageVersion int64 `protobuf:"varint,24,opt,name=storage_version,json=storageVersion,proto3" json:"storage_version,omitempty"` - SegmentInsertFiles *SegmentInsertFiles `protobuf:"bytes,25,opt,name=segment_insert_files,json=segmentInsertFiles,proto3" json:"segment_insert_files,omitempty"` - StoragePluginContext *StoragePluginContext `protobuf:"bytes,26,opt,name=storage_plugin_context,json=storagePluginContext,proto3" json:"storage_plugin_context,omitempty"` + FieldSchema *schemapb.FieldSchema `protobuf:"bytes,12,opt,name=field_schema,json=fieldSchema,proto3" json:"field_schema,omitempty"` + StorageConfig *StorageConfig `protobuf:"bytes,13,opt,name=storage_config,json=storageConfig,proto3" json:"storage_config,omitempty"` + IndexParams []*commonpb.KeyValuePair `protobuf:"bytes,14,rep,name=index_params,json=indexParams,proto3" json:"index_params,omitempty"` + TypeParams []*commonpb.KeyValuePair `protobuf:"bytes,15,rep,name=type_params,json=typeParams,proto3" json:"type_params,omitempty"` + StorePath string `protobuf:"bytes,16,opt,name=store_path,json=storePath,proto3" json:"store_path,omitempty"` + StoreVersion int64 `protobuf:"varint,17,opt,name=store_version,json=storeVersion,proto3" json:"store_version,omitempty"` + IndexStorePath string `protobuf:"bytes,18,opt,name=index_store_path,json=indexStorePath,proto3" json:"index_store_path,omitempty"` + OptFields []*OptionalFieldInfo `protobuf:"bytes,19,rep,name=opt_fields,json=optFields,proto3" json:"opt_fields,omitempty"` + PartitionKeyIsolation bool `protobuf:"varint,20,opt,name=partition_key_isolation,json=partitionKeyIsolation,proto3" json:"partition_key_isolation,omitempty"` + CurrentScalarIndexVersion int32 `protobuf:"varint,21,opt,name=current_scalar_index_version,json=currentScalarIndexVersion,proto3" json:"current_scalar_index_version,omitempty"` + JsonKeyStatsTantivyMemory int64 `protobuf:"varint,22,opt,name=json_key_stats_tantivy_memory,json=jsonKeyStatsTantivyMemory,proto3" json:"json_key_stats_tantivy_memory,omitempty"` + LackBinlogRows int64 `protobuf:"varint,23,opt,name=lack_binlog_rows,json=lackBinlogRows,proto3" json:"lack_binlog_rows,omitempty"` + StorageVersion int64 `protobuf:"varint,24,opt,name=storage_version,json=storageVersion,proto3" json:"storage_version,omitempty"` + SegmentInsertFiles *SegmentInsertFiles `protobuf:"bytes,25,opt,name=segment_insert_files,json=segmentInsertFiles,proto3" json:"segment_insert_files,omitempty"` + StoragePluginContext *StoragePluginContext `protobuf:"bytes,26,opt,name=storage_plugin_context,json=storagePluginContext,proto3" json:"storage_plugin_context,omitempty"` + JsonStatsMaxShreddingColumns int64 `protobuf:"varint,27,opt,name=json_stats_max_shredding_columns,json=jsonStatsMaxShreddingColumns,proto3" json:"json_stats_max_shredding_columns,omitempty"` + JsonStatsShreddingRatioThreshold float64 `protobuf:"fixed64,28,opt,name=json_stats_shredding_ratio_threshold,json=jsonStatsShreddingRatioThreshold,proto3" json:"json_stats_shredding_ratio_threshold,omitempty"` + JsonStatsWriteBatchSize int64 `protobuf:"varint,29,opt,name=json_stats_write_batch_size,json=jsonStatsWriteBatchSize,proto3" json:"json_stats_write_batch_size,omitempty"` } func (x *BuildIndexInfo) Reset() { @@ -888,6 +891,27 @@ func (x *BuildIndexInfo) GetStoragePluginContext() *StoragePluginContext { return nil } +func (x *BuildIndexInfo) GetJsonStatsMaxShreddingColumns() int64 { + if x != nil { + return x.JsonStatsMaxShreddingColumns + } + return 0 +} + +func (x *BuildIndexInfo) GetJsonStatsShreddingRatioThreshold() float64 { + if x != nil { + return x.JsonStatsShreddingRatioThreshold + } + return 0 +} + +func (x *BuildIndexInfo) GetJsonStatsWriteBatchSize() int64 { + if x != nil { + return x.JsonStatsWriteBatchSize + } + return 0 +} + type StoragePluginContext struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -1076,6 +1100,7 @@ type LoadJsonKeyIndexInfo struct { PartitionID int64 `protobuf:"varint,7,opt,name=partitionID,proto3" json:"partitionID,omitempty"` LoadPriority commonpb.LoadPriority `protobuf:"varint,8,opt,name=load_priority,json=loadPriority,proto3,enum=milvus.proto.common.LoadPriority" json:"load_priority,omitempty"` EnableMmap bool `protobuf:"varint,9,opt,name=enable_mmap,json=enableMmap,proto3" json:"enable_mmap,omitempty"` + MmapDirPath string `protobuf:"bytes,10,opt,name=mmap_dir_path,json=mmapDirPath,proto3" json:"mmap_dir_path,omitempty"` } func (x *LoadJsonKeyIndexInfo) Reset() { @@ -1173,6 +1198,13 @@ func (x *LoadJsonKeyIndexInfo) GetEnableMmap() bool { return false } +func (x *LoadJsonKeyIndexInfo) GetMmapDirPath() string { + if x != nil { + return x.MmapDirPath + } + return "" +} + var File_index_cgo_msg_proto protoreflect.FileDescriptor var file_index_cgo_msg_proto_rawDesc = []byte{ @@ -1262,7 +1294,7 @@ var file_index_cgo_msg_proto_rawDesc = []byte{ 0x65, 0x6c, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x61, 0x74, 0x61, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x09, 0x64, - 0x61, 0x74, 0x61, 0x50, 0x61, 0x74, 0x68, 0x73, 0x22, 0xa2, 0x0a, 0x0a, 0x0e, 0x42, 0x75, 0x69, + 0x61, 0x74, 0x61, 0x50, 0x61, 0x74, 0x68, 0x73, 0x22, 0xf8, 0x0b, 0x0a, 0x0e, 0x42, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x75, 0x69, @@ -1344,40 +1376,31 @@ var file_index_cgo_msg_proto_rawDesc = []byte{ 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x63, 0x67, 0x6f, 0x2e, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x52, 0x14, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, - 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x22, 0x90, 0x01, - 0x0a, 0x14, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, - 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2c, 0x0a, 0x12, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, - 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x10, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5a, 0x6f, - 0x6e, 0x65, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, - 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x65, 0x6e, 0x63, - 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x0d, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, - 0x22, 0xe0, 0x02, 0x0a, 0x11, 0x4c, 0x6f, 0x61, 0x64, 0x54, 0x65, 0x78, 0x74, 0x49, 0x6e, 0x64, - 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, - 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44, - 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x75, - 0x69, 0x6c, 0x64, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62, 0x75, 0x69, - 0x6c, 0x64, 0x49, 0x44, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, - 0x03, 0x28, 0x09, 0x52, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, - 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x46, 0x0a, 0x0d, 0x6c, 0x6f, - 0x61, 0x64, 0x5f, 0x70, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x69, 0x6f, - 0x72, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, - 0x74, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6d, 0x6d, 0x61, - 0x70, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x4d, - 0x6d, 0x61, 0x70, 0x22, 0xe3, 0x02, 0x0a, 0x14, 0x4c, 0x6f, 0x61, 0x64, 0x4a, 0x73, 0x6f, 0x6e, - 0x4b, 0x65, 0x79, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, + 0x50, 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x46, 0x0a, + 0x20, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6d, 0x61, 0x78, 0x5f, + 0x73, 0x68, 0x72, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, + 0x73, 0x18, 0x1b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x1c, 0x6a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x73, 0x4d, 0x61, 0x78, 0x53, 0x68, 0x72, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, + 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x73, 0x5f, 0x73, 0x68, 0x72, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x61, + 0x74, 0x69, 0x6f, 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x1c, 0x20, + 0x01, 0x28, 0x01, 0x52, 0x20, 0x6a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x68, + 0x72, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x54, 0x68, 0x72, 0x65, + 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x12, 0x3c, 0x0a, 0x1b, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, + 0x61, 0x74, 0x73, 0x5f, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, + 0x73, 0x69, 0x7a, 0x65, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x6a, 0x73, 0x6f, 0x6e, + 0x53, 0x74, 0x61, 0x74, 0x73, 0x57, 0x72, 0x69, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, + 0x69, 0x7a, 0x65, 0x22, 0x90, 0x01, 0x0a, 0x14, 0x53, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x50, + 0x6c, 0x75, 0x67, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x2c, 0x0a, 0x12, + 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x7a, 0x6f, 0x6e, 0x65, 0x5f, + 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, + 0x74, 0x69, 0x6f, 0x6e, 0x5a, 0x6f, 0x6e, 0x65, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, + 0x25, 0x0a, 0x0e, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x6b, 0x65, + 0x79, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x65, 0x6e, 0x63, 0x72, 0x79, 0x70, 0x74, + 0x69, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x22, 0xe0, 0x02, 0x0a, 0x11, 0x4c, 0x6f, 0x61, 0x64, 0x54, + 0x65, 0x78, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, @@ -1398,11 +1421,36 @@ var file_index_cgo_msg_proto_rawDesc = []byte{ 0x61, 0x64, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x52, 0x0c, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1f, 0x0a, 0x0b, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6d, 0x6d, 0x61, 0x70, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x65, - 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x6d, 0x61, 0x70, 0x42, 0x35, 0x5a, 0x33, 0x67, 0x69, 0x74, - 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, - 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x63, 0x67, 0x6f, 0x70, 0x62, - 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x6d, 0x61, 0x70, 0x22, 0x87, 0x03, 0x0a, 0x14, 0x4c, 0x6f, + 0x61, 0x64, 0x4a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x07, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, + 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x44, + 0x12, 0x14, 0x0a, 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, + 0x05, 0x66, 0x69, 0x6c, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x46, 0x69, 0x65, + 0x6c, 0x64, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x46, 0x0a, 0x0d, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x70, + 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, + 0x52, 0x0c, 0x6c, 0x6f, 0x61, 0x64, 0x50, 0x72, 0x69, 0x6f, 0x72, 0x69, 0x74, 0x79, 0x12, 0x1f, + 0x0a, 0x0b, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x6d, 0x6d, 0x61, 0x70, 0x18, 0x09, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0a, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x4d, 0x6d, 0x61, 0x70, 0x12, + 0x22, 0x0a, 0x0d, 0x6d, 0x6d, 0x61, 0x70, 0x5f, 0x64, 0x69, 0x72, 0x5f, 0x70, 0x61, 0x74, 0x68, + 0x18, 0x0a, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x6d, 0x6d, 0x61, 0x70, 0x44, 0x69, 0x72, 0x50, + 0x61, 0x74, 0x68, 0x42, 0x35, 0x5a, 0x33, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, + 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x63, 0x67, 0x6f, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, } var ( diff --git a/pkg/proto/plan.proto b/pkg/proto/plan.proto index 74dfd3723e..6fcd185a7c 100644 --- a/pkg/proto/plan.proto +++ b/pkg/proto/plan.proto @@ -262,6 +262,10 @@ message ScoreFunction { float weight = 2; } +message PlanOption { + bool expr_use_json_stats = 1; +}; + message PlanNode { oneof node { VectorANNS vector_anns = 1; @@ -271,4 +275,5 @@ message PlanNode { repeated int64 output_field_ids = 3; repeated string dynamic_fields = 5; repeated ScoreFunction scorers = 6; + PlanOption plan_options = 7; } diff --git a/pkg/proto/planpb/plan.pb.go b/pkg/proto/planpb/plan.pb.go index 25eb4a3f6b..01ebf547be 100644 --- a/pkg/proto/planpb/plan.pb.go +++ b/pkg/proto/planpb/plan.pb.go @@ -2495,6 +2495,53 @@ func (x *ScoreFunction) GetWeight() float32 { return 0 } +type PlanOption struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + ExprUseJsonStats bool `protobuf:"varint,1,opt,name=expr_use_json_stats,json=exprUseJsonStats,proto3" json:"expr_use_json_stats,omitempty"` +} + +func (x *PlanOption) Reset() { + *x = PlanOption{} + if protoimpl.UnsafeEnabled { + mi := &file_plan_proto_msgTypes[26] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *PlanOption) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PlanOption) ProtoMessage() {} + +func (x *PlanOption) ProtoReflect() protoreflect.Message { + mi := &file_plan_proto_msgTypes[26] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use PlanOption.ProtoReflect.Descriptor instead. +func (*PlanOption) Descriptor() ([]byte, []int) { + return file_plan_proto_rawDescGZIP(), []int{26} +} + +func (x *PlanOption) GetExprUseJsonStats() bool { + if x != nil { + return x.ExprUseJsonStats + } + return false +} + type PlanNode struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -2509,12 +2556,13 @@ type PlanNode struct { OutputFieldIds []int64 `protobuf:"varint,3,rep,packed,name=output_field_ids,json=outputFieldIds,proto3" json:"output_field_ids,omitempty"` DynamicFields []string `protobuf:"bytes,5,rep,name=dynamic_fields,json=dynamicFields,proto3" json:"dynamic_fields,omitempty"` Scorers []*ScoreFunction `protobuf:"bytes,6,rep,name=scorers,proto3" json:"scorers,omitempty"` + PlanOptions *PlanOption `protobuf:"bytes,7,opt,name=plan_options,json=planOptions,proto3" json:"plan_options,omitempty"` } func (x *PlanNode) Reset() { *x = PlanNode{} if protoimpl.UnsafeEnabled { - mi := &file_plan_proto_msgTypes[26] + mi := &file_plan_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2527,7 +2575,7 @@ func (x *PlanNode) String() string { func (*PlanNode) ProtoMessage() {} func (x *PlanNode) ProtoReflect() protoreflect.Message { - mi := &file_plan_proto_msgTypes[26] + mi := &file_plan_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2540,7 +2588,7 @@ func (x *PlanNode) ProtoReflect() protoreflect.Message { // Deprecated: Use PlanNode.ProtoReflect.Descriptor instead. func (*PlanNode) Descriptor() ([]byte, []int) { - return file_plan_proto_rawDescGZIP(), []int{26} + return file_plan_proto_rawDescGZIP(), []int{27} } func (m *PlanNode) GetNode() isPlanNode_Node { @@ -2592,6 +2640,13 @@ func (x *PlanNode) GetScorers() []*ScoreFunction { return nil } +func (x *PlanNode) GetPlanOptions() *PlanOption { + if x != nil { + return x.PlanOptions + } + return nil +} + type isPlanNode_Node interface { isPlanNode_Node() } @@ -3028,67 +3083,75 @@ var file_plan_proto_rawDesc = []byte{ 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, 0x70, 0x72, 0x52, 0x06, 0x66, 0x69, 0x6c, 0x74, 0x65, 0x72, 0x12, 0x16, 0x0a, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x02, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0xd6, 0x02, 0x0a, 0x08, 0x50, 0x6c, - 0x61, 0x6e, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x5f, 0x61, 0x6e, 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, - 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x41, 0x4e, 0x4e, 0x53, 0x48, 0x00, 0x52, 0x0a, 0x76, 0x65, - 0x63, 0x74, 0x6f, 0x72, 0x41, 0x6e, 0x6e, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x70, 0x72, 0x65, 0x64, - 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, - 0x2e, 0x45, 0x78, 0x70, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, - 0x74, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6c, 0x61, 0x6e, - 0x4e, 0x6f, 0x64, 0x65, 0x48, 0x00, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x28, 0x0a, - 0x10, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x64, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x46, - 0x69, 0x65, 0x6c, 0x64, 0x49, 0x64, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x64, 0x79, 0x6e, 0x61, 0x6d, - 0x69, 0x63, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, - 0x0d, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x3a, - 0x0a, 0x07, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x02, 0x52, 0x06, 0x77, 0x65, 0x69, 0x67, 0x68, 0x74, 0x22, 0x3b, 0x0a, 0x0a, 0x50, 0x6c, 0x61, + 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x13, 0x65, 0x78, 0x70, 0x72, 0x5f, + 0x75, 0x73, 0x65, 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x08, 0x52, 0x10, 0x65, 0x78, 0x70, 0x72, 0x55, 0x73, 0x65, 0x4a, 0x73, 0x6f, + 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x22, 0x98, 0x03, 0x0a, 0x08, 0x50, 0x6c, 0x61, 0x6e, 0x4e, + 0x6f, 0x64, 0x65, 0x12, 0x40, 0x0a, 0x0b, 0x76, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x5f, 0x61, 0x6e, + 0x6e, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x56, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x41, 0x4e, 0x4e, 0x53, 0x48, 0x00, 0x52, 0x0a, 0x76, 0x65, 0x63, 0x74, 0x6f, + 0x72, 0x41, 0x6e, 0x6e, 0x73, 0x12, 0x39, 0x0a, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, + 0x74, 0x65, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, 0x2e, 0x45, 0x78, + 0x70, 0x72, 0x48, 0x00, 0x52, 0x0a, 0x70, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, + 0x12, 0x38, 0x0a, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, - 0x6c, 0x61, 0x6e, 0x2e, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x07, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x72, 0x73, 0x42, 0x06, 0x0a, 0x04, 0x6e, 0x6f, - 0x64, 0x65, 0x2a, 0xea, 0x01, 0x0a, 0x06, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, - 0x07, 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x47, 0x72, - 0x65, 0x61, 0x74, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x47, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x02, 0x12, 0x0c, 0x0a, - 0x08, 0x4c, 0x65, 0x73, 0x73, 0x54, 0x68, 0x61, 0x6e, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4c, - 0x65, 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x04, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x71, - 0x75, 0x61, 0x6c, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x74, 0x45, 0x71, 0x75, 0x61, - 0x6c, 0x10, 0x06, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x4d, 0x61, 0x74, - 0x63, 0x68, 0x10, 0x07, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x6f, 0x73, 0x74, 0x66, 0x69, 0x78, 0x4d, - 0x61, 0x74, 0x63, 0x68, 0x10, 0x08, 0x12, 0x09, 0x0a, 0x05, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, - 0x09, 0x12, 0x09, 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x10, 0x0a, 0x12, 0x06, 0x0a, 0x02, - 0x49, 0x6e, 0x10, 0x0b, 0x12, 0x09, 0x0a, 0x05, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x10, 0x0c, 0x12, - 0x0d, 0x0a, 0x09, 0x54, 0x65, 0x78, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0d, 0x12, 0x0f, - 0x0a, 0x0b, 0x50, 0x68, 0x72, 0x61, 0x73, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0e, 0x12, - 0x0e, 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0f, 0x2a, - 0x58, 0x0a, 0x0b, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, - 0x0a, 0x07, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, - 0x64, 0x64, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x75, 0x62, 0x10, 0x02, 0x12, 0x07, 0x0a, - 0x03, 0x4d, 0x75, 0x6c, 0x10, 0x03, 0x12, 0x07, 0x0a, 0x03, 0x44, 0x69, 0x76, 0x10, 0x04, 0x12, - 0x07, 0x0a, 0x03, 0x4d, 0x6f, 0x64, 0x10, 0x05, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x72, 0x72, 0x61, - 0x79, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0x06, 0x2a, 0xe1, 0x01, 0x0a, 0x0a, 0x56, 0x65, - 0x63, 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x42, 0x69, 0x6e, 0x61, - 0x72, 0x79, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x6c, - 0x6f, 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x46, - 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x02, 0x12, 0x12, - 0x0a, 0x0e, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, - 0x10, 0x03, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x70, 0x61, 0x72, 0x73, 0x65, 0x46, 0x6c, 0x6f, 0x61, - 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x6e, 0x74, - 0x38, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x05, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x6d, 0x62, - 0x4c, 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, - 0x06, 0x12, 0x18, 0x0a, 0x14, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, - 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x07, 0x12, 0x19, 0x0a, 0x15, 0x45, - 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, - 0x63, 0x74, 0x6f, 0x72, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, - 0x74, 0x49, 0x6e, 0x74, 0x38, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x09, 0x42, 0x31, 0x5a, - 0x2f, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, - 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x6c, 0x61, 0x6e, 0x70, 0x62, - 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x6c, 0x61, 0x6e, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x50, 0x6c, 0x61, 0x6e, 0x4e, 0x6f, 0x64, + 0x65, 0x48, 0x00, 0x52, 0x05, 0x71, 0x75, 0x65, 0x72, 0x79, 0x12, 0x28, 0x0a, 0x10, 0x6f, 0x75, + 0x74, 0x70, 0x75, 0x74, 0x5f, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x03, 0x52, 0x0e, 0x6f, 0x75, 0x74, 0x70, 0x75, 0x74, 0x46, 0x69, 0x65, 0x6c, + 0x64, 0x49, 0x64, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x64, 0x79, 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x64, 0x79, + 0x6e, 0x61, 0x6d, 0x69, 0x63, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x3a, 0x0a, 0x07, 0x73, + 0x63, 0x6f, 0x72, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, 0x6e, + 0x2e, 0x53, 0x63, 0x6f, 0x72, 0x65, 0x46, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, + 0x73, 0x63, 0x6f, 0x72, 0x65, 0x72, 0x73, 0x12, 0x40, 0x0a, 0x0c, 0x70, 0x6c, 0x61, 0x6e, 0x5f, + 0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x70, 0x6c, 0x61, + 0x6e, 0x2e, 0x50, 0x6c, 0x61, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0b, 0x70, 0x6c, + 0x61, 0x6e, 0x4f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x42, 0x06, 0x0a, 0x04, 0x6e, 0x6f, 0x64, + 0x65, 0x2a, 0xea, 0x01, 0x0a, 0x06, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, + 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x47, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x72, 0x54, 0x68, 0x61, 0x6e, 0x10, 0x01, 0x12, 0x10, 0x0a, 0x0c, 0x47, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x72, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x02, 0x12, 0x0c, 0x0a, 0x08, + 0x4c, 0x65, 0x73, 0x73, 0x54, 0x68, 0x61, 0x6e, 0x10, 0x03, 0x12, 0x0d, 0x0a, 0x09, 0x4c, 0x65, + 0x73, 0x73, 0x45, 0x71, 0x75, 0x61, 0x6c, 0x10, 0x04, 0x12, 0x09, 0x0a, 0x05, 0x45, 0x71, 0x75, + 0x61, 0x6c, 0x10, 0x05, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x74, 0x45, 0x71, 0x75, 0x61, 0x6c, + 0x10, 0x06, 0x12, 0x0f, 0x0a, 0x0b, 0x50, 0x72, 0x65, 0x66, 0x69, 0x78, 0x4d, 0x61, 0x74, 0x63, + 0x68, 0x10, 0x07, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x6f, 0x73, 0x74, 0x66, 0x69, 0x78, 0x4d, 0x61, + 0x74, 0x63, 0x68, 0x10, 0x08, 0x12, 0x09, 0x0a, 0x05, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x09, + 0x12, 0x09, 0x0a, 0x05, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x10, 0x0a, 0x12, 0x06, 0x0a, 0x02, 0x49, + 0x6e, 0x10, 0x0b, 0x12, 0x09, 0x0a, 0x05, 0x4e, 0x6f, 0x74, 0x49, 0x6e, 0x10, 0x0c, 0x12, 0x0d, + 0x0a, 0x09, 0x54, 0x65, 0x78, 0x74, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0d, 0x12, 0x0f, 0x0a, + 0x0b, 0x50, 0x68, 0x72, 0x61, 0x73, 0x65, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0e, 0x12, 0x0e, + 0x0a, 0x0a, 0x49, 0x6e, 0x6e, 0x65, 0x72, 0x4d, 0x61, 0x74, 0x63, 0x68, 0x10, 0x0f, 0x2a, 0x58, + 0x0a, 0x0b, 0x41, 0x72, 0x69, 0x74, 0x68, 0x4f, 0x70, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0b, 0x0a, + 0x07, 0x55, 0x6e, 0x6b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x41, 0x64, + 0x64, 0x10, 0x01, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x75, 0x62, 0x10, 0x02, 0x12, 0x07, 0x0a, 0x03, + 0x4d, 0x75, 0x6c, 0x10, 0x03, 0x12, 0x07, 0x0a, 0x03, 0x44, 0x69, 0x76, 0x10, 0x04, 0x12, 0x07, + 0x0a, 0x03, 0x4d, 0x6f, 0x64, 0x10, 0x05, 0x12, 0x0f, 0x0a, 0x0b, 0x41, 0x72, 0x72, 0x61, 0x79, + 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x10, 0x06, 0x2a, 0xe1, 0x01, 0x0a, 0x0a, 0x56, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x54, 0x79, 0x70, 0x65, 0x12, 0x10, 0x0a, 0x0c, 0x42, 0x69, 0x6e, 0x61, 0x72, + 0x79, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x00, 0x12, 0x0f, 0x0a, 0x0b, 0x46, 0x6c, 0x6f, + 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x01, 0x12, 0x11, 0x0a, 0x0d, 0x46, 0x6c, + 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x02, 0x12, 0x12, 0x0a, + 0x0e, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, + 0x03, 0x12, 0x15, 0x0a, 0x11, 0x53, 0x70, 0x61, 0x72, 0x73, 0x65, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x04, 0x12, 0x0e, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x38, + 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x05, 0x12, 0x16, 0x0a, 0x12, 0x45, 0x6d, 0x62, 0x4c, + 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x06, + 0x12, 0x18, 0x0a, 0x14, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x31, 0x36, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x07, 0x12, 0x19, 0x0a, 0x15, 0x45, 0x6d, + 0x62, 0x4c, 0x69, 0x73, 0x74, 0x42, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x31, 0x36, 0x56, 0x65, 0x63, + 0x74, 0x6f, 0x72, 0x10, 0x08, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x6d, 0x62, 0x4c, 0x69, 0x73, 0x74, + 0x49, 0x6e, 0x74, 0x38, 0x56, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x10, 0x09, 0x42, 0x31, 0x5a, 0x2f, + 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, + 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x70, 0x6c, 0x61, 0x6e, 0x70, 0x62, 0x62, + 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -3104,7 +3167,7 @@ func file_plan_proto_rawDescGZIP() []byte { } var file_plan_proto_enumTypes = make([]protoimpl.EnumInfo, 7) -var file_plan_proto_msgTypes = make([]protoimpl.MessageInfo, 27) +var file_plan_proto_msgTypes = make([]protoimpl.MessageInfo, 28) var file_plan_proto_goTypes = []interface{}{ (OpType)(0), // 0: milvus.proto.plan.OpType (ArithOpType)(0), // 1: milvus.proto.plan.ArithOpType @@ -3139,16 +3202,17 @@ var file_plan_proto_goTypes = []interface{}{ (*VectorANNS)(nil), // 30: milvus.proto.plan.VectorANNS (*QueryPlanNode)(nil), // 31: milvus.proto.plan.QueryPlanNode (*ScoreFunction)(nil), // 32: milvus.proto.plan.ScoreFunction - (*PlanNode)(nil), // 33: milvus.proto.plan.PlanNode - (schemapb.DataType)(0), // 34: milvus.proto.schema.DataType + (*PlanOption)(nil), // 33: milvus.proto.plan.PlanOption + (*PlanNode)(nil), // 34: milvus.proto.plan.PlanNode + (schemapb.DataType)(0), // 35: milvus.proto.schema.DataType } var file_plan_proto_depIdxs = []int32{ 8, // 0: milvus.proto.plan.GenericValue.array_val:type_name -> milvus.proto.plan.Array 7, // 1: milvus.proto.plan.Array.array:type_name -> milvus.proto.plan.GenericValue - 34, // 2: milvus.proto.plan.Array.element_type:type_name -> milvus.proto.schema.DataType + 35, // 2: milvus.proto.plan.Array.element_type:type_name -> milvus.proto.schema.DataType 9, // 3: milvus.proto.plan.QueryInfo.search_iterator_v2_info:type_name -> milvus.proto.plan.SearchIteratorV2Info - 34, // 4: milvus.proto.plan.ColumnInfo.data_type:type_name -> milvus.proto.schema.DataType - 34, // 5: milvus.proto.plan.ColumnInfo.element_type:type_name -> milvus.proto.schema.DataType + 35, // 4: milvus.proto.plan.ColumnInfo.data_type:type_name -> milvus.proto.schema.DataType + 35, // 5: milvus.proto.plan.ColumnInfo.element_type:type_name -> milvus.proto.schema.DataType 11, // 6: milvus.proto.plan.ColumnExpr.info:type_name -> milvus.proto.plan.ColumnInfo 11, // 7: milvus.proto.plan.ExistsExpr.info:type_name -> milvus.proto.plan.ColumnInfo 7, // 8: milvus.proto.plan.ValueExpr.value:type_name -> milvus.proto.plan.GenericValue @@ -3212,11 +3276,12 @@ var file_plan_proto_depIdxs = []int32{ 29, // 66: milvus.proto.plan.PlanNode.predicates:type_name -> milvus.proto.plan.Expr 31, // 67: milvus.proto.plan.PlanNode.query:type_name -> milvus.proto.plan.QueryPlanNode 32, // 68: milvus.proto.plan.PlanNode.scorers:type_name -> milvus.proto.plan.ScoreFunction - 69, // [69:69] is the sub-list for method output_type - 69, // [69:69] is the sub-list for method input_type - 69, // [69:69] is the sub-list for extension type_name - 69, // [69:69] is the sub-list for extension extendee - 0, // [0:69] is the sub-list for field type_name + 33, // 69: milvus.proto.plan.PlanNode.plan_options:type_name -> milvus.proto.plan.PlanOption + 70, // [70:70] is the sub-list for method output_type + 70, // [70:70] is the sub-list for method input_type + 70, // [70:70] is the sub-list for extension type_name + 70, // [70:70] is the sub-list for extension extendee + 0, // [0:70] is the sub-list for field type_name } func init() { file_plan_proto_init() } @@ -3538,6 +3603,18 @@ func file_plan_proto_init() { } } file_plan_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*PlanOption); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_plan_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*PlanNode); i { case 0: return &v.state @@ -3577,7 +3654,7 @@ func file_plan_proto_init() { (*Expr_NullExpr)(nil), (*Expr_RandomSampleExpr)(nil), } - file_plan_proto_msgTypes[26].OneofWrappers = []interface{}{ + file_plan_proto_msgTypes[27].OneofWrappers = []interface{}{ (*PlanNode_VectorAnns)(nil), (*PlanNode_Predicates)(nil), (*PlanNode_Query)(nil), @@ -3588,7 +3665,7 @@ func file_plan_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_plan_proto_rawDesc, NumEnums: 7, - NumMessages: 27, + NumMessages: 28, NumExtensions: 0, NumServices: 0, }, diff --git a/pkg/proto/query_coord.proto b/pkg/proto/query_coord.proto index 5006cdd864..0c3ca21997 100644 --- a/pkg/proto/query_coord.proto +++ b/pkg/proto/query_coord.proto @@ -395,6 +395,14 @@ message FieldIndexInfo { int64 index_store_version = 12; } +message JsonStatsInfo { + int64 fieldID = 1; + int64 dataFormatVersion = 2; + int64 indexID = 3; + int64 buildID = 4; + int64 versionID = 5; +} + enum LoadScope { Full = 0; Delta = 1; @@ -657,6 +665,7 @@ message SegmentVersionInfo { data.SegmentLevel level = 8; bool is_sorted = 9; repeated int64 field_json_index_stats = 10; + map json_stats_info = 11; } message ChannelVersionInfo { diff --git a/pkg/proto/querypb/query_coord.pb.go b/pkg/proto/querypb/query_coord.pb.go index d310292904..048275adef 100644 --- a/pkg/proto/querypb/query_coord.pb.go +++ b/pkg/proto/querypb/query_coord.pb.go @@ -2438,6 +2438,85 @@ func (x *FieldIndexInfo) GetIndexStoreVersion() int64 { return 0 } +type JsonStatsInfo struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + FieldID int64 `protobuf:"varint,1,opt,name=fieldID,proto3" json:"fieldID,omitempty"` + DataFormatVersion int64 `protobuf:"varint,2,opt,name=dataFormatVersion,proto3" json:"dataFormatVersion,omitempty"` + IndexID int64 `protobuf:"varint,3,opt,name=indexID,proto3" json:"indexID,omitempty"` + BuildID int64 `protobuf:"varint,4,opt,name=buildID,proto3" json:"buildID,omitempty"` + VersionID int64 `protobuf:"varint,5,opt,name=versionID,proto3" json:"versionID,omitempty"` +} + +func (x *JsonStatsInfo) Reset() { + *x = JsonStatsInfo{} + if protoimpl.UnsafeEnabled { + mi := &file_query_coord_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *JsonStatsInfo) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*JsonStatsInfo) ProtoMessage() {} + +func (x *JsonStatsInfo) ProtoReflect() protoreflect.Message { + mi := &file_query_coord_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use JsonStatsInfo.ProtoReflect.Descriptor instead. +func (*JsonStatsInfo) Descriptor() ([]byte, []int) { + return file_query_coord_proto_rawDescGZIP(), []int{23} +} + +func (x *JsonStatsInfo) GetFieldID() int64 { + if x != nil { + return x.FieldID + } + return 0 +} + +func (x *JsonStatsInfo) GetDataFormatVersion() int64 { + if x != nil { + return x.DataFormatVersion + } + return 0 +} + +func (x *JsonStatsInfo) GetIndexID() int64 { + if x != nil { + return x.IndexID + } + return 0 +} + +func (x *JsonStatsInfo) GetBuildID() int64 { + if x != nil { + return x.BuildID + } + return 0 +} + +func (x *JsonStatsInfo) GetVersionID() int64 { + if x != nil { + return x.VersionID + } + return 0 +} + type LoadSegmentsRequest struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -2462,7 +2541,7 @@ type LoadSegmentsRequest struct { func (x *LoadSegmentsRequest) Reset() { *x = LoadSegmentsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[23] + mi := &file_query_coord_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2475,7 +2554,7 @@ func (x *LoadSegmentsRequest) String() string { func (*LoadSegmentsRequest) ProtoMessage() {} func (x *LoadSegmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[23] + mi := &file_query_coord_proto_msgTypes[24] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2488,7 +2567,7 @@ func (x *LoadSegmentsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LoadSegmentsRequest.ProtoReflect.Descriptor instead. func (*LoadSegmentsRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{23} + return file_query_coord_proto_rawDescGZIP(), []int{24} } func (x *LoadSegmentsRequest) GetBase() *commonpb.MsgBase { @@ -2610,7 +2689,7 @@ type ReleaseSegmentsRequest struct { func (x *ReleaseSegmentsRequest) Reset() { *x = ReleaseSegmentsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[24] + mi := &file_query_coord_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2623,7 +2702,7 @@ func (x *ReleaseSegmentsRequest) String() string { func (*ReleaseSegmentsRequest) ProtoMessage() {} func (x *ReleaseSegmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[24] + mi := &file_query_coord_proto_msgTypes[25] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2636,7 +2715,7 @@ func (x *ReleaseSegmentsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReleaseSegmentsRequest.ProtoReflect.Descriptor instead. func (*ReleaseSegmentsRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{24} + return file_query_coord_proto_rawDescGZIP(), []int{25} } func (x *ReleaseSegmentsRequest) GetBase() *commonpb.MsgBase { @@ -2725,7 +2804,7 @@ type SearchRequest struct { func (x *SearchRequest) Reset() { *x = SearchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[25] + mi := &file_query_coord_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2738,7 +2817,7 @@ func (x *SearchRequest) String() string { func (*SearchRequest) ProtoMessage() {} func (x *SearchRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[25] + mi := &file_query_coord_proto_msgTypes[26] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2751,7 +2830,7 @@ func (x *SearchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SearchRequest.ProtoReflect.Descriptor instead. func (*SearchRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{25} + return file_query_coord_proto_rawDescGZIP(), []int{26} } func (x *SearchRequest) GetReq() *internalpb.SearchRequest { @@ -2811,7 +2890,7 @@ type QueryRequest struct { func (x *QueryRequest) Reset() { *x = QueryRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[26] + mi := &file_query_coord_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2824,7 +2903,7 @@ func (x *QueryRequest) String() string { func (*QueryRequest) ProtoMessage() {} func (x *QueryRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[26] + mi := &file_query_coord_proto_msgTypes[27] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2837,7 +2916,7 @@ func (x *QueryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryRequest.ProtoReflect.Descriptor instead. func (*QueryRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{26} + return file_query_coord_proto_rawDescGZIP(), []int{27} } func (x *QueryRequest) GetReq() *internalpb.RetrieveRequest { @@ -2888,7 +2967,7 @@ type SyncReplicaSegmentsRequest struct { func (x *SyncReplicaSegmentsRequest) Reset() { *x = SyncReplicaSegmentsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[27] + mi := &file_query_coord_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2901,7 +2980,7 @@ func (x *SyncReplicaSegmentsRequest) String() string { func (*SyncReplicaSegmentsRequest) ProtoMessage() {} func (x *SyncReplicaSegmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[27] + mi := &file_query_coord_proto_msgTypes[28] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2914,7 +2993,7 @@ func (x *SyncReplicaSegmentsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SyncReplicaSegmentsRequest.ProtoReflect.Descriptor instead. func (*SyncReplicaSegmentsRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{27} + return file_query_coord_proto_rawDescGZIP(), []int{28} } func (x *SyncReplicaSegmentsRequest) GetBase() *commonpb.MsgBase { @@ -2952,7 +3031,7 @@ type ReplicaSegmentsInfo struct { func (x *ReplicaSegmentsInfo) Reset() { *x = ReplicaSegmentsInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[28] + mi := &file_query_coord_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2965,7 +3044,7 @@ func (x *ReplicaSegmentsInfo) String() string { func (*ReplicaSegmentsInfo) ProtoMessage() {} func (x *ReplicaSegmentsInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[28] + mi := &file_query_coord_proto_msgTypes[29] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2978,7 +3057,7 @@ func (x *ReplicaSegmentsInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ReplicaSegmentsInfo.ProtoReflect.Descriptor instead. func (*ReplicaSegmentsInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{28} + return file_query_coord_proto_rawDescGZIP(), []int{29} } func (x *ReplicaSegmentsInfo) GetNodeId() int64 { @@ -3021,7 +3100,7 @@ type GetLoadInfoRequest struct { func (x *GetLoadInfoRequest) Reset() { *x = GetLoadInfoRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[29] + mi := &file_query_coord_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3034,7 +3113,7 @@ func (x *GetLoadInfoRequest) String() string { func (*GetLoadInfoRequest) ProtoMessage() {} func (x *GetLoadInfoRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[29] + mi := &file_query_coord_proto_msgTypes[30] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3047,7 +3126,7 @@ func (x *GetLoadInfoRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetLoadInfoRequest.ProtoReflect.Descriptor instead. func (*GetLoadInfoRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{29} + return file_query_coord_proto_rawDescGZIP(), []int{30} } func (x *GetLoadInfoRequest) GetBase() *commonpb.MsgBase { @@ -3078,7 +3157,7 @@ type GetLoadInfoResponse struct { func (x *GetLoadInfoResponse) Reset() { *x = GetLoadInfoResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[30] + mi := &file_query_coord_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3091,7 +3170,7 @@ func (x *GetLoadInfoResponse) String() string { func (*GetLoadInfoResponse) ProtoMessage() {} func (x *GetLoadInfoResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[30] + mi := &file_query_coord_proto_msgTypes[31] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3104,7 +3183,7 @@ func (x *GetLoadInfoResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetLoadInfoResponse.ProtoReflect.Descriptor instead. func (*GetLoadInfoResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{30} + return file_query_coord_proto_rawDescGZIP(), []int{31} } func (x *GetLoadInfoResponse) GetStatus() *commonpb.Status { @@ -3148,7 +3227,7 @@ type HandoffSegmentsRequest struct { func (x *HandoffSegmentsRequest) Reset() { *x = HandoffSegmentsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[31] + mi := &file_query_coord_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3161,7 +3240,7 @@ func (x *HandoffSegmentsRequest) String() string { func (*HandoffSegmentsRequest) ProtoMessage() {} func (x *HandoffSegmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[31] + mi := &file_query_coord_proto_msgTypes[32] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3174,7 +3253,7 @@ func (x *HandoffSegmentsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use HandoffSegmentsRequest.ProtoReflect.Descriptor instead. func (*HandoffSegmentsRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{31} + return file_query_coord_proto_rawDescGZIP(), []int{32} } func (x *HandoffSegmentsRequest) GetBase() *commonpb.MsgBase { @@ -3214,7 +3293,7 @@ type LoadBalanceRequest struct { func (x *LoadBalanceRequest) Reset() { *x = LoadBalanceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[32] + mi := &file_query_coord_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3227,7 +3306,7 @@ func (x *LoadBalanceRequest) String() string { func (*LoadBalanceRequest) ProtoMessage() {} func (x *LoadBalanceRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[32] + mi := &file_query_coord_proto_msgTypes[33] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3240,7 +3319,7 @@ func (x *LoadBalanceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LoadBalanceRequest.ProtoReflect.Descriptor instead. func (*LoadBalanceRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{32} + return file_query_coord_proto_rawDescGZIP(), []int{33} } func (x *LoadBalanceRequest) GetBase() *commonpb.MsgBase { @@ -3300,7 +3379,7 @@ type DmChannelWatchInfo struct { func (x *DmChannelWatchInfo) Reset() { *x = DmChannelWatchInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[33] + mi := &file_query_coord_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3313,7 +3392,7 @@ func (x *DmChannelWatchInfo) String() string { func (*DmChannelWatchInfo) ProtoMessage() {} func (x *DmChannelWatchInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[33] + mi := &file_query_coord_proto_msgTypes[34] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3326,7 +3405,7 @@ func (x *DmChannelWatchInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use DmChannelWatchInfo.ProtoReflect.Descriptor instead. func (*DmChannelWatchInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{33} + return file_query_coord_proto_rawDescGZIP(), []int{34} } func (x *DmChannelWatchInfo) GetCollectionID() int64 { @@ -3379,7 +3458,7 @@ type QueryChannelInfo struct { func (x *QueryChannelInfo) Reset() { *x = QueryChannelInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[34] + mi := &file_query_coord_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3392,7 +3471,7 @@ func (x *QueryChannelInfo) String() string { func (*QueryChannelInfo) ProtoMessage() {} func (x *QueryChannelInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[34] + mi := &file_query_coord_proto_msgTypes[35] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3405,7 +3484,7 @@ func (x *QueryChannelInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryChannelInfo.ProtoReflect.Descriptor instead. func (*QueryChannelInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{34} + return file_query_coord_proto_rawDescGZIP(), []int{35} } func (x *QueryChannelInfo) GetCollectionID() int64 { @@ -3456,7 +3535,7 @@ type PartitionStates struct { func (x *PartitionStates) Reset() { *x = PartitionStates{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[35] + mi := &file_query_coord_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3469,7 +3548,7 @@ func (x *PartitionStates) String() string { func (*PartitionStates) ProtoMessage() {} func (x *PartitionStates) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[35] + mi := &file_query_coord_proto_msgTypes[36] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3482,7 +3561,7 @@ func (x *PartitionStates) ProtoReflect() protoreflect.Message { // Deprecated: Use PartitionStates.ProtoReflect.Descriptor instead. func (*PartitionStates) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{35} + return file_query_coord_proto_rawDescGZIP(), []int{36} } func (x *PartitionStates) GetPartitionID() int64 { @@ -3537,7 +3616,7 @@ type SegmentInfo struct { func (x *SegmentInfo) Reset() { *x = SegmentInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[36] + mi := &file_query_coord_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3550,7 +3629,7 @@ func (x *SegmentInfo) String() string { func (*SegmentInfo) ProtoMessage() {} func (x *SegmentInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[36] + mi := &file_query_coord_proto_msgTypes[37] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3563,7 +3642,7 @@ func (x *SegmentInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SegmentInfo.ProtoReflect.Descriptor instead. func (*SegmentInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{36} + return file_query_coord_proto_rawDescGZIP(), []int{37} } func (x *SegmentInfo) GetSegmentID() int64 { @@ -3725,7 +3804,7 @@ type CollectionInfo struct { func (x *CollectionInfo) Reset() { *x = CollectionInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[37] + mi := &file_query_coord_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3738,7 +3817,7 @@ func (x *CollectionInfo) String() string { func (*CollectionInfo) ProtoMessage() {} func (x *CollectionInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[37] + mi := &file_query_coord_proto_msgTypes[38] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3751,7 +3830,7 @@ func (x *CollectionInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use CollectionInfo.ProtoReflect.Descriptor instead. func (*CollectionInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{37} + return file_query_coord_proto_rawDescGZIP(), []int{38} } func (x *CollectionInfo) GetCollectionID() int64 { @@ -3829,7 +3908,7 @@ type UnsubscribeChannels struct { func (x *UnsubscribeChannels) Reset() { *x = UnsubscribeChannels{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[38] + mi := &file_query_coord_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3842,7 +3921,7 @@ func (x *UnsubscribeChannels) String() string { func (*UnsubscribeChannels) ProtoMessage() {} func (x *UnsubscribeChannels) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[38] + mi := &file_query_coord_proto_msgTypes[39] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3855,7 +3934,7 @@ func (x *UnsubscribeChannels) ProtoReflect() protoreflect.Message { // Deprecated: Use UnsubscribeChannels.ProtoReflect.Descriptor instead. func (*UnsubscribeChannels) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{38} + return file_query_coord_proto_rawDescGZIP(), []int{39} } func (x *UnsubscribeChannels) GetCollectionID() int64 { @@ -3884,7 +3963,7 @@ type UnsubscribeChannelInfo struct { func (x *UnsubscribeChannelInfo) Reset() { *x = UnsubscribeChannelInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[39] + mi := &file_query_coord_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3897,7 +3976,7 @@ func (x *UnsubscribeChannelInfo) String() string { func (*UnsubscribeChannelInfo) ProtoMessage() {} func (x *UnsubscribeChannelInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[39] + mi := &file_query_coord_proto_msgTypes[40] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3910,7 +3989,7 @@ func (x *UnsubscribeChannelInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use UnsubscribeChannelInfo.ProtoReflect.Descriptor instead. func (*UnsubscribeChannelInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{39} + return file_query_coord_proto_rawDescGZIP(), []int{40} } func (x *UnsubscribeChannelInfo) GetNodeID() int64 { @@ -3941,7 +4020,7 @@ type SegmentChangeInfo struct { func (x *SegmentChangeInfo) Reset() { *x = SegmentChangeInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[40] + mi := &file_query_coord_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3954,7 +4033,7 @@ func (x *SegmentChangeInfo) String() string { func (*SegmentChangeInfo) ProtoMessage() {} func (x *SegmentChangeInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[40] + mi := &file_query_coord_proto_msgTypes[41] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3967,7 +4046,7 @@ func (x *SegmentChangeInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SegmentChangeInfo.ProtoReflect.Descriptor instead. func (*SegmentChangeInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{40} + return file_query_coord_proto_rawDescGZIP(), []int{41} } func (x *SegmentChangeInfo) GetOnlineNodeID() int64 { @@ -4010,7 +4089,7 @@ type SealedSegmentsChangeInfo struct { func (x *SealedSegmentsChangeInfo) Reset() { *x = SealedSegmentsChangeInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[41] + mi := &file_query_coord_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4023,7 +4102,7 @@ func (x *SealedSegmentsChangeInfo) String() string { func (*SealedSegmentsChangeInfo) ProtoMessage() {} func (x *SealedSegmentsChangeInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[41] + mi := &file_query_coord_proto_msgTypes[42] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4036,7 +4115,7 @@ func (x *SealedSegmentsChangeInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SealedSegmentsChangeInfo.ProtoReflect.Descriptor instead. func (*SealedSegmentsChangeInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{41} + return file_query_coord_proto_rawDescGZIP(), []int{42} } func (x *SealedSegmentsChangeInfo) GetBase() *commonpb.MsgBase { @@ -4066,7 +4145,7 @@ type GetDataDistributionRequest struct { func (x *GetDataDistributionRequest) Reset() { *x = GetDataDistributionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[42] + mi := &file_query_coord_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4079,7 +4158,7 @@ func (x *GetDataDistributionRequest) String() string { func (*GetDataDistributionRequest) ProtoMessage() {} func (x *GetDataDistributionRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[42] + mi := &file_query_coord_proto_msgTypes[43] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4092,7 +4171,7 @@ func (x *GetDataDistributionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDataDistributionRequest.ProtoReflect.Descriptor instead. func (*GetDataDistributionRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{42} + return file_query_coord_proto_rawDescGZIP(), []int{43} } func (x *GetDataDistributionRequest) GetBase() *commonpb.MsgBase { @@ -4134,7 +4213,7 @@ type GetDataDistributionResponse struct { func (x *GetDataDistributionResponse) Reset() { *x = GetDataDistributionResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[43] + mi := &file_query_coord_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4147,7 +4226,7 @@ func (x *GetDataDistributionResponse) String() string { func (*GetDataDistributionResponse) ProtoMessage() {} func (x *GetDataDistributionResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[43] + mi := &file_query_coord_proto_msgTypes[44] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4160,7 +4239,7 @@ func (x *GetDataDistributionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetDataDistributionResponse.ProtoReflect.Descriptor instead. func (*GetDataDistributionResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{43} + return file_query_coord_proto_rawDescGZIP(), []int{44} } func (x *GetDataDistributionResponse) GetStatus() *commonpb.Status { @@ -4238,7 +4317,7 @@ type LeaderView struct { func (x *LeaderView) Reset() { *x = LeaderView{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[44] + mi := &file_query_coord_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4251,7 +4330,7 @@ func (x *LeaderView) String() string { func (*LeaderView) ProtoMessage() {} func (x *LeaderView) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[44] + mi := &file_query_coord_proto_msgTypes[45] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4264,7 +4343,7 @@ func (x *LeaderView) ProtoReflect() protoreflect.Message { // Deprecated: Use LeaderView.ProtoReflect.Descriptor instead. func (*LeaderView) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{44} + return file_query_coord_proto_rawDescGZIP(), []int{45} } func (x *LeaderView) GetCollection() int64 { @@ -4341,7 +4420,7 @@ type LeaderViewStatus struct { func (x *LeaderViewStatus) Reset() { *x = LeaderViewStatus{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[45] + mi := &file_query_coord_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4354,7 +4433,7 @@ func (x *LeaderViewStatus) String() string { func (*LeaderViewStatus) ProtoMessage() {} func (x *LeaderViewStatus) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[45] + mi := &file_query_coord_proto_msgTypes[46] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4367,7 +4446,7 @@ func (x *LeaderViewStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use LeaderViewStatus.ProtoReflect.Descriptor instead. func (*LeaderViewStatus) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{45} + return file_query_coord_proto_rawDescGZIP(), []int{46} } func (x *LeaderViewStatus) GetServiceable() bool { @@ -4389,7 +4468,7 @@ type SegmentDist struct { func (x *SegmentDist) Reset() { *x = SegmentDist{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[46] + mi := &file_query_coord_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4402,7 +4481,7 @@ func (x *SegmentDist) String() string { func (*SegmentDist) ProtoMessage() {} func (x *SegmentDist) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[46] + mi := &file_query_coord_proto_msgTypes[47] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4415,7 +4494,7 @@ func (x *SegmentDist) ProtoReflect() protoreflect.Message { // Deprecated: Use SegmentDist.ProtoReflect.Descriptor instead. func (*SegmentDist) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{46} + return file_query_coord_proto_rawDescGZIP(), []int{47} } func (x *SegmentDist) GetNodeID() int64 { @@ -4447,12 +4526,13 @@ type SegmentVersionInfo struct { Level datapb.SegmentLevel `protobuf:"varint,8,opt,name=level,proto3,enum=milvus.proto.data.SegmentLevel" json:"level,omitempty"` IsSorted bool `protobuf:"varint,9,opt,name=is_sorted,json=isSorted,proto3" json:"is_sorted,omitempty"` FieldJsonIndexStats []int64 `protobuf:"varint,10,rep,packed,name=field_json_index_stats,json=fieldJsonIndexStats,proto3" json:"field_json_index_stats,omitempty"` + JsonStatsInfo map[int64]*JsonStatsInfo `protobuf:"bytes,11,rep,name=json_stats_info,json=jsonStatsInfo,proto3" json:"json_stats_info,omitempty" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` } func (x *SegmentVersionInfo) Reset() { *x = SegmentVersionInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[47] + mi := &file_query_coord_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4465,7 +4545,7 @@ func (x *SegmentVersionInfo) String() string { func (*SegmentVersionInfo) ProtoMessage() {} func (x *SegmentVersionInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[47] + mi := &file_query_coord_proto_msgTypes[48] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4478,7 +4558,7 @@ func (x *SegmentVersionInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use SegmentVersionInfo.ProtoReflect.Descriptor instead. func (*SegmentVersionInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{47} + return file_query_coord_proto_rawDescGZIP(), []int{48} } func (x *SegmentVersionInfo) GetID() int64 { @@ -4551,6 +4631,13 @@ func (x *SegmentVersionInfo) GetFieldJsonIndexStats() []int64 { return nil } +func (x *SegmentVersionInfo) GetJsonStatsInfo() map[int64]*JsonStatsInfo { + if x != nil { + return x.JsonStatsInfo + } + return nil +} + type ChannelVersionInfo struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -4564,7 +4651,7 @@ type ChannelVersionInfo struct { func (x *ChannelVersionInfo) Reset() { *x = ChannelVersionInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[48] + mi := &file_query_coord_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4577,7 +4664,7 @@ func (x *ChannelVersionInfo) String() string { func (*ChannelVersionInfo) ProtoMessage() {} func (x *ChannelVersionInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[48] + mi := &file_query_coord_proto_msgTypes[49] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4590,7 +4677,7 @@ func (x *ChannelVersionInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ChannelVersionInfo.ProtoReflect.Descriptor instead. func (*ChannelVersionInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{48} + return file_query_coord_proto_rawDescGZIP(), []int{49} } func (x *ChannelVersionInfo) GetChannel() string { @@ -4634,7 +4721,7 @@ type CollectionLoadInfo struct { func (x *CollectionLoadInfo) Reset() { *x = CollectionLoadInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[49] + mi := &file_query_coord_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4647,7 +4734,7 @@ func (x *CollectionLoadInfo) String() string { func (*CollectionLoadInfo) ProtoMessage() {} func (x *CollectionLoadInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[49] + mi := &file_query_coord_proto_msgTypes[50] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4660,7 +4747,7 @@ func (x *CollectionLoadInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use CollectionLoadInfo.ProtoReflect.Descriptor instead. func (*CollectionLoadInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{49} + return file_query_coord_proto_rawDescGZIP(), []int{50} } func (x *CollectionLoadInfo) GetCollectionID() int64 { @@ -4749,7 +4836,7 @@ type PartitionLoadInfo struct { func (x *PartitionLoadInfo) Reset() { *x = PartitionLoadInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[50] + mi := &file_query_coord_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4762,7 +4849,7 @@ func (x *PartitionLoadInfo) String() string { func (*PartitionLoadInfo) ProtoMessage() {} func (x *PartitionLoadInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[50] + mi := &file_query_coord_proto_msgTypes[51] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4775,7 +4862,7 @@ func (x *PartitionLoadInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use PartitionLoadInfo.ProtoReflect.Descriptor instead. func (*PartitionLoadInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{50} + return file_query_coord_proto_rawDescGZIP(), []int{51} } func (x *PartitionLoadInfo) GetCollectionID() int64 { @@ -4831,7 +4918,7 @@ type ChannelNodeInfo struct { func (x *ChannelNodeInfo) Reset() { *x = ChannelNodeInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[51] + mi := &file_query_coord_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4844,7 +4931,7 @@ func (x *ChannelNodeInfo) String() string { func (*ChannelNodeInfo) ProtoMessage() {} func (x *ChannelNodeInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[51] + mi := &file_query_coord_proto_msgTypes[52] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4857,7 +4944,7 @@ func (x *ChannelNodeInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ChannelNodeInfo.ProtoReflect.Descriptor instead. func (*ChannelNodeInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{51} + return file_query_coord_proto_rawDescGZIP(), []int{52} } func (x *ChannelNodeInfo) GetRwNodes() []int64 { @@ -4890,7 +4977,7 @@ type Replica struct { func (x *Replica) Reset() { *x = Replica{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[52] + mi := &file_query_coord_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4903,7 +4990,7 @@ func (x *Replica) String() string { func (*Replica) ProtoMessage() {} func (x *Replica) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[52] + mi := &file_query_coord_proto_msgTypes[53] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4916,7 +5003,7 @@ func (x *Replica) ProtoReflect() protoreflect.Message { // Deprecated: Use Replica.ProtoReflect.Descriptor instead. func (*Replica) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{52} + return file_query_coord_proto_rawDescGZIP(), []int{53} } func (x *Replica) GetID() int64 { @@ -4999,7 +5086,7 @@ type SyncAction struct { func (x *SyncAction) Reset() { *x = SyncAction{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[53] + mi := &file_query_coord_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5012,7 +5099,7 @@ func (x *SyncAction) String() string { func (*SyncAction) ProtoMessage() {} func (x *SyncAction) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[53] + mi := &file_query_coord_proto_msgTypes[54] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5025,7 +5112,7 @@ func (x *SyncAction) ProtoReflect() protoreflect.Message { // Deprecated: Use SyncAction.ProtoReflect.Descriptor instead. func (*SyncAction) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{53} + return file_query_coord_proto_rawDescGZIP(), []int{54} } func (x *SyncAction) GetType() SyncType { @@ -5145,7 +5232,7 @@ type SyncDistributionRequest struct { func (x *SyncDistributionRequest) Reset() { *x = SyncDistributionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[54] + mi := &file_query_coord_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5158,7 +5245,7 @@ func (x *SyncDistributionRequest) String() string { func (*SyncDistributionRequest) ProtoMessage() {} func (x *SyncDistributionRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[54] + mi := &file_query_coord_proto_msgTypes[55] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5171,7 +5258,7 @@ func (x *SyncDistributionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SyncDistributionRequest.ProtoReflect.Descriptor instead. func (*SyncDistributionRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{54} + return file_query_coord_proto_rawDescGZIP(), []int{55} } func (x *SyncDistributionRequest) GetBase() *commonpb.MsgBase { @@ -5252,7 +5339,7 @@ type ResourceGroup struct { func (x *ResourceGroup) Reset() { *x = ResourceGroup{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[55] + mi := &file_query_coord_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5265,7 +5352,7 @@ func (x *ResourceGroup) String() string { func (*ResourceGroup) ProtoMessage() {} func (x *ResourceGroup) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[55] + mi := &file_query_coord_proto_msgTypes[56] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5278,7 +5365,7 @@ func (x *ResourceGroup) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceGroup.ProtoReflect.Descriptor instead. func (*ResourceGroup) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{55} + return file_query_coord_proto_rawDescGZIP(), []int{56} } func (x *ResourceGroup) GetName() string { @@ -5326,7 +5413,7 @@ type TransferReplicaRequest struct { func (x *TransferReplicaRequest) Reset() { *x = TransferReplicaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[56] + mi := &file_query_coord_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5339,7 +5426,7 @@ func (x *TransferReplicaRequest) String() string { func (*TransferReplicaRequest) ProtoMessage() {} func (x *TransferReplicaRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[56] + mi := &file_query_coord_proto_msgTypes[57] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5352,7 +5439,7 @@ func (x *TransferReplicaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferReplicaRequest.ProtoReflect.Descriptor instead. func (*TransferReplicaRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{56} + return file_query_coord_proto_rawDescGZIP(), []int{57} } func (x *TransferReplicaRequest) GetBase() *commonpb.MsgBase { @@ -5402,7 +5489,7 @@ type DescribeResourceGroupRequest struct { func (x *DescribeResourceGroupRequest) Reset() { *x = DescribeResourceGroupRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[57] + mi := &file_query_coord_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5415,7 +5502,7 @@ func (x *DescribeResourceGroupRequest) String() string { func (*DescribeResourceGroupRequest) ProtoMessage() {} func (x *DescribeResourceGroupRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[57] + mi := &file_query_coord_proto_msgTypes[58] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5428,7 +5515,7 @@ func (x *DescribeResourceGroupRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DescribeResourceGroupRequest.ProtoReflect.Descriptor instead. func (*DescribeResourceGroupRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{57} + return file_query_coord_proto_rawDescGZIP(), []int{58} } func (x *DescribeResourceGroupRequest) GetBase() *commonpb.MsgBase { @@ -5457,7 +5544,7 @@ type DescribeResourceGroupResponse struct { func (x *DescribeResourceGroupResponse) Reset() { *x = DescribeResourceGroupResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[58] + mi := &file_query_coord_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5470,7 +5557,7 @@ func (x *DescribeResourceGroupResponse) String() string { func (*DescribeResourceGroupResponse) ProtoMessage() {} func (x *DescribeResourceGroupResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[58] + mi := &file_query_coord_proto_msgTypes[59] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5483,7 +5570,7 @@ func (x *DescribeResourceGroupResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DescribeResourceGroupResponse.ProtoReflect.Descriptor instead. func (*DescribeResourceGroupResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{58} + return file_query_coord_proto_rawDescGZIP(), []int{59} } func (x *DescribeResourceGroupResponse) GetStatus() *commonpb.Status { @@ -5523,7 +5610,7 @@ type ResourceGroupInfo struct { func (x *ResourceGroupInfo) Reset() { *x = ResourceGroupInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[59] + mi := &file_query_coord_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5536,7 +5623,7 @@ func (x *ResourceGroupInfo) String() string { func (*ResourceGroupInfo) ProtoMessage() {} func (x *ResourceGroupInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[59] + mi := &file_query_coord_proto_msgTypes[60] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5549,7 +5636,7 @@ func (x *ResourceGroupInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceGroupInfo.ProtoReflect.Descriptor instead. func (*ResourceGroupInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{59} + return file_query_coord_proto_rawDescGZIP(), []int{60} } func (x *ResourceGroupInfo) GetName() string { @@ -5628,7 +5715,7 @@ type DeleteRequest struct { func (x *DeleteRequest) Reset() { *x = DeleteRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[60] + mi := &file_query_coord_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5641,7 +5728,7 @@ func (x *DeleteRequest) String() string { func (*DeleteRequest) ProtoMessage() {} func (x *DeleteRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[60] + mi := &file_query_coord_proto_msgTypes[61] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5654,7 +5741,7 @@ func (x *DeleteRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteRequest.ProtoReflect.Descriptor instead. func (*DeleteRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{60} + return file_query_coord_proto_rawDescGZIP(), []int{61} } func (x *DeleteRequest) GetBase() *commonpb.MsgBase { @@ -5738,7 +5825,7 @@ type DeleteBatchRequest struct { func (x *DeleteBatchRequest) Reset() { *x = DeleteBatchRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[61] + mi := &file_query_coord_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5751,7 +5838,7 @@ func (x *DeleteBatchRequest) String() string { func (*DeleteBatchRequest) ProtoMessage() {} func (x *DeleteBatchRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[61] + mi := &file_query_coord_proto_msgTypes[62] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5764,7 +5851,7 @@ func (x *DeleteBatchRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteBatchRequest.ProtoReflect.Descriptor instead. func (*DeleteBatchRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{61} + return file_query_coord_proto_rawDescGZIP(), []int{62} } func (x *DeleteBatchRequest) GetBase() *commonpb.MsgBase { @@ -5838,7 +5925,7 @@ type DeleteBatchResponse struct { func (x *DeleteBatchResponse) Reset() { *x = DeleteBatchResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[62] + mi := &file_query_coord_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5851,7 +5938,7 @@ func (x *DeleteBatchResponse) String() string { func (*DeleteBatchResponse) ProtoMessage() {} func (x *DeleteBatchResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[62] + mi := &file_query_coord_proto_msgTypes[63] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5864,7 +5951,7 @@ func (x *DeleteBatchResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteBatchResponse.ProtoReflect.Descriptor instead. func (*DeleteBatchResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{62} + return file_query_coord_proto_rawDescGZIP(), []int{63} } func (x *DeleteBatchResponse) GetStatus() *commonpb.Status { @@ -5900,7 +5987,7 @@ type ActivateCheckerRequest struct { func (x *ActivateCheckerRequest) Reset() { *x = ActivateCheckerRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[63] + mi := &file_query_coord_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5913,7 +6000,7 @@ func (x *ActivateCheckerRequest) String() string { func (*ActivateCheckerRequest) ProtoMessage() {} func (x *ActivateCheckerRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[63] + mi := &file_query_coord_proto_msgTypes[64] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5926,7 +6013,7 @@ func (x *ActivateCheckerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ActivateCheckerRequest.ProtoReflect.Descriptor instead. func (*ActivateCheckerRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{63} + return file_query_coord_proto_rawDescGZIP(), []int{64} } func (x *ActivateCheckerRequest) GetBase() *commonpb.MsgBase { @@ -5955,7 +6042,7 @@ type DeactivateCheckerRequest struct { func (x *DeactivateCheckerRequest) Reset() { *x = DeactivateCheckerRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[64] + mi := &file_query_coord_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5968,7 +6055,7 @@ func (x *DeactivateCheckerRequest) String() string { func (*DeactivateCheckerRequest) ProtoMessage() {} func (x *DeactivateCheckerRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[64] + mi := &file_query_coord_proto_msgTypes[65] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5981,7 +6068,7 @@ func (x *DeactivateCheckerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeactivateCheckerRequest.ProtoReflect.Descriptor instead. func (*DeactivateCheckerRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{64} + return file_query_coord_proto_rawDescGZIP(), []int{65} } func (x *DeactivateCheckerRequest) GetBase() *commonpb.MsgBase { @@ -6010,7 +6097,7 @@ type ListCheckersRequest struct { func (x *ListCheckersRequest) Reset() { *x = ListCheckersRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[65] + mi := &file_query_coord_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6023,7 +6110,7 @@ func (x *ListCheckersRequest) String() string { func (*ListCheckersRequest) ProtoMessage() {} func (x *ListCheckersRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[65] + mi := &file_query_coord_proto_msgTypes[66] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6036,7 +6123,7 @@ func (x *ListCheckersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCheckersRequest.ProtoReflect.Descriptor instead. func (*ListCheckersRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{65} + return file_query_coord_proto_rawDescGZIP(), []int{66} } func (x *ListCheckersRequest) GetBase() *commonpb.MsgBase { @@ -6065,7 +6152,7 @@ type ListCheckersResponse struct { func (x *ListCheckersResponse) Reset() { *x = ListCheckersResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[66] + mi := &file_query_coord_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6078,7 +6165,7 @@ func (x *ListCheckersResponse) String() string { func (*ListCheckersResponse) ProtoMessage() {} func (x *ListCheckersResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[66] + mi := &file_query_coord_proto_msgTypes[67] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6091,7 +6178,7 @@ func (x *ListCheckersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListCheckersResponse.ProtoReflect.Descriptor instead. func (*ListCheckersResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{66} + return file_query_coord_proto_rawDescGZIP(), []int{67} } func (x *ListCheckersResponse) GetStatus() *commonpb.Status { @@ -6122,7 +6209,7 @@ type CheckerInfo struct { func (x *CheckerInfo) Reset() { *x = CheckerInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[67] + mi := &file_query_coord_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6135,7 +6222,7 @@ func (x *CheckerInfo) String() string { func (*CheckerInfo) ProtoMessage() {} func (x *CheckerInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[67] + mi := &file_query_coord_proto_msgTypes[68] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6148,7 +6235,7 @@ func (x *CheckerInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckerInfo.ProtoReflect.Descriptor instead. func (*CheckerInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{67} + return file_query_coord_proto_rawDescGZIP(), []int{68} } func (x *CheckerInfo) GetId() int32 { @@ -6192,7 +6279,7 @@ type SegmentTarget struct { func (x *SegmentTarget) Reset() { *x = SegmentTarget{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[68] + mi := &file_query_coord_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6205,7 +6292,7 @@ func (x *SegmentTarget) String() string { func (*SegmentTarget) ProtoMessage() {} func (x *SegmentTarget) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[68] + mi := &file_query_coord_proto_msgTypes[69] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6218,7 +6305,7 @@ func (x *SegmentTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use SegmentTarget.ProtoReflect.Descriptor instead. func (*SegmentTarget) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{68} + return file_query_coord_proto_rawDescGZIP(), []int{69} } func (x *SegmentTarget) GetID() int64 { @@ -6254,7 +6341,7 @@ type PartitionTarget struct { func (x *PartitionTarget) Reset() { *x = PartitionTarget{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[69] + mi := &file_query_coord_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6267,7 +6354,7 @@ func (x *PartitionTarget) String() string { func (*PartitionTarget) ProtoMessage() {} func (x *PartitionTarget) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[69] + mi := &file_query_coord_proto_msgTypes[70] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6280,7 +6367,7 @@ func (x *PartitionTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use PartitionTarget.ProtoReflect.Descriptor instead. func (*PartitionTarget) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{69} + return file_query_coord_proto_rawDescGZIP(), []int{70} } func (x *PartitionTarget) GetPartitionID() int64 { @@ -6313,7 +6400,7 @@ type ChannelTarget struct { func (x *ChannelTarget) Reset() { *x = ChannelTarget{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[70] + mi := &file_query_coord_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6326,7 +6413,7 @@ func (x *ChannelTarget) String() string { func (*ChannelTarget) ProtoMessage() {} func (x *ChannelTarget) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[70] + mi := &file_query_coord_proto_msgTypes[71] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6339,7 +6426,7 @@ func (x *ChannelTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use ChannelTarget.ProtoReflect.Descriptor instead. func (*ChannelTarget) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{70} + return file_query_coord_proto_rawDescGZIP(), []int{71} } func (x *ChannelTarget) GetChannelName() string { @@ -6397,7 +6484,7 @@ type CollectionTarget struct { func (x *CollectionTarget) Reset() { *x = CollectionTarget{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[71] + mi := &file_query_coord_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6410,7 +6497,7 @@ func (x *CollectionTarget) String() string { func (*CollectionTarget) ProtoMessage() {} func (x *CollectionTarget) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[71] + mi := &file_query_coord_proto_msgTypes[72] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6423,7 +6510,7 @@ func (x *CollectionTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use CollectionTarget.ProtoReflect.Descriptor instead. func (*CollectionTarget) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{71} + return file_query_coord_proto_rawDescGZIP(), []int{72} } func (x *CollectionTarget) GetCollectionID() int64 { @@ -6460,7 +6547,7 @@ type NodeInfo struct { func (x *NodeInfo) Reset() { *x = NodeInfo{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[72] + mi := &file_query_coord_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6473,7 +6560,7 @@ func (x *NodeInfo) String() string { func (*NodeInfo) ProtoMessage() {} func (x *NodeInfo) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[72] + mi := &file_query_coord_proto_msgTypes[73] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6486,7 +6573,7 @@ func (x *NodeInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use NodeInfo.ProtoReflect.Descriptor instead. func (*NodeInfo) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{72} + return file_query_coord_proto_rawDescGZIP(), []int{73} } func (x *NodeInfo) GetID() int64 { @@ -6521,7 +6608,7 @@ type ListQueryNodeRequest struct { func (x *ListQueryNodeRequest) Reset() { *x = ListQueryNodeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[73] + mi := &file_query_coord_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6534,7 +6621,7 @@ func (x *ListQueryNodeRequest) String() string { func (*ListQueryNodeRequest) ProtoMessage() {} func (x *ListQueryNodeRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[73] + mi := &file_query_coord_proto_msgTypes[74] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6547,7 +6634,7 @@ func (x *ListQueryNodeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListQueryNodeRequest.ProtoReflect.Descriptor instead. func (*ListQueryNodeRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{73} + return file_query_coord_proto_rawDescGZIP(), []int{74} } func (x *ListQueryNodeRequest) GetBase() *commonpb.MsgBase { @@ -6569,7 +6656,7 @@ type ListQueryNodeResponse struct { func (x *ListQueryNodeResponse) Reset() { *x = ListQueryNodeResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[74] + mi := &file_query_coord_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6582,7 +6669,7 @@ func (x *ListQueryNodeResponse) String() string { func (*ListQueryNodeResponse) ProtoMessage() {} func (x *ListQueryNodeResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[74] + mi := &file_query_coord_proto_msgTypes[75] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6595,7 +6682,7 @@ func (x *ListQueryNodeResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListQueryNodeResponse.ProtoReflect.Descriptor instead. func (*ListQueryNodeResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{74} + return file_query_coord_proto_rawDescGZIP(), []int{75} } func (x *ListQueryNodeResponse) GetStatus() *commonpb.Status { @@ -6624,7 +6711,7 @@ type GetQueryNodeDistributionRequest struct { func (x *GetQueryNodeDistributionRequest) Reset() { *x = GetQueryNodeDistributionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[75] + mi := &file_query_coord_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6637,7 +6724,7 @@ func (x *GetQueryNodeDistributionRequest) String() string { func (*GetQueryNodeDistributionRequest) ProtoMessage() {} func (x *GetQueryNodeDistributionRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[75] + mi := &file_query_coord_proto_msgTypes[76] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6650,7 +6737,7 @@ func (x *GetQueryNodeDistributionRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetQueryNodeDistributionRequest.ProtoReflect.Descriptor instead. func (*GetQueryNodeDistributionRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{75} + return file_query_coord_proto_rawDescGZIP(), []int{76} } func (x *GetQueryNodeDistributionRequest) GetBase() *commonpb.MsgBase { @@ -6681,7 +6768,7 @@ type GetQueryNodeDistributionResponse struct { func (x *GetQueryNodeDistributionResponse) Reset() { *x = GetQueryNodeDistributionResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[76] + mi := &file_query_coord_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6694,7 +6781,7 @@ func (x *GetQueryNodeDistributionResponse) String() string { func (*GetQueryNodeDistributionResponse) ProtoMessage() {} func (x *GetQueryNodeDistributionResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[76] + mi := &file_query_coord_proto_msgTypes[77] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6707,7 +6794,7 @@ func (x *GetQueryNodeDistributionResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetQueryNodeDistributionResponse.ProtoReflect.Descriptor instead. func (*GetQueryNodeDistributionResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{76} + return file_query_coord_proto_rawDescGZIP(), []int{77} } func (x *GetQueryNodeDistributionResponse) GetStatus() *commonpb.Status { @@ -6749,7 +6836,7 @@ type SuspendBalanceRequest struct { func (x *SuspendBalanceRequest) Reset() { *x = SuspendBalanceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[77] + mi := &file_query_coord_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6762,7 +6849,7 @@ func (x *SuspendBalanceRequest) String() string { func (*SuspendBalanceRequest) ProtoMessage() {} func (x *SuspendBalanceRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[77] + mi := &file_query_coord_proto_msgTypes[78] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6775,7 +6862,7 @@ func (x *SuspendBalanceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendBalanceRequest.ProtoReflect.Descriptor instead. func (*SuspendBalanceRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{77} + return file_query_coord_proto_rawDescGZIP(), []int{78} } func (x *SuspendBalanceRequest) GetBase() *commonpb.MsgBase { @@ -6796,7 +6883,7 @@ type ResumeBalanceRequest struct { func (x *ResumeBalanceRequest) Reset() { *x = ResumeBalanceRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[78] + mi := &file_query_coord_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6809,7 +6896,7 @@ func (x *ResumeBalanceRequest) String() string { func (*ResumeBalanceRequest) ProtoMessage() {} func (x *ResumeBalanceRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[78] + mi := &file_query_coord_proto_msgTypes[79] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6822,7 +6909,7 @@ func (x *ResumeBalanceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeBalanceRequest.ProtoReflect.Descriptor instead. func (*ResumeBalanceRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{78} + return file_query_coord_proto_rawDescGZIP(), []int{79} } func (x *ResumeBalanceRequest) GetBase() *commonpb.MsgBase { @@ -6843,7 +6930,7 @@ type CheckBalanceStatusRequest struct { func (x *CheckBalanceStatusRequest) Reset() { *x = CheckBalanceStatusRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[79] + mi := &file_query_coord_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6856,7 +6943,7 @@ func (x *CheckBalanceStatusRequest) String() string { func (*CheckBalanceStatusRequest) ProtoMessage() {} func (x *CheckBalanceStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[79] + mi := &file_query_coord_proto_msgTypes[80] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6869,7 +6956,7 @@ func (x *CheckBalanceStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckBalanceStatusRequest.ProtoReflect.Descriptor instead. func (*CheckBalanceStatusRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{79} + return file_query_coord_proto_rawDescGZIP(), []int{80} } func (x *CheckBalanceStatusRequest) GetBase() *commonpb.MsgBase { @@ -6891,7 +6978,7 @@ type CheckBalanceStatusResponse struct { func (x *CheckBalanceStatusResponse) Reset() { *x = CheckBalanceStatusResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[80] + mi := &file_query_coord_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6904,7 +6991,7 @@ func (x *CheckBalanceStatusResponse) String() string { func (*CheckBalanceStatusResponse) ProtoMessage() {} func (x *CheckBalanceStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[80] + mi := &file_query_coord_proto_msgTypes[81] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6917,7 +7004,7 @@ func (x *CheckBalanceStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckBalanceStatusResponse.ProtoReflect.Descriptor instead. func (*CheckBalanceStatusResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{80} + return file_query_coord_proto_rawDescGZIP(), []int{81} } func (x *CheckBalanceStatusResponse) GetStatus() *commonpb.Status { @@ -6946,7 +7033,7 @@ type SuspendNodeRequest struct { func (x *SuspendNodeRequest) Reset() { *x = SuspendNodeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[81] + mi := &file_query_coord_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6959,7 +7046,7 @@ func (x *SuspendNodeRequest) String() string { func (*SuspendNodeRequest) ProtoMessage() {} func (x *SuspendNodeRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[81] + mi := &file_query_coord_proto_msgTypes[82] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6972,7 +7059,7 @@ func (x *SuspendNodeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendNodeRequest.ProtoReflect.Descriptor instead. func (*SuspendNodeRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{81} + return file_query_coord_proto_rawDescGZIP(), []int{82} } func (x *SuspendNodeRequest) GetBase() *commonpb.MsgBase { @@ -7001,7 +7088,7 @@ type ResumeNodeRequest struct { func (x *ResumeNodeRequest) Reset() { *x = ResumeNodeRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[82] + mi := &file_query_coord_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7014,7 +7101,7 @@ func (x *ResumeNodeRequest) String() string { func (*ResumeNodeRequest) ProtoMessage() {} func (x *ResumeNodeRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[82] + mi := &file_query_coord_proto_msgTypes[83] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7027,7 +7114,7 @@ func (x *ResumeNodeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeNodeRequest.ProtoReflect.Descriptor instead. func (*ResumeNodeRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{82} + return file_query_coord_proto_rawDescGZIP(), []int{83} } func (x *ResumeNodeRequest) GetBase() *commonpb.MsgBase { @@ -7061,7 +7148,7 @@ type TransferSegmentRequest struct { func (x *TransferSegmentRequest) Reset() { *x = TransferSegmentRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[83] + mi := &file_query_coord_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7074,7 +7161,7 @@ func (x *TransferSegmentRequest) String() string { func (*TransferSegmentRequest) ProtoMessage() {} func (x *TransferSegmentRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[83] + mi := &file_query_coord_proto_msgTypes[84] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7087,7 +7174,7 @@ func (x *TransferSegmentRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferSegmentRequest.ProtoReflect.Descriptor instead. func (*TransferSegmentRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{83} + return file_query_coord_proto_rawDescGZIP(), []int{84} } func (x *TransferSegmentRequest) GetBase() *commonpb.MsgBase { @@ -7156,7 +7243,7 @@ type TransferChannelRequest struct { func (x *TransferChannelRequest) Reset() { *x = TransferChannelRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[84] + mi := &file_query_coord_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7169,7 +7256,7 @@ func (x *TransferChannelRequest) String() string { func (*TransferChannelRequest) ProtoMessage() {} func (x *TransferChannelRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[84] + mi := &file_query_coord_proto_msgTypes[85] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7182,7 +7269,7 @@ func (x *TransferChannelRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use TransferChannelRequest.ProtoReflect.Descriptor instead. func (*TransferChannelRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{84} + return file_query_coord_proto_rawDescGZIP(), []int{85} } func (x *TransferChannelRequest) GetBase() *commonpb.MsgBase { @@ -7247,7 +7334,7 @@ type CheckQueryNodeDistributionRequest struct { func (x *CheckQueryNodeDistributionRequest) Reset() { *x = CheckQueryNodeDistributionRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[85] + mi := &file_query_coord_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7260,7 +7347,7 @@ func (x *CheckQueryNodeDistributionRequest) String() string { func (*CheckQueryNodeDistributionRequest) ProtoMessage() {} func (x *CheckQueryNodeDistributionRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[85] + mi := &file_query_coord_proto_msgTypes[86] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7273,7 +7360,7 @@ func (x *CheckQueryNodeDistributionRequest) ProtoReflect() protoreflect.Message // Deprecated: Use CheckQueryNodeDistributionRequest.ProtoReflect.Descriptor instead. func (*CheckQueryNodeDistributionRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{85} + return file_query_coord_proto_rawDescGZIP(), []int{86} } func (x *CheckQueryNodeDistributionRequest) GetBase() *commonpb.MsgBase { @@ -7312,7 +7399,7 @@ type UpdateLoadConfigRequest struct { func (x *UpdateLoadConfigRequest) Reset() { *x = UpdateLoadConfigRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[86] + mi := &file_query_coord_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7325,7 +7412,7 @@ func (x *UpdateLoadConfigRequest) String() string { func (*UpdateLoadConfigRequest) ProtoMessage() {} func (x *UpdateLoadConfigRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[86] + mi := &file_query_coord_proto_msgTypes[87] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7338,7 +7425,7 @@ func (x *UpdateLoadConfigRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateLoadConfigRequest.ProtoReflect.Descriptor instead. func (*UpdateLoadConfigRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{86} + return file_query_coord_proto_rawDescGZIP(), []int{87} } func (x *UpdateLoadConfigRequest) GetBase() *commonpb.MsgBase { @@ -7390,7 +7477,7 @@ type UpdateSchemaRequest struct { func (x *UpdateSchemaRequest) Reset() { *x = UpdateSchemaRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[87] + mi := &file_query_coord_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7403,7 +7490,7 @@ func (x *UpdateSchemaRequest) String() string { func (*UpdateSchemaRequest) ProtoMessage() {} func (x *UpdateSchemaRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[87] + mi := &file_query_coord_proto_msgTypes[88] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7416,7 +7503,7 @@ func (x *UpdateSchemaRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateSchemaRequest.ProtoReflect.Descriptor instead. func (*UpdateSchemaRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{87} + return file_query_coord_proto_rawDescGZIP(), []int{88} } func (x *UpdateSchemaRequest) GetBase() *commonpb.MsgBase { @@ -7464,7 +7551,7 @@ type RunAnalyzerRequest struct { func (x *RunAnalyzerRequest) Reset() { *x = RunAnalyzerRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[88] + mi := &file_query_coord_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7477,7 +7564,7 @@ func (x *RunAnalyzerRequest) String() string { func (*RunAnalyzerRequest) ProtoMessage() {} func (x *RunAnalyzerRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[88] + mi := &file_query_coord_proto_msgTypes[89] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7490,7 +7577,7 @@ func (x *RunAnalyzerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RunAnalyzerRequest.ProtoReflect.Descriptor instead. func (*RunAnalyzerRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{88} + return file_query_coord_proto_rawDescGZIP(), []int{89} } func (x *RunAnalyzerRequest) GetBase() *commonpb.MsgBase { @@ -7553,7 +7640,7 @@ type ListLoadedSegmentsRequest struct { func (x *ListLoadedSegmentsRequest) Reset() { *x = ListLoadedSegmentsRequest{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[89] + mi := &file_query_coord_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7566,7 +7653,7 @@ func (x *ListLoadedSegmentsRequest) String() string { func (*ListLoadedSegmentsRequest) ProtoMessage() {} func (x *ListLoadedSegmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[89] + mi := &file_query_coord_proto_msgTypes[90] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7579,7 +7666,7 @@ func (x *ListLoadedSegmentsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListLoadedSegmentsRequest.ProtoReflect.Descriptor instead. func (*ListLoadedSegmentsRequest) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{89} + return file_query_coord_proto_rawDescGZIP(), []int{90} } func (x *ListLoadedSegmentsRequest) GetBase() *commonpb.MsgBase { @@ -7601,7 +7688,7 @@ type ListLoadedSegmentsResponse struct { func (x *ListLoadedSegmentsResponse) Reset() { *x = ListLoadedSegmentsResponse{} if protoimpl.UnsafeEnabled { - mi := &file_query_coord_proto_msgTypes[90] + mi := &file_query_coord_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7614,7 +7701,7 @@ func (x *ListLoadedSegmentsResponse) String() string { func (*ListLoadedSegmentsResponse) ProtoMessage() {} func (x *ListLoadedSegmentsResponse) ProtoReflect() protoreflect.Message { - mi := &file_query_coord_proto_msgTypes[90] + mi := &file_query_coord_proto_msgTypes[91] if protoimpl.UnsafeEnabled && x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7627,7 +7714,7 @@ func (x *ListLoadedSegmentsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListLoadedSegmentsResponse.ProtoReflect.Descriptor instead. func (*ListLoadedSegmentsResponse) Descriptor() ([]byte, []int) { - return file_query_coord_proto_rawDescGZIP(), []int{90} + return file_query_coord_proto_rawDescGZIP(), []int{91} } func (x *ListLoadedSegmentsResponse) GetStatus() *commonpb.Status { @@ -8137,782 +8224,781 @@ var file_query_coord_proto_rawDesc = []byte{ 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x53, 0x74, 0x6f, 0x72, 0x65, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xaf, 0x05, 0x0a, 0x13, 0x4c, 0x6f, 0x61, 0x64, - 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xa9, 0x01, 0x0a, 0x0d, 0x4a, 0x73, 0x6f, 0x6e, + 0x53, 0x74, 0x61, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x66, 0x69, 0x65, + 0x6c, 0x64, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x49, 0x44, 0x12, 0x2c, 0x0a, 0x11, 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x6d, 0x61, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, + 0x64, 0x61, 0x74, 0x61, 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x62, + 0x75, 0x69, 0x6c, 0x64, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62, 0x75, + 0x69, 0x6c, 0x64, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x22, 0xaf, 0x05, 0x0a, 0x13, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, + 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1d, 0x0a, + 0x0a, 0x64, 0x73, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x09, 0x64, 0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x39, 0x0a, 0x05, + 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x05, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, + 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, + 0x3d, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, + 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x1c, + 0x0a, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x12, 0x46, 0x0a, 0x0f, + 0x64, 0x65, 0x6c, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x50, 0x6f, 0x73, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, + 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x23, + 0x0a, 0x0d, 0x6e, 0x65, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6e, 0x65, 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x0a, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, + 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x6f, 0x70, + 0x65, 0x12, 0x45, 0x0a, 0x0f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, + 0x6c, 0x69, 0x73, 0x74, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, + 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x49, 0x6e, 0x66, 0x6f, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x61, 0x7a, 0x79, + 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x6c, 0x61, 0x7a, + 0x79, 0x4c, 0x6f, 0x61, 0x64, 0x22, 0x8d, 0x03, 0x0a, 0x16, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, + 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, + 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x62, + 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x64, 0x62, 0x49, 0x44, 0x12, 0x22, + 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x04, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x44, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x49, 0x44, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, + 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, + 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x73, + 0x68, 0x61, 0x72, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x68, 0x61, 0x72, + 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, + 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6e, 0x65, 0x65, 0x64, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, + 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, + 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x97, 0x02, 0x0a, 0x0d, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x36, 0x0a, 0x03, 0x72, 0x65, 0x71, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x61, + 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x03, 0x72, 0x65, 0x71, 0x12, + 0x21, 0x0a, 0x0c, 0x64, 0x6d, 0x6c, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x6d, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, + 0x6c, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, + 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, + 0x44, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, + 0x5f, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x66, + 0x72, 0x6f, 0x6d, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x33, + 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, + 0x6f, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x5f, 0x63, 0x68, 0x61, + 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x75, 0x6d, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0f, + 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x75, 0x6d, 0x22, + 0xec, 0x01, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x12, 0x38, 0x0a, 0x03, 0x72, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x03, 0x72, 0x65, 0x71, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6d, + 0x6c, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0b, 0x64, 0x6d, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1e, 0x0a, + 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x2a, 0x0a, + 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6c, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x66, 0x72, 0x6f, 0x6d, 0x53, 0x68, + 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x63, 0x6f, + 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x61, + 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0xc7, + 0x01, 0x0a, 0x1a, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, + 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, + 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, + 0x23, 0x0a, 0x0d, 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, + 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x52, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, + 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x8e, 0x01, 0x0a, 0x13, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x1f, 0x0a, 0x0b, + 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x73, 0x12, 0x1a, 0x0a, + 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, + 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x6b, 0x0a, 0x12, 0x47, 0x65, 0x74, + 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, - 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x64, 0x73, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x64, 0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x12, 0x39, 0x0a, 0x05, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, - 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x6f, 0x61, 0x64, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x12, 0x3d, 0x0a, 0x06, 0x73, - 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, - 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, - 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, - 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x44, 0x12, 0x3d, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6d, 0x65, 0x74, 0x61, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, - 0x4d, 0x65, 0x74, 0x61, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x4d, 0x65, - 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x18, - 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, - 0x12, 0x46, 0x0a, 0x0f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, - 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0e, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x65, 0x64, 0x5f, 0x74, 0x72, 0x61, 0x6e, 0x73, - 0x66, 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6e, 0x65, 0x65, 0x64, 0x54, - 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x3c, 0x0a, 0x0a, 0x6c, 0x6f, 0x61, 0x64, 0x5f, - 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x09, 0x6c, 0x6f, 0x61, 0x64, - 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x45, 0x0a, 0x0f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x69, - 0x6e, 0x66, 0x6f, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, - 0x64, 0x65, 0x78, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x4c, 0x69, 0x73, 0x74, 0x12, 0x1b, 0x0a, 0x09, - 0x6c, 0x61, 0x7a, 0x79, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x08, 0x6c, 0x61, 0x7a, 0x79, 0x4c, 0x6f, 0x61, 0x64, 0x22, 0x8d, 0x03, 0x0a, 0x16, 0x52, 0x65, - 0x6c, 0x65, 0x61, 0x73, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, - 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x12, - 0x0a, 0x04, 0x64, 0x62, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x64, 0x62, - 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0c, 0x70, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, - 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x63, - 0x6f, 0x70, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, - 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, - 0x14, 0x0a, 0x05, 0x73, 0x68, 0x61, 0x72, 0x64, 0x18, 0x08, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, - 0x73, 0x68, 0x61, 0x72, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x65, 0x65, 0x64, 0x5f, 0x74, 0x72, - 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0c, 0x6e, 0x65, - 0x65, 0x64, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x12, 0x3d, 0x0a, 0x0a, 0x63, 0x68, - 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, - 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, - 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x97, 0x02, 0x0a, 0x0d, 0x53, 0x65, - 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x36, 0x0a, 0x03, 0x72, - 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, - 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x03, - 0x72, 0x65, 0x71, 0x12, 0x21, 0x0a, 0x0c, 0x64, 0x6d, 0x6c, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x6d, 0x6c, 0x43, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, - 0x68, 0x61, 0x72, 0x64, 0x5f, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, - 0x08, 0x52, 0x0f, 0x66, 0x72, 0x6f, 0x6d, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, - 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, - 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x2a, 0x0a, 0x11, 0x74, 0x6f, 0x74, 0x61, 0x6c, - 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x75, 0x6d, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x05, 0x52, 0x0f, 0x74, 0x6f, 0x74, 0x61, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x4e, 0x75, 0x6d, 0x22, 0xec, 0x01, 0x0a, 0x0c, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x12, 0x38, 0x0a, 0x03, 0x72, 0x65, 0x71, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, - 0x76, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x52, 0x03, 0x72, 0x65, 0x71, 0x12, 0x21, - 0x0a, 0x0c, 0x64, 0x6d, 0x6c, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x6d, 0x6c, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, - 0x73, 0x12, 0x2a, 0x0a, 0x11, 0x66, 0x72, 0x6f, 0x6d, 0x5f, 0x73, 0x68, 0x61, 0x72, 0x64, 0x5f, - 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0f, 0x66, 0x72, - 0x6f, 0x6d, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x12, 0x33, 0x0a, - 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, - 0x70, 0x65, 0x22, 0xc7, 0x01, 0x0a, 0x1a, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, - 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, - 0x61, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x63, 0x68, 0x61, - 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x52, 0x0a, 0x10, 0x72, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x8e, 0x01, 0x0a, - 0x13, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x17, 0x0a, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x12, 0x21, 0x0a, - 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, - 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, - 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, - 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, - 0x03, 0x28, 0x03, 0x52, 0x08, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0x6b, 0x0a, - 0x12, 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xe4, 0x01, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x4c, 0x6f, + 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, + 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, + 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x12, 0x39, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x54, + 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x1e, 0x0a, + 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x22, 0xbc, 0x01, + 0x0a, 0x16, 0x48, 0x61, 0x6e, 0x64, 0x6f, 0x66, 0x66, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x43, 0x0a, 0x0c, 0x73, 0x65, + 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x12, + 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x10, 0x72, 0x65, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0xac, 0x02, 0x0a, + 0x12, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, - 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x22, 0xe4, 0x01, 0x0a, 0x13, 0x47, - 0x65, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, - 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, - 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x39, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, - 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, - 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, - 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x73, 0x22, 0xbc, 0x01, 0x0a, 0x16, 0x48, 0x61, 0x6e, 0x64, 0x6f, 0x66, 0x66, 0x53, 0x65, 0x67, - 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, - 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x43, - 0x0a, 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, - 0x66, 0x6f, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x5f, - 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x10, - 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x22, 0xac, 0x02, 0x0a, 0x12, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, - 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, - 0x03, 0x52, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, - 0x12, 0x4b, 0x0a, 0x0e, 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x73, - 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x54, 0x72, - 0x69, 0x67, 0x67, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, - 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, - 0x0b, 0x64, 0x73, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x18, 0x04, 0x20, 0x03, - 0x28, 0x03, 0x52, 0x0a, 0x64, 0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x12, 0x2b, - 0x0a, 0x11, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x49, 0x44, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x10, 0x73, 0x65, 0x61, 0x6c, 0x65, - 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x63, - 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, - 0xb4, 0x01, 0x0a, 0x12, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x57, 0x61, 0x74, - 0x63, 0x68, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x6d, - 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, - 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x6f, 0x64, 0x65, - 0x49, 0x44, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x0c, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x12, 0x1c, 0x0a, - 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x12, 0x19, 0x0a, 0x08, 0x6e, - 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x6e, - 0x6f, 0x64, 0x65, 0x49, 0x64, 0x73, 0x22, 0xa8, 0x02, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, 0x79, - 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, - 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, - 0x23, 0x0a, 0x0d, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x71, 0x75, 0x65, 0x72, 0x79, 0x43, 0x68, 0x61, - 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x30, 0x0a, 0x14, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x72, 0x65, - 0x73, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x12, 0x71, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, - 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x55, 0x0a, 0x16, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, - 0x5f, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x14, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, - 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x42, 0x0a, - 0x0d, 0x73, 0x65, 0x65, 0x6b, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x73, 0x65, 0x65, 0x6b, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x22, 0x9e, 0x01, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x38, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x50, 0x61, 0x72, 0x74, - 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, - 0x65, 0x12, 0x2f, 0x0a, 0x13, 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x65, - 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, - 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, - 0x67, 0x65, 0x22, 0xf2, 0x05, 0x0a, 0x0b, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, - 0x66, 0x6f, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, - 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x19, - 0x0a, 0x08, 0x6d, 0x65, 0x6d, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x07, 0x6d, 0x65, 0x6d, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x75, 0x6d, - 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x75, 0x6d, - 0x52, 0x6f, 0x77, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x18, 0x08, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x12, 0x1c, 0x0a, - 0x09, 0x64, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x09, 0x64, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x26, 0x0a, 0x0e, 0x63, - 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x18, 0x0a, 0x20, - 0x03, 0x28, 0x03, 0x52, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, - 0x72, 0x6f, 0x6d, 0x12, 0x30, 0x0a, 0x13, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, - 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, - 0x52, 0x13, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x61, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x46, 0x0a, 0x0d, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x5f, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, - 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, - 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x43, 0x0a, - 0x0b, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x0d, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, - 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0a, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, - 0x6f, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, - 0x73, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x49, 0x64, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, - 0x0f, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x73, 0x12, 0x21, - 0x0a, 0x0c, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x10, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x49, 0x6e, 0x64, 0x65, - 0x78, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x66, 0x61, 0x6b, 0x65, 0x18, 0x11, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x46, 0x61, 0x6b, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x65, - 0x76, 0x65, 0x6c, 0x18, 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, - 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x13, - 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x27, - 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x18, 0x14, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xd0, 0x03, 0x0a, 0x0e, 0x43, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x22, - 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x03, 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x44, 0x73, 0x12, 0x4e, 0x0a, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x73, 0x74, 0x61, 0x74, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, - 0x73, 0x52, 0x0f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x73, 0x12, 0x39, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x54, - 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3d, 0x0a, - 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x33, 0x0a, 0x15, - 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x03, 0x52, 0x14, 0x72, 0x65, 0x6c, - 0x65, 0x61, 0x73, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, - 0x73, 0x12, 0x2f, 0x0a, 0x13, 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x65, - 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, - 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, - 0x67, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, - 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x49, 0x64, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x6e, - 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x55, 0x0a, 0x13, 0x55, 0x6e, - 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x09, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x73, 0x22, 0x8a, 0x01, 0x0a, 0x16, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, - 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, - 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, - 0x64, 0x65, 0x49, 0x44, 0x12, 0x58, 0x0a, 0x13, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, - 0x0b, 0x32, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, - 0x62, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x12, 0x63, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0xf5, - 0x01, 0x0a, 0x11, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x6e, - 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6f, 0x6e, 0x6c, - 0x69, 0x6e, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x48, 0x0a, 0x0f, 0x6f, 0x6e, 0x6c, - 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, + 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x12, 0x4b, 0x0a, 0x0e, + 0x62, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x0e, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, + 0x72, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0d, 0x62, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x1f, 0x0a, 0x0b, 0x64, 0x73, 0x74, + 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, + 0x64, 0x73, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x65, + 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, + 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x10, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x22, 0xb4, 0x01, 0x0a, 0x12, + 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x57, 0x61, 0x74, 0x63, 0x68, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x6d, 0x43, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x6d, 0x43, 0x68, 0x61, + 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x23, 0x0a, 0x0d, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x5f, 0x6c, + 0x6f, 0x61, 0x64, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6e, 0x6f, 0x64, + 0x65, 0x49, 0x44, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x5f, + 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, + 0x64, 0x73, 0x22, 0xa8, 0x02, 0x0a, 0x10, 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, + 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x09, 0x52, 0x0c, 0x71, 0x75, 0x65, 0x72, 0x79, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, + 0x12, 0x30, 0x0a, 0x14, 0x71, 0x75, 0x65, 0x72, 0x79, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, + 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x12, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x6e, + 0x65, 0x6c, 0x12, 0x55, 0x0a, 0x16, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x5f, 0x73, 0x65, 0x61, + 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x0e, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, - 0x6e, 0x74, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x6e, - 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x66, 0x66, - 0x6c, 0x69, 0x6e, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x4a, 0x0a, 0x10, 0x6f, 0x66, - 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x89, 0x01, 0x0a, 0x18, 0x53, 0x65, 0x61, 0x6c, 0x65, - 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, - 0x6e, 0x66, 0x6f, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, - 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x3b, 0x0a, 0x05, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x69, 0x6e, 0x66, - 0x6f, 0x73, 0x22, 0xb4, 0x02, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, - 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, - 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, - 0x61, 0x73, 0x65, 0x12, 0x61, 0x0a, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, - 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, - 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x54, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x61, - 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x54, 0x73, 0x1a, 0x5d, 0x0a, 0x10, 0x43, 0x68, - 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, - 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, - 0x12, 0x33, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, - 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, - 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9c, 0x03, 0x0a, 0x1b, 0x47, 0x65, - 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, - 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, - 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x42, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, - 0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x08, 0x63, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x41, - 0x0a, 0x0c, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x5f, 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, - 0x56, 0x69, 0x65, 0x77, 0x52, 0x0b, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, - 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x54, - 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x4d, 0x6f, 0x64, - 0x69, 0x66, 0x79, 0x54, 0x73, 0x12, 0x28, 0x0a, 0x0f, 0x6d, 0x65, 0x6d, 0x43, 0x61, 0x70, 0x61, - 0x63, 0x69, 0x74, 0x79, 0x49, 0x6e, 0x4d, 0x42, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, - 0x6d, 0x65, 0x6d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x49, 0x6e, 0x4d, 0x42, 0x12, - 0x17, 0x0a, 0x07, 0x63, 0x70, 0x75, 0x5f, 0x6e, 0x75, 0x6d, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x06, 0x63, 0x70, 0x75, 0x4e, 0x75, 0x6d, 0x22, 0xc1, 0x06, 0x0a, 0x0a, 0x4c, 0x65, 0x61, - 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x63, 0x6f, 0x6c, - 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, - 0x6c, 0x12, 0x52, 0x0a, 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x69, 0x73, - 0x74, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, - 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, - 0x69, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x44, 0x69, 0x73, 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, - 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, - 0x03, 0x52, 0x11, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x49, 0x44, 0x73, 0x12, 0x5e, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x5f, - 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, + 0x6e, 0x66, 0x6f, 0x52, 0x14, 0x67, 0x6c, 0x6f, 0x62, 0x61, 0x6c, 0x53, 0x65, 0x61, 0x6c, 0x65, + 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x0d, 0x73, 0x65, 0x65, + 0x6b, 0x5f, 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x0c, 0x73, 0x65, 0x65, 0x6b, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x22, 0x9e, 0x01, + 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, + 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x49, 0x44, 0x12, 0x38, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0e, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x2f, 0x0a, + 0x13, 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, + 0x74, 0x61, 0x67, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x69, 0x6e, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x22, 0xf2, + 0x05, 0x0a, 0x0b, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x1c, + 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x65, + 0x6d, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6d, 0x65, + 0x6d, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x6f, 0x77, + 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x75, 0x6d, 0x52, 0x6f, 0x77, 0x73, + 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x07, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4e, 0x61, 0x6d, 0x65, 0x12, + 0x18, 0x0a, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x07, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x64, 0x6d, 0x43, + 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x09, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x64, 0x6d, + 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x26, 0x0a, 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x61, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x03, 0x52, + 0x0e, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x46, 0x72, 0x6f, 0x6d, 0x12, + 0x30, 0x0a, 0x13, 0x63, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x43, 0x6f, 0x6d, 0x70, + 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x08, 0x52, 0x13, 0x63, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x64, 0x42, 0x79, 0x43, 0x6f, 0x6d, 0x70, 0x61, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x46, 0x0a, 0x0d, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x18, 0x0c, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x0c, 0x73, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x43, 0x0a, 0x0b, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x2e, 0x47, - 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x0f, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x73, 0x12, 0x24, 0x0a, 0x0d, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x54, 0x61, 0x72, - 0x67, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x13, 0x6e, 0x75, - 0x6d, 0x5f, 0x6f, 0x66, 0x5f, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x6f, 0x77, - 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x4f, 0x66, 0x47, 0x72, - 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x74, 0x0a, 0x18, 0x70, 0x61, 0x72, - 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, + 0x65, 0x72, 0x79, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x0a, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x12, 0x1f, + 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x0e, 0x20, + 0x03, 0x28, 0x03, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x73, 0x12, + 0x19, 0x0a, 0x08, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x0f, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x07, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x64, 0x73, 0x12, 0x21, 0x0a, 0x0c, 0x65, 0x6e, + 0x61, 0x62, 0x6c, 0x65, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x10, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x0b, 0x65, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x12, 0x17, 0x0a, + 0x07, 0x69, 0x73, 0x5f, 0x66, 0x61, 0x6b, 0x65, 0x18, 0x11, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, + 0x69, 0x73, 0x46, 0x61, 0x6b, 0x65, 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, + 0x12, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1b, 0x0a, + 0x09, 0x69, 0x73, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x13, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x08, 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x74, + 0x6f, 0x72, 0x61, 0x67, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x14, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x56, 0x65, 0x72, 0x73, + 0x69, 0x6f, 0x6e, 0x22, 0xd0, 0x03, 0x0a, 0x0e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, + 0x52, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x12, 0x4e, + 0x0a, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x50, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x0f, 0x70, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x39, + 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, + 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, 0x68, + 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, + 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x33, 0x0a, 0x15, 0x72, 0x65, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x03, 0x52, 0x14, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x12, 0x2f, 0x0a, + 0x13, 0x69, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x5f, 0x70, 0x65, 0x72, 0x63, 0x65, 0x6e, + 0x74, 0x61, 0x67, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x12, 0x69, 0x6e, 0x4d, 0x65, + 0x6d, 0x6f, 0x72, 0x79, 0x50, 0x65, 0x72, 0x63, 0x65, 0x6e, 0x74, 0x61, 0x67, 0x65, 0x12, 0x1f, + 0x0a, 0x0b, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x08, 0x20, + 0x03, 0x28, 0x03, 0x52, 0x0a, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x64, 0x73, 0x12, + 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, + 0x72, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, + 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x55, 0x0a, 0x13, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, + 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x22, 0x0a, + 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x44, 0x12, 0x1a, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x09, 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0x8a, 0x01, + 0x0a, 0x16, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, 0x61, + 0x6e, 0x6e, 0x65, 0x6c, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, + 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, + 0x12, 0x58, 0x0a, 0x13, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x63, + 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x27, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x43, 0x68, + 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x12, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x22, 0xf5, 0x01, 0x0a, 0x11, 0x53, + 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x23, 0x0a, 0x0d, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, + 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x4e, + 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x48, 0x0a, 0x0f, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x5f, + 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, + 0x0e, 0x6f, 0x6e, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x25, 0x0a, 0x0e, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, + 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, + 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x4a, 0x0a, 0x10, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, + 0x65, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x0f, 0x6f, 0x66, 0x66, 0x6c, 0x69, 0x6e, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x22, 0x89, 0x01, 0x0a, 0x18, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, + 0x65, 0x12, 0x3b, 0x0a, 0x05, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x43, 0x68, 0x61, + 0x6e, 0x67, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x22, 0xb4, + 0x02, 0x0a, 0x1a, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, + 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, + 0x61, 0x0a, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x18, 0x02, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, + 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x73, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, + 0x74, 0x73, 0x12, 0x22, 0x0a, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x54, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x55, 0x70, + 0x64, 0x61, 0x74, 0x65, 0x54, 0x73, 0x1a, 0x5d, 0x0a, 0x10, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, + 0x6f, 0x69, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x33, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, + 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x9c, 0x03, 0x0a, 0x1b, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, + 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, + 0x49, 0x44, 0x12, 0x42, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x03, + 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x73, 0x65, + 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, + 0x6c, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, + 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x08, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x41, 0x0a, 0x0c, 0x6c, 0x65, + 0x61, 0x64, 0x65, 0x72, 0x5f, 0x76, 0x69, 0x65, 0x77, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, + 0x52, 0x0b, 0x6c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x73, 0x12, 0x22, 0x0a, + 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x54, 0x73, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x0c, 0x6c, 0x61, 0x73, 0x74, 0x4d, 0x6f, 0x64, 0x69, 0x66, 0x79, 0x54, + 0x73, 0x12, 0x28, 0x0a, 0x0f, 0x6d, 0x65, 0x6d, 0x43, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, + 0x49, 0x6e, 0x4d, 0x42, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x52, 0x0f, 0x6d, 0x65, 0x6d, 0x43, + 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x49, 0x6e, 0x4d, 0x42, 0x12, 0x17, 0x0a, 0x07, 0x63, + 0x70, 0x75, 0x5f, 0x6e, 0x75, 0x6d, 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x63, 0x70, + 0x75, 0x4e, 0x75, 0x6d, 0x22, 0xc1, 0x06, 0x0a, 0x0a, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, + 0x69, 0x65, 0x77, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x52, 0x0a, + 0x0c, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x64, 0x69, 0x73, 0x74, 0x18, 0x03, 0x20, + 0x03, 0x28, 0x0b, 0x32, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, + 0x69, 0x65, 0x77, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x74, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0b, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, + 0x74, 0x12, 0x2d, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, 0x11, 0x67, + 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, + 0x12, 0x5e, 0x0a, 0x10, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x33, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x2e, 0x47, 0x72, 0x6f, 0x77, 0x69, + 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x0f, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x12, 0x24, 0x0a, 0x0d, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, + 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2d, 0x0a, 0x13, 0x6e, 0x75, 0x6d, 0x5f, 0x6f, 0x66, + 0x5f, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x4f, 0x66, 0x47, 0x72, 0x6f, 0x77, 0x69, 0x6e, + 0x67, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x74, 0x0a, 0x18, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, + 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, + 0x74, 0x72, 0x79, 0x52, 0x16, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, + 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x73, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x2e, 0x50, 0x61, 0x72, 0x74, + 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x5f, 0x0a, 0x10, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x35, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x74, 0x52, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x61, 0x0a, 0x14, 0x47, 0x72, + 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x33, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x49, 0x0a, + 0x1b, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, + 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, + 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x34, 0x0a, 0x10, 0x4c, 0x65, 0x61, 0x64, + 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x20, 0x0a, 0x0b, + 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x22, 0x3f, + 0x0a, 0x0b, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x74, 0x12, 0x16, 0x0a, + 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, + 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, + 0xd1, 0x05, 0x0a, 0x12, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x70, 0x61, 0x72, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, + 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x18, + 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x14, 0x6c, 0x61, 0x73, 0x74, + 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, 0x44, 0x65, 0x6c, 0x74, + 0x61, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x54, 0x0a, 0x0a, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x07, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, + 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, + 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, + 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, + 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x73, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x53, 0x6f, + 0x72, 0x74, 0x65, 0x64, 0x12, 0x33, 0x0a, 0x16, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x6a, 0x73, + 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x18, 0x0a, + 0x20, 0x03, 0x28, 0x03, 0x52, 0x13, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4a, 0x73, 0x6f, 0x6e, 0x49, + 0x6e, 0x64, 0x65, 0x78, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x61, 0x0a, 0x0f, 0x6a, 0x73, 0x6f, + 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x0b, 0x20, 0x03, + 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x56, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x6a, + 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x1a, 0x60, 0x0a, 0x0e, + 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, + 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, + 0x12, 0x38, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, + 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x63, + 0x0a, 0x12, 0x4a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x37, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0x68, 0x0a, 0x12, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x56, 0x65, + 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, + 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xbc, 0x04, + 0x0a, 0x12, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, 0x64, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x2f, 0x0a, 0x13, 0x72, 0x65, 0x6c, 0x65, + 0x61, 0x73, 0x65, 0x64, 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, + 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x12, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, + 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, + 0x12, 0x36, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x5d, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, + 0x64, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, + 0x38, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, + 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, + 0x65, 0x78, 0x49, 0x44, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x12, 0x39, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, + 0x74, 0x79, 0x70, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x4c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, + 0x70, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x74, 0x69, + 0x6d, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x6f, 0x76, + 0x65, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, + 0x66, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x6c, 0x6f, + 0x61, 0x64, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x62, 0x49, 0x44, + 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x64, 0x62, 0x49, 0x44, 0x12, 0x3d, 0x0a, 0x1b, + 0x75, 0x73, 0x65, 0x72, 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x18, 0x75, 0x73, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, + 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4d, 0x6f, 0x64, 0x65, 0x1a, 0x3f, 0x0a, 0x11, 0x46, + 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, + 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xfc, 0x02, 0x0a, + 0x11, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x0d, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, + 0x36, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, + 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x5c, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, + 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, + 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, + 0x49, 0x44, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, + 0x64, 0x65, 0x78, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, + 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x72, 0x65, + 0x63, 0x6f, 0x76, 0x65, 0x72, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x1a, 0x3f, 0x0a, 0x11, 0x46, 0x69, + 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x2c, 0x0a, 0x0f, 0x43, + 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, + 0x0a, 0x08, 0x72, 0x77, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x03, + 0x52, 0x07, 0x72, 0x77, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0xa0, 0x03, 0x0a, 0x07, 0x52, 0x65, + 0x70, 0x6c, 0x69, 0x63, 0x61, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x64, + 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, + 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, + 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x5f, 0x6e, 0x6f, 0x64, + 0x65, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x72, 0x6f, 0x4e, 0x6f, 0x64, 0x65, + 0x73, 0x12, 0x5f, 0x0a, 0x12, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x6f, 0x64, + 0x65, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, + 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, + 0x52, 0x10, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x72, 0x77, 0x5f, 0x73, 0x71, 0x5f, 0x6e, 0x6f, 0x64, 0x65, + 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x03, 0x52, 0x09, 0x72, 0x77, 0x53, 0x71, 0x4e, 0x6f, 0x64, + 0x65, 0x73, 0x12, 0x1e, 0x0a, 0x0b, 0x72, 0x6f, 0x5f, 0x73, 0x71, 0x5f, 0x6e, 0x6f, 0x64, 0x65, + 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x03, 0x52, 0x09, 0x72, 0x6f, 0x53, 0x71, 0x4e, 0x6f, 0x64, + 0x65, 0x73, 0x1a, 0x68, 0x0a, 0x15, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, + 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x84, 0x07, 0x0a, + 0x0a, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x04, 0x74, + 0x79, 0x70, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, + 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, + 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, + 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x16, 0x0a, + 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, + 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x37, 0x0a, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x28, 0x0a, 0x0f, 0x67, 0x72, 0x6f, 0x77, + 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x07, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x0f, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x12, 0x26, 0x0a, 0x0e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, 0x6e, 0x54, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x18, 0x08, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x65, 0x61, 0x6c, + 0x65, 0x64, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x54, 0x61, + 0x72, 0x67, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x03, 0x52, 0x0d, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x12, 0x28, 0x0a, 0x0f, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x54, 0x61, 0x72, + 0x67, 0x65, 0x74, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0f, 0x64, 0x72, 0x6f, 0x70, 0x70, + 0x65, 0x64, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x3d, 0x0a, 0x0a, 0x63, 0x68, + 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, + 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x74, 0x0a, 0x18, 0x70, 0x61, 0x72, + 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x76, 0x65, 0x72, + 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x16, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, - 0x3c, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x1a, 0x5f, 0x0a, - 0x10, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, 0x74, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, - 0x6b, 0x65, 0x79, 0x12, 0x35, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, - 0x69, 0x73, 0x74, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x61, - 0x0a, 0x14, 0x47, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x33, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, - 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, - 0x01, 0x1a, 0x49, 0x0a, 0x1b, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, - 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, - 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, - 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x34, 0x0a, 0x10, - 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x56, 0x69, 0x65, 0x77, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, - 0x12, 0x20, 0x0a, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x61, 0x62, 0x6c, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x73, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x61, 0x62, - 0x6c, 0x65, 0x22, 0x3f, 0x0a, 0x0b, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x73, - 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x22, 0x89, 0x04, 0x0a, 0x12, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x56, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, - 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x70, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x70, - 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, - 0x6e, 0x65, 0x6c, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x14, - 0x6c, 0x61, 0x73, 0x74, 0x5f, 0x64, 0x65, 0x6c, 0x74, 0x61, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, - 0x74, 0x61, 0x6d, 0x70, 0x18, 0x06, 0x20, 0x01, 0x28, 0x04, 0x52, 0x12, 0x6c, 0x61, 0x73, 0x74, - 0x44, 0x65, 0x6c, 0x74, 0x61, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x54, - 0x0a, 0x0a, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x18, 0x07, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x56, - 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, - 0x49, 0x6e, 0x66, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x09, 0x69, 0x6e, 0x64, 0x65, 0x78, - 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x08, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, - 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x69, - 0x73, 0x5f, 0x73, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, - 0x69, 0x73, 0x53, 0x6f, 0x72, 0x74, 0x65, 0x64, 0x12, 0x33, 0x0a, 0x16, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x5f, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x73, 0x74, 0x61, - 0x74, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x03, 0x52, 0x13, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x4a, - 0x73, 0x6f, 0x6e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x53, 0x74, 0x61, 0x74, 0x73, 0x1a, 0x60, 0x0a, - 0x0e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, - 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, - 0x79, 0x12, 0x38, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, - 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, - 0x68, 0x0a, 0x12, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, - 0x1e, 0x0a, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x0a, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, - 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0xbc, 0x04, 0x0a, 0x12, 0x43, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, - 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x2f, 0x0a, 0x13, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, - 0x5f, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, - 0x03, 0x52, 0x12, 0x72, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x36, 0x0a, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x6d, + 0x39, 0x0a, 0x08, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x50, 0x18, 0x0d, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x08, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x50, 0x12, 0x72, 0x0a, 0x18, 0x73, 0x65, + 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x6f, 0x77, + 0x5f, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x12, 0x5d, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x6e, - 0x64, 0x65, 0x78, 0x49, 0x44, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x38, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, 0x64, 0x49, - 0x6e, 0x66, 0x6f, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0c, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, - 0x78, 0x49, 0x44, 0x12, 0x39, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x06, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, - 0x54, 0x79, 0x70, 0x65, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x23, - 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x18, - 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x54, 0x69, - 0x6d, 0x65, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x66, 0x69, 0x65, 0x6c, - 0x64, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, 0x6c, 0x6f, 0x61, 0x64, 0x46, 0x69, - 0x65, 0x6c, 0x64, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x62, 0x49, 0x44, 0x18, 0x09, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x04, 0x64, 0x62, 0x49, 0x44, 0x12, 0x3d, 0x0a, 0x1b, 0x75, 0x73, 0x65, 0x72, - 0x5f, 0x73, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x0a, 0x20, 0x01, 0x28, 0x08, 0x52, 0x18, 0x75, - 0x73, 0x65, 0x72, 0x53, 0x70, 0x65, 0x63, 0x69, 0x66, 0x69, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, - 0x69, 0x63, 0x61, 0x4d, 0x6f, 0x64, 0x65, 0x1a, 0x3f, 0x0a, 0x11, 0x46, 0x69, 0x65, 0x6c, 0x64, - 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, - 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, - 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xfc, 0x02, 0x0a, 0x11, 0x50, 0x61, 0x72, - 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x22, - 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, - 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, - 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x36, 0x0a, 0x06, 0x73, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1e, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x5c, 0x0a, 0x0d, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x49, 0x44, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x37, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, - 0x6f, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x0c, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, - 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, 0x72, 0x5f, 0x74, 0x69, 0x6d, - 0x65, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0c, 0x72, 0x65, 0x63, 0x6f, 0x76, 0x65, - 0x72, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x1a, 0x3f, 0x0a, 0x11, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x49, - 0x6e, 0x64, 0x65, 0x78, 0x49, 0x44, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, - 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, - 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x2c, 0x0a, 0x0f, 0x43, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x77, - 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x72, 0x77, - 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x22, 0xa0, 0x03, 0x0a, 0x07, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, - 0x61, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, - 0x44, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x61, + 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x77, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x15, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, + 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x77, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x49, + 0x0a, 0x1b, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, + 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x48, 0x0a, 0x1a, 0x53, 0x65, 0x61, + 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x77, 0x43, 0x6f, 0x75, + 0x6e, 0x74, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, + 0x02, 0x38, 0x01, 0x22, 0xc0, 0x03, 0x0a, 0x17, 0x53, 0x79, 0x6e, 0x63, 0x44, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, + 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x03, - 0x20, 0x03, 0x28, 0x03, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x25, 0x0a, 0x0e, 0x72, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x04, 0x20, - 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x12, 0x19, 0x0a, 0x08, 0x72, 0x6f, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x05, - 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x72, 0x6f, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x5f, 0x0a, - 0x12, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x5f, 0x69, 0x6e, - 0x66, 0x6f, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, - 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x63, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x12, 0x1e, - 0x0a, 0x0b, 0x72, 0x77, 0x5f, 0x73, 0x71, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x07, 0x20, - 0x03, 0x28, 0x03, 0x52, 0x09, 0x72, 0x77, 0x53, 0x71, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x1e, - 0x0a, 0x0b, 0x72, 0x6f, 0x5f, 0x73, 0x71, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x08, 0x20, - 0x03, 0x28, 0x03, 0x52, 0x09, 0x72, 0x6f, 0x53, 0x71, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x1a, 0x68, - 0x0a, 0x15, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, - 0x6f, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x39, 0x0a, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x84, 0x07, 0x0a, 0x0a, 0x53, 0x79, 0x6e, - 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x30, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x54, - 0x79, 0x70, 0x65, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, - 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, - 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x73, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, - 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, - 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, - 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x37, 0x0a, 0x04, 0x69, - 0x6e, 0x66, 0x6f, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x04, - 0x69, 0x6e, 0x66, 0x6f, 0x12, 0x28, 0x0a, 0x0f, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x49, - 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, 0x07, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0f, 0x67, - 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x26, - 0x0a, 0x0e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, - 0x18, 0x08, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0e, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x49, 0x6e, - 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x24, 0x0a, 0x0d, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, - 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0d, 0x54, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x28, 0x0a, 0x0f, - 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x49, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x18, - 0x0a, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0f, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x49, 0x6e, - 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x3d, 0x0a, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, - 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, - 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x12, 0x74, 0x0a, 0x18, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, - 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, 0x6e, - 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x16, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, - 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x39, 0x0a, 0x08, 0x64, - 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x50, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, - 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x08, 0x64, 0x65, - 0x6c, 0x65, 0x74, 0x65, 0x43, 0x50, 0x12, 0x72, 0x0a, 0x18, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, - 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x72, 0x6f, 0x77, 0x5f, 0x63, 0x6f, 0x75, - 0x6e, 0x74, 0x18, 0x0e, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x39, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, - 0x6e, 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x2e, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x77, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x52, 0x15, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, - 0x6e, 0x74, 0x52, 0x6f, 0x77, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x1a, 0x49, 0x0a, 0x1b, 0x50, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x48, 0x0a, 0x1a, 0x53, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x6f, 0x77, 0x43, 0x6f, 0x75, 0x6e, 0x74, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, - 0xc0, 0x03, 0x0a, 0x17, 0x53, 0x79, 0x6e, 0x63, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, + 0x38, 0x0a, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x52, 0x07, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, 0x68, + 0x65, 0x6d, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, + 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, + 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x3d, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, + 0x5f, 0x6d, 0x65, 0x74, 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6c, + 0x6f, 0x61, 0x64, 0x4d, 0x65, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x49, 0x44, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, + 0x45, 0x0a, 0x0f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x6c, 0x69, + 0x73, 0x74, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x49, 0x6e, + 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, + 0x66, 0x6f, 0x4c, 0x69, 0x73, 0x74, 0x22, 0x97, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x08, + 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, + 0x18, 0x01, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x05, 0x6e, 0x6f, 0x64, + 0x65, 0x73, 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x72, 0x67, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, + 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x22, 0xf7, 0x01, 0x0a, 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x22, 0x0a, - 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x44, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x38, 0x0a, 0x07, 0x61, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, + 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x32, 0x0a, + 0x15, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x12, 0x32, 0x0a, 0x15, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x13, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, + 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x75, 0x6d, + 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, + 0x6e, 0x75, 0x6d, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x22, 0x77, 0x0a, 0x1c, 0x44, 0x65, + 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, + 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, + 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, + 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x22, 0xa2, 0x01, 0x0a, 0x1d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x4c, 0x0a, 0x0e, 0x72, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, + 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, 0xf0, 0x05, 0x0a, 0x11, 0x52, 0x65, 0x73, + 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, + 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, + 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, + 0x74, 0x79, 0x12, 0x2c, 0x0a, 0x12, 0x6e, 0x75, 0x6d, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, + 0x62, 0x6c, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, + 0x6e, 0x75, 0x6d, 0x41, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, + 0x12, 0x69, 0x0a, 0x12, 0x6e, 0x75, 0x6d, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5f, 0x72, + 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x41, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x07, 0x61, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x12, 0x3d, 0x0a, 0x09, 0x6c, 0x6f, 0x61, 0x64, 0x5f, 0x6d, 0x65, 0x74, - 0x61, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, - 0x64, 0x4d, 0x65, 0x74, 0x61, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x08, 0x6c, 0x6f, 0x61, 0x64, 0x4d, - 0x65, 0x74, 0x61, 0x12, 0x1c, 0x0a, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, 0x44, - 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x49, - 0x44, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x08, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x45, 0x0a, 0x0f, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x5f, 0x6c, 0x69, 0x73, 0x74, 0x18, 0x09, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x49, 0x6e, 0x66, 0x6f, 0x4c, 0x69, - 0x73, 0x74, 0x22, 0x97, 0x01, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1e, 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, - 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, - 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, - 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x3c, - 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x67, - 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, - 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0xf7, 0x01, 0x0a, - 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, - 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x32, 0x0a, 0x15, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, - 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x32, 0x0a, - 0x15, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x13, 0x74, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, - 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1f, 0x0a, 0x0b, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0a, 0x6e, 0x75, 0x6d, 0x52, - 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x22, 0x77, 0x0a, 0x1c, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, - 0x62, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, - 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, - 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x22, - 0xa2, 0x01, 0x0a, 0x1d, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, - 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, - 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x4c, 0x0a, 0x0e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x79, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, + 0x6e, 0x66, 0x6f, 0x2e, 0x4e, 0x75, 0x6d, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x4c, 0x6f, + 0x61, 0x64, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x12, 0x66, 0x0a, 0x11, 0x6e, + 0x75, 0x6d, 0x5f, 0x6f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x6f, 0x64, 0x65, + 0x18, 0x05, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4e, 0x75, + 0x6d, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x6e, 0x74, + 0x72, 0x79, 0x52, 0x0f, 0x6e, 0x75, 0x6d, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x4e, + 0x6f, 0x64, 0x65, 0x12, 0x66, 0x0a, 0x11, 0x6e, 0x75, 0x6d, 0x5f, 0x69, 0x6e, 0x63, 0x6f, 0x6d, + 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, - 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0d, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, - 0x72, 0x6f, 0x75, 0x70, 0x22, 0xf0, 0x05, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, - 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, - 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x1e, - 0x0a, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, - 0x42, 0x02, 0x18, 0x01, 0x52, 0x08, 0x63, 0x61, 0x70, 0x61, 0x63, 0x69, 0x74, 0x79, 0x12, 0x2c, - 0x0a, 0x12, 0x6e, 0x75, 0x6d, 0x5f, 0x61, 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x5f, - 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x41, - 0x76, 0x61, 0x69, 0x6c, 0x61, 0x62, 0x6c, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x69, 0x0a, 0x12, - 0x6e, 0x75, 0x6d, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x70, 0x6c, 0x69, - 0x63, 0x61, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x2e, - 0x4e, 0x75, 0x6d, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6e, 0x75, 0x6d, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, - 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x12, 0x66, 0x0a, 0x11, 0x6e, 0x75, 0x6d, 0x5f, 0x6f, - 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x05, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4e, 0x75, 0x6d, 0x4f, 0x75, 0x74, - 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, - 0x6e, 0x75, 0x6d, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x12, - 0x66, 0x0a, 0x11, 0x6e, 0x75, 0x6d, 0x5f, 0x69, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x5f, - 0x6e, 0x6f, 0x64, 0x65, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x3a, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x49, 0x6e, 0x66, - 0x6f, 0x2e, 0x4e, 0x75, 0x6d, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, - 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6e, 0x75, 0x6d, 0x49, 0x6e, 0x63, 0x6f, 0x6d, - 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x3c, 0x0a, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, - 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x67, 0x2e, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x06, 0x63, - 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x33, 0x0a, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x08, - 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, - 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x1a, 0x43, 0x0a, 0x15, 0x4e, 0x75, - 0x6d, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x45, 0x6e, - 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, - 0x42, 0x0a, 0x14, 0x4e, 0x75, 0x6d, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x4e, 0x6f, - 0x64, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x70, 0x49, 0x6e, 0x66, 0x6f, 0x2e, 0x4e, 0x75, 0x6d, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, + 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0f, 0x6e, 0x75, 0x6d, 0x49, + 0x6e, 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x3c, 0x0a, 0x06, 0x63, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x72, 0x67, 0x2e, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x43, 0x6f, 0x6e, 0x66, 0x69, + 0x67, 0x52, 0x06, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x33, 0x0a, 0x05, 0x6e, 0x6f, 0x64, + 0x65, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4e, + 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x05, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x1a, 0x43, + 0x0a, 0x15, 0x4e, 0x75, 0x6d, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x52, 0x65, 0x70, 0x6c, 0x69, + 0x63, 0x61, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, - 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4e, 0x75, 0x6d, 0x49, 0x6e, 0x63, 0x6f, 0x6d, 0x69, + 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4e, 0x75, 0x6d, 0x4f, 0x75, 0x74, 0x67, 0x6f, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x76, 0x61, - 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xfa, 0x02, 0x0a, 0x0d, 0x44, 0x65, 0x6c, 0x65, - 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, - 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, - 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, - 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, - 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, - 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x63, 0x68, 0x61, - 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x0c, 0x70, 0x72, 0x69, 0x6d, 0x61, - 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, - 0x65, 0x6d, 0x61, 0x2e, 0x49, 0x44, 0x73, 0x52, 0x0b, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, - 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, - 0x70, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x04, 0x52, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, - 0x61, 0x6d, 0x70, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x08, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, - 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x75, 0x73, 0x65, - 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, 0x07, 0x75, 0x73, 0x65, - 0x4c, 0x6f, 0x61, 0x64, 0x22, 0xe6, 0x02, 0x0a, 0x12, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, - 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x23, 0x0a, - 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x02, - 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, - 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, - 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, - 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, - 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x76, 0x63, - 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x73, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x03, 0x52, - 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x73, 0x12, 0x3b, 0x0a, 0x0c, 0x70, + 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x42, 0x0a, 0x14, 0x4e, 0x75, 0x6d, 0x49, 0x6e, + 0x63, 0x6f, 0x6d, 0x69, 0x6e, 0x67, 0x4e, 0x6f, 0x64, 0x65, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xfa, 0x02, 0x0a, 0x0d, + 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, + 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, + 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, + 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x63, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, + 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1d, 0x0a, 0x0a, + 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x12, 0x3b, 0x0a, 0x0c, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x49, 0x44, 0x73, 0x52, 0x0b, 0x70, 0x72, 0x69, @@ -8921,176 +9007,218 @@ var file_query_coord_proto_rawDesc = []byte{ 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x12, 0x33, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x61, 0x74, - 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x22, 0x8a, 0x01, - 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x66, 0x61, - 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x09, - 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x49, 0x64, 0x73, 0x12, 0x1f, 0x0a, 0x0b, 0x6d, 0x69, 0x73, - 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, - 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x49, 0x64, 0x73, 0x22, 0x68, 0x0a, 0x16, 0x41, 0x63, + 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x19, 0x0a, + 0x08, 0x75, 0x73, 0x65, 0x5f, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x09, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x07, 0x75, 0x73, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x22, 0xe6, 0x02, 0x0a, 0x12, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, + 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x5f, + 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, + 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x21, 0x0a, 0x0c, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, + 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x64, 0x12, 0x23, 0x0a, 0x0d, 0x76, 0x63, 0x68, + 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x0c, 0x76, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x1f, + 0x0a, 0x0b, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x05, 0x20, + 0x03, 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x64, 0x73, 0x12, + 0x3b, 0x0a, 0x0c, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, + 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x18, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x49, 0x44, 0x73, 0x52, + 0x0b, 0x70, 0x72, 0x69, 0x6d, 0x61, 0x72, 0x79, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x1e, 0x0a, 0x0a, + 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x18, 0x07, 0x20, 0x03, 0x28, 0x04, + 0x52, 0x0a, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x73, 0x12, 0x33, 0x0a, 0x05, + 0x73, 0x63, 0x6f, 0x70, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1d, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x70, + 0x65, 0x22, 0x8a, 0x01, 0x0a, 0x13, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, + 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1d, + 0x0a, 0x0a, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x03, 0x52, 0x09, 0x66, 0x61, 0x69, 0x6c, 0x65, 0x64, 0x49, 0x64, 0x73, 0x12, 0x1f, 0x0a, + 0x0b, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x5f, 0x69, 0x64, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x03, 0x52, 0x0a, 0x6d, 0x69, 0x73, 0x73, 0x69, 0x6e, 0x67, 0x49, 0x64, 0x73, 0x22, 0x68, + 0x0a, 0x16, 0x41, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, + 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x68, + 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x22, 0x6a, 0x0a, 0x18, 0x44, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x65, 0x72, 0x49, 0x44, 0x22, 0x6a, 0x0a, 0x18, 0x44, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, - 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, - 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x18, - 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x09, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, - 0x22, 0x67, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, - 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1e, 0x0a, 0x0a, 0x63, 0x68, 0x65, - 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x05, 0x52, 0x0a, 0x63, - 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x73, 0x22, 0x90, 0x01, 0x0a, 0x14, 0x4c, 0x69, - 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x65, 0x72, 0x49, 0x44, 0x22, 0x67, 0x0a, 0x13, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, + 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1e, 0x0a, + 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x05, 0x52, 0x0a, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x44, 0x73, 0x22, 0x90, 0x01, + 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x63, + 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, + 0x66, 0x6f, 0x52, 0x0c, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x73, + 0x22, 0x65, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, + 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, + 0x12, 0x0a, 0x04, 0x64, 0x65, 0x73, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, + 0x65, 0x73, 0x63, 0x12, 0x1c, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, + 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, + 0x64, 0x12, 0x14, 0x0a, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x22, 0x76, 0x0a, 0x0d, 0x53, 0x65, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, + 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, + 0x1e, 0x0a, 0x0b, 0x6e, 0x75, 0x6d, 0x5f, 0x6f, 0x66, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x6e, 0x75, 0x6d, 0x4f, 0x66, 0x52, 0x6f, 0x77, 0x73, 0x22, + 0x72, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, + 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x3d, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x73, 0x22, 0xf1, 0x02, 0x0a, 0x0d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, + 0x4e, 0x61, 0x6d, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, + 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x12, 0x64, 0x72, 0x6f, 0x70, 0x70, + 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, + 0x03, 0x28, 0x03, 0x52, 0x11, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, + 0x67, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, + 0x28, 0x03, 0x52, 0x11, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x49, 0x44, 0x73, 0x12, 0x50, 0x0a, 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, + 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x0d, 0x73, 0x65, 0x65, 0x6b, 0x5f, + 0x70, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, + 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x73, + 0x65, 0x65, 0x6b, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x11, 0x64, + 0x65, 0x6c, 0x65, 0x74, 0x65, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x68, 0x65, + 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x22, 0x9c, 0x01, 0x0a, 0x10, 0x43, 0x6f, 0x6c, 0x6c, + 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x22, 0x0a, 0x0c, + 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, + 0x12, 0x4a, 0x0a, 0x0f, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, + 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x0e, 0x43, 0x68, + 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x12, 0x18, 0x0a, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x4a, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, + 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, + 0x01, 0x28, 0x09, 0x52, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, + 0x74, 0x65, 0x22, 0x48, 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, + 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, + 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, + 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x88, 0x01, 0x0a, + 0x15, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3a, 0x0a, 0x09, 0x6e, + 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x22, 0x6b, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, + 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, + 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, + 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x44, 0x22, 0xb9, 0x01, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0e, + 0x0a, 0x02, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x23, + 0x0a, 0x0d, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, + 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, + 0x6d, 0x65, 0x73, 0x12, 0x2b, 0x0a, 0x11, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, + 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, 0x10, + 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, + 0x22, 0x49, 0x0a, 0x15, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, + 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x48, 0x0a, 0x14, 0x52, + 0x65, 0x73, 0x75, 0x6d, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, + 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x4d, 0x0a, 0x19, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, + 0x62, 0x61, 0x73, 0x65, 0x22, 0x6e, 0x0a, 0x1a, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, + 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, - 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x43, 0x0a, 0x0c, 0x63, 0x68, 0x65, 0x63, 0x6b, - 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x0c, - 0x63, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x73, 0x22, 0x65, 0x0a, 0x0b, - 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, 0x0a, 0x02, 0x69, - 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x64, - 0x65, 0x73, 0x63, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x64, 0x65, 0x73, 0x63, 0x12, - 0x1c, 0x0a, 0x09, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, 0x18, 0x03, 0x20, 0x01, - 0x28, 0x08, 0x52, 0x09, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x64, 0x12, 0x14, 0x0a, - 0x05, 0x66, 0x6f, 0x75, 0x6e, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x08, 0x52, 0x05, 0x66, 0x6f, - 0x75, 0x6e, 0x64, 0x22, 0x76, 0x0a, 0x0d, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x61, - 0x72, 0x67, 0x65, 0x74, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x02, 0x49, 0x44, 0x12, 0x35, 0x0a, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x02, 0x20, - 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x4c, - 0x65, 0x76, 0x65, 0x6c, 0x52, 0x05, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x1e, 0x0a, 0x0b, 0x6e, - 0x75, 0x6d, 0x5f, 0x6f, 0x66, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x09, 0x6e, 0x75, 0x6d, 0x4f, 0x66, 0x52, 0x6f, 0x77, 0x73, 0x22, 0x72, 0x0a, 0x0f, 0x50, - 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x20, - 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, - 0x12, 0x3d, 0x0a, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x02, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x54, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x08, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, - 0xf1, 0x02, 0x0a, 0x0d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x54, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x12, 0x20, 0x0a, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, - 0x61, 0x6d, 0x65, 0x12, 0x2d, 0x0a, 0x12, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x5f, 0x73, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, - 0x11, 0x64, 0x72, 0x6f, 0x70, 0x70, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, - 0x44, 0x73, 0x12, 0x2d, 0x0a, 0x12, 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x5f, 0x73, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x11, - 0x67, 0x72, 0x6f, 0x77, 0x69, 0x6e, 0x67, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, - 0x73, 0x12, 0x50, 0x0a, 0x11, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x5f, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, - 0x74, 0x52, 0x10, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, - 0x65, 0x74, 0x73, 0x12, 0x42, 0x0a, 0x0d, 0x73, 0x65, 0x65, 0x6b, 0x5f, 0x70, 0x6f, 0x73, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, - 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x0c, 0x73, 0x65, 0x65, 0x6b, 0x50, - 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x4a, 0x0a, 0x11, 0x64, 0x65, 0x6c, 0x65, 0x74, - 0x65, 0x5f, 0x63, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, 0x69, 0x6e, 0x74, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x6d, 0x73, 0x67, 0x2e, 0x4d, 0x73, 0x67, 0x50, 0x6f, 0x73, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x10, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x70, 0x6f, - 0x69, 0x6e, 0x74, 0x22, 0x9c, 0x01, 0x0a, 0x10, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, - 0x6f, 0x6e, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, - 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x4a, 0x0a, 0x0f, - 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x18, - 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x52, 0x0e, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, - 0x6c, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, - 0x6f, 0x6e, 0x22, 0x4a, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x0e, - 0x0a, 0x02, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x18, - 0x0a, 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x07, 0x61, 0x64, 0x64, 0x72, 0x65, 0x73, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, - 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x22, 0x48, - 0x0a, 0x14, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, - 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x88, 0x01, 0x0a, 0x15, 0x4c, 0x69, 0x73, - 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, - 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, - 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x3a, 0x0a, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x49, - 0x6e, 0x66, 0x6f, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x09, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x6e, - 0x66, 0x6f, 0x73, 0x22, 0x6b, 0x0a, 0x1f, 0x47, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, - 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, - 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, - 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x22, 0xb9, 0x01, 0x0a, 0x20, 0x47, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, - 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0e, 0x0a, 0x02, 0x49, 0x44, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x02, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x63, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, - 0x09, 0x52, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, - 0x2b, 0x0a, 0x11, 0x73, 0x65, 0x61, 0x6c, 0x65, 0x64, 0x5f, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x49, 0x44, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x03, 0x52, 0x10, 0x73, 0x65, 0x61, 0x6c, - 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x22, 0x49, 0x0a, 0x15, - 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, - 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x48, 0x0a, 0x14, 0x52, 0x65, 0x73, 0x75, 0x6d, - 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, - 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, - 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, - 0x65, 0x22, 0x4d, 0x0a, 0x19, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, - 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, + 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x61, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x41, 0x63, + 0x74, 0x69, 0x76, 0x65, 0x22, 0x5e, 0x0a, 0x12, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x4e, + 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, + 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, + 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, + 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x44, 0x22, 0x5d, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x4e, 0x6f, + 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, + 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, + 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, + 0x65, 0x49, 0x44, 0x22, 0x94, 0x02, 0x0a, 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, + 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, - 0x22, 0x6e, 0x0a, 0x1a, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, - 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x69, 0x73, 0x5f, 0x61, 0x63, 0x74, 0x69, 0x76, 0x65, - 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x69, 0x73, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, - 0x22, 0x5e, 0x0a, 0x12, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, - 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, - 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x22, 0x5d, 0x0a, 0x11, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, + 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x23, + 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, + 0x65, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x72, 0x61, 0x6e, + 0x73, 0x66, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, + 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x41, 0x6c, 0x6c, 0x12, 0x20, 0x0a, 0x0c, 0x74, + 0x6f, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x08, 0x52, 0x0a, 0x74, 0x6f, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x1b, 0x0a, + 0x09, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, + 0x52, 0x08, 0x63, 0x6f, 0x70, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x99, 0x02, 0x0a, 0x16, 0x54, + 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, - 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x16, 0x0a, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, - 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x22, - 0x94, 0x02, 0x0a, 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, - 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, - 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x1c, 0x0a, 0x09, - 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, + 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, + 0x65, 0x6c, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, + 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, @@ -9101,535 +9229,517 @@ var file_query_coord_proto_rawDesc = []byte{ 0x6c, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x74, 0x6f, 0x41, 0x6c, 0x6c, 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x6d, 0x6f, 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x63, 0x6f, - 0x70, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x99, 0x02, 0x0a, 0x16, 0x54, 0x72, 0x61, 0x6e, 0x73, - 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, - 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, - 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, - 0x61, 0x73, 0x65, 0x12, 0x21, 0x0a, 0x0c, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x5f, 0x6e, - 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x63, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x4e, 0x61, 0x6d, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x73, - 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x74, - 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x12, 0x21, 0x0a, 0x0c, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x5f, 0x61, 0x6c, 0x6c, - 0x18, 0x05, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x74, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, - 0x41, 0x6c, 0x6c, 0x12, 0x20, 0x0a, 0x0c, 0x74, 0x6f, 0x5f, 0x61, 0x6c, 0x6c, 0x5f, 0x6e, 0x6f, - 0x64, 0x65, 0x73, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0a, 0x74, 0x6f, 0x41, 0x6c, 0x6c, - 0x4e, 0x6f, 0x64, 0x65, 0x73, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x6f, 0x70, 0x79, 0x5f, 0x6d, 0x6f, - 0x64, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, 0x63, 0x6f, 0x70, 0x79, 0x4d, 0x6f, - 0x64, 0x65, 0x22, 0x9f, 0x01, 0x0a, 0x21, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, - 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, - 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x23, 0x0a, 0x0d, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, 0x03, 0x20, 0x01, 0x28, - 0x03, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x12, - 0x23, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, - 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x4e, 0x6f, - 0x64, 0x65, 0x49, 0x44, 0x22, 0xd5, 0x01, 0x0a, 0x17, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4c, - 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, - 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x62, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, - 0x52, 0x04, 0x64, 0x62, 0x49, 0x44, 0x12, 0x24, 0x0a, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0d, 0x63, - 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x12, 0x25, 0x0a, 0x0e, - 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x04, - 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x4e, 0x75, 0x6d, - 0x62, 0x65, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, - 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0e, 0x72, 0x65, - 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x22, 0xc4, 0x01, 0x0a, - 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, + 0x70, 0x79, 0x4d, 0x6f, 0x64, 0x65, 0x22, 0x9f, 0x01, 0x0a, 0x21, 0x43, 0x68, 0x65, 0x63, 0x6b, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, + 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, + 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x23, + 0x0a, 0x0d, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x5f, 0x6e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x4e, 0x6f, 0x64, + 0x65, 0x49, 0x44, 0x12, 0x23, 0x0a, 0x0d, 0x74, 0x61, 0x72, 0x67, 0x65, 0x74, 0x5f, 0x6e, 0x6f, + 0x64, 0x65, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x74, 0x61, 0x72, 0x67, + 0x65, 0x74, 0x4e, 0x6f, 0x64, 0x65, 0x49, 0x44, 0x22, 0xd5, 0x01, 0x0a, 0x17, 0x55, 0x70, 0x64, + 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, - 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x3d, 0x0a, 0x06, 0x73, 0x63, - 0x68, 0x65, 0x6d, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x63, 0x68, 0x65, 0x6d, - 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x18, 0x0a, 0x07, 0x76, 0x65, 0x72, - 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x76, 0x65, 0x72, 0x73, - 0x69, 0x6f, 0x6e, 0x22, 0x82, 0x02, 0x0a, 0x12, 0x52, 0x75, 0x6e, 0x41, 0x6e, 0x61, 0x6c, 0x79, - 0x7a, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, - 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, - 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x18, 0x0a, 0x07, - 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, - 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x5f, - 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, 0x65, 0x6c, 0x64, 0x49, - 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x5f, 0x6e, 0x61, - 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x61, 0x6e, 0x61, 0x6c, 0x79, - 0x7a, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x6c, 0x61, 0x63, - 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x18, 0x05, 0x20, 0x03, 0x28, 0x0c, 0x52, 0x0b, 0x70, - 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x12, 0x1f, 0x0a, 0x0b, 0x77, 0x69, - 0x74, 0x68, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28, 0x08, 0x52, - 0x0a, 0x77, 0x69, 0x74, 0x68, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, 0x1b, 0x0a, 0x09, 0x77, - 0x69, 0x74, 0x68, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x08, - 0x77, 0x69, 0x74, 0x68, 0x48, 0x61, 0x73, 0x68, 0x22, 0x4d, 0x0a, 0x19, 0x4c, 0x69, 0x73, 0x74, - 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, - 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x71, 0x0a, 0x1a, 0x4c, 0x69, 0x73, 0x74, 0x4c, - 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, - 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1e, 0x0a, 0x0a, 0x73, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x0a, - 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x2a, 0x36, 0x0a, 0x09, 0x4c, 0x6f, - 0x61, 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x46, 0x75, 0x6c, 0x6c, 0x10, - 0x00, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, - 0x49, 0x6e, 0x64, 0x65, 0x78, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x10, 0x03, 0x2a, 0x40, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, - 0x0b, 0x0a, 0x07, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, - 0x41, 0x6c, 0x6c, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x69, - 0x6e, 0x67, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x69, 0x63, - 0x61, 0x6c, 0x10, 0x03, 0x2a, 0x7a, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x74, 0x45, 0x78, 0x69, - 0x73, 0x74, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x6f, 0x74, 0x50, 0x72, 0x65, 0x73, 0x65, - 0x6e, 0x74, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x6e, 0x44, 0x69, 0x73, 0x6b, 0x10, 0x02, - 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, 0x4d, 0x65, 0x6d, - 0x6f, 0x72, 0x79, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, - 0x79, 0x10, 0x04, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, 0x6e, - 0x47, 0x50, 0x55, 0x10, 0x05, 0x12, 0x09, 0x0a, 0x05, 0x49, 0x6e, 0x47, 0x50, 0x55, 0x10, 0x06, - 0x2a, 0x64, 0x0a, 0x10, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x43, 0x6f, 0x6e, 0x64, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x43, 0x6f, - 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x48, 0x61, 0x6e, - 0x64, 0x6f, 0x66, 0x66, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, - 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x47, 0x72, 0x70, 0x63, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, 0x64, 0x65, - 0x44, 0x6f, 0x77, 0x6e, 0x10, 0x04, 0x2a, 0x42, 0x0a, 0x08, 0x4c, 0x6f, 0x61, 0x64, 0x54, 0x79, - 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x54, 0x79, 0x70, - 0x65, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, - 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x02, 0x2a, 0x32, 0x0a, 0x0a, 0x4c, 0x6f, - 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, 0x49, 0x6e, 0x76, 0x61, - 0x6c, 0x69, 0x64, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x6f, 0x61, 0x64, 0x69, 0x6e, 0x67, - 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x10, 0x02, 0x2a, 0x57, - 0x0a, 0x08, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, 0x0a, 0x06, 0x52, 0x65, - 0x6d, 0x6f, 0x76, 0x65, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x65, 0x74, 0x10, 0x01, 0x12, - 0x09, 0x0a, 0x05, 0x41, 0x6d, 0x65, 0x6e, 0x64, 0x10, 0x02, 0x12, 0x11, 0x0a, 0x0d, 0x55, 0x70, - 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x10, 0x03, 0x12, 0x18, 0x0a, - 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, - 0x53, 0x74, 0x61, 0x74, 0x73, 0x10, 0x04, 0x32, 0xfe, 0x1d, 0x0a, 0x0a, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x12, 0x70, 0x0a, 0x13, 0x53, 0x68, 0x6f, 0x77, 0x4c, 0x6f, - 0x61, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2a, 0x2e, + 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x62, 0x49, 0x44, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x04, 0x64, 0x62, 0x49, 0x44, 0x12, 0x24, 0x0a, 0x0d, 0x63, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x0d, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x73, + 0x12, 0x25, 0x0a, 0x0e, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x5f, 0x6e, 0x75, 0x6d, 0x62, + 0x65, 0x72, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x52, 0x0d, 0x72, 0x65, 0x70, 0x6c, 0x69, 0x63, + 0x61, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x27, 0x0a, 0x0f, 0x72, 0x65, 0x73, 0x6f, 0x75, + 0x72, 0x63, 0x65, 0x5f, 0x67, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x18, 0x05, 0x20, 0x03, 0x28, 0x09, + 0x52, 0x0e, 0x72, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, + 0x22, 0xc4, 0x01, 0x0a, 0x13, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, + 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, + 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, + 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x3d, + 0x0a, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x25, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x73, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x2e, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x53, + 0x63, 0x68, 0x65, 0x6d, 0x61, 0x52, 0x06, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x18, 0x0a, + 0x07, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, + 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x82, 0x02, 0x0a, 0x12, 0x52, 0x75, 0x6e, 0x41, + 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, + 0x0a, 0x04, 0x62, 0x61, 0x73, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x4d, 0x73, 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, + 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x02, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x19, 0x0a, 0x08, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x5f, 0x69, 0x64, 0x18, 0x03, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x66, 0x69, + 0x65, 0x6c, 0x64, 0x49, 0x64, 0x12, 0x25, 0x0a, 0x0e, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, + 0x72, 0x5f, 0x6e, 0x61, 0x6d, 0x65, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x61, + 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65, 0x73, 0x12, 0x20, 0x0a, 0x0b, + 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x18, 0x05, 0x20, 0x03, 0x28, + 0x0c, 0x52, 0x0b, 0x70, 0x6c, 0x61, 0x63, 0x65, 0x68, 0x6f, 0x6c, 0x64, 0x65, 0x72, 0x12, 0x1f, + 0x0a, 0x0b, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x08, 0x52, 0x0a, 0x77, 0x69, 0x74, 0x68, 0x44, 0x65, 0x74, 0x61, 0x69, 0x6c, 0x12, + 0x1b, 0x0a, 0x09, 0x77, 0x69, 0x74, 0x68, 0x5f, 0x68, 0x61, 0x73, 0x68, 0x18, 0x07, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x08, 0x77, 0x69, 0x74, 0x68, 0x48, 0x61, 0x73, 0x68, 0x22, 0x4d, 0x0a, 0x19, + 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, + 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x30, 0x0a, 0x04, 0x62, 0x61, 0x73, + 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4d, 0x73, + 0x67, 0x42, 0x61, 0x73, 0x65, 0x52, 0x04, 0x62, 0x61, 0x73, 0x65, 0x22, 0x71, 0x0a, 0x1a, 0x4c, + 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1e, + 0x0a, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, + 0x28, 0x03, 0x52, 0x0a, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x73, 0x2a, 0x36, + 0x0a, 0x09, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x63, 0x6f, 0x70, 0x65, 0x12, 0x08, 0x0a, 0x04, 0x46, + 0x75, 0x6c, 0x6c, 0x10, 0x00, 0x12, 0x09, 0x0a, 0x05, 0x44, 0x65, 0x6c, 0x74, 0x61, 0x10, 0x01, + 0x12, 0x09, 0x0a, 0x05, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x10, 0x02, 0x12, 0x09, 0x0a, 0x05, 0x53, + 0x74, 0x61, 0x74, 0x73, 0x10, 0x03, 0x2a, 0x40, 0x0a, 0x09, 0x44, 0x61, 0x74, 0x61, 0x53, 0x63, + 0x6f, 0x70, 0x65, 0x12, 0x0b, 0x0a, 0x07, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, 0x6e, 0x10, 0x00, + 0x12, 0x07, 0x0a, 0x03, 0x41, 0x6c, 0x6c, 0x10, 0x01, 0x12, 0x0d, 0x0a, 0x09, 0x53, 0x74, 0x72, + 0x65, 0x61, 0x6d, 0x69, 0x6e, 0x67, 0x10, 0x02, 0x12, 0x0e, 0x0a, 0x0a, 0x48, 0x69, 0x73, 0x74, + 0x6f, 0x72, 0x69, 0x63, 0x61, 0x6c, 0x10, 0x03, 0x2a, 0x7a, 0x0a, 0x0e, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x12, 0x0c, 0x0a, 0x08, 0x4e, 0x6f, + 0x74, 0x45, 0x78, 0x69, 0x73, 0x74, 0x10, 0x00, 0x12, 0x0e, 0x0a, 0x0a, 0x4e, 0x6f, 0x74, 0x50, + 0x72, 0x65, 0x73, 0x65, 0x6e, 0x74, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4f, 0x6e, 0x44, 0x69, + 0x73, 0x6b, 0x10, 0x02, 0x12, 0x13, 0x0a, 0x0f, 0x50, 0x61, 0x72, 0x74, 0x69, 0x61, 0x6c, 0x49, + 0x6e, 0x4d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, 0x49, 0x6e, 0x4d, + 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x10, 0x04, 0x12, 0x10, 0x0a, 0x0c, 0x50, 0x61, 0x72, 0x74, 0x69, + 0x61, 0x6c, 0x49, 0x6e, 0x47, 0x50, 0x55, 0x10, 0x05, 0x12, 0x09, 0x0a, 0x05, 0x49, 0x6e, 0x47, + 0x50, 0x55, 0x10, 0x06, 0x2a, 0x64, 0x0a, 0x10, 0x54, 0x72, 0x69, 0x67, 0x67, 0x65, 0x72, 0x43, + 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x13, 0x0a, 0x0f, 0x55, 0x6e, 0x4b, 0x6e, + 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x00, 0x12, 0x0b, 0x0a, + 0x07, 0x48, 0x61, 0x6e, 0x64, 0x6f, 0x66, 0x66, 0x10, 0x01, 0x12, 0x0f, 0x0a, 0x0b, 0x4c, 0x6f, + 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x10, 0x02, 0x12, 0x0f, 0x0a, 0x0b, 0x47, + 0x72, 0x70, 0x63, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x10, 0x03, 0x12, 0x0c, 0x0a, 0x08, + 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x6f, 0x77, 0x6e, 0x10, 0x04, 0x2a, 0x42, 0x0a, 0x08, 0x4c, 0x6f, + 0x61, 0x64, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0f, 0x0a, 0x0b, 0x55, 0x6e, 0x4b, 0x6e, 0x6f, 0x77, + 0x6e, 0x54, 0x79, 0x70, 0x65, 0x10, 0x00, 0x12, 0x11, 0x0a, 0x0d, 0x4c, 0x6f, 0x61, 0x64, 0x50, + 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x01, 0x12, 0x12, 0x0a, 0x0e, 0x4c, 0x6f, + 0x61, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x10, 0x02, 0x2a, 0x32, + 0x0a, 0x0a, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x0b, 0x0a, 0x07, + 0x49, 0x6e, 0x76, 0x61, 0x6c, 0x69, 0x64, 0x10, 0x00, 0x12, 0x0b, 0x0a, 0x07, 0x4c, 0x6f, 0x61, + 0x64, 0x69, 0x6e, 0x67, 0x10, 0x01, 0x12, 0x0a, 0x0a, 0x06, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, + 0x10, 0x02, 0x2a, 0x57, 0x0a, 0x08, 0x53, 0x79, 0x6e, 0x63, 0x54, 0x79, 0x70, 0x65, 0x12, 0x0a, + 0x0a, 0x06, 0x52, 0x65, 0x6d, 0x6f, 0x76, 0x65, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x53, 0x65, + 0x74, 0x10, 0x01, 0x12, 0x09, 0x0a, 0x05, 0x41, 0x6d, 0x65, 0x6e, 0x64, 0x10, 0x02, 0x12, 0x11, + 0x0a, 0x0d, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x10, + 0x03, 0x12, 0x18, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, + 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x10, 0x04, 0x32, 0xfe, 0x1d, 0x0a, 0x0a, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x12, 0x70, 0x0a, 0x13, 0x53, 0x68, + 0x6f, 0x77, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6c, 0x6c, 0x65, + 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, - 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, 0x53, 0x68, 0x6f, 0x77, - 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x29, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, - 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x4c, 0x6f, 0x61, 0x64, 0x50, - 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, - 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x50, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, - 0x6c, 0x65, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6c, - 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, - 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, - 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6c, 0x6c, - 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6c, 0x65, - 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x17, 0x53, 0x79, 0x6e, 0x63, 0x4e, 0x65, 0x77, 0x43, 0x72, - 0x65, 0x61, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x32, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x4e, 0x65, 0x77, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, - 0x00, 0x12, 0x75, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, - 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x50, - 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, - 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x4c, - 0x6f, 0x61, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x29, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, - 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, - 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0b, 0x4c, 0x6f, 0x61, 0x64, 0x42, - 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, - 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x7b, 0x0a, - 0x12, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, - 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, - 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, - 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65, - 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, - 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, - 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x47, - 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x6c, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, 0x65, - 0x72, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, - 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, - 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x62, 0x0a, - 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x12, 0x27, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, - 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x65, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, - 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x14, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, - 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, - 0x12, 0x61, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, - 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x44, 0x72, 0x6f, 0x70, - 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0c, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4e, - 0x6f, 0x64, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, - 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, - 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x12, - 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, - 0x75, 0x65, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x70, - 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, - 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x77, 0x0a, 0x12, 0x4c, 0x69, - 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, - 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, - 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x7e, 0x0a, 0x15, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, - 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x30, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, - 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, 0x73, 0x6f, - 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, - 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, - 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, - 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x0c, 0x4c, 0x69, - 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, - 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x5c, 0x0a, 0x0f, 0x41, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x65, 0x72, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x41, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, - 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, - 0x11, 0x44, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, - 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, - 0x66, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, - 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, - 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x73, - 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x87, 0x01, 0x0a, 0x18, 0x47, 0x65, 0x74, 0x51, - 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, - 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, - 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x42, 0x61, 0x6c, 0x61, - 0x6e, 0x63, 0x65, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, - 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, - 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x58, 0x0a, - 0x0d, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x28, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, - 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x12, 0x43, 0x68, 0x65, 0x63, 0x6b, - 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x2d, 0x2e, + 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, + 0x53, 0x68, 0x6f, 0x77, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, - 0x0a, 0x0b, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x26, 0x2e, + 0x72, 0x79, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, + 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x4c, + 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x4e, 0x6f, - 0x64, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x4e, 0x6f, - 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x54, 0x72, 0x61, 0x6e, - 0x73, 0x66, 0x65, 0x72, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x2a, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, - 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x54, - 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x1a, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, - 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, - 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5e, 0x0a, 0x10, 0x55, 0x70, 0x64, 0x61, - 0x74, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x2b, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x66, - 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x32, 0xee, 0x14, 0x0a, 0x09, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x6c, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, - 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2e, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x53, - 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, - 0x65, 0x73, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x54, - 0x69, 0x63, 0x6b, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x43, 0x68, - 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x71, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, - 0x74, 0x69, 0x63, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x32, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, - 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, - 0x73, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x57, 0x61, 0x74, 0x63, 0x68, 0x44, - 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x57, - 0x61, 0x74, 0x63, 0x68, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, - 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x55, 0x6e, 0x73, 0x75, 0x62, 0x44, 0x6d, 0x43, - 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x55, 0x6e, 0x73, 0x75, - 0x62, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, - 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, - 0x12, 0x56, 0x0a, 0x0c, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, - 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x65, - 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, - 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, - 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x4c, 0x6f, - 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x29, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, - 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2c, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, - 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x52, 0x65, 0x6c, 0x65, - 0x61, 0x73, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, - 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, - 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, - 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x64, 0x0a, 0x13, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, - 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, - 0x6e, 0x63, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, + 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, - 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0d, 0x47, 0x65, 0x74, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, - 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, - 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, - 0x22, 0x00, 0x12, 0x53, 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x12, 0x21, 0x2e, 0x6d, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x65, 0x61, + 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, - 0x79, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, - 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x0e, 0x53, 0x65, 0x61, 0x72, 0x63, - 0x68, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, - 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x73, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, 0x79, 0x12, 0x20, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, - 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, - 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, - 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x0b, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, - 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x73, 0x22, 0x00, 0x30, 0x01, 0x12, 0x5b, 0x0a, 0x0d, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, - 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, - 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x65, - 0x61, 0x6d, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6c, + 0x79, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x4c, 0x6f, 0x61, + 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, + 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, - 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x30, 0x01, 0x12, 0x7b, 0x0a, 0x12, 0x53, 0x68, 0x6f, 0x77, - 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, - 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, - 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, - 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, - 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, - 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, - 0x69, 0x63, 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, - 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, - 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x78, 0x0a, 0x13, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, - 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x2e, + 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x17, 0x53, 0x79, 0x6e, 0x63, 0x4e, + 0x65, 0x77, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, + 0x6f, 0x6e, 0x12, 0x32, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x4e, 0x65, 0x77, 0x43, + 0x72, 0x65, 0x61, 0x74, 0x65, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x12, 0x2d, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x47, 0x65, 0x74, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, + 0x47, 0x65, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, + 0x66, 0x6f, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, + 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, - 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, - 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, - 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, - 0x12, 0x5e, 0x0a, 0x10, 0x53, 0x79, 0x6e, 0x63, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, - 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x44, 0x69, - 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, + 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0b, 0x4c, + 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x4c, 0x6f, 0x61, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, + 0x00, 0x12, 0x7b, 0x0a, 0x12, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, + 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, + 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, + 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, + 0x0a, 0x0a, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x26, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, + 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, + 0x62, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x12, 0x27, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, + 0x74, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x6c, 0x0a, 0x0f, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, 0x4c, + 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, + 0x68, 0x61, 0x72, 0x64, 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x68, 0x61, 0x72, 0x64, + 0x4c, 0x65, 0x61, 0x64, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x62, 0x0a, 0x0b, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, + 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, + 0x74, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x43, 0x68, 0x65, 0x63, 0x6b, 0x48, 0x65, 0x61, 0x6c, 0x74, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x65, 0x0a, 0x13, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2f, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, + 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x14, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x12, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x22, 0x00, 0x12, 0x61, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x6f, + 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x44, 0x72, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, + 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x57, 0x0a, 0x0c, 0x54, 0x72, 0x61, 0x6e, 0x73, + 0x66, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, - 0x12, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, - 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x0b, - 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, 0x26, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, - 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, - 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, - 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, - 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x56, - 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x12, 0x27, + 0x12, 0x5c, 0x0a, 0x0f, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x52, 0x65, 0x70, 0x6c, + 0x69, 0x63, 0x61, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, + 0x72, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x77, + 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, + 0x6f, 0x75, 0x70, 0x73, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x7e, 0x0a, 0x15, 0x44, 0x65, 0x73, 0x63, 0x72, + 0x69, 0x62, 0x65, 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, + 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, 0x52, 0x65, + 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69, 0x62, 0x65, + 0x52, 0x65, 0x73, 0x6f, 0x75, 0x72, 0x63, 0x65, 0x47, 0x72, 0x6f, 0x75, 0x70, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x12, 0x4c, 0x69, 0x73, 0x74, 0x4c, + 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2d, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2e, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x6f, 0x61, 0x64, 0x65, 0x64, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x63, + 0x0a, 0x0c, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, - 0x65, 0x72, 0x79, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, 0x6d, 0x61, - 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, - 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x61, 0x0a, 0x0b, 0x52, 0x75, 0x6e, 0x41, 0x6e, 0x61, - 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x75, 0x6e, 0x41, 0x6e, - 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x52, 0x75, 0x6e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x52, - 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x32, 0x5a, 0x30, 0x67, 0x69, 0x74, - 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, - 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x70, 0x62, 0x62, 0x06, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, + 0x74, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, + 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x41, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, + 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x41, 0x63, 0x74, 0x69, + 0x76, 0x61, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, + 0x00, 0x12, 0x60, 0x0a, 0x11, 0x44, 0x65, 0x61, 0x63, 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, + 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x61, 0x63, + 0x74, 0x69, 0x76, 0x61, 0x74, 0x65, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x65, 0x72, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x22, 0x00, 0x12, 0x66, 0x0a, 0x0d, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x29, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x69, 0x73, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, + 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x87, 0x01, 0x0a, 0x18, + 0x47, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x33, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, + 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x34, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, + 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, + 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x75, 0x73, + 0x70, 0x65, 0x6e, 0x64, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, + 0x00, 0x12, 0x58, 0x0a, 0x0d, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x12, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6d, 0x65, 0x42, 0x61, + 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x75, 0x0a, 0x12, 0x43, + 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, + 0x73, 0x12, 0x2d, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, + 0x6e, 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, 0x6b, 0x42, 0x61, 0x6c, 0x61, 0x6e, + 0x63, 0x65, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0b, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x4e, 0x6f, 0x64, + 0x65, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x75, 0x73, 0x70, 0x65, 0x6e, 0x64, 0x4e, 0x6f, + 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0a, 0x52, 0x65, 0x73, 0x75, + 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x73, 0x75, + 0x6d, 0x65, 0x4e, 0x6f, 0x64, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, + 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x12, + 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x54, 0x72, + 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x2a, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x54, 0x72, 0x61, 0x6e, 0x73, 0x66, 0x65, 0x72, 0x43, 0x68, 0x61, 0x6e, 0x6e, + 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x72, 0x0a, 0x1a, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x35, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x43, 0x68, 0x65, 0x63, + 0x6b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, + 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5e, 0x0a, 0x10, + 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x61, 0x64, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, + 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x4c, 0x6f, 0x61, 0x64, + 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x32, 0xee, 0x14, 0x0a, + 0x09, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x6c, 0x0a, 0x12, 0x47, 0x65, + 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, + 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, + 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x6f, 0x6e, 0x65, 0x6e, 0x74, + 0x53, 0x74, 0x61, 0x74, 0x65, 0x73, 0x22, 0x00, 0x12, 0x6d, 0x0a, 0x12, 0x47, 0x65, 0x74, 0x54, + 0x69, 0x6d, 0x65, 0x54, 0x69, 0x63, 0x6b, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x30, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x54, 0x69, 0x6d, 0x65, 0x54, 0x69, + 0x63, 0x6b, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x71, 0x0a, 0x14, 0x47, 0x65, 0x74, 0x53, 0x74, + 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, + 0x32, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, + 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, + 0x73, 0x74, 0x69, 0x63, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, 0x57, 0x61, + 0x74, 0x63, 0x68, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x73, 0x12, 0x2a, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x57, 0x61, 0x74, 0x63, 0x68, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, + 0x6c, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, + 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x0e, 0x55, 0x6e, 0x73, 0x75, + 0x62, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, + 0x55, 0x6e, 0x73, 0x75, 0x62, 0x44, 0x6d, 0x43, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x22, 0x00, 0x12, 0x56, 0x0a, 0x0c, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x53, 0x65, + 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, + 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x43, 0x6f, + 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, + 0x0a, 0x0e, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, + 0x12, 0x29, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x4c, 0x6f, 0x61, 0x64, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, + 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x11, 0x52, 0x65, + 0x6c, 0x65, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x12, + 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x50, 0x61, 0x72, 0x74, + 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5c, 0x0a, 0x0f, + 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, + 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, 0x65, 0x6c, 0x65, 0x61, 0x73, 0x65, 0x53, 0x65, 0x67, 0x6d, + 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0e, 0x47, 0x65, + 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x29, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2a, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, + 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x64, 0x0a, 0x13, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x70, + 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x2e, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x53, 0x79, 0x6e, 0x63, 0x52, 0x65, 0x70, 0x6c, 0x69, 0x63, 0x61, 0x53, 0x65, 0x67, + 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x69, 0x0a, 0x0d, 0x47, + 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x12, 0x28, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x47, 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x2c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x47, + 0x65, 0x74, 0x53, 0x74, 0x61, 0x74, 0x69, 0x73, 0x74, 0x69, 0x63, 0x73, 0x52, 0x65, 0x73, 0x70, + 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x06, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, + 0x12, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x61, 0x72, + 0x63, 0x68, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x12, 0x5b, 0x0a, 0x0e, 0x53, + 0x65, 0x61, 0x72, 0x63, 0x68, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x21, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, + 0x72, 0x79, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x65, 0x61, 0x72, 0x63, 0x68, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x12, 0x53, 0x0a, 0x05, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x12, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, + 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x12, 0x5b, 0x0a, + 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x12, 0x20, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, + 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x30, 0x01, 0x12, 0x5b, 0x0a, 0x0d, 0x51, 0x75, + 0x65, 0x72, 0x79, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x20, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, + 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x26, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, + 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, 0x65, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x12, 0x63, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, + 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x20, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x52, 0x65, 0x74, 0x72, 0x69, 0x65, 0x76, + 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0x00, 0x30, 0x01, 0x12, 0x7b, 0x0a, 0x12, + 0x53, 0x68, 0x6f, 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x6e, 0x73, 0x12, 0x30, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, 0x77, 0x43, + 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x1a, 0x31, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, + 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x6e, 0x61, 0x6c, 0x2e, 0x53, 0x68, 0x6f, + 0x77, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x75, 0x72, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x5f, 0x0a, 0x0a, 0x47, 0x65, 0x74, + 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, + 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x47, 0x65, 0x74, 0x4d, 0x65, 0x74, 0x72, 0x69, 0x63, 0x73, + 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x78, 0x0a, 0x13, 0x47, 0x65, + 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, + 0x6e, 0x12, 0x2e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, + 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x2f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x47, 0x65, 0x74, 0x44, 0x61, 0x74, 0x61, 0x44, 0x69, + 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, + 0x73, 0x65, 0x22, 0x00, 0x12, 0x5e, 0x0a, 0x10, 0x53, 0x79, 0x6e, 0x63, 0x44, 0x69, 0x73, 0x74, + 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x2b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x53, 0x79, + 0x6e, 0x63, 0x44, 0x69, 0x73, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x75, 0x73, 0x22, 0x00, 0x12, 0x4a, 0x0a, 0x06, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x12, 0x21, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, + 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, + 0x12, 0x60, 0x0a, 0x0b, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x12, + 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, + 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, + 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x44, 0x65, 0x6c, + 0x65, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, + 0x22, 0x00, 0x12, 0x56, 0x0a, 0x0c, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, 0x68, 0x65, + 0x6d, 0x61, 0x12, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x53, 0x63, + 0x68, 0x65, 0x6d, 0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, + 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x61, 0x0a, 0x0b, 0x52, 0x75, + 0x6e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x71, 0x75, 0x65, 0x72, 0x79, 0x2e, 0x52, + 0x75, 0x6e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x72, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x28, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x52, 0x75, 0x6e, 0x41, 0x6e, 0x61, 0x6c, 0x79, + 0x7a, 0x65, 0x72, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x32, 0x5a, + 0x30, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, + 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, + 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x71, 0x75, 0x65, 0x72, 0x79, 0x70, + 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, } var ( @@ -9645,7 +9755,7 @@ func file_query_coord_proto_rawDescGZIP() []byte { } var file_query_coord_proto_enumTypes = make([]protoimpl.EnumInfo, 7) -var file_query_coord_proto_msgTypes = make([]protoimpl.MessageInfo, 111) +var file_query_coord_proto_msgTypes = make([]protoimpl.MessageInfo, 113) var file_query_coord_proto_goTypes = []interface{}{ (LoadScope)(0), // 0: milvus.proto.query.LoadScope (DataScope)(0), // 1: milvus.proto.query.DataScope @@ -9677,449 +9787,453 @@ var file_query_coord_proto_goTypes = []interface{}{ (*UnsubDmChannelRequest)(nil), // 27: milvus.proto.query.UnsubDmChannelRequest (*SegmentLoadInfo)(nil), // 28: milvus.proto.query.SegmentLoadInfo (*FieldIndexInfo)(nil), // 29: milvus.proto.query.FieldIndexInfo - (*LoadSegmentsRequest)(nil), // 30: milvus.proto.query.LoadSegmentsRequest - (*ReleaseSegmentsRequest)(nil), // 31: milvus.proto.query.ReleaseSegmentsRequest - (*SearchRequest)(nil), // 32: milvus.proto.query.SearchRequest - (*QueryRequest)(nil), // 33: milvus.proto.query.QueryRequest - (*SyncReplicaSegmentsRequest)(nil), // 34: milvus.proto.query.SyncReplicaSegmentsRequest - (*ReplicaSegmentsInfo)(nil), // 35: milvus.proto.query.ReplicaSegmentsInfo - (*GetLoadInfoRequest)(nil), // 36: milvus.proto.query.GetLoadInfoRequest - (*GetLoadInfoResponse)(nil), // 37: milvus.proto.query.GetLoadInfoResponse - (*HandoffSegmentsRequest)(nil), // 38: milvus.proto.query.HandoffSegmentsRequest - (*LoadBalanceRequest)(nil), // 39: milvus.proto.query.LoadBalanceRequest - (*DmChannelWatchInfo)(nil), // 40: milvus.proto.query.DmChannelWatchInfo - (*QueryChannelInfo)(nil), // 41: milvus.proto.query.QueryChannelInfo - (*PartitionStates)(nil), // 42: milvus.proto.query.PartitionStates - (*SegmentInfo)(nil), // 43: milvus.proto.query.SegmentInfo - (*CollectionInfo)(nil), // 44: milvus.proto.query.CollectionInfo - (*UnsubscribeChannels)(nil), // 45: milvus.proto.query.UnsubscribeChannels - (*UnsubscribeChannelInfo)(nil), // 46: milvus.proto.query.UnsubscribeChannelInfo - (*SegmentChangeInfo)(nil), // 47: milvus.proto.query.SegmentChangeInfo - (*SealedSegmentsChangeInfo)(nil), // 48: milvus.proto.query.SealedSegmentsChangeInfo - (*GetDataDistributionRequest)(nil), // 49: milvus.proto.query.GetDataDistributionRequest - (*GetDataDistributionResponse)(nil), // 50: milvus.proto.query.GetDataDistributionResponse - (*LeaderView)(nil), // 51: milvus.proto.query.LeaderView - (*LeaderViewStatus)(nil), // 52: milvus.proto.query.LeaderViewStatus - (*SegmentDist)(nil), // 53: milvus.proto.query.SegmentDist - (*SegmentVersionInfo)(nil), // 54: milvus.proto.query.SegmentVersionInfo - (*ChannelVersionInfo)(nil), // 55: milvus.proto.query.ChannelVersionInfo - (*CollectionLoadInfo)(nil), // 56: milvus.proto.query.CollectionLoadInfo - (*PartitionLoadInfo)(nil), // 57: milvus.proto.query.PartitionLoadInfo - (*ChannelNodeInfo)(nil), // 58: milvus.proto.query.ChannelNodeInfo - (*Replica)(nil), // 59: milvus.proto.query.Replica - (*SyncAction)(nil), // 60: milvus.proto.query.SyncAction - (*SyncDistributionRequest)(nil), // 61: milvus.proto.query.SyncDistributionRequest - (*ResourceGroup)(nil), // 62: milvus.proto.query.ResourceGroup - (*TransferReplicaRequest)(nil), // 63: milvus.proto.query.TransferReplicaRequest - (*DescribeResourceGroupRequest)(nil), // 64: milvus.proto.query.DescribeResourceGroupRequest - (*DescribeResourceGroupResponse)(nil), // 65: milvus.proto.query.DescribeResourceGroupResponse - (*ResourceGroupInfo)(nil), // 66: milvus.proto.query.ResourceGroupInfo - (*DeleteRequest)(nil), // 67: milvus.proto.query.DeleteRequest - (*DeleteBatchRequest)(nil), // 68: milvus.proto.query.DeleteBatchRequest - (*DeleteBatchResponse)(nil), // 69: milvus.proto.query.DeleteBatchResponse - (*ActivateCheckerRequest)(nil), // 70: milvus.proto.query.ActivateCheckerRequest - (*DeactivateCheckerRequest)(nil), // 71: milvus.proto.query.DeactivateCheckerRequest - (*ListCheckersRequest)(nil), // 72: milvus.proto.query.ListCheckersRequest - (*ListCheckersResponse)(nil), // 73: milvus.proto.query.ListCheckersResponse - (*CheckerInfo)(nil), // 74: milvus.proto.query.CheckerInfo - (*SegmentTarget)(nil), // 75: milvus.proto.query.SegmentTarget - (*PartitionTarget)(nil), // 76: milvus.proto.query.PartitionTarget - (*ChannelTarget)(nil), // 77: milvus.proto.query.ChannelTarget - (*CollectionTarget)(nil), // 78: milvus.proto.query.CollectionTarget - (*NodeInfo)(nil), // 79: milvus.proto.query.NodeInfo - (*ListQueryNodeRequest)(nil), // 80: milvus.proto.query.ListQueryNodeRequest - (*ListQueryNodeResponse)(nil), // 81: milvus.proto.query.ListQueryNodeResponse - (*GetQueryNodeDistributionRequest)(nil), // 82: milvus.proto.query.GetQueryNodeDistributionRequest - (*GetQueryNodeDistributionResponse)(nil), // 83: milvus.proto.query.GetQueryNodeDistributionResponse - (*SuspendBalanceRequest)(nil), // 84: milvus.proto.query.SuspendBalanceRequest - (*ResumeBalanceRequest)(nil), // 85: milvus.proto.query.ResumeBalanceRequest - (*CheckBalanceStatusRequest)(nil), // 86: milvus.proto.query.CheckBalanceStatusRequest - (*CheckBalanceStatusResponse)(nil), // 87: milvus.proto.query.CheckBalanceStatusResponse - (*SuspendNodeRequest)(nil), // 88: milvus.proto.query.SuspendNodeRequest - (*ResumeNodeRequest)(nil), // 89: milvus.proto.query.ResumeNodeRequest - (*TransferSegmentRequest)(nil), // 90: milvus.proto.query.TransferSegmentRequest - (*TransferChannelRequest)(nil), // 91: milvus.proto.query.TransferChannelRequest - (*CheckQueryNodeDistributionRequest)(nil), // 92: milvus.proto.query.CheckQueryNodeDistributionRequest - (*UpdateLoadConfigRequest)(nil), // 93: milvus.proto.query.UpdateLoadConfigRequest - (*UpdateSchemaRequest)(nil), // 94: milvus.proto.query.UpdateSchemaRequest - (*RunAnalyzerRequest)(nil), // 95: milvus.proto.query.RunAnalyzerRequest - (*ListLoadedSegmentsRequest)(nil), // 96: milvus.proto.query.ListLoadedSegmentsRequest - (*ListLoadedSegmentsResponse)(nil), // 97: milvus.proto.query.ListLoadedSegmentsResponse - nil, // 98: milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry - nil, // 99: milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry - nil, // 100: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry - nil, // 101: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry - nil, // 102: milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry - nil, // 103: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry - nil, // 104: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry - nil, // 105: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry - nil, // 106: milvus.proto.query.LeaderView.SegmentDistEntry - nil, // 107: milvus.proto.query.LeaderView.GrowingSegmentsEntry - nil, // 108: milvus.proto.query.LeaderView.PartitionStatsVersionsEntry - nil, // 109: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry - nil, // 110: milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry - nil, // 111: milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry - nil, // 112: milvus.proto.query.Replica.ChannelNodeInfosEntry - nil, // 113: milvus.proto.query.SyncAction.PartitionStatsVersionsEntry - nil, // 114: milvus.proto.query.SyncAction.SealedSegmentRowCountEntry - nil, // 115: milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry - nil, // 116: milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry - nil, // 117: milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry - (*commonpb.MsgBase)(nil), // 118: milvus.proto.common.MsgBase - (*commonpb.Status)(nil), // 119: milvus.proto.common.Status - (*schemapb.LongArray)(nil), // 120: milvus.proto.schema.LongArray - (*schemapb.CollectionSchema)(nil), // 121: milvus.proto.schema.CollectionSchema - (commonpb.LoadPriority)(0), // 122: milvus.proto.common.LoadPriority - (*internalpb.GetStatisticsRequest)(nil), // 123: milvus.proto.internal.GetStatisticsRequest - (*indexpb.IndexInfo)(nil), // 124: milvus.proto.index.IndexInfo - (*commonpb.KeyValuePair)(nil), // 125: milvus.proto.common.KeyValuePair - (*datapb.VchannelInfo)(nil), // 126: milvus.proto.data.VchannelInfo - (*datapb.SegmentInfo)(nil), // 127: milvus.proto.data.SegmentInfo - (*datapb.FieldBinlog)(nil), // 128: milvus.proto.data.FieldBinlog - (*msgpb.MsgPosition)(nil), // 129: milvus.proto.msg.MsgPosition - (datapb.SegmentLevel)(0), // 130: milvus.proto.data.SegmentLevel - (*internalpb.SearchRequest)(nil), // 131: milvus.proto.internal.SearchRequest - (*internalpb.RetrieveRequest)(nil), // 132: milvus.proto.internal.RetrieveRequest - (commonpb.SegmentState)(0), // 133: milvus.proto.common.SegmentState - (*rgpb.ResourceGroupConfig)(nil), // 134: milvus.proto.rg.ResourceGroupConfig - (*commonpb.NodeInfo)(nil), // 135: milvus.proto.common.NodeInfo - (*schemapb.IDs)(nil), // 136: milvus.proto.schema.IDs - (*datapb.TextIndexStats)(nil), // 137: milvus.proto.data.TextIndexStats - (*datapb.JsonKeyStats)(nil), // 138: milvus.proto.data.JsonKeyStats - (*internalpb.ShowConfigurationsRequest)(nil), // 139: milvus.proto.internal.ShowConfigurationsRequest - (*milvuspb.GetMetricsRequest)(nil), // 140: milvus.proto.milvus.GetMetricsRequest - (*milvuspb.GetReplicasRequest)(nil), // 141: milvus.proto.milvus.GetReplicasRequest - (*milvuspb.CheckHealthRequest)(nil), // 142: milvus.proto.milvus.CheckHealthRequest - (*milvuspb.CreateResourceGroupRequest)(nil), // 143: milvus.proto.milvus.CreateResourceGroupRequest - (*milvuspb.DropResourceGroupRequest)(nil), // 144: milvus.proto.milvus.DropResourceGroupRequest - (*milvuspb.TransferNodeRequest)(nil), // 145: milvus.proto.milvus.TransferNodeRequest - (*milvuspb.ListResourceGroupsRequest)(nil), // 146: milvus.proto.milvus.ListResourceGroupsRequest - (*milvuspb.GetComponentStatesRequest)(nil), // 147: milvus.proto.milvus.GetComponentStatesRequest - (*internalpb.GetTimeTickChannelRequest)(nil), // 148: milvus.proto.internal.GetTimeTickChannelRequest - (*internalpb.GetStatisticsChannelRequest)(nil), // 149: milvus.proto.internal.GetStatisticsChannelRequest - (*internalpb.ShowConfigurationsResponse)(nil), // 150: milvus.proto.internal.ShowConfigurationsResponse - (*milvuspb.GetMetricsResponse)(nil), // 151: milvus.proto.milvus.GetMetricsResponse - (*milvuspb.GetReplicasResponse)(nil), // 152: milvus.proto.milvus.GetReplicasResponse - (*milvuspb.CheckHealthResponse)(nil), // 153: milvus.proto.milvus.CheckHealthResponse - (*milvuspb.ListResourceGroupsResponse)(nil), // 154: milvus.proto.milvus.ListResourceGroupsResponse - (*milvuspb.ComponentStates)(nil), // 155: milvus.proto.milvus.ComponentStates - (*milvuspb.StringResponse)(nil), // 156: milvus.proto.milvus.StringResponse - (*internalpb.GetStatisticsResponse)(nil), // 157: milvus.proto.internal.GetStatisticsResponse - (*internalpb.SearchResults)(nil), // 158: milvus.proto.internal.SearchResults - (*internalpb.RetrieveResults)(nil), // 159: milvus.proto.internal.RetrieveResults - (*milvuspb.RunAnalyzerResponse)(nil), // 160: milvus.proto.milvus.RunAnalyzerResponse + (*JsonStatsInfo)(nil), // 30: milvus.proto.query.JsonStatsInfo + (*LoadSegmentsRequest)(nil), // 31: milvus.proto.query.LoadSegmentsRequest + (*ReleaseSegmentsRequest)(nil), // 32: milvus.proto.query.ReleaseSegmentsRequest + (*SearchRequest)(nil), // 33: milvus.proto.query.SearchRequest + (*QueryRequest)(nil), // 34: milvus.proto.query.QueryRequest + (*SyncReplicaSegmentsRequest)(nil), // 35: milvus.proto.query.SyncReplicaSegmentsRequest + (*ReplicaSegmentsInfo)(nil), // 36: milvus.proto.query.ReplicaSegmentsInfo + (*GetLoadInfoRequest)(nil), // 37: milvus.proto.query.GetLoadInfoRequest + (*GetLoadInfoResponse)(nil), // 38: milvus.proto.query.GetLoadInfoResponse + (*HandoffSegmentsRequest)(nil), // 39: milvus.proto.query.HandoffSegmentsRequest + (*LoadBalanceRequest)(nil), // 40: milvus.proto.query.LoadBalanceRequest + (*DmChannelWatchInfo)(nil), // 41: milvus.proto.query.DmChannelWatchInfo + (*QueryChannelInfo)(nil), // 42: milvus.proto.query.QueryChannelInfo + (*PartitionStates)(nil), // 43: milvus.proto.query.PartitionStates + (*SegmentInfo)(nil), // 44: milvus.proto.query.SegmentInfo + (*CollectionInfo)(nil), // 45: milvus.proto.query.CollectionInfo + (*UnsubscribeChannels)(nil), // 46: milvus.proto.query.UnsubscribeChannels + (*UnsubscribeChannelInfo)(nil), // 47: milvus.proto.query.UnsubscribeChannelInfo + (*SegmentChangeInfo)(nil), // 48: milvus.proto.query.SegmentChangeInfo + (*SealedSegmentsChangeInfo)(nil), // 49: milvus.proto.query.SealedSegmentsChangeInfo + (*GetDataDistributionRequest)(nil), // 50: milvus.proto.query.GetDataDistributionRequest + (*GetDataDistributionResponse)(nil), // 51: milvus.proto.query.GetDataDistributionResponse + (*LeaderView)(nil), // 52: milvus.proto.query.LeaderView + (*LeaderViewStatus)(nil), // 53: milvus.proto.query.LeaderViewStatus + (*SegmentDist)(nil), // 54: milvus.proto.query.SegmentDist + (*SegmentVersionInfo)(nil), // 55: milvus.proto.query.SegmentVersionInfo + (*ChannelVersionInfo)(nil), // 56: milvus.proto.query.ChannelVersionInfo + (*CollectionLoadInfo)(nil), // 57: milvus.proto.query.CollectionLoadInfo + (*PartitionLoadInfo)(nil), // 58: milvus.proto.query.PartitionLoadInfo + (*ChannelNodeInfo)(nil), // 59: milvus.proto.query.ChannelNodeInfo + (*Replica)(nil), // 60: milvus.proto.query.Replica + (*SyncAction)(nil), // 61: milvus.proto.query.SyncAction + (*SyncDistributionRequest)(nil), // 62: milvus.proto.query.SyncDistributionRequest + (*ResourceGroup)(nil), // 63: milvus.proto.query.ResourceGroup + (*TransferReplicaRequest)(nil), // 64: milvus.proto.query.TransferReplicaRequest + (*DescribeResourceGroupRequest)(nil), // 65: milvus.proto.query.DescribeResourceGroupRequest + (*DescribeResourceGroupResponse)(nil), // 66: milvus.proto.query.DescribeResourceGroupResponse + (*ResourceGroupInfo)(nil), // 67: milvus.proto.query.ResourceGroupInfo + (*DeleteRequest)(nil), // 68: milvus.proto.query.DeleteRequest + (*DeleteBatchRequest)(nil), // 69: milvus.proto.query.DeleteBatchRequest + (*DeleteBatchResponse)(nil), // 70: milvus.proto.query.DeleteBatchResponse + (*ActivateCheckerRequest)(nil), // 71: milvus.proto.query.ActivateCheckerRequest + (*DeactivateCheckerRequest)(nil), // 72: milvus.proto.query.DeactivateCheckerRequest + (*ListCheckersRequest)(nil), // 73: milvus.proto.query.ListCheckersRequest + (*ListCheckersResponse)(nil), // 74: milvus.proto.query.ListCheckersResponse + (*CheckerInfo)(nil), // 75: milvus.proto.query.CheckerInfo + (*SegmentTarget)(nil), // 76: milvus.proto.query.SegmentTarget + (*PartitionTarget)(nil), // 77: milvus.proto.query.PartitionTarget + (*ChannelTarget)(nil), // 78: milvus.proto.query.ChannelTarget + (*CollectionTarget)(nil), // 79: milvus.proto.query.CollectionTarget + (*NodeInfo)(nil), // 80: milvus.proto.query.NodeInfo + (*ListQueryNodeRequest)(nil), // 81: milvus.proto.query.ListQueryNodeRequest + (*ListQueryNodeResponse)(nil), // 82: milvus.proto.query.ListQueryNodeResponse + (*GetQueryNodeDistributionRequest)(nil), // 83: milvus.proto.query.GetQueryNodeDistributionRequest + (*GetQueryNodeDistributionResponse)(nil), // 84: milvus.proto.query.GetQueryNodeDistributionResponse + (*SuspendBalanceRequest)(nil), // 85: milvus.proto.query.SuspendBalanceRequest + (*ResumeBalanceRequest)(nil), // 86: milvus.proto.query.ResumeBalanceRequest + (*CheckBalanceStatusRequest)(nil), // 87: milvus.proto.query.CheckBalanceStatusRequest + (*CheckBalanceStatusResponse)(nil), // 88: milvus.proto.query.CheckBalanceStatusResponse + (*SuspendNodeRequest)(nil), // 89: milvus.proto.query.SuspendNodeRequest + (*ResumeNodeRequest)(nil), // 90: milvus.proto.query.ResumeNodeRequest + (*TransferSegmentRequest)(nil), // 91: milvus.proto.query.TransferSegmentRequest + (*TransferChannelRequest)(nil), // 92: milvus.proto.query.TransferChannelRequest + (*CheckQueryNodeDistributionRequest)(nil), // 93: milvus.proto.query.CheckQueryNodeDistributionRequest + (*UpdateLoadConfigRequest)(nil), // 94: milvus.proto.query.UpdateLoadConfigRequest + (*UpdateSchemaRequest)(nil), // 95: milvus.proto.query.UpdateSchemaRequest + (*RunAnalyzerRequest)(nil), // 96: milvus.proto.query.RunAnalyzerRequest + (*ListLoadedSegmentsRequest)(nil), // 97: milvus.proto.query.ListLoadedSegmentsRequest + (*ListLoadedSegmentsResponse)(nil), // 98: milvus.proto.query.ListLoadedSegmentsResponse + nil, // 99: milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry + nil, // 100: milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry + nil, // 101: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry + nil, // 102: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry + nil, // 103: milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry + nil, // 104: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry + nil, // 105: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry + nil, // 106: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry + nil, // 107: milvus.proto.query.LeaderView.SegmentDistEntry + nil, // 108: milvus.proto.query.LeaderView.GrowingSegmentsEntry + nil, // 109: milvus.proto.query.LeaderView.PartitionStatsVersionsEntry + nil, // 110: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry + nil, // 111: milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry + nil, // 112: milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry + nil, // 113: milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry + nil, // 114: milvus.proto.query.Replica.ChannelNodeInfosEntry + nil, // 115: milvus.proto.query.SyncAction.PartitionStatsVersionsEntry + nil, // 116: milvus.proto.query.SyncAction.SealedSegmentRowCountEntry + nil, // 117: milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry + nil, // 118: milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry + nil, // 119: milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry + (*commonpb.MsgBase)(nil), // 120: milvus.proto.common.MsgBase + (*commonpb.Status)(nil), // 121: milvus.proto.common.Status + (*schemapb.LongArray)(nil), // 122: milvus.proto.schema.LongArray + (*schemapb.CollectionSchema)(nil), // 123: milvus.proto.schema.CollectionSchema + (commonpb.LoadPriority)(0), // 124: milvus.proto.common.LoadPriority + (*internalpb.GetStatisticsRequest)(nil), // 125: milvus.proto.internal.GetStatisticsRequest + (*indexpb.IndexInfo)(nil), // 126: milvus.proto.index.IndexInfo + (*commonpb.KeyValuePair)(nil), // 127: milvus.proto.common.KeyValuePair + (*datapb.VchannelInfo)(nil), // 128: milvus.proto.data.VchannelInfo + (*datapb.SegmentInfo)(nil), // 129: milvus.proto.data.SegmentInfo + (*datapb.FieldBinlog)(nil), // 130: milvus.proto.data.FieldBinlog + (*msgpb.MsgPosition)(nil), // 131: milvus.proto.msg.MsgPosition + (datapb.SegmentLevel)(0), // 132: milvus.proto.data.SegmentLevel + (*internalpb.SearchRequest)(nil), // 133: milvus.proto.internal.SearchRequest + (*internalpb.RetrieveRequest)(nil), // 134: milvus.proto.internal.RetrieveRequest + (commonpb.SegmentState)(0), // 135: milvus.proto.common.SegmentState + (*rgpb.ResourceGroupConfig)(nil), // 136: milvus.proto.rg.ResourceGroupConfig + (*commonpb.NodeInfo)(nil), // 137: milvus.proto.common.NodeInfo + (*schemapb.IDs)(nil), // 138: milvus.proto.schema.IDs + (*datapb.TextIndexStats)(nil), // 139: milvus.proto.data.TextIndexStats + (*datapb.JsonKeyStats)(nil), // 140: milvus.proto.data.JsonKeyStats + (*internalpb.ShowConfigurationsRequest)(nil), // 141: milvus.proto.internal.ShowConfigurationsRequest + (*milvuspb.GetMetricsRequest)(nil), // 142: milvus.proto.milvus.GetMetricsRequest + (*milvuspb.GetReplicasRequest)(nil), // 143: milvus.proto.milvus.GetReplicasRequest + (*milvuspb.CheckHealthRequest)(nil), // 144: milvus.proto.milvus.CheckHealthRequest + (*milvuspb.CreateResourceGroupRequest)(nil), // 145: milvus.proto.milvus.CreateResourceGroupRequest + (*milvuspb.DropResourceGroupRequest)(nil), // 146: milvus.proto.milvus.DropResourceGroupRequest + (*milvuspb.TransferNodeRequest)(nil), // 147: milvus.proto.milvus.TransferNodeRequest + (*milvuspb.ListResourceGroupsRequest)(nil), // 148: milvus.proto.milvus.ListResourceGroupsRequest + (*milvuspb.GetComponentStatesRequest)(nil), // 149: milvus.proto.milvus.GetComponentStatesRequest + (*internalpb.GetTimeTickChannelRequest)(nil), // 150: milvus.proto.internal.GetTimeTickChannelRequest + (*internalpb.GetStatisticsChannelRequest)(nil), // 151: milvus.proto.internal.GetStatisticsChannelRequest + (*internalpb.ShowConfigurationsResponse)(nil), // 152: milvus.proto.internal.ShowConfigurationsResponse + (*milvuspb.GetMetricsResponse)(nil), // 153: milvus.proto.milvus.GetMetricsResponse + (*milvuspb.GetReplicasResponse)(nil), // 154: milvus.proto.milvus.GetReplicasResponse + (*milvuspb.CheckHealthResponse)(nil), // 155: milvus.proto.milvus.CheckHealthResponse + (*milvuspb.ListResourceGroupsResponse)(nil), // 156: milvus.proto.milvus.ListResourceGroupsResponse + (*milvuspb.ComponentStates)(nil), // 157: milvus.proto.milvus.ComponentStates + (*milvuspb.StringResponse)(nil), // 158: milvus.proto.milvus.StringResponse + (*internalpb.GetStatisticsResponse)(nil), // 159: milvus.proto.internal.GetStatisticsResponse + (*internalpb.SearchResults)(nil), // 160: milvus.proto.internal.SearchResults + (*internalpb.RetrieveResults)(nil), // 161: milvus.proto.internal.RetrieveResults + (*milvuspb.RunAnalyzerResponse)(nil), // 162: milvus.proto.milvus.RunAnalyzerResponse } var file_query_coord_proto_depIdxs = []int32{ - 118, // 0: milvus.proto.query.ShowCollectionsRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 1: milvus.proto.query.ShowCollectionsResponse.status:type_name -> milvus.proto.common.Status - 120, // 2: milvus.proto.query.ShowCollectionsResponse.load_fields:type_name -> milvus.proto.schema.LongArray - 118, // 3: milvus.proto.query.ShowPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 4: milvus.proto.query.ShowPartitionsResponse.status:type_name -> milvus.proto.common.Status - 118, // 5: milvus.proto.query.LoadCollectionRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 6: milvus.proto.query.LoadCollectionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 98, // 7: milvus.proto.query.LoadCollectionRequest.field_indexID:type_name -> milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry - 122, // 8: milvus.proto.query.LoadCollectionRequest.priority:type_name -> milvus.proto.common.LoadPriority - 118, // 9: milvus.proto.query.ReleaseCollectionRequest.base:type_name -> milvus.proto.common.MsgBase - 123, // 10: milvus.proto.query.GetStatisticsRequest.req:type_name -> milvus.proto.internal.GetStatisticsRequest + 120, // 0: milvus.proto.query.ShowCollectionsRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 1: milvus.proto.query.ShowCollectionsResponse.status:type_name -> milvus.proto.common.Status + 122, // 2: milvus.proto.query.ShowCollectionsResponse.load_fields:type_name -> milvus.proto.schema.LongArray + 120, // 3: milvus.proto.query.ShowPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 4: milvus.proto.query.ShowPartitionsResponse.status:type_name -> milvus.proto.common.Status + 120, // 5: milvus.proto.query.LoadCollectionRequest.base:type_name -> milvus.proto.common.MsgBase + 123, // 6: milvus.proto.query.LoadCollectionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 99, // 7: milvus.proto.query.LoadCollectionRequest.field_indexID:type_name -> milvus.proto.query.LoadCollectionRequest.FieldIndexIDEntry + 124, // 8: milvus.proto.query.LoadCollectionRequest.priority:type_name -> milvus.proto.common.LoadPriority + 120, // 9: milvus.proto.query.ReleaseCollectionRequest.base:type_name -> milvus.proto.common.MsgBase + 125, // 10: milvus.proto.query.GetStatisticsRequest.req:type_name -> milvus.proto.internal.GetStatisticsRequest 1, // 11: milvus.proto.query.GetStatisticsRequest.scope:type_name -> milvus.proto.query.DataScope - 118, // 12: milvus.proto.query.LoadPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 13: milvus.proto.query.LoadPartitionsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 99, // 14: milvus.proto.query.LoadPartitionsRequest.field_indexID:type_name -> milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry - 124, // 15: milvus.proto.query.LoadPartitionsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 122, // 16: milvus.proto.query.LoadPartitionsRequest.priority:type_name -> milvus.proto.common.LoadPriority - 118, // 17: milvus.proto.query.ReleasePartitionsRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 18: milvus.proto.query.GetPartitionStatesRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 19: milvus.proto.query.GetPartitionStatesResponse.status:type_name -> milvus.proto.common.Status - 42, // 20: milvus.proto.query.GetPartitionStatesResponse.partition_descriptions:type_name -> milvus.proto.query.PartitionStates - 118, // 21: milvus.proto.query.GetSegmentInfoRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 22: milvus.proto.query.GetSegmentInfoResponse.status:type_name -> milvus.proto.common.Status - 43, // 23: milvus.proto.query.GetSegmentInfoResponse.infos:type_name -> milvus.proto.query.SegmentInfo - 118, // 24: milvus.proto.query.GetShardLeadersRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 25: milvus.proto.query.GetShardLeadersResponse.status:type_name -> milvus.proto.common.Status + 120, // 12: milvus.proto.query.LoadPartitionsRequest.base:type_name -> milvus.proto.common.MsgBase + 123, // 13: milvus.proto.query.LoadPartitionsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 100, // 14: milvus.proto.query.LoadPartitionsRequest.field_indexID:type_name -> milvus.proto.query.LoadPartitionsRequest.FieldIndexIDEntry + 126, // 15: milvus.proto.query.LoadPartitionsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 124, // 16: milvus.proto.query.LoadPartitionsRequest.priority:type_name -> milvus.proto.common.LoadPriority + 120, // 17: milvus.proto.query.ReleasePartitionsRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 18: milvus.proto.query.GetPartitionStatesRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 19: milvus.proto.query.GetPartitionStatesResponse.status:type_name -> milvus.proto.common.Status + 43, // 20: milvus.proto.query.GetPartitionStatesResponse.partition_descriptions:type_name -> milvus.proto.query.PartitionStates + 120, // 21: milvus.proto.query.GetSegmentInfoRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 22: milvus.proto.query.GetSegmentInfoResponse.status:type_name -> milvus.proto.common.Status + 44, // 23: milvus.proto.query.GetSegmentInfoResponse.infos:type_name -> milvus.proto.query.SegmentInfo + 120, // 24: milvus.proto.query.GetShardLeadersRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 25: milvus.proto.query.GetShardLeadersResponse.status:type_name -> milvus.proto.common.Status 23, // 26: milvus.proto.query.GetShardLeadersResponse.shards:type_name -> milvus.proto.query.ShardLeadersList - 118, // 27: milvus.proto.query.UpdateResourceGroupsRequest.base:type_name -> milvus.proto.common.MsgBase - 100, // 28: milvus.proto.query.UpdateResourceGroupsRequest.resource_groups:type_name -> milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry - 118, // 29: milvus.proto.query.SyncNewCreatedPartitionRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 27: milvus.proto.query.UpdateResourceGroupsRequest.base:type_name -> milvus.proto.common.MsgBase + 101, // 28: milvus.proto.query.UpdateResourceGroupsRequest.resource_groups:type_name -> milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry + 120, // 29: milvus.proto.query.SyncNewCreatedPartitionRequest.base:type_name -> milvus.proto.common.MsgBase 4, // 30: milvus.proto.query.LoadMetaInfo.load_type:type_name -> milvus.proto.query.LoadType - 125, // 31: milvus.proto.query.LoadMetaInfo.db_properties:type_name -> milvus.proto.common.KeyValuePair - 118, // 32: milvus.proto.query.WatchDmChannelsRequest.base:type_name -> milvus.proto.common.MsgBase - 126, // 33: milvus.proto.query.WatchDmChannelsRequest.infos:type_name -> milvus.proto.data.VchannelInfo - 121, // 34: milvus.proto.query.WatchDmChannelsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 127, // 35: milvus.proto.query.WatchDmChannelsRequest.exclude_infos:type_name -> milvus.proto.data.SegmentInfo + 127, // 31: milvus.proto.query.LoadMetaInfo.db_properties:type_name -> milvus.proto.common.KeyValuePair + 120, // 32: milvus.proto.query.WatchDmChannelsRequest.base:type_name -> milvus.proto.common.MsgBase + 128, // 33: milvus.proto.query.WatchDmChannelsRequest.infos:type_name -> milvus.proto.data.VchannelInfo + 123, // 34: milvus.proto.query.WatchDmChannelsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 129, // 35: milvus.proto.query.WatchDmChannelsRequest.exclude_infos:type_name -> milvus.proto.data.SegmentInfo 25, // 36: milvus.proto.query.WatchDmChannelsRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo - 101, // 37: milvus.proto.query.WatchDmChannelsRequest.segment_infos:type_name -> milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry - 124, // 38: milvus.proto.query.WatchDmChannelsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 102, // 39: milvus.proto.query.WatchDmChannelsRequest.sealed_segment_row_count:type_name -> milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry - 118, // 40: milvus.proto.query.UnsubDmChannelRequest.base:type_name -> milvus.proto.common.MsgBase - 128, // 41: milvus.proto.query.SegmentLoadInfo.binlog_paths:type_name -> milvus.proto.data.FieldBinlog - 128, // 42: milvus.proto.query.SegmentLoadInfo.statslogs:type_name -> milvus.proto.data.FieldBinlog - 128, // 43: milvus.proto.query.SegmentLoadInfo.deltalogs:type_name -> milvus.proto.data.FieldBinlog + 102, // 37: milvus.proto.query.WatchDmChannelsRequest.segment_infos:type_name -> milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry + 126, // 38: milvus.proto.query.WatchDmChannelsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 103, // 39: milvus.proto.query.WatchDmChannelsRequest.sealed_segment_row_count:type_name -> milvus.proto.query.WatchDmChannelsRequest.SealedSegmentRowCountEntry + 120, // 40: milvus.proto.query.UnsubDmChannelRequest.base:type_name -> milvus.proto.common.MsgBase + 130, // 41: milvus.proto.query.SegmentLoadInfo.binlog_paths:type_name -> milvus.proto.data.FieldBinlog + 130, // 42: milvus.proto.query.SegmentLoadInfo.statslogs:type_name -> milvus.proto.data.FieldBinlog + 130, // 43: milvus.proto.query.SegmentLoadInfo.deltalogs:type_name -> milvus.proto.data.FieldBinlog 29, // 44: milvus.proto.query.SegmentLoadInfo.index_infos:type_name -> milvus.proto.query.FieldIndexInfo - 129, // 45: milvus.proto.query.SegmentLoadInfo.start_position:type_name -> milvus.proto.msg.MsgPosition - 129, // 46: milvus.proto.query.SegmentLoadInfo.delta_position:type_name -> milvus.proto.msg.MsgPosition - 130, // 47: milvus.proto.query.SegmentLoadInfo.level:type_name -> milvus.proto.data.SegmentLevel - 103, // 48: milvus.proto.query.SegmentLoadInfo.textStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry - 128, // 49: milvus.proto.query.SegmentLoadInfo.bm25logs:type_name -> milvus.proto.data.FieldBinlog - 104, // 50: milvus.proto.query.SegmentLoadInfo.jsonKeyStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry - 122, // 51: milvus.proto.query.SegmentLoadInfo.priority:type_name -> milvus.proto.common.LoadPriority - 125, // 52: milvus.proto.query.FieldIndexInfo.index_params:type_name -> milvus.proto.common.KeyValuePair - 118, // 53: milvus.proto.query.LoadSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 131, // 45: milvus.proto.query.SegmentLoadInfo.start_position:type_name -> milvus.proto.msg.MsgPosition + 131, // 46: milvus.proto.query.SegmentLoadInfo.delta_position:type_name -> milvus.proto.msg.MsgPosition + 132, // 47: milvus.proto.query.SegmentLoadInfo.level:type_name -> milvus.proto.data.SegmentLevel + 104, // 48: milvus.proto.query.SegmentLoadInfo.textStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry + 130, // 49: milvus.proto.query.SegmentLoadInfo.bm25logs:type_name -> milvus.proto.data.FieldBinlog + 105, // 50: milvus.proto.query.SegmentLoadInfo.jsonKeyStatsLogs:type_name -> milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry + 124, // 51: milvus.proto.query.SegmentLoadInfo.priority:type_name -> milvus.proto.common.LoadPriority + 127, // 52: milvus.proto.query.FieldIndexInfo.index_params:type_name -> milvus.proto.common.KeyValuePair + 120, // 53: milvus.proto.query.LoadSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase 28, // 54: milvus.proto.query.LoadSegmentsRequest.infos:type_name -> milvus.proto.query.SegmentLoadInfo - 121, // 55: milvus.proto.query.LoadSegmentsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 123, // 55: milvus.proto.query.LoadSegmentsRequest.schema:type_name -> milvus.proto.schema.CollectionSchema 25, // 56: milvus.proto.query.LoadSegmentsRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo - 129, // 57: milvus.proto.query.LoadSegmentsRequest.delta_positions:type_name -> milvus.proto.msg.MsgPosition + 131, // 57: milvus.proto.query.LoadSegmentsRequest.delta_positions:type_name -> milvus.proto.msg.MsgPosition 0, // 58: milvus.proto.query.LoadSegmentsRequest.load_scope:type_name -> milvus.proto.query.LoadScope - 124, // 59: milvus.proto.query.LoadSegmentsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 118, // 60: milvus.proto.query.ReleaseSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 126, // 59: milvus.proto.query.LoadSegmentsRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 120, // 60: milvus.proto.query.ReleaseSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase 1, // 61: milvus.proto.query.ReleaseSegmentsRequest.scope:type_name -> milvus.proto.query.DataScope - 129, // 62: milvus.proto.query.ReleaseSegmentsRequest.checkpoint:type_name -> milvus.proto.msg.MsgPosition - 131, // 63: milvus.proto.query.SearchRequest.req:type_name -> milvus.proto.internal.SearchRequest + 131, // 62: milvus.proto.query.ReleaseSegmentsRequest.checkpoint:type_name -> milvus.proto.msg.MsgPosition + 133, // 63: milvus.proto.query.SearchRequest.req:type_name -> milvus.proto.internal.SearchRequest 1, // 64: milvus.proto.query.SearchRequest.scope:type_name -> milvus.proto.query.DataScope - 132, // 65: milvus.proto.query.QueryRequest.req:type_name -> milvus.proto.internal.RetrieveRequest + 134, // 65: milvus.proto.query.QueryRequest.req:type_name -> milvus.proto.internal.RetrieveRequest 1, // 66: milvus.proto.query.QueryRequest.scope:type_name -> milvus.proto.query.DataScope - 118, // 67: milvus.proto.query.SyncReplicaSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 35, // 68: milvus.proto.query.SyncReplicaSegmentsRequest.replica_segments:type_name -> milvus.proto.query.ReplicaSegmentsInfo - 118, // 69: milvus.proto.query.GetLoadInfoRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 70: milvus.proto.query.GetLoadInfoResponse.status:type_name -> milvus.proto.common.Status - 121, // 71: milvus.proto.query.GetLoadInfoResponse.schema:type_name -> milvus.proto.schema.CollectionSchema + 120, // 67: milvus.proto.query.SyncReplicaSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 36, // 68: milvus.proto.query.SyncReplicaSegmentsRequest.replica_segments:type_name -> milvus.proto.query.ReplicaSegmentsInfo + 120, // 69: milvus.proto.query.GetLoadInfoRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 70: milvus.proto.query.GetLoadInfoResponse.status:type_name -> milvus.proto.common.Status + 123, // 71: milvus.proto.query.GetLoadInfoResponse.schema:type_name -> milvus.proto.schema.CollectionSchema 4, // 72: milvus.proto.query.GetLoadInfoResponse.load_type:type_name -> milvus.proto.query.LoadType - 118, // 73: milvus.proto.query.HandoffSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 43, // 74: milvus.proto.query.HandoffSegmentsRequest.segmentInfos:type_name -> milvus.proto.query.SegmentInfo - 118, // 75: milvus.proto.query.LoadBalanceRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 73: milvus.proto.query.HandoffSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 44, // 74: milvus.proto.query.HandoffSegmentsRequest.segmentInfos:type_name -> milvus.proto.query.SegmentInfo + 120, // 75: milvus.proto.query.LoadBalanceRequest.base:type_name -> milvus.proto.common.MsgBase 3, // 76: milvus.proto.query.LoadBalanceRequest.balance_reason:type_name -> milvus.proto.query.TriggerCondition - 43, // 77: milvus.proto.query.QueryChannelInfo.global_sealed_segments:type_name -> milvus.proto.query.SegmentInfo - 129, // 78: milvus.proto.query.QueryChannelInfo.seek_position:type_name -> milvus.proto.msg.MsgPosition + 44, // 77: milvus.proto.query.QueryChannelInfo.global_sealed_segments:type_name -> milvus.proto.query.SegmentInfo + 131, // 78: milvus.proto.query.QueryChannelInfo.seek_position:type_name -> milvus.proto.msg.MsgPosition 2, // 79: milvus.proto.query.PartitionStates.state:type_name -> milvus.proto.query.PartitionState - 133, // 80: milvus.proto.query.SegmentInfo.segment_state:type_name -> milvus.proto.common.SegmentState + 135, // 80: milvus.proto.query.SegmentInfo.segment_state:type_name -> milvus.proto.common.SegmentState 29, // 81: milvus.proto.query.SegmentInfo.index_infos:type_name -> milvus.proto.query.FieldIndexInfo - 130, // 82: milvus.proto.query.SegmentInfo.level:type_name -> milvus.proto.data.SegmentLevel - 42, // 83: milvus.proto.query.CollectionInfo.partition_states:type_name -> milvus.proto.query.PartitionStates + 132, // 82: milvus.proto.query.SegmentInfo.level:type_name -> milvus.proto.data.SegmentLevel + 43, // 83: milvus.proto.query.CollectionInfo.partition_states:type_name -> milvus.proto.query.PartitionStates 4, // 84: milvus.proto.query.CollectionInfo.load_type:type_name -> milvus.proto.query.LoadType - 121, // 85: milvus.proto.query.CollectionInfo.schema:type_name -> milvus.proto.schema.CollectionSchema - 45, // 86: milvus.proto.query.UnsubscribeChannelInfo.collection_channels:type_name -> milvus.proto.query.UnsubscribeChannels - 43, // 87: milvus.proto.query.SegmentChangeInfo.online_segments:type_name -> milvus.proto.query.SegmentInfo - 43, // 88: milvus.proto.query.SegmentChangeInfo.offline_segments:type_name -> milvus.proto.query.SegmentInfo - 118, // 89: milvus.proto.query.SealedSegmentsChangeInfo.base:type_name -> milvus.proto.common.MsgBase - 47, // 90: milvus.proto.query.SealedSegmentsChangeInfo.infos:type_name -> milvus.proto.query.SegmentChangeInfo - 118, // 91: milvus.proto.query.GetDataDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 105, // 92: milvus.proto.query.GetDataDistributionRequest.checkpoints:type_name -> milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry - 119, // 93: milvus.proto.query.GetDataDistributionResponse.status:type_name -> milvus.proto.common.Status - 54, // 94: milvus.proto.query.GetDataDistributionResponse.segments:type_name -> milvus.proto.query.SegmentVersionInfo - 55, // 95: milvus.proto.query.GetDataDistributionResponse.channels:type_name -> milvus.proto.query.ChannelVersionInfo - 51, // 96: milvus.proto.query.GetDataDistributionResponse.leader_views:type_name -> milvus.proto.query.LeaderView - 106, // 97: milvus.proto.query.LeaderView.segment_dist:type_name -> milvus.proto.query.LeaderView.SegmentDistEntry - 107, // 98: milvus.proto.query.LeaderView.growing_segments:type_name -> milvus.proto.query.LeaderView.GrowingSegmentsEntry - 108, // 99: milvus.proto.query.LeaderView.partition_stats_versions:type_name -> milvus.proto.query.LeaderView.PartitionStatsVersionsEntry - 52, // 100: milvus.proto.query.LeaderView.status:type_name -> milvus.proto.query.LeaderViewStatus - 109, // 101: milvus.proto.query.SegmentVersionInfo.index_info:type_name -> milvus.proto.query.SegmentVersionInfo.IndexInfoEntry - 130, // 102: milvus.proto.query.SegmentVersionInfo.level:type_name -> milvus.proto.data.SegmentLevel - 5, // 103: milvus.proto.query.CollectionLoadInfo.status:type_name -> milvus.proto.query.LoadStatus - 110, // 104: milvus.proto.query.CollectionLoadInfo.field_indexID:type_name -> milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry - 4, // 105: milvus.proto.query.CollectionLoadInfo.load_type:type_name -> milvus.proto.query.LoadType - 5, // 106: milvus.proto.query.PartitionLoadInfo.status:type_name -> milvus.proto.query.LoadStatus - 111, // 107: milvus.proto.query.PartitionLoadInfo.field_indexID:type_name -> milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry - 112, // 108: milvus.proto.query.Replica.channel_node_infos:type_name -> milvus.proto.query.Replica.ChannelNodeInfosEntry - 6, // 109: milvus.proto.query.SyncAction.type:type_name -> milvus.proto.query.SyncType - 28, // 110: milvus.proto.query.SyncAction.info:type_name -> milvus.proto.query.SegmentLoadInfo - 129, // 111: milvus.proto.query.SyncAction.checkpoint:type_name -> milvus.proto.msg.MsgPosition - 113, // 112: milvus.proto.query.SyncAction.partition_stats_versions:type_name -> milvus.proto.query.SyncAction.PartitionStatsVersionsEntry - 129, // 113: milvus.proto.query.SyncAction.deleteCP:type_name -> milvus.proto.msg.MsgPosition - 114, // 114: milvus.proto.query.SyncAction.sealed_segment_row_count:type_name -> milvus.proto.query.SyncAction.SealedSegmentRowCountEntry - 118, // 115: milvus.proto.query.SyncDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 60, // 116: milvus.proto.query.SyncDistributionRequest.actions:type_name -> milvus.proto.query.SyncAction - 121, // 117: milvus.proto.query.SyncDistributionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 25, // 118: milvus.proto.query.SyncDistributionRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo - 124, // 119: milvus.proto.query.SyncDistributionRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo - 134, // 120: milvus.proto.query.ResourceGroup.config:type_name -> milvus.proto.rg.ResourceGroupConfig - 118, // 121: milvus.proto.query.TransferReplicaRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 122: milvus.proto.query.DescribeResourceGroupRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 123: milvus.proto.query.DescribeResourceGroupResponse.status:type_name -> milvus.proto.common.Status - 66, // 124: milvus.proto.query.DescribeResourceGroupResponse.resource_group:type_name -> milvus.proto.query.ResourceGroupInfo - 115, // 125: milvus.proto.query.ResourceGroupInfo.num_loaded_replica:type_name -> milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry - 116, // 126: milvus.proto.query.ResourceGroupInfo.num_outgoing_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry - 117, // 127: milvus.proto.query.ResourceGroupInfo.num_incoming_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry - 134, // 128: milvus.proto.query.ResourceGroupInfo.config:type_name -> milvus.proto.rg.ResourceGroupConfig - 135, // 129: milvus.proto.query.ResourceGroupInfo.nodes:type_name -> milvus.proto.common.NodeInfo - 118, // 130: milvus.proto.query.DeleteRequest.base:type_name -> milvus.proto.common.MsgBase - 136, // 131: milvus.proto.query.DeleteRequest.primary_keys:type_name -> milvus.proto.schema.IDs - 1, // 132: milvus.proto.query.DeleteRequest.scope:type_name -> milvus.proto.query.DataScope - 118, // 133: milvus.proto.query.DeleteBatchRequest.base:type_name -> milvus.proto.common.MsgBase - 136, // 134: milvus.proto.query.DeleteBatchRequest.primary_keys:type_name -> milvus.proto.schema.IDs - 1, // 135: milvus.proto.query.DeleteBatchRequest.scope:type_name -> milvus.proto.query.DataScope - 119, // 136: milvus.proto.query.DeleteBatchResponse.status:type_name -> milvus.proto.common.Status - 118, // 137: milvus.proto.query.ActivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 138: milvus.proto.query.DeactivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 139: milvus.proto.query.ListCheckersRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 140: milvus.proto.query.ListCheckersResponse.status:type_name -> milvus.proto.common.Status - 74, // 141: milvus.proto.query.ListCheckersResponse.checkerInfos:type_name -> milvus.proto.query.CheckerInfo - 130, // 142: milvus.proto.query.SegmentTarget.level:type_name -> milvus.proto.data.SegmentLevel - 75, // 143: milvus.proto.query.PartitionTarget.segments:type_name -> milvus.proto.query.SegmentTarget - 76, // 144: milvus.proto.query.ChannelTarget.partition_targets:type_name -> milvus.proto.query.PartitionTarget - 129, // 145: milvus.proto.query.ChannelTarget.seek_position:type_name -> milvus.proto.msg.MsgPosition - 129, // 146: milvus.proto.query.ChannelTarget.delete_checkpoint:type_name -> milvus.proto.msg.MsgPosition - 77, // 147: milvus.proto.query.CollectionTarget.Channel_targets:type_name -> milvus.proto.query.ChannelTarget - 118, // 148: milvus.proto.query.ListQueryNodeRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 149: milvus.proto.query.ListQueryNodeResponse.status:type_name -> milvus.proto.common.Status - 79, // 150: milvus.proto.query.ListQueryNodeResponse.nodeInfos:type_name -> milvus.proto.query.NodeInfo - 118, // 151: milvus.proto.query.GetQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 152: milvus.proto.query.GetQueryNodeDistributionResponse.status:type_name -> milvus.proto.common.Status - 118, // 153: milvus.proto.query.SuspendBalanceRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 154: milvus.proto.query.ResumeBalanceRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 155: milvus.proto.query.CheckBalanceStatusRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 156: milvus.proto.query.CheckBalanceStatusResponse.status:type_name -> milvus.proto.common.Status - 118, // 157: milvus.proto.query.SuspendNodeRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 158: milvus.proto.query.ResumeNodeRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 159: milvus.proto.query.TransferSegmentRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 160: milvus.proto.query.TransferChannelRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 161: milvus.proto.query.CheckQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 162: milvus.proto.query.UpdateLoadConfigRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 163: milvus.proto.query.UpdateSchemaRequest.base:type_name -> milvus.proto.common.MsgBase - 121, // 164: milvus.proto.query.UpdateSchemaRequest.schema:type_name -> milvus.proto.schema.CollectionSchema - 118, // 165: milvus.proto.query.RunAnalyzerRequest.base:type_name -> milvus.proto.common.MsgBase - 118, // 166: milvus.proto.query.ListLoadedSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase - 119, // 167: milvus.proto.query.ListLoadedSegmentsResponse.status:type_name -> milvus.proto.common.Status - 134, // 168: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry.value:type_name -> milvus.proto.rg.ResourceGroupConfig - 127, // 169: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry.value:type_name -> milvus.proto.data.SegmentInfo - 137, // 170: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry.value:type_name -> milvus.proto.data.TextIndexStats - 138, // 171: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry.value:type_name -> milvus.proto.data.JsonKeyStats - 129, // 172: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry.value:type_name -> milvus.proto.msg.MsgPosition - 53, // 173: milvus.proto.query.LeaderView.SegmentDistEntry.value:type_name -> milvus.proto.query.SegmentDist - 129, // 174: milvus.proto.query.LeaderView.GrowingSegmentsEntry.value:type_name -> milvus.proto.msg.MsgPosition - 29, // 175: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry.value:type_name -> milvus.proto.query.FieldIndexInfo - 58, // 176: milvus.proto.query.Replica.ChannelNodeInfosEntry.value:type_name -> milvus.proto.query.ChannelNodeInfo - 7, // 177: milvus.proto.query.QueryCoord.ShowLoadCollections:input_type -> milvus.proto.query.ShowCollectionsRequest - 9, // 178: milvus.proto.query.QueryCoord.ShowLoadPartitions:input_type -> milvus.proto.query.ShowPartitionsRequest - 14, // 179: milvus.proto.query.QueryCoord.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest - 15, // 180: milvus.proto.query.QueryCoord.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest - 11, // 181: milvus.proto.query.QueryCoord.LoadCollection:input_type -> milvus.proto.query.LoadCollectionRequest - 12, // 182: milvus.proto.query.QueryCoord.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest - 24, // 183: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:input_type -> milvus.proto.query.SyncNewCreatedPartitionRequest - 16, // 184: milvus.proto.query.QueryCoord.GetPartitionStates:input_type -> milvus.proto.query.GetPartitionStatesRequest - 18, // 185: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest - 39, // 186: milvus.proto.query.QueryCoord.LoadBalance:input_type -> milvus.proto.query.LoadBalanceRequest - 139, // 187: milvus.proto.query.QueryCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest - 140, // 188: milvus.proto.query.QueryCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest - 141, // 189: milvus.proto.query.QueryCoord.GetReplicas:input_type -> milvus.proto.milvus.GetReplicasRequest - 20, // 190: milvus.proto.query.QueryCoord.GetShardLeaders:input_type -> milvus.proto.query.GetShardLeadersRequest - 142, // 191: milvus.proto.query.QueryCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest - 143, // 192: milvus.proto.query.QueryCoord.CreateResourceGroup:input_type -> milvus.proto.milvus.CreateResourceGroupRequest - 22, // 193: milvus.proto.query.QueryCoord.UpdateResourceGroups:input_type -> milvus.proto.query.UpdateResourceGroupsRequest - 144, // 194: milvus.proto.query.QueryCoord.DropResourceGroup:input_type -> milvus.proto.milvus.DropResourceGroupRequest - 145, // 195: milvus.proto.query.QueryCoord.TransferNode:input_type -> milvus.proto.milvus.TransferNodeRequest - 63, // 196: milvus.proto.query.QueryCoord.TransferReplica:input_type -> milvus.proto.query.TransferReplicaRequest - 146, // 197: milvus.proto.query.QueryCoord.ListResourceGroups:input_type -> milvus.proto.milvus.ListResourceGroupsRequest - 64, // 198: milvus.proto.query.QueryCoord.DescribeResourceGroup:input_type -> milvus.proto.query.DescribeResourceGroupRequest - 96, // 199: milvus.proto.query.QueryCoord.ListLoadedSegments:input_type -> milvus.proto.query.ListLoadedSegmentsRequest - 72, // 200: milvus.proto.query.QueryCoord.ListCheckers:input_type -> milvus.proto.query.ListCheckersRequest - 70, // 201: milvus.proto.query.QueryCoord.ActivateChecker:input_type -> milvus.proto.query.ActivateCheckerRequest - 71, // 202: milvus.proto.query.QueryCoord.DeactivateChecker:input_type -> milvus.proto.query.DeactivateCheckerRequest - 80, // 203: milvus.proto.query.QueryCoord.ListQueryNode:input_type -> milvus.proto.query.ListQueryNodeRequest - 82, // 204: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:input_type -> milvus.proto.query.GetQueryNodeDistributionRequest - 84, // 205: milvus.proto.query.QueryCoord.SuspendBalance:input_type -> milvus.proto.query.SuspendBalanceRequest - 85, // 206: milvus.proto.query.QueryCoord.ResumeBalance:input_type -> milvus.proto.query.ResumeBalanceRequest - 86, // 207: milvus.proto.query.QueryCoord.CheckBalanceStatus:input_type -> milvus.proto.query.CheckBalanceStatusRequest - 88, // 208: milvus.proto.query.QueryCoord.SuspendNode:input_type -> milvus.proto.query.SuspendNodeRequest - 89, // 209: milvus.proto.query.QueryCoord.ResumeNode:input_type -> milvus.proto.query.ResumeNodeRequest - 90, // 210: milvus.proto.query.QueryCoord.TransferSegment:input_type -> milvus.proto.query.TransferSegmentRequest - 91, // 211: milvus.proto.query.QueryCoord.TransferChannel:input_type -> milvus.proto.query.TransferChannelRequest - 92, // 212: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:input_type -> milvus.proto.query.CheckQueryNodeDistributionRequest - 93, // 213: milvus.proto.query.QueryCoord.UpdateLoadConfig:input_type -> milvus.proto.query.UpdateLoadConfigRequest - 147, // 214: milvus.proto.query.QueryNode.GetComponentStates:input_type -> milvus.proto.milvus.GetComponentStatesRequest - 148, // 215: milvus.proto.query.QueryNode.GetTimeTickChannel:input_type -> milvus.proto.internal.GetTimeTickChannelRequest - 149, // 216: milvus.proto.query.QueryNode.GetStatisticsChannel:input_type -> milvus.proto.internal.GetStatisticsChannelRequest - 26, // 217: milvus.proto.query.QueryNode.WatchDmChannels:input_type -> milvus.proto.query.WatchDmChannelsRequest - 27, // 218: milvus.proto.query.QueryNode.UnsubDmChannel:input_type -> milvus.proto.query.UnsubDmChannelRequest - 30, // 219: milvus.proto.query.QueryNode.LoadSegments:input_type -> milvus.proto.query.LoadSegmentsRequest - 12, // 220: milvus.proto.query.QueryNode.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest - 14, // 221: milvus.proto.query.QueryNode.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest - 15, // 222: milvus.proto.query.QueryNode.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest - 31, // 223: milvus.proto.query.QueryNode.ReleaseSegments:input_type -> milvus.proto.query.ReleaseSegmentsRequest - 18, // 224: milvus.proto.query.QueryNode.GetSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest - 34, // 225: milvus.proto.query.QueryNode.SyncReplicaSegments:input_type -> milvus.proto.query.SyncReplicaSegmentsRequest - 13, // 226: milvus.proto.query.QueryNode.GetStatistics:input_type -> milvus.proto.query.GetStatisticsRequest - 32, // 227: milvus.proto.query.QueryNode.Search:input_type -> milvus.proto.query.SearchRequest - 32, // 228: milvus.proto.query.QueryNode.SearchSegments:input_type -> milvus.proto.query.SearchRequest - 33, // 229: milvus.proto.query.QueryNode.Query:input_type -> milvus.proto.query.QueryRequest - 33, // 230: milvus.proto.query.QueryNode.QueryStream:input_type -> milvus.proto.query.QueryRequest - 33, // 231: milvus.proto.query.QueryNode.QuerySegments:input_type -> milvus.proto.query.QueryRequest - 33, // 232: milvus.proto.query.QueryNode.QueryStreamSegments:input_type -> milvus.proto.query.QueryRequest - 139, // 233: milvus.proto.query.QueryNode.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest - 140, // 234: milvus.proto.query.QueryNode.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest - 49, // 235: milvus.proto.query.QueryNode.GetDataDistribution:input_type -> milvus.proto.query.GetDataDistributionRequest - 61, // 236: milvus.proto.query.QueryNode.SyncDistribution:input_type -> milvus.proto.query.SyncDistributionRequest - 67, // 237: milvus.proto.query.QueryNode.Delete:input_type -> milvus.proto.query.DeleteRequest - 68, // 238: milvus.proto.query.QueryNode.DeleteBatch:input_type -> milvus.proto.query.DeleteBatchRequest - 94, // 239: milvus.proto.query.QueryNode.UpdateSchema:input_type -> milvus.proto.query.UpdateSchemaRequest - 95, // 240: milvus.proto.query.QueryNode.RunAnalyzer:input_type -> milvus.proto.query.RunAnalyzerRequest - 8, // 241: milvus.proto.query.QueryCoord.ShowLoadCollections:output_type -> milvus.proto.query.ShowCollectionsResponse - 10, // 242: milvus.proto.query.QueryCoord.ShowLoadPartitions:output_type -> milvus.proto.query.ShowPartitionsResponse - 119, // 243: milvus.proto.query.QueryCoord.LoadPartitions:output_type -> milvus.proto.common.Status - 119, // 244: milvus.proto.query.QueryCoord.ReleasePartitions:output_type -> milvus.proto.common.Status - 119, // 245: milvus.proto.query.QueryCoord.LoadCollection:output_type -> milvus.proto.common.Status - 119, // 246: milvus.proto.query.QueryCoord.ReleaseCollection:output_type -> milvus.proto.common.Status - 119, // 247: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:output_type -> milvus.proto.common.Status - 17, // 248: milvus.proto.query.QueryCoord.GetPartitionStates:output_type -> milvus.proto.query.GetPartitionStatesResponse - 19, // 249: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse - 119, // 250: milvus.proto.query.QueryCoord.LoadBalance:output_type -> milvus.proto.common.Status - 150, // 251: milvus.proto.query.QueryCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse - 151, // 252: milvus.proto.query.QueryCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse - 152, // 253: milvus.proto.query.QueryCoord.GetReplicas:output_type -> milvus.proto.milvus.GetReplicasResponse - 21, // 254: milvus.proto.query.QueryCoord.GetShardLeaders:output_type -> milvus.proto.query.GetShardLeadersResponse - 153, // 255: milvus.proto.query.QueryCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse - 119, // 256: milvus.proto.query.QueryCoord.CreateResourceGroup:output_type -> milvus.proto.common.Status - 119, // 257: milvus.proto.query.QueryCoord.UpdateResourceGroups:output_type -> milvus.proto.common.Status - 119, // 258: milvus.proto.query.QueryCoord.DropResourceGroup:output_type -> milvus.proto.common.Status - 119, // 259: milvus.proto.query.QueryCoord.TransferNode:output_type -> milvus.proto.common.Status - 119, // 260: milvus.proto.query.QueryCoord.TransferReplica:output_type -> milvus.proto.common.Status - 154, // 261: milvus.proto.query.QueryCoord.ListResourceGroups:output_type -> milvus.proto.milvus.ListResourceGroupsResponse - 65, // 262: milvus.proto.query.QueryCoord.DescribeResourceGroup:output_type -> milvus.proto.query.DescribeResourceGroupResponse - 97, // 263: milvus.proto.query.QueryCoord.ListLoadedSegments:output_type -> milvus.proto.query.ListLoadedSegmentsResponse - 73, // 264: milvus.proto.query.QueryCoord.ListCheckers:output_type -> milvus.proto.query.ListCheckersResponse - 119, // 265: milvus.proto.query.QueryCoord.ActivateChecker:output_type -> milvus.proto.common.Status - 119, // 266: milvus.proto.query.QueryCoord.DeactivateChecker:output_type -> milvus.proto.common.Status - 81, // 267: milvus.proto.query.QueryCoord.ListQueryNode:output_type -> milvus.proto.query.ListQueryNodeResponse - 83, // 268: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:output_type -> milvus.proto.query.GetQueryNodeDistributionResponse - 119, // 269: milvus.proto.query.QueryCoord.SuspendBalance:output_type -> milvus.proto.common.Status - 119, // 270: milvus.proto.query.QueryCoord.ResumeBalance:output_type -> milvus.proto.common.Status - 87, // 271: milvus.proto.query.QueryCoord.CheckBalanceStatus:output_type -> milvus.proto.query.CheckBalanceStatusResponse - 119, // 272: milvus.proto.query.QueryCoord.SuspendNode:output_type -> milvus.proto.common.Status - 119, // 273: milvus.proto.query.QueryCoord.ResumeNode:output_type -> milvus.proto.common.Status - 119, // 274: milvus.proto.query.QueryCoord.TransferSegment:output_type -> milvus.proto.common.Status - 119, // 275: milvus.proto.query.QueryCoord.TransferChannel:output_type -> milvus.proto.common.Status - 119, // 276: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:output_type -> milvus.proto.common.Status - 119, // 277: milvus.proto.query.QueryCoord.UpdateLoadConfig:output_type -> milvus.proto.common.Status - 155, // 278: milvus.proto.query.QueryNode.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates - 156, // 279: milvus.proto.query.QueryNode.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse - 156, // 280: milvus.proto.query.QueryNode.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse - 119, // 281: milvus.proto.query.QueryNode.WatchDmChannels:output_type -> milvus.proto.common.Status - 119, // 282: milvus.proto.query.QueryNode.UnsubDmChannel:output_type -> milvus.proto.common.Status - 119, // 283: milvus.proto.query.QueryNode.LoadSegments:output_type -> milvus.proto.common.Status - 119, // 284: milvus.proto.query.QueryNode.ReleaseCollection:output_type -> milvus.proto.common.Status - 119, // 285: milvus.proto.query.QueryNode.LoadPartitions:output_type -> milvus.proto.common.Status - 119, // 286: milvus.proto.query.QueryNode.ReleasePartitions:output_type -> milvus.proto.common.Status - 119, // 287: milvus.proto.query.QueryNode.ReleaseSegments:output_type -> milvus.proto.common.Status - 19, // 288: milvus.proto.query.QueryNode.GetSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse - 119, // 289: milvus.proto.query.QueryNode.SyncReplicaSegments:output_type -> milvus.proto.common.Status - 157, // 290: milvus.proto.query.QueryNode.GetStatistics:output_type -> milvus.proto.internal.GetStatisticsResponse - 158, // 291: milvus.proto.query.QueryNode.Search:output_type -> milvus.proto.internal.SearchResults - 158, // 292: milvus.proto.query.QueryNode.SearchSegments:output_type -> milvus.proto.internal.SearchResults - 159, // 293: milvus.proto.query.QueryNode.Query:output_type -> milvus.proto.internal.RetrieveResults - 159, // 294: milvus.proto.query.QueryNode.QueryStream:output_type -> milvus.proto.internal.RetrieveResults - 159, // 295: milvus.proto.query.QueryNode.QuerySegments:output_type -> milvus.proto.internal.RetrieveResults - 159, // 296: milvus.proto.query.QueryNode.QueryStreamSegments:output_type -> milvus.proto.internal.RetrieveResults - 150, // 297: milvus.proto.query.QueryNode.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse - 151, // 298: milvus.proto.query.QueryNode.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse - 50, // 299: milvus.proto.query.QueryNode.GetDataDistribution:output_type -> milvus.proto.query.GetDataDistributionResponse - 119, // 300: milvus.proto.query.QueryNode.SyncDistribution:output_type -> milvus.proto.common.Status - 119, // 301: milvus.proto.query.QueryNode.Delete:output_type -> milvus.proto.common.Status - 69, // 302: milvus.proto.query.QueryNode.DeleteBatch:output_type -> milvus.proto.query.DeleteBatchResponse - 119, // 303: milvus.proto.query.QueryNode.UpdateSchema:output_type -> milvus.proto.common.Status - 160, // 304: milvus.proto.query.QueryNode.RunAnalyzer:output_type -> milvus.proto.milvus.RunAnalyzerResponse - 241, // [241:305] is the sub-list for method output_type - 177, // [177:241] is the sub-list for method input_type - 177, // [177:177] is the sub-list for extension type_name - 177, // [177:177] is the sub-list for extension extendee - 0, // [0:177] is the sub-list for field type_name + 123, // 85: milvus.proto.query.CollectionInfo.schema:type_name -> milvus.proto.schema.CollectionSchema + 46, // 86: milvus.proto.query.UnsubscribeChannelInfo.collection_channels:type_name -> milvus.proto.query.UnsubscribeChannels + 44, // 87: milvus.proto.query.SegmentChangeInfo.online_segments:type_name -> milvus.proto.query.SegmentInfo + 44, // 88: milvus.proto.query.SegmentChangeInfo.offline_segments:type_name -> milvus.proto.query.SegmentInfo + 120, // 89: milvus.proto.query.SealedSegmentsChangeInfo.base:type_name -> milvus.proto.common.MsgBase + 48, // 90: milvus.proto.query.SealedSegmentsChangeInfo.infos:type_name -> milvus.proto.query.SegmentChangeInfo + 120, // 91: milvus.proto.query.GetDataDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 106, // 92: milvus.proto.query.GetDataDistributionRequest.checkpoints:type_name -> milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry + 121, // 93: milvus.proto.query.GetDataDistributionResponse.status:type_name -> milvus.proto.common.Status + 55, // 94: milvus.proto.query.GetDataDistributionResponse.segments:type_name -> milvus.proto.query.SegmentVersionInfo + 56, // 95: milvus.proto.query.GetDataDistributionResponse.channels:type_name -> milvus.proto.query.ChannelVersionInfo + 52, // 96: milvus.proto.query.GetDataDistributionResponse.leader_views:type_name -> milvus.proto.query.LeaderView + 107, // 97: milvus.proto.query.LeaderView.segment_dist:type_name -> milvus.proto.query.LeaderView.SegmentDistEntry + 108, // 98: milvus.proto.query.LeaderView.growing_segments:type_name -> milvus.proto.query.LeaderView.GrowingSegmentsEntry + 109, // 99: milvus.proto.query.LeaderView.partition_stats_versions:type_name -> milvus.proto.query.LeaderView.PartitionStatsVersionsEntry + 53, // 100: milvus.proto.query.LeaderView.status:type_name -> milvus.proto.query.LeaderViewStatus + 110, // 101: milvus.proto.query.SegmentVersionInfo.index_info:type_name -> milvus.proto.query.SegmentVersionInfo.IndexInfoEntry + 132, // 102: milvus.proto.query.SegmentVersionInfo.level:type_name -> milvus.proto.data.SegmentLevel + 111, // 103: milvus.proto.query.SegmentVersionInfo.json_stats_info:type_name -> milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry + 5, // 104: milvus.proto.query.CollectionLoadInfo.status:type_name -> milvus.proto.query.LoadStatus + 112, // 105: milvus.proto.query.CollectionLoadInfo.field_indexID:type_name -> milvus.proto.query.CollectionLoadInfo.FieldIndexIDEntry + 4, // 106: milvus.proto.query.CollectionLoadInfo.load_type:type_name -> milvus.proto.query.LoadType + 5, // 107: milvus.proto.query.PartitionLoadInfo.status:type_name -> milvus.proto.query.LoadStatus + 113, // 108: milvus.proto.query.PartitionLoadInfo.field_indexID:type_name -> milvus.proto.query.PartitionLoadInfo.FieldIndexIDEntry + 114, // 109: milvus.proto.query.Replica.channel_node_infos:type_name -> milvus.proto.query.Replica.ChannelNodeInfosEntry + 6, // 110: milvus.proto.query.SyncAction.type:type_name -> milvus.proto.query.SyncType + 28, // 111: milvus.proto.query.SyncAction.info:type_name -> milvus.proto.query.SegmentLoadInfo + 131, // 112: milvus.proto.query.SyncAction.checkpoint:type_name -> milvus.proto.msg.MsgPosition + 115, // 113: milvus.proto.query.SyncAction.partition_stats_versions:type_name -> milvus.proto.query.SyncAction.PartitionStatsVersionsEntry + 131, // 114: milvus.proto.query.SyncAction.deleteCP:type_name -> milvus.proto.msg.MsgPosition + 116, // 115: milvus.proto.query.SyncAction.sealed_segment_row_count:type_name -> milvus.proto.query.SyncAction.SealedSegmentRowCountEntry + 120, // 116: milvus.proto.query.SyncDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 61, // 117: milvus.proto.query.SyncDistributionRequest.actions:type_name -> milvus.proto.query.SyncAction + 123, // 118: milvus.proto.query.SyncDistributionRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 25, // 119: milvus.proto.query.SyncDistributionRequest.load_meta:type_name -> milvus.proto.query.LoadMetaInfo + 126, // 120: milvus.proto.query.SyncDistributionRequest.index_info_list:type_name -> milvus.proto.index.IndexInfo + 136, // 121: milvus.proto.query.ResourceGroup.config:type_name -> milvus.proto.rg.ResourceGroupConfig + 120, // 122: milvus.proto.query.TransferReplicaRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 123: milvus.proto.query.DescribeResourceGroupRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 124: milvus.proto.query.DescribeResourceGroupResponse.status:type_name -> milvus.proto.common.Status + 67, // 125: milvus.proto.query.DescribeResourceGroupResponse.resource_group:type_name -> milvus.proto.query.ResourceGroupInfo + 117, // 126: milvus.proto.query.ResourceGroupInfo.num_loaded_replica:type_name -> milvus.proto.query.ResourceGroupInfo.NumLoadedReplicaEntry + 118, // 127: milvus.proto.query.ResourceGroupInfo.num_outgoing_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumOutgoingNodeEntry + 119, // 128: milvus.proto.query.ResourceGroupInfo.num_incoming_node:type_name -> milvus.proto.query.ResourceGroupInfo.NumIncomingNodeEntry + 136, // 129: milvus.proto.query.ResourceGroupInfo.config:type_name -> milvus.proto.rg.ResourceGroupConfig + 137, // 130: milvus.proto.query.ResourceGroupInfo.nodes:type_name -> milvus.proto.common.NodeInfo + 120, // 131: milvus.proto.query.DeleteRequest.base:type_name -> milvus.proto.common.MsgBase + 138, // 132: milvus.proto.query.DeleteRequest.primary_keys:type_name -> milvus.proto.schema.IDs + 1, // 133: milvus.proto.query.DeleteRequest.scope:type_name -> milvus.proto.query.DataScope + 120, // 134: milvus.proto.query.DeleteBatchRequest.base:type_name -> milvus.proto.common.MsgBase + 138, // 135: milvus.proto.query.DeleteBatchRequest.primary_keys:type_name -> milvus.proto.schema.IDs + 1, // 136: milvus.proto.query.DeleteBatchRequest.scope:type_name -> milvus.proto.query.DataScope + 121, // 137: milvus.proto.query.DeleteBatchResponse.status:type_name -> milvus.proto.common.Status + 120, // 138: milvus.proto.query.ActivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 139: milvus.proto.query.DeactivateCheckerRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 140: milvus.proto.query.ListCheckersRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 141: milvus.proto.query.ListCheckersResponse.status:type_name -> milvus.proto.common.Status + 75, // 142: milvus.proto.query.ListCheckersResponse.checkerInfos:type_name -> milvus.proto.query.CheckerInfo + 132, // 143: milvus.proto.query.SegmentTarget.level:type_name -> milvus.proto.data.SegmentLevel + 76, // 144: milvus.proto.query.PartitionTarget.segments:type_name -> milvus.proto.query.SegmentTarget + 77, // 145: milvus.proto.query.ChannelTarget.partition_targets:type_name -> milvus.proto.query.PartitionTarget + 131, // 146: milvus.proto.query.ChannelTarget.seek_position:type_name -> milvus.proto.msg.MsgPosition + 131, // 147: milvus.proto.query.ChannelTarget.delete_checkpoint:type_name -> milvus.proto.msg.MsgPosition + 78, // 148: milvus.proto.query.CollectionTarget.Channel_targets:type_name -> milvus.proto.query.ChannelTarget + 120, // 149: milvus.proto.query.ListQueryNodeRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 150: milvus.proto.query.ListQueryNodeResponse.status:type_name -> milvus.proto.common.Status + 80, // 151: milvus.proto.query.ListQueryNodeResponse.nodeInfos:type_name -> milvus.proto.query.NodeInfo + 120, // 152: milvus.proto.query.GetQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 153: milvus.proto.query.GetQueryNodeDistributionResponse.status:type_name -> milvus.proto.common.Status + 120, // 154: milvus.proto.query.SuspendBalanceRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 155: milvus.proto.query.ResumeBalanceRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 156: milvus.proto.query.CheckBalanceStatusRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 157: milvus.proto.query.CheckBalanceStatusResponse.status:type_name -> milvus.proto.common.Status + 120, // 158: milvus.proto.query.SuspendNodeRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 159: milvus.proto.query.ResumeNodeRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 160: milvus.proto.query.TransferSegmentRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 161: milvus.proto.query.TransferChannelRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 162: milvus.proto.query.CheckQueryNodeDistributionRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 163: milvus.proto.query.UpdateLoadConfigRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 164: milvus.proto.query.UpdateSchemaRequest.base:type_name -> milvus.proto.common.MsgBase + 123, // 165: milvus.proto.query.UpdateSchemaRequest.schema:type_name -> milvus.proto.schema.CollectionSchema + 120, // 166: milvus.proto.query.RunAnalyzerRequest.base:type_name -> milvus.proto.common.MsgBase + 120, // 167: milvus.proto.query.ListLoadedSegmentsRequest.base:type_name -> milvus.proto.common.MsgBase + 121, // 168: milvus.proto.query.ListLoadedSegmentsResponse.status:type_name -> milvus.proto.common.Status + 136, // 169: milvus.proto.query.UpdateResourceGroupsRequest.ResourceGroupsEntry.value:type_name -> milvus.proto.rg.ResourceGroupConfig + 129, // 170: milvus.proto.query.WatchDmChannelsRequest.SegmentInfosEntry.value:type_name -> milvus.proto.data.SegmentInfo + 139, // 171: milvus.proto.query.SegmentLoadInfo.TextStatsLogsEntry.value:type_name -> milvus.proto.data.TextIndexStats + 140, // 172: milvus.proto.query.SegmentLoadInfo.JsonKeyStatsLogsEntry.value:type_name -> milvus.proto.data.JsonKeyStats + 131, // 173: milvus.proto.query.GetDataDistributionRequest.CheckpointsEntry.value:type_name -> milvus.proto.msg.MsgPosition + 54, // 174: milvus.proto.query.LeaderView.SegmentDistEntry.value:type_name -> milvus.proto.query.SegmentDist + 131, // 175: milvus.proto.query.LeaderView.GrowingSegmentsEntry.value:type_name -> milvus.proto.msg.MsgPosition + 29, // 176: milvus.proto.query.SegmentVersionInfo.IndexInfoEntry.value:type_name -> milvus.proto.query.FieldIndexInfo + 30, // 177: milvus.proto.query.SegmentVersionInfo.JsonStatsInfoEntry.value:type_name -> milvus.proto.query.JsonStatsInfo + 59, // 178: milvus.proto.query.Replica.ChannelNodeInfosEntry.value:type_name -> milvus.proto.query.ChannelNodeInfo + 7, // 179: milvus.proto.query.QueryCoord.ShowLoadCollections:input_type -> milvus.proto.query.ShowCollectionsRequest + 9, // 180: milvus.proto.query.QueryCoord.ShowLoadPartitions:input_type -> milvus.proto.query.ShowPartitionsRequest + 14, // 181: milvus.proto.query.QueryCoord.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest + 15, // 182: milvus.proto.query.QueryCoord.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest + 11, // 183: milvus.proto.query.QueryCoord.LoadCollection:input_type -> milvus.proto.query.LoadCollectionRequest + 12, // 184: milvus.proto.query.QueryCoord.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest + 24, // 185: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:input_type -> milvus.proto.query.SyncNewCreatedPartitionRequest + 16, // 186: milvus.proto.query.QueryCoord.GetPartitionStates:input_type -> milvus.proto.query.GetPartitionStatesRequest + 18, // 187: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest + 40, // 188: milvus.proto.query.QueryCoord.LoadBalance:input_type -> milvus.proto.query.LoadBalanceRequest + 141, // 189: milvus.proto.query.QueryCoord.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest + 142, // 190: milvus.proto.query.QueryCoord.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest + 143, // 191: milvus.proto.query.QueryCoord.GetReplicas:input_type -> milvus.proto.milvus.GetReplicasRequest + 20, // 192: milvus.proto.query.QueryCoord.GetShardLeaders:input_type -> milvus.proto.query.GetShardLeadersRequest + 144, // 193: milvus.proto.query.QueryCoord.CheckHealth:input_type -> milvus.proto.milvus.CheckHealthRequest + 145, // 194: milvus.proto.query.QueryCoord.CreateResourceGroup:input_type -> milvus.proto.milvus.CreateResourceGroupRequest + 22, // 195: milvus.proto.query.QueryCoord.UpdateResourceGroups:input_type -> milvus.proto.query.UpdateResourceGroupsRequest + 146, // 196: milvus.proto.query.QueryCoord.DropResourceGroup:input_type -> milvus.proto.milvus.DropResourceGroupRequest + 147, // 197: milvus.proto.query.QueryCoord.TransferNode:input_type -> milvus.proto.milvus.TransferNodeRequest + 64, // 198: milvus.proto.query.QueryCoord.TransferReplica:input_type -> milvus.proto.query.TransferReplicaRequest + 148, // 199: milvus.proto.query.QueryCoord.ListResourceGroups:input_type -> milvus.proto.milvus.ListResourceGroupsRequest + 65, // 200: milvus.proto.query.QueryCoord.DescribeResourceGroup:input_type -> milvus.proto.query.DescribeResourceGroupRequest + 97, // 201: milvus.proto.query.QueryCoord.ListLoadedSegments:input_type -> milvus.proto.query.ListLoadedSegmentsRequest + 73, // 202: milvus.proto.query.QueryCoord.ListCheckers:input_type -> milvus.proto.query.ListCheckersRequest + 71, // 203: milvus.proto.query.QueryCoord.ActivateChecker:input_type -> milvus.proto.query.ActivateCheckerRequest + 72, // 204: milvus.proto.query.QueryCoord.DeactivateChecker:input_type -> milvus.proto.query.DeactivateCheckerRequest + 81, // 205: milvus.proto.query.QueryCoord.ListQueryNode:input_type -> milvus.proto.query.ListQueryNodeRequest + 83, // 206: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:input_type -> milvus.proto.query.GetQueryNodeDistributionRequest + 85, // 207: milvus.proto.query.QueryCoord.SuspendBalance:input_type -> milvus.proto.query.SuspendBalanceRequest + 86, // 208: milvus.proto.query.QueryCoord.ResumeBalance:input_type -> milvus.proto.query.ResumeBalanceRequest + 87, // 209: milvus.proto.query.QueryCoord.CheckBalanceStatus:input_type -> milvus.proto.query.CheckBalanceStatusRequest + 89, // 210: milvus.proto.query.QueryCoord.SuspendNode:input_type -> milvus.proto.query.SuspendNodeRequest + 90, // 211: milvus.proto.query.QueryCoord.ResumeNode:input_type -> milvus.proto.query.ResumeNodeRequest + 91, // 212: milvus.proto.query.QueryCoord.TransferSegment:input_type -> milvus.proto.query.TransferSegmentRequest + 92, // 213: milvus.proto.query.QueryCoord.TransferChannel:input_type -> milvus.proto.query.TransferChannelRequest + 93, // 214: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:input_type -> milvus.proto.query.CheckQueryNodeDistributionRequest + 94, // 215: milvus.proto.query.QueryCoord.UpdateLoadConfig:input_type -> milvus.proto.query.UpdateLoadConfigRequest + 149, // 216: milvus.proto.query.QueryNode.GetComponentStates:input_type -> milvus.proto.milvus.GetComponentStatesRequest + 150, // 217: milvus.proto.query.QueryNode.GetTimeTickChannel:input_type -> milvus.proto.internal.GetTimeTickChannelRequest + 151, // 218: milvus.proto.query.QueryNode.GetStatisticsChannel:input_type -> milvus.proto.internal.GetStatisticsChannelRequest + 26, // 219: milvus.proto.query.QueryNode.WatchDmChannels:input_type -> milvus.proto.query.WatchDmChannelsRequest + 27, // 220: milvus.proto.query.QueryNode.UnsubDmChannel:input_type -> milvus.proto.query.UnsubDmChannelRequest + 31, // 221: milvus.proto.query.QueryNode.LoadSegments:input_type -> milvus.proto.query.LoadSegmentsRequest + 12, // 222: milvus.proto.query.QueryNode.ReleaseCollection:input_type -> milvus.proto.query.ReleaseCollectionRequest + 14, // 223: milvus.proto.query.QueryNode.LoadPartitions:input_type -> milvus.proto.query.LoadPartitionsRequest + 15, // 224: milvus.proto.query.QueryNode.ReleasePartitions:input_type -> milvus.proto.query.ReleasePartitionsRequest + 32, // 225: milvus.proto.query.QueryNode.ReleaseSegments:input_type -> milvus.proto.query.ReleaseSegmentsRequest + 18, // 226: milvus.proto.query.QueryNode.GetSegmentInfo:input_type -> milvus.proto.query.GetSegmentInfoRequest + 35, // 227: milvus.proto.query.QueryNode.SyncReplicaSegments:input_type -> milvus.proto.query.SyncReplicaSegmentsRequest + 13, // 228: milvus.proto.query.QueryNode.GetStatistics:input_type -> milvus.proto.query.GetStatisticsRequest + 33, // 229: milvus.proto.query.QueryNode.Search:input_type -> milvus.proto.query.SearchRequest + 33, // 230: milvus.proto.query.QueryNode.SearchSegments:input_type -> milvus.proto.query.SearchRequest + 34, // 231: milvus.proto.query.QueryNode.Query:input_type -> milvus.proto.query.QueryRequest + 34, // 232: milvus.proto.query.QueryNode.QueryStream:input_type -> milvus.proto.query.QueryRequest + 34, // 233: milvus.proto.query.QueryNode.QuerySegments:input_type -> milvus.proto.query.QueryRequest + 34, // 234: milvus.proto.query.QueryNode.QueryStreamSegments:input_type -> milvus.proto.query.QueryRequest + 141, // 235: milvus.proto.query.QueryNode.ShowConfigurations:input_type -> milvus.proto.internal.ShowConfigurationsRequest + 142, // 236: milvus.proto.query.QueryNode.GetMetrics:input_type -> milvus.proto.milvus.GetMetricsRequest + 50, // 237: milvus.proto.query.QueryNode.GetDataDistribution:input_type -> milvus.proto.query.GetDataDistributionRequest + 62, // 238: milvus.proto.query.QueryNode.SyncDistribution:input_type -> milvus.proto.query.SyncDistributionRequest + 68, // 239: milvus.proto.query.QueryNode.Delete:input_type -> milvus.proto.query.DeleteRequest + 69, // 240: milvus.proto.query.QueryNode.DeleteBatch:input_type -> milvus.proto.query.DeleteBatchRequest + 95, // 241: milvus.proto.query.QueryNode.UpdateSchema:input_type -> milvus.proto.query.UpdateSchemaRequest + 96, // 242: milvus.proto.query.QueryNode.RunAnalyzer:input_type -> milvus.proto.query.RunAnalyzerRequest + 8, // 243: milvus.proto.query.QueryCoord.ShowLoadCollections:output_type -> milvus.proto.query.ShowCollectionsResponse + 10, // 244: milvus.proto.query.QueryCoord.ShowLoadPartitions:output_type -> milvus.proto.query.ShowPartitionsResponse + 121, // 245: milvus.proto.query.QueryCoord.LoadPartitions:output_type -> milvus.proto.common.Status + 121, // 246: milvus.proto.query.QueryCoord.ReleasePartitions:output_type -> milvus.proto.common.Status + 121, // 247: milvus.proto.query.QueryCoord.LoadCollection:output_type -> milvus.proto.common.Status + 121, // 248: milvus.proto.query.QueryCoord.ReleaseCollection:output_type -> milvus.proto.common.Status + 121, // 249: milvus.proto.query.QueryCoord.SyncNewCreatedPartition:output_type -> milvus.proto.common.Status + 17, // 250: milvus.proto.query.QueryCoord.GetPartitionStates:output_type -> milvus.proto.query.GetPartitionStatesResponse + 19, // 251: milvus.proto.query.QueryCoord.GetLoadSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse + 121, // 252: milvus.proto.query.QueryCoord.LoadBalance:output_type -> milvus.proto.common.Status + 152, // 253: milvus.proto.query.QueryCoord.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse + 153, // 254: milvus.proto.query.QueryCoord.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse + 154, // 255: milvus.proto.query.QueryCoord.GetReplicas:output_type -> milvus.proto.milvus.GetReplicasResponse + 21, // 256: milvus.proto.query.QueryCoord.GetShardLeaders:output_type -> milvus.proto.query.GetShardLeadersResponse + 155, // 257: milvus.proto.query.QueryCoord.CheckHealth:output_type -> milvus.proto.milvus.CheckHealthResponse + 121, // 258: milvus.proto.query.QueryCoord.CreateResourceGroup:output_type -> milvus.proto.common.Status + 121, // 259: milvus.proto.query.QueryCoord.UpdateResourceGroups:output_type -> milvus.proto.common.Status + 121, // 260: milvus.proto.query.QueryCoord.DropResourceGroup:output_type -> milvus.proto.common.Status + 121, // 261: milvus.proto.query.QueryCoord.TransferNode:output_type -> milvus.proto.common.Status + 121, // 262: milvus.proto.query.QueryCoord.TransferReplica:output_type -> milvus.proto.common.Status + 156, // 263: milvus.proto.query.QueryCoord.ListResourceGroups:output_type -> milvus.proto.milvus.ListResourceGroupsResponse + 66, // 264: milvus.proto.query.QueryCoord.DescribeResourceGroup:output_type -> milvus.proto.query.DescribeResourceGroupResponse + 98, // 265: milvus.proto.query.QueryCoord.ListLoadedSegments:output_type -> milvus.proto.query.ListLoadedSegmentsResponse + 74, // 266: milvus.proto.query.QueryCoord.ListCheckers:output_type -> milvus.proto.query.ListCheckersResponse + 121, // 267: milvus.proto.query.QueryCoord.ActivateChecker:output_type -> milvus.proto.common.Status + 121, // 268: milvus.proto.query.QueryCoord.DeactivateChecker:output_type -> milvus.proto.common.Status + 82, // 269: milvus.proto.query.QueryCoord.ListQueryNode:output_type -> milvus.proto.query.ListQueryNodeResponse + 84, // 270: milvus.proto.query.QueryCoord.GetQueryNodeDistribution:output_type -> milvus.proto.query.GetQueryNodeDistributionResponse + 121, // 271: milvus.proto.query.QueryCoord.SuspendBalance:output_type -> milvus.proto.common.Status + 121, // 272: milvus.proto.query.QueryCoord.ResumeBalance:output_type -> milvus.proto.common.Status + 88, // 273: milvus.proto.query.QueryCoord.CheckBalanceStatus:output_type -> milvus.proto.query.CheckBalanceStatusResponse + 121, // 274: milvus.proto.query.QueryCoord.SuspendNode:output_type -> milvus.proto.common.Status + 121, // 275: milvus.proto.query.QueryCoord.ResumeNode:output_type -> milvus.proto.common.Status + 121, // 276: milvus.proto.query.QueryCoord.TransferSegment:output_type -> milvus.proto.common.Status + 121, // 277: milvus.proto.query.QueryCoord.TransferChannel:output_type -> milvus.proto.common.Status + 121, // 278: milvus.proto.query.QueryCoord.CheckQueryNodeDistribution:output_type -> milvus.proto.common.Status + 121, // 279: milvus.proto.query.QueryCoord.UpdateLoadConfig:output_type -> milvus.proto.common.Status + 157, // 280: milvus.proto.query.QueryNode.GetComponentStates:output_type -> milvus.proto.milvus.ComponentStates + 158, // 281: milvus.proto.query.QueryNode.GetTimeTickChannel:output_type -> milvus.proto.milvus.StringResponse + 158, // 282: milvus.proto.query.QueryNode.GetStatisticsChannel:output_type -> milvus.proto.milvus.StringResponse + 121, // 283: milvus.proto.query.QueryNode.WatchDmChannels:output_type -> milvus.proto.common.Status + 121, // 284: milvus.proto.query.QueryNode.UnsubDmChannel:output_type -> milvus.proto.common.Status + 121, // 285: milvus.proto.query.QueryNode.LoadSegments:output_type -> milvus.proto.common.Status + 121, // 286: milvus.proto.query.QueryNode.ReleaseCollection:output_type -> milvus.proto.common.Status + 121, // 287: milvus.proto.query.QueryNode.LoadPartitions:output_type -> milvus.proto.common.Status + 121, // 288: milvus.proto.query.QueryNode.ReleasePartitions:output_type -> milvus.proto.common.Status + 121, // 289: milvus.proto.query.QueryNode.ReleaseSegments:output_type -> milvus.proto.common.Status + 19, // 290: milvus.proto.query.QueryNode.GetSegmentInfo:output_type -> milvus.proto.query.GetSegmentInfoResponse + 121, // 291: milvus.proto.query.QueryNode.SyncReplicaSegments:output_type -> milvus.proto.common.Status + 159, // 292: milvus.proto.query.QueryNode.GetStatistics:output_type -> milvus.proto.internal.GetStatisticsResponse + 160, // 293: milvus.proto.query.QueryNode.Search:output_type -> milvus.proto.internal.SearchResults + 160, // 294: milvus.proto.query.QueryNode.SearchSegments:output_type -> milvus.proto.internal.SearchResults + 161, // 295: milvus.proto.query.QueryNode.Query:output_type -> milvus.proto.internal.RetrieveResults + 161, // 296: milvus.proto.query.QueryNode.QueryStream:output_type -> milvus.proto.internal.RetrieveResults + 161, // 297: milvus.proto.query.QueryNode.QuerySegments:output_type -> milvus.proto.internal.RetrieveResults + 161, // 298: milvus.proto.query.QueryNode.QueryStreamSegments:output_type -> milvus.proto.internal.RetrieveResults + 152, // 299: milvus.proto.query.QueryNode.ShowConfigurations:output_type -> milvus.proto.internal.ShowConfigurationsResponse + 153, // 300: milvus.proto.query.QueryNode.GetMetrics:output_type -> milvus.proto.milvus.GetMetricsResponse + 51, // 301: milvus.proto.query.QueryNode.GetDataDistribution:output_type -> milvus.proto.query.GetDataDistributionResponse + 121, // 302: milvus.proto.query.QueryNode.SyncDistribution:output_type -> milvus.proto.common.Status + 121, // 303: milvus.proto.query.QueryNode.Delete:output_type -> milvus.proto.common.Status + 70, // 304: milvus.proto.query.QueryNode.DeleteBatch:output_type -> milvus.proto.query.DeleteBatchResponse + 121, // 305: milvus.proto.query.QueryNode.UpdateSchema:output_type -> milvus.proto.common.Status + 162, // 306: milvus.proto.query.QueryNode.RunAnalyzer:output_type -> milvus.proto.milvus.RunAnalyzerResponse + 243, // [243:307] is the sub-list for method output_type + 179, // [179:243] is the sub-list for method input_type + 179, // [179:179] is the sub-list for extension type_name + 179, // [179:179] is the sub-list for extension extendee + 0, // [0:179] is the sub-list for field type_name } func init() { file_query_coord_proto_init() } @@ -10405,7 +10519,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*LoadSegmentsRequest); i { + switch v := v.(*JsonStatsInfo); i { case 0: return &v.state case 1: @@ -10417,7 +10531,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReleaseSegmentsRequest); i { + switch v := v.(*LoadSegmentsRequest); i { case 0: return &v.state case 1: @@ -10429,7 +10543,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[25].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SearchRequest); i { + switch v := v.(*ReleaseSegmentsRequest); i { case 0: return &v.state case 1: @@ -10441,7 +10555,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[26].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryRequest); i { + switch v := v.(*SearchRequest); i { case 0: return &v.state case 1: @@ -10453,7 +10567,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[27].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SyncReplicaSegmentsRequest); i { + switch v := v.(*QueryRequest); i { case 0: return &v.state case 1: @@ -10465,7 +10579,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[28].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ReplicaSegmentsInfo); i { + switch v := v.(*SyncReplicaSegmentsRequest); i { case 0: return &v.state case 1: @@ -10477,7 +10591,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[29].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetLoadInfoRequest); i { + switch v := v.(*ReplicaSegmentsInfo); i { case 0: return &v.state case 1: @@ -10489,7 +10603,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[30].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetLoadInfoResponse); i { + switch v := v.(*GetLoadInfoRequest); i { case 0: return &v.state case 1: @@ -10501,7 +10615,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[31].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*HandoffSegmentsRequest); i { + switch v := v.(*GetLoadInfoResponse); i { case 0: return &v.state case 1: @@ -10513,7 +10627,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[32].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*LoadBalanceRequest); i { + switch v := v.(*HandoffSegmentsRequest); i { case 0: return &v.state case 1: @@ -10525,7 +10639,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[33].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DmChannelWatchInfo); i { + switch v := v.(*LoadBalanceRequest); i { case 0: return &v.state case 1: @@ -10537,7 +10651,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[34].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*QueryChannelInfo); i { + switch v := v.(*DmChannelWatchInfo); i { case 0: return &v.state case 1: @@ -10549,7 +10663,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[35].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PartitionStates); i { + switch v := v.(*QueryChannelInfo); i { case 0: return &v.state case 1: @@ -10561,7 +10675,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[36].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SegmentInfo); i { + switch v := v.(*PartitionStates); i { case 0: return &v.state case 1: @@ -10573,7 +10687,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[37].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CollectionInfo); i { + switch v := v.(*SegmentInfo); i { case 0: return &v.state case 1: @@ -10585,7 +10699,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[38].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UnsubscribeChannels); i { + switch v := v.(*CollectionInfo); i { case 0: return &v.state case 1: @@ -10597,7 +10711,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[39].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UnsubscribeChannelInfo); i { + switch v := v.(*UnsubscribeChannels); i { case 0: return &v.state case 1: @@ -10609,7 +10723,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[40].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SegmentChangeInfo); i { + switch v := v.(*UnsubscribeChannelInfo); i { case 0: return &v.state case 1: @@ -10621,7 +10735,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[41].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SealedSegmentsChangeInfo); i { + switch v := v.(*SegmentChangeInfo); i { case 0: return &v.state case 1: @@ -10633,7 +10747,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[42].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetDataDistributionRequest); i { + switch v := v.(*SealedSegmentsChangeInfo); i { case 0: return &v.state case 1: @@ -10645,7 +10759,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[43].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetDataDistributionResponse); i { + switch v := v.(*GetDataDistributionRequest); i { case 0: return &v.state case 1: @@ -10657,7 +10771,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[44].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*LeaderView); i { + switch v := v.(*GetDataDistributionResponse); i { case 0: return &v.state case 1: @@ -10669,7 +10783,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[45].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*LeaderViewStatus); i { + switch v := v.(*LeaderView); i { case 0: return &v.state case 1: @@ -10681,7 +10795,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[46].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SegmentDist); i { + switch v := v.(*LeaderViewStatus); i { case 0: return &v.state case 1: @@ -10693,7 +10807,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[47].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SegmentVersionInfo); i { + switch v := v.(*SegmentDist); i { case 0: return &v.state case 1: @@ -10705,7 +10819,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[48].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChannelVersionInfo); i { + switch v := v.(*SegmentVersionInfo); i { case 0: return &v.state case 1: @@ -10717,7 +10831,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[49].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CollectionLoadInfo); i { + switch v := v.(*ChannelVersionInfo); i { case 0: return &v.state case 1: @@ -10729,7 +10843,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[50].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PartitionLoadInfo); i { + switch v := v.(*CollectionLoadInfo); i { case 0: return &v.state case 1: @@ -10741,7 +10855,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[51].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChannelNodeInfo); i { + switch v := v.(*PartitionLoadInfo); i { case 0: return &v.state case 1: @@ -10753,7 +10867,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[52].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*Replica); i { + switch v := v.(*ChannelNodeInfo); i { case 0: return &v.state case 1: @@ -10765,7 +10879,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[53].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SyncAction); i { + switch v := v.(*Replica); i { case 0: return &v.state case 1: @@ -10777,7 +10891,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[54].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SyncDistributionRequest); i { + switch v := v.(*SyncAction); i { case 0: return &v.state case 1: @@ -10789,7 +10903,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[55].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResourceGroup); i { + switch v := v.(*SyncDistributionRequest); i { case 0: return &v.state case 1: @@ -10801,7 +10915,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[56].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferReplicaRequest); i { + switch v := v.(*ResourceGroup); i { case 0: return &v.state case 1: @@ -10813,7 +10927,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[57].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DescribeResourceGroupRequest); i { + switch v := v.(*TransferReplicaRequest); i { case 0: return &v.state case 1: @@ -10825,7 +10939,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[58].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DescribeResourceGroupResponse); i { + switch v := v.(*DescribeResourceGroupRequest); i { case 0: return &v.state case 1: @@ -10837,7 +10951,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[59].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResourceGroupInfo); i { + switch v := v.(*DescribeResourceGroupResponse); i { case 0: return &v.state case 1: @@ -10849,7 +10963,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[60].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteRequest); i { + switch v := v.(*ResourceGroupInfo); i { case 0: return &v.state case 1: @@ -10861,7 +10975,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[61].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteBatchRequest); i { + switch v := v.(*DeleteRequest); i { case 0: return &v.state case 1: @@ -10873,7 +10987,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[62].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeleteBatchResponse); i { + switch v := v.(*DeleteBatchRequest); i { case 0: return &v.state case 1: @@ -10885,7 +10999,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[63].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ActivateCheckerRequest); i { + switch v := v.(*DeleteBatchResponse); i { case 0: return &v.state case 1: @@ -10897,7 +11011,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[64].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*DeactivateCheckerRequest); i { + switch v := v.(*ActivateCheckerRequest); i { case 0: return &v.state case 1: @@ -10909,7 +11023,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[65].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListCheckersRequest); i { + switch v := v.(*DeactivateCheckerRequest); i { case 0: return &v.state case 1: @@ -10921,7 +11035,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[66].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListCheckersResponse); i { + switch v := v.(*ListCheckersRequest); i { case 0: return &v.state case 1: @@ -10933,7 +11047,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[67].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckerInfo); i { + switch v := v.(*ListCheckersResponse); i { case 0: return &v.state case 1: @@ -10945,7 +11059,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[68].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SegmentTarget); i { + switch v := v.(*CheckerInfo); i { case 0: return &v.state case 1: @@ -10957,7 +11071,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[69].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*PartitionTarget); i { + switch v := v.(*SegmentTarget); i { case 0: return &v.state case 1: @@ -10969,7 +11083,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[70].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ChannelTarget); i { + switch v := v.(*PartitionTarget); i { case 0: return &v.state case 1: @@ -10981,7 +11095,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[71].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CollectionTarget); i { + switch v := v.(*ChannelTarget); i { case 0: return &v.state case 1: @@ -10993,7 +11107,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[72].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*NodeInfo); i { + switch v := v.(*CollectionTarget); i { case 0: return &v.state case 1: @@ -11005,7 +11119,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[73].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListQueryNodeRequest); i { + switch v := v.(*NodeInfo); i { case 0: return &v.state case 1: @@ -11017,7 +11131,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[74].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListQueryNodeResponse); i { + switch v := v.(*ListQueryNodeRequest); i { case 0: return &v.state case 1: @@ -11029,7 +11143,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[75].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetQueryNodeDistributionRequest); i { + switch v := v.(*ListQueryNodeResponse); i { case 0: return &v.state case 1: @@ -11041,7 +11155,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[76].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*GetQueryNodeDistributionResponse); i { + switch v := v.(*GetQueryNodeDistributionRequest); i { case 0: return &v.state case 1: @@ -11053,7 +11167,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[77].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SuspendBalanceRequest); i { + switch v := v.(*GetQueryNodeDistributionResponse); i { case 0: return &v.state case 1: @@ -11065,7 +11179,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[78].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResumeBalanceRequest); i { + switch v := v.(*SuspendBalanceRequest); i { case 0: return &v.state case 1: @@ -11077,7 +11191,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[79].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckBalanceStatusRequest); i { + switch v := v.(*ResumeBalanceRequest); i { case 0: return &v.state case 1: @@ -11089,7 +11203,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[80].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckBalanceStatusResponse); i { + switch v := v.(*CheckBalanceStatusRequest); i { case 0: return &v.state case 1: @@ -11101,7 +11215,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[81].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*SuspendNodeRequest); i { + switch v := v.(*CheckBalanceStatusResponse); i { case 0: return &v.state case 1: @@ -11113,7 +11227,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[82].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ResumeNodeRequest); i { + switch v := v.(*SuspendNodeRequest); i { case 0: return &v.state case 1: @@ -11125,7 +11239,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[83].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferSegmentRequest); i { + switch v := v.(*ResumeNodeRequest); i { case 0: return &v.state case 1: @@ -11137,7 +11251,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[84].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*TransferChannelRequest); i { + switch v := v.(*TransferSegmentRequest); i { case 0: return &v.state case 1: @@ -11149,7 +11263,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[85].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*CheckQueryNodeDistributionRequest); i { + switch v := v.(*TransferChannelRequest); i { case 0: return &v.state case 1: @@ -11161,7 +11275,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[86].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateLoadConfigRequest); i { + switch v := v.(*CheckQueryNodeDistributionRequest); i { case 0: return &v.state case 1: @@ -11173,7 +11287,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[87].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*UpdateSchemaRequest); i { + switch v := v.(*UpdateLoadConfigRequest); i { case 0: return &v.state case 1: @@ -11185,7 +11299,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[88].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*RunAnalyzerRequest); i { + switch v := v.(*UpdateSchemaRequest); i { case 0: return &v.state case 1: @@ -11197,7 +11311,7 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[89].Exporter = func(v interface{}, i int) interface{} { - switch v := v.(*ListLoadedSegmentsRequest); i { + switch v := v.(*RunAnalyzerRequest); i { case 0: return &v.state case 1: @@ -11209,6 +11323,18 @@ func file_query_coord_proto_init() { } } file_query_coord_proto_msgTypes[90].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*ListLoadedSegmentsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_query_coord_proto_msgTypes[91].Exporter = func(v interface{}, i int) interface{} { switch v := v.(*ListLoadedSegmentsResponse); i { case 0: return &v.state @@ -11227,7 +11353,7 @@ func file_query_coord_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: file_query_coord_proto_rawDesc, NumEnums: 7, - NumMessages: 111, + NumMessages: 113, NumExtensions: 0, NumServices: 2, }, diff --git a/pkg/proto/worker.proto b/pkg/proto/worker.proto index 253e853329..9a9aa9dd7d 100644 --- a/pkg/proto/worker.proto +++ b/pkg/proto/worker.proto @@ -192,6 +192,9 @@ message CreateStatsRequest { int64 storage_version = 25; int32 current_scalar_index_version = 26; repeated common.KeyValuePair plugin_context = 27; + int64 json_stats_max_shredding_columns = 28; + double json_stats_shredding_ratio_threshold = 29; + int64 json_stats_write_batch_size = 30; } message CreateJobV2Request { diff --git a/pkg/proto/workerpb/worker.pb.go b/pkg/proto/workerpb/worker.pb.go index 21b5116508..b9a4cf6e6e 100644 --- a/pkg/proto/workerpb/worker.pb.go +++ b/pkg/proto/workerpb/worker.pb.go @@ -1087,11 +1087,14 @@ type CreateStatsRequest struct { JsonKeyStatsTantivyMemory int64 `protobuf:"varint,21,opt,name=json_key_stats_tantivy_memory,json=jsonKeyStatsTantivyMemory,proto3" json:"json_key_stats_tantivy_memory,omitempty"` JsonKeyStatsDataFormat int64 `protobuf:"varint,22,opt,name=json_key_stats_data_format,json=jsonKeyStatsDataFormat,proto3" json:"json_key_stats_data_format,omitempty"` // deprecated, the sort logic has been moved into the compaction process. - EnableJsonKeyStatsInSort bool `protobuf:"varint,23,opt,name=enable_json_key_stats_in_sort,json=enableJsonKeyStatsInSort,proto3" json:"enable_json_key_stats_in_sort,omitempty"` - TaskSlot int64 `protobuf:"varint,24,opt,name=task_slot,json=taskSlot,proto3" json:"task_slot,omitempty"` - StorageVersion int64 `protobuf:"varint,25,opt,name=storage_version,json=storageVersion,proto3" json:"storage_version,omitempty"` - CurrentScalarIndexVersion int32 `protobuf:"varint,26,opt,name=current_scalar_index_version,json=currentScalarIndexVersion,proto3" json:"current_scalar_index_version,omitempty"` - PluginContext []*commonpb.KeyValuePair `protobuf:"bytes,27,rep,name=plugin_context,json=pluginContext,proto3" json:"plugin_context,omitempty"` + EnableJsonKeyStatsInSort bool `protobuf:"varint,23,opt,name=enable_json_key_stats_in_sort,json=enableJsonKeyStatsInSort,proto3" json:"enable_json_key_stats_in_sort,omitempty"` + TaskSlot int64 `protobuf:"varint,24,opt,name=task_slot,json=taskSlot,proto3" json:"task_slot,omitempty"` + StorageVersion int64 `protobuf:"varint,25,opt,name=storage_version,json=storageVersion,proto3" json:"storage_version,omitempty"` + CurrentScalarIndexVersion int32 `protobuf:"varint,26,opt,name=current_scalar_index_version,json=currentScalarIndexVersion,proto3" json:"current_scalar_index_version,omitempty"` + PluginContext []*commonpb.KeyValuePair `protobuf:"bytes,27,rep,name=plugin_context,json=pluginContext,proto3" json:"plugin_context,omitempty"` + JsonStatsMaxShreddingColumns int64 `protobuf:"varint,28,opt,name=json_stats_max_shredding_columns,json=jsonStatsMaxShreddingColumns,proto3" json:"json_stats_max_shredding_columns,omitempty"` + JsonStatsShreddingRatioThreshold float64 `protobuf:"fixed64,29,opt,name=json_stats_shredding_ratio_threshold,json=jsonStatsShreddingRatioThreshold,proto3" json:"json_stats_shredding_ratio_threshold,omitempty"` + JsonStatsWriteBatchSize int64 `protobuf:"varint,30,opt,name=json_stats_write_batch_size,json=jsonStatsWriteBatchSize,proto3" json:"json_stats_write_batch_size,omitempty"` } func (x *CreateStatsRequest) Reset() { @@ -1315,6 +1318,27 @@ func (x *CreateStatsRequest) GetPluginContext() []*commonpb.KeyValuePair { return nil } +func (x *CreateStatsRequest) GetJsonStatsMaxShreddingColumns() int64 { + if x != nil { + return x.JsonStatsMaxShreddingColumns + } + return 0 +} + +func (x *CreateStatsRequest) GetJsonStatsShreddingRatioThreshold() float64 { + if x != nil { + return x.JsonStatsShreddingRatioThreshold + } + return 0 +} + +func (x *CreateStatsRequest) GetJsonStatsWriteBatchSize() int64 { + if x != nil { + return x.JsonStatsWriteBatchSize + } + return 0 +} + type CreateJobV2Request struct { state protoimpl.MessageState sizeCache protoimpl.SizeCache @@ -2389,7 +2413,7 @@ var file_worker_proto_rawDesc = []byte{ 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, - 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xf2, 0x09, 0x0a, 0x12, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, + 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0xc8, 0x0b, 0x0a, 0x12, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, @@ -2468,234 +2492,248 @@ var file_worker_proto_rawDesc = []byte{ 0x78, 0x74, 0x18, 0x1b, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x4b, 0x65, 0x79, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x50, 0x61, 0x69, 0x72, 0x52, 0x0d, 0x70, 0x6c, 0x75, - 0x67, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x22, 0xf8, 0x02, 0x0a, 0x12, 0x43, - 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, - 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, - 0x16, 0x0a, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x12, 0x36, 0x0a, 0x08, 0x6a, 0x6f, 0x62, 0x5f, 0x74, - 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x4a, - 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x6a, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, - 0x4d, 0x0a, 0x0f, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x41, 0x6e, - 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0e, - 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4b, - 0x0a, 0x0d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, - 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0c, 0x69, - 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x4d, 0x0a, 0x0d, 0x73, - 0x74, 0x61, 0x74, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x53, 0x74, - 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x48, 0x00, 0x52, 0x0c, 0x73, 0x74, - 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x42, 0x09, 0x0a, 0x07, 0x72, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x84, 0x01, 0x0a, 0x12, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, - 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, - 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, - 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x74, 0x61, - 0x73, 0x6b, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x74, 0x61, 0x73, - 0x6b, 0x49, 0x44, 0x73, 0x12, 0x36, 0x0a, 0x08, 0x6a, 0x6f, 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, - 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x54, - 0x79, 0x70, 0x65, 0x52, 0x07, 0x6a, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x22, 0x92, 0x03, 0x0a, - 0x0d, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, - 0x0a, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x44, 0x12, 0x35, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, - 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, - 0x64, 0x65, 0x78, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, - 0x26, 0x0a, 0x0f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x6b, 0x65, - 0x79, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x46, - 0x69, 0x6c, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x27, 0x0a, 0x0f, 0x73, 0x65, 0x72, 0x69, 0x61, - 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, - 0x52, 0x0e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x53, 0x69, 0x7a, 0x65, - 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, - 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x61, 0x73, 0x6f, - 0x6e, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, - 0x52, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x13, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x73, - 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, - 0x28, 0x03, 0x52, 0x11, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x53, 0x74, 0x6f, 0x72, 0x65, 0x56, 0x65, - 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6d, 0x65, 0x6d, 0x5f, 0x73, 0x69, 0x7a, - 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, 0x65, 0x6d, 0x53, 0x69, 0x7a, 0x65, - 0x12, 0x3f, 0x0a, 0x1c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x5f, 0x73, 0x63, 0x61, 0x6c, - 0x61, 0x72, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, - 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x19, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, - 0x63, 0x61, 0x6c, 0x61, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, - 0x6e, 0x22, 0x4e, 0x0a, 0x0f, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, - 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, - 0x54, 0x61, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x22, 0xa3, 0x01, 0x0a, 0x0d, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x18, 0x01, 0x20, - 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x12, 0x32, 0x0a, 0x05, 0x73, - 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, - 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, - 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, - 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, - 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x6f, 0x69, 0x64, 0x73, 0x5f, 0x66, 0x69, - 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x6f, - 0x69, 0x64, 0x73, 0x46, 0x69, 0x6c, 0x65, 0x22, 0x4d, 0x0a, 0x0e, 0x41, 0x6e, 0x61, 0x6c, 0x79, - 0x7a, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x07, 0x72, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, - 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, - 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xdd, 0x06, 0x0a, 0x0b, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x12, 0x32, - 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, - 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, - 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x69, 0x6c, 0x52, 0x65, 0x61, - 0x73, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, - 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, - 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, - 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, - 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, - 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, - 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, - 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, - 0x6c, 0x12, 0x3f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x5f, 0x6c, 0x6f, 0x67, 0x73, - 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, - 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x0a, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x4c, 0x6f, - 0x67, 0x73, 0x12, 0x3d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6c, 0x6f, 0x67, 0x73, - 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, - 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x09, 0x73, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, - 0x73, 0x12, 0x5a, 0x0a, 0x0f, 0x74, 0x65, 0x78, 0x74, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, - 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x32, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x54, 0x65, 0x78, 0x74, - 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, - 0x74, 0x65, 0x78, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x19, 0x0a, - 0x08, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, - 0x07, 0x6e, 0x75, 0x6d, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x3b, 0x0a, 0x09, 0x62, 0x6d, 0x32, 0x35, - 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, - 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x08, 0x62, 0x6d, 0x32, - 0x35, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x64, 0x0a, 0x13, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x6b, 0x65, - 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0d, 0x20, 0x03, - 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, - 0x75, 0x6c, 0x74, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x4c, 0x6f, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, 0x10, 0x6a, 0x73, 0x6f, 0x6e, 0x4b, - 0x65, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x1a, 0x63, 0x0a, 0x12, 0x54, - 0x65, 0x78, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, - 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, - 0x6b, 0x65, 0x79, 0x12, 0x37, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, - 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x65, 0x78, 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, - 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, - 0x1a, 0x64, 0x0a, 0x15, 0x4a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x4c, 0x6f, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, - 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x35, 0x0a, 0x05, 0x76, - 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4a, - 0x73, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, - 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x49, 0x0a, 0x0c, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, - 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x39, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, - 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x22, 0xeb, 0x02, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, - 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, - 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x1c, - 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, - 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, 0x51, 0x0a, 0x11, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, - 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, - 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x49, 0x6e, 0x64, - 0x65, 0x78, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x48, 0x00, 0x52, 0x0f, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, - 0x54, 0x0a, 0x13, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x72, - 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, - 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, - 0x78, 0x2e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, - 0x48, 0x00, 0x52, 0x11, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, - 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6a, - 0x6f, 0x62, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, - 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, - 0x74, 0x73, 0x48, 0x00, 0x52, 0x0f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x4a, 0x6f, 0x62, 0x52, 0x65, - 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x08, 0x0a, 0x06, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, - 0x83, 0x01, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, - 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, - 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, - 0x72, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x73, 0x18, 0x02, - 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x73, 0x12, 0x36, 0x0a, + 0x67, 0x69, 0x6e, 0x43, 0x6f, 0x6e, 0x74, 0x65, 0x78, 0x74, 0x12, 0x46, 0x0a, 0x20, 0x6a, 0x73, + 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6d, 0x61, 0x78, 0x5f, 0x73, 0x68, 0x72, + 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x63, 0x6f, 0x6c, 0x75, 0x6d, 0x6e, 0x73, 0x18, 0x1c, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x1c, 0x6a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4d, + 0x61, 0x78, 0x53, 0x68, 0x72, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x43, 0x6f, 0x6c, 0x75, 0x6d, + 0x6e, 0x73, 0x12, 0x4e, 0x0a, 0x24, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, + 0x5f, 0x73, 0x68, 0x72, 0x65, 0x64, 0x64, 0x69, 0x6e, 0x67, 0x5f, 0x72, 0x61, 0x74, 0x69, 0x6f, + 0x5f, 0x74, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, 0x6c, 0x64, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x01, + 0x52, 0x20, 0x6a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x53, 0x68, 0x72, 0x65, 0x64, + 0x64, 0x69, 0x6e, 0x67, 0x52, 0x61, 0x74, 0x69, 0x6f, 0x54, 0x68, 0x72, 0x65, 0x73, 0x68, 0x6f, + 0x6c, 0x64, 0x12, 0x3c, 0x0a, 0x1b, 0x6a, 0x73, 0x6f, 0x6e, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, + 0x5f, 0x77, 0x72, 0x69, 0x74, 0x65, 0x5f, 0x62, 0x61, 0x74, 0x63, 0x68, 0x5f, 0x73, 0x69, 0x7a, + 0x65, 0x18, 0x1e, 0x20, 0x01, 0x28, 0x03, 0x52, 0x17, 0x6a, 0x73, 0x6f, 0x6e, 0x53, 0x74, 0x61, + 0x74, 0x73, 0x57, 0x72, 0x69, 0x74, 0x65, 0x42, 0x61, 0x74, 0x63, 0x68, 0x53, 0x69, 0x7a, 0x65, + 0x22, 0xf8, 0x02, 0x0a, 0x12, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x56, 0x32, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, + 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, + 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x18, + 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x12, 0x36, 0x0a, 0x08, 0x6a, 0x6f, 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x6a, 0x6f, - 0x62, 0x54, 0x79, 0x70, 0x65, 0x32, 0xf7, 0x06, 0x0a, 0x09, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4e, - 0x6f, 0x64, 0x65, 0x12, 0x50, 0x0a, 0x09, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, - 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, - 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, - 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x09, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, - 0x62, 0x73, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, - 0x00, 0x12, 0x4e, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x23, 0x2e, + 0x62, 0x54, 0x79, 0x70, 0x65, 0x12, 0x4d, 0x0a, 0x0f, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, + 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x22, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x2e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x48, 0x00, 0x52, 0x0e, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x4b, 0x0a, 0x0d, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x72, 0x65, + 0x71, 0x75, 0x65, 0x73, 0x74, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x24, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x48, 0x00, 0x52, 0x0c, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x12, 0x4d, 0x0a, 0x0d, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x72, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x18, 0x06, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x48, 0x00, 0x52, 0x0c, 0x73, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x42, 0x09, 0x0a, 0x07, 0x72, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x22, 0x84, 0x01, 0x0a, 0x12, + 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, + 0x12, 0x18, 0x0a, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x03, 0x52, 0x07, 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x73, 0x12, 0x36, 0x0a, 0x08, 0x6a, 0x6f, + 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x52, 0x07, 0x6a, 0x6f, 0x62, 0x54, 0x79, + 0x70, 0x65, 0x22, 0x92, 0x03, 0x0a, 0x0d, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x54, 0x61, 0x73, 0x6b, + 0x49, 0x6e, 0x66, 0x6f, 0x12, 0x18, 0x0a, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x44, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x62, 0x75, 0x69, 0x6c, 0x64, 0x49, 0x44, 0x12, 0x35, + 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1f, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, + 0x6d, 0x6f, 0x6e, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x26, 0x0a, 0x0f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x66, + 0x69, 0x6c, 0x65, 0x5f, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x03, 0x20, 0x03, 0x28, 0x09, 0x52, 0x0d, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x46, 0x69, 0x6c, 0x65, 0x4b, 0x65, 0x79, 0x73, 0x12, 0x27, 0x0a, + 0x0f, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, 0x65, 0x64, 0x5f, 0x73, 0x69, 0x7a, 0x65, + 0x18, 0x04, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0e, 0x73, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x69, 0x7a, + 0x65, 0x64, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x5f, 0x72, + 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x69, + 0x6c, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x32, 0x0a, 0x15, 0x63, 0x75, 0x72, 0x72, 0x65, + 0x6e, 0x74, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, + 0x18, 0x06, 0x20, 0x01, 0x28, 0x05, 0x52, 0x13, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x49, + 0x6e, 0x64, 0x65, 0x78, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x2e, 0x0a, 0x13, 0x69, + 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x73, 0x74, 0x6f, 0x72, 0x65, 0x5f, 0x76, 0x65, 0x72, 0x73, 0x69, + 0x6f, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28, 0x03, 0x52, 0x11, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x53, + 0x74, 0x6f, 0x72, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x0a, 0x08, 0x6d, + 0x65, 0x6d, 0x5f, 0x73, 0x69, 0x7a, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x04, 0x52, 0x07, 0x6d, + 0x65, 0x6d, 0x53, 0x69, 0x7a, 0x65, 0x12, 0x3f, 0x0a, 0x1c, 0x63, 0x75, 0x72, 0x72, 0x65, 0x6e, + 0x74, 0x5f, 0x73, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x5f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x76, + 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x18, 0x09, 0x20, 0x01, 0x28, 0x05, 0x52, 0x19, 0x63, 0x75, + 0x72, 0x72, 0x65, 0x6e, 0x74, 0x53, 0x63, 0x61, 0x6c, 0x61, 0x72, 0x49, 0x6e, 0x64, 0x65, 0x78, + 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, 0x22, 0x4e, 0x0a, 0x0f, 0x49, 0x6e, 0x64, 0x65, 0x78, + 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x3b, 0x0a, 0x07, 0x72, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, + 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x54, 0x61, 0x73, 0x6b, 0x49, 0x6e, 0x66, 0x6f, 0x52, 0x07, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xa3, 0x01, 0x0a, 0x0d, 0x41, 0x6e, 0x61, 0x6c, + 0x79, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x74, 0x61, 0x73, + 0x6b, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x61, 0x73, 0x6b, 0x49, + 0x44, 0x12, 0x32, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0e, + 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x05, + 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, 0x5f, 0x72, 0x65, + 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, 0x61, 0x69, 0x6c, + 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x25, 0x0a, 0x0e, 0x63, 0x65, 0x6e, 0x74, 0x72, 0x6f, + 0x69, 0x64, 0x73, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0d, + 0x63, 0x65, 0x6e, 0x74, 0x72, 0x6f, 0x69, 0x64, 0x73, 0x46, 0x69, 0x6c, 0x65, 0x22, 0x4d, 0x0a, + 0x0e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, + 0x3b, 0x0a, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, 0x65, 0x73, + 0x75, 0x6c, 0x74, 0x52, 0x07, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xdd, 0x06, 0x0a, + 0x0b, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x16, 0x0a, 0x06, + 0x74, 0x61, 0x73, 0x6b, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x06, 0x74, 0x61, + 0x73, 0x6b, 0x49, 0x44, 0x12, 0x32, 0x0a, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x18, 0x02, 0x20, + 0x01, 0x28, 0x0e, 0x32, 0x1c, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, + 0x65, 0x52, 0x05, 0x73, 0x74, 0x61, 0x74, 0x65, 0x12, 0x1f, 0x0a, 0x0b, 0x66, 0x61, 0x69, 0x6c, + 0x5f, 0x72, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0a, 0x66, + 0x61, 0x69, 0x6c, 0x52, 0x65, 0x61, 0x73, 0x6f, 0x6e, 0x12, 0x22, 0x0a, 0x0c, 0x63, 0x6f, 0x6c, + 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x04, 0x20, 0x01, 0x28, 0x03, 0x52, + 0x0c, 0x63, 0x6f, 0x6c, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, 0x20, 0x0a, + 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x18, 0x05, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x0b, 0x70, 0x61, 0x72, 0x74, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x49, 0x44, 0x12, + 0x1c, 0x0a, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x03, 0x52, 0x09, 0x73, 0x65, 0x67, 0x6d, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x12, 0x18, 0x0a, + 0x07, 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x18, 0x07, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, + 0x63, 0x68, 0x61, 0x6e, 0x6e, 0x65, 0x6c, 0x12, 0x3f, 0x0a, 0x0b, 0x69, 0x6e, 0x73, 0x65, 0x72, + 0x74, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x08, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x0a, 0x69, 0x6e, + 0x73, 0x65, 0x72, 0x74, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x3d, 0x0a, 0x0a, 0x73, 0x74, 0x61, 0x74, + 0x73, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x09, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, + 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f, 0x67, 0x52, 0x09, 0x73, 0x74, + 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x5a, 0x0a, 0x0f, 0x74, 0x65, 0x78, 0x74, 0x5f, + 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0a, 0x20, 0x03, 0x28, 0x0b, + 0x32, 0x32, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x2e, 0x54, 0x65, 0x78, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x45, + 0x6e, 0x74, 0x72, 0x79, 0x52, 0x0d, 0x74, 0x65, 0x78, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, + 0x6f, 0x67, 0x73, 0x12, 0x19, 0x0a, 0x08, 0x6e, 0x75, 0x6d, 0x5f, 0x72, 0x6f, 0x77, 0x73, 0x18, + 0x0b, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x6e, 0x75, 0x6d, 0x52, 0x6f, 0x77, 0x73, 0x12, 0x3b, + 0x0a, 0x09, 0x62, 0x6d, 0x32, 0x35, 0x5f, 0x6c, 0x6f, 0x67, 0x73, 0x18, 0x0c, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x1e, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x46, 0x69, 0x65, 0x6c, 0x64, 0x42, 0x69, 0x6e, 0x6c, 0x6f, + 0x67, 0x52, 0x08, 0x62, 0x6d, 0x32, 0x35, 0x4c, 0x6f, 0x67, 0x73, 0x12, 0x64, 0x0a, 0x13, 0x6a, + 0x73, 0x6f, 0x6e, 0x5f, 0x6b, 0x65, 0x79, 0x5f, 0x73, 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6c, 0x6f, + 0x67, 0x73, 0x18, 0x0d, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x35, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, + 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x52, + 0x10, 0x6a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, + 0x73, 0x1a, 0x63, 0x0a, 0x12, 0x54, 0x65, 0x78, 0x74, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, + 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x37, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x21, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x64, 0x61, 0x74, 0x61, 0x2e, 0x54, 0x65, 0x78, + 0x74, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x1a, 0x64, 0x0a, 0x15, 0x4a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, + 0x79, 0x53, 0x74, 0x61, 0x74, 0x73, 0x4c, 0x6f, 0x67, 0x73, 0x45, 0x6e, 0x74, 0x72, 0x79, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x35, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, + 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, + 0x64, 0x61, 0x74, 0x61, 0x2e, 0x4a, 0x73, 0x6f, 0x6e, 0x4b, 0x65, 0x79, 0x53, 0x74, 0x61, 0x74, + 0x73, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x3a, 0x02, 0x38, 0x01, 0x22, 0x49, 0x0a, 0x0c, + 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x39, 0x0a, 0x07, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x1f, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, - 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, - 0x00, 0x12, 0x60, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x73, - 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, - 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, - 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x47, 0x65, - 0x74, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, - 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0b, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, - 0x56, 0x32, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, - 0x62, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, - 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, - 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x0b, 0x51, 0x75, 0x65, - 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x07, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x22, 0xeb, 0x02, 0x0a, 0x13, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, + 0x33, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, + 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, + 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x52, 0x06, 0x73, 0x74, + 0x61, 0x74, 0x75, 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, + 0x44, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, + 0x49, 0x44, 0x12, 0x51, 0x0a, 0x11, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, + 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x23, 0x2e, + 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x2e, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, + 0x74, 0x73, 0x48, 0x00, 0x52, 0x0f, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x4a, 0x6f, 0x62, 0x52, 0x65, + 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x54, 0x0a, 0x13, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, + 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x0b, 0x32, 0x22, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x41, 0x6e, 0x61, 0x6c, 0x79, 0x7a, 0x65, 0x52, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x48, 0x00, 0x52, 0x11, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x7a, + 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x12, 0x4e, 0x0a, 0x11, 0x73, + 0x74, 0x61, 0x74, 0x73, 0x5f, 0x6a, 0x6f, 0x62, 0x5f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, + 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x20, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x53, 0x74, 0x61, 0x74, + 0x73, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x48, 0x00, 0x52, 0x0f, 0x73, 0x74, 0x61, 0x74, + 0x73, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x73, 0x42, 0x08, 0x0a, 0x06, 0x72, + 0x65, 0x73, 0x75, 0x6c, 0x74, 0x22, 0x83, 0x01, 0x0a, 0x11, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, + 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x1c, 0x0a, 0x09, 0x63, + 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x09, + 0x63, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x44, 0x12, 0x18, 0x0a, 0x07, 0x74, 0x61, 0x73, + 0x6b, 0x49, 0x44, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, 0x03, 0x52, 0x07, 0x74, 0x61, 0x73, 0x6b, + 0x49, 0x44, 0x73, 0x12, 0x36, 0x0a, 0x08, 0x6a, 0x6f, 0x62, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, + 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, + 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x4a, 0x6f, 0x62, 0x54, 0x79, + 0x70, 0x65, 0x52, 0x07, 0x6a, 0x6f, 0x62, 0x54, 0x79, 0x70, 0x65, 0x32, 0xf7, 0x06, 0x0a, 0x09, + 0x49, 0x6e, 0x64, 0x65, 0x78, 0x4e, 0x6f, 0x64, 0x65, 0x12, 0x50, 0x0a, 0x09, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, + 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, + 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x09, 0x51, + 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, - 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, - 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0a, 0x44, - 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, - 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x44, - 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x4a, + 0x6f, 0x62, 0x73, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, + 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, + 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x60, 0x0a, 0x0b, 0x47, 0x65, 0x74, 0x4a, 0x6f, + 0x62, 0x53, 0x74, 0x61, 0x74, 0x73, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x47, 0x65, 0x74, 0x4a, + 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x2e, 0x47, 0x65, 0x74, 0x4a, 0x6f, 0x62, 0x53, 0x74, 0x61, 0x74, 0x73, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x54, 0x0a, 0x0b, 0x43, 0x72, 0x65, + 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x56, 0x32, 0x12, 0x26, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, + 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, + 0x65, 0x61, 0x74, 0x65, 0x4a, 0x6f, 0x62, 0x56, 0x32, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, - 0x52, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x25, 0x2e, - 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, - 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, - 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, - 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, - 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x09, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x61, 0x73, 0x6b, - 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, - 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x60, 0x0a, 0x0b, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x12, 0x26, + 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, + 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x27, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, - 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, - 0x4e, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x23, 0x2e, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, - 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, - 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, - 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x42, - 0x33, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, - 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, - 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x77, 0x6f, 0x72, 0x6b, - 0x65, 0x72, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, + 0x79, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x52, 0x0a, 0x0a, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x12, + 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, + 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x4a, 0x6f, 0x62, 0x73, 0x56, 0x32, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x52, 0x0a, 0x0a, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, + 0x61, 0x73, 0x6b, 0x12, 0x25, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, + 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x43, 0x72, 0x65, 0x61, 0x74, 0x65, 0x54, + 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, + 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, + 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x22, 0x00, 0x12, 0x5a, 0x0a, 0x09, 0x51, 0x75, 0x65, + 0x72, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x12, 0x24, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, + 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x25, 0x2e, 0x6d, + 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x69, 0x6e, 0x64, 0x65, + 0x78, 0x2e, 0x51, 0x75, 0x65, 0x72, 0x79, 0x54, 0x61, 0x73, 0x6b, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x4e, 0x0a, 0x08, 0x44, 0x72, 0x6f, 0x70, 0x54, 0x61, 0x73, + 0x6b, 0x12, 0x23, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, + 0x2e, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x44, 0x72, 0x6f, 0x70, 0x54, 0x61, 0x73, 0x6b, 0x52, + 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1b, 0x2e, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2e, + 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2e, 0x63, 0x6f, 0x6d, 0x6d, 0x6f, 0x6e, 0x2e, 0x53, 0x74, 0x61, + 0x74, 0x75, 0x73, 0x22, 0x00, 0x42, 0x33, 0x5a, 0x31, 0x67, 0x69, 0x74, 0x68, 0x75, 0x62, 0x2e, + 0x63, 0x6f, 0x6d, 0x2f, 0x6d, 0x69, 0x6c, 0x76, 0x75, 0x73, 0x2d, 0x69, 0x6f, 0x2f, 0x6d, 0x69, + 0x6c, 0x76, 0x75, 0x73, 0x2f, 0x70, 0x6b, 0x67, 0x2f, 0x76, 0x32, 0x2f, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x2f, 0x77, 0x6f, 0x72, 0x6b, 0x65, 0x72, 0x70, 0x62, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, + 0x6f, 0x33, } var ( diff --git a/pkg/util/paramtable/component_param.go b/pkg/util/paramtable/component_param.go index 04c57d65a8..37c21bf328 100644 --- a/pkg/util/paramtable/component_param.go +++ b/pkg/util/paramtable/component_param.go @@ -317,6 +317,8 @@ type commonConfig struct { EnableConfigParamTypeCheck ParamItem `refreshable:"true"` EnablePosixMode ParamItem `refreshable:"false"` + + UsingJSONStatsForQuery ParamItem `refreshable:"true"` } func (p *commonConfig) init(base *BaseTable) { @@ -1130,6 +1132,15 @@ This helps Milvus-CDC synchronize incremental data`, } p.EnabledOptimizeExpr.Init(base.mgr) + p.UsingJSONStatsForQuery = ParamItem{ + Key: "common.UsingJSONStatsForQuery", + Version: "2.5.6", + DefaultValue: "true", + Doc: "Indicates whether to use json stats when query", + Export: true, + } + p.UsingJSONStatsForQuery.Init(base.mgr) + p.EnabledJSONKeyStats = ParamItem{ Key: "common.enabledJSONKeyStats", Version: "2.5.5", @@ -2946,6 +2957,7 @@ type queryNodeConfig struct { MmapVectorIndex ParamItem `refreshable:"false"` MmapScalarField ParamItem `refreshable:"false"` MmapScalarIndex ParamItem `refreshable:"false"` + MmapJSONStats ParamItem `refreshable:"false"` GrowingMmapEnabled ParamItem `refreshable:"false"` FixedFileSizeForMmapManager ParamItem `refreshable:"false"` MaxMmapDiskPercentageForMmapManager ParamItem `refreshable:"false"` @@ -3025,7 +3037,6 @@ type queryNodeConfig struct { WorkerPoolingSize ParamItem `refreshable:"false"` // Json Key Stats - JSONKeyStatsCommitInterval ParamItem `refreshable:"false"` EnabledGrowingSegmentJSONKeyStats ParamItem `refreshable:"false"` // Idf Oracle @@ -3627,6 +3638,15 @@ This defaults to true, indicating that Milvus creates temporary index for growin } p.MmapScalarIndex.Init(base.mgr) + p.MmapJSONStats = ParamItem{ + Key: "queryNode.mmap.jsonStats", + Version: "2.6.1", + DefaultValue: "true", + Doc: "Enable mmap for loading json stats", + Export: true, + } + p.MmapJSONStats.Init(base.mgr) + p.GrowingMmapEnabled = ParamItem{ Key: "queryNode.mmap.growingMmapEnabled", Version: "2.4.6", @@ -4031,15 +4051,6 @@ user-task-polling: } p.ExprResCacheCapacityBytes.Init(base.mgr) - p.JSONKeyStatsCommitInterval = ParamItem{ - Key: "queryNode.segcore.jsonKeyStatsCommitInterval", - Version: "2.5.0", - DefaultValue: "200", - Doc: "the commit interval for the JSON key Stats to commit", - Export: true, - } - p.JSONKeyStatsCommitInterval.Init(base.mgr) - p.CleanExcludeSegInterval = ParamItem{ Key: "queryCoord.cleanExcludeSegmentInterval", Version: "2.4.0", @@ -4271,12 +4282,14 @@ type dataCoordConfig struct { StatsTaskSlotUsage ParamItem `refreshable:"true"` AnalyzeTaskSlotUsage ParamItem `refreshable:"true"` - EnableSortCompaction ParamItem `refreshable:"true"` - TaskCheckInterval ParamItem `refreshable:"true"` - SortCompactionTriggerCount ParamItem `refreshable:"true"` - JSONStatsTriggerCount ParamItem `refreshable:"true"` - JSONStatsTriggerInterval ParamItem `refreshable:"true"` - JSONKeyStatsMemoryBudgetInTantivy ParamItem `refreshable:"false"` + EnableSortCompaction ParamItem `refreshable:"true"` + TaskCheckInterval ParamItem `refreshable:"true"` + SortCompactionTriggerCount ParamItem `refreshable:"true"` + JSONStatsTriggerCount ParamItem `refreshable:"true"` + JSONStatsTriggerInterval ParamItem `refreshable:"true"` + JSONStatsMaxShreddingColumns ParamItem `refreshable:"true"` + JSONStatsShreddingRatioThreshold ParamItem `refreshable:"true"` + JSONStatsWriteBatchSize ParamItem `refreshable:"true"` RequestTimeoutSeconds ParamItem `refreshable:"true"` } @@ -5364,14 +5377,32 @@ if param targetVecIndexVersion is not set, the default value is -1, which means } p.RequestTimeoutSeconds.Init(base.mgr) - p.JSONKeyStatsMemoryBudgetInTantivy = ParamItem{ - Key: "dataCoord.jsonKeyStatsMemoryBudgetInTantivy", - Version: "2.5.5", - DefaultValue: "16777216", - Doc: "the memory budget for the JSON index In Tantivy, the unit is bytes", + p.JSONStatsMaxShreddingColumns = ParamItem{ + Key: "dataCoord.jsonStatsMaxShreddingColumns", + Version: "2.6.1", + DefaultValue: "1024", + Doc: "the max number of columns to shred", Export: true, } - p.JSONKeyStatsMemoryBudgetInTantivy.Init(base.mgr) + p.JSONStatsMaxShreddingColumns.Init(base.mgr) + + p.JSONStatsShreddingRatioThreshold = ParamItem{ + Key: "dataCoord.jsonStatsShreddingRatioThreshold", + Version: "2.6.1", + DefaultValue: "0.3", + Doc: "the ratio threshold to shred", + Export: true, + } + p.JSONStatsShreddingRatioThreshold.Init(base.mgr) + + p.JSONStatsWriteBatchSize = ParamItem{ + Key: "dataCoord.jsonStatsWriteBatchSize", + Version: "2.6.1", + DefaultValue: "81920", + Doc: "the batch size to write", + Export: true, + } + p.JSONStatsWriteBatchSize.Init(base.mgr) } // ///////////////////////////////////////////////////////////////////////////// diff --git a/scripts/3rdparty_build.sh b/scripts/3rdparty_build.sh index 011c2fd33f..b8876c07fe 100644 --- a/scripts/3rdparty_build.sh +++ b/scripts/3rdparty_build.sh @@ -98,6 +98,11 @@ fi unameOut="$(uname -s)" case "${unameOut}" in Darwin*) + # Use ccache as compiler launcher + export CMAKE_C_COMPILER_LAUNCHER=ccache + export CMAKE_CXX_COMPILER_LAUNCHER=ccache + echo "Using CXX: $CXX" + echo "Using CC: $CC" conan install ${CPP_SRC_DIR} --install-folder conan --build=missing -s build_type=${BUILD_TYPE} -s compiler=clang -s compiler.version=${llvm_version} -s compiler.libcxx=libc++ -s compiler.cppstd=17 -r default-conan-local -u || { echo 'conan install failed'; exit 1; } ;; Linux*) diff --git a/scripts/run_cpp_unittest.sh b/scripts/run_cpp_unittest.sh index 636fddcd30..03df6f84f3 100755 --- a/scripts/run_cpp_unittest.sh +++ b/scripts/run_cpp_unittest.sh @@ -71,6 +71,13 @@ for UNITTEST_DIR in "${UNITTEST_DIRS[@]}"; do fi fi + echo "Running json_stats unittest" + ${UNITTEST_DIR}/json_stats_test + if [ $? -ne 0 ]; then + echo ${UNITTEST_DIR}/json_stats_test "run failed" + exit 1 + fi + done # run cwrapper unittest diff --git a/scripts/setenv.sh b/scripts/setenv.sh index 63a99f5585..bbf2afefef 100644 --- a/scripts/setenv.sh +++ b/scripts/setenv.sh @@ -66,9 +66,9 @@ case "${unameOut}" in fi llvm_prefix="$(brew --prefix llvm@${llvm_version})" export CLANG_TOOLS_PATH="${llvm_prefix}/bin" - export CC="ccache ${llvm_prefix}/bin/clang" - export CXX="ccache ${llvm_prefix}/bin/clang++" - export ASM="${llvm_prefix}/bin/clang" + export CC=${llvm_prefix}/bin/clang + export CXX=${llvm_prefix}/bin/clang++ + export ASM=${llvm_prefix}/bin/clang export CFLAGS="-Wno-deprecated-declarations -I$(brew --prefix libomp)/include" export CXXFLAGS=${CFLAGS} export LDFLAGS="-L$(brew --prefix libomp)/lib"