Check system field in segCore

Signed-off-by: bigsheeper <yihao.dai@zilliz.com>

internal/core/src/common/Schema.cpp

@@ -30,7 +30,19 @@ std::shared_ptr<Schema>
 Schema::ParseFrom(const milvus::proto::schema::CollectionSchema& schema_proto) {
     auto schema = std::make_shared<Schema>();
     schema->set_auto_id(schema_proto.autoid());
+
+    // NOTE: only two system
+    std::set<std::string> system_field_names = {"RowID", "Timestamp"};
+
     for (const milvus::proto::schema::FieldSchema& child : schema_proto.fields()) {
+        auto field_id = child.fieldid();
+        auto name = child.name();
+        if (field_id < 100) {
+            // system field id
+            AssertInfo(system_field_names.count(name), "id of non system field should be >= 100");
+            continue;
+        }
+
         auto data_type = DataType(child.data_type());
 
         if (child.is_primary_key()) {
@@ -51,9 +63,9 @@ Schema::ParseFrom(const milvus::proto::schema::CollectionSchema& schema_proto) {
             auto dim = boost::lexical_cast<int64_t>(type_map.at("dim"));
             AssertInfo(index_map.count("metric_type"), "index not found");
             auto metric_type = GetMetricType(index_map.at("metric_type"));
-            schema->AddField(child.name(), data_type, dim, metric_type);
+            schema->AddField(name, data_type, dim, metric_type);
         } else {
-            schema->AddField(child.name(), data_type);
+            schema->AddField(name, data_type);
         }
     }
     return schema;

internal/core/src/indexbuilder/IndexWrapper.cpp

@@ -67,75 +67,65 @@ IndexWrapper::parse() {
         config_[key] = value;
     }
 
-    if (!config_.contains(milvus::knowhere::meta::DIM)) {
-        // should raise exception here?
-        PanicInfo("dim must be specific in type params or index params!");
-    } else {
-        auto dim = config_[milvus::knowhere::meta::DIM].get<std::string>();
-        config_[milvus::knowhere::meta::DIM] = std::stoi(dim);
-    }
+    auto stoi_closure = [](const std::string& s) -> int { return std::stoi(s); };
 
-    if (!config_.contains(milvus::knowhere::meta::TOPK)) {
-    } else {
-        auto topk = config_[milvus::knowhere::meta::TOPK].get<std::string>();
-        config_[milvus::knowhere::meta::TOPK] = std::stoi(topk);
-    }
+    /***************************** meta *******************************/
+    check_parameter<int>(milvus::knowhere::meta::DIM, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::meta::TOPK, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::nlist)) {
-    } else {
-        auto nlist = config_[milvus::knowhere::IndexParams::nlist].get<std::string>();
-        config_[milvus::knowhere::IndexParams::nlist] = std::stoi(nlist);
-    }
+    /***************************** IVF Params *******************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::nprobe, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::nlist, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::m, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::nbits, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::nprobe)) {
-    } else {
-        auto nprobe = config_[milvus::knowhere::IndexParams::nprobe].get<std::string>();
-        config_[milvus::knowhere::IndexParams::nprobe] = std::stoi(nprobe);
-    }
+    /************************** NSG Parameter **************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::knng, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::search_length, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::out_degree, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::candidate, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::nbits)) {
-    } else {
-        auto nbits = config_[milvus::knowhere::IndexParams::nbits].get<std::string>();
-        config_[milvus::knowhere::IndexParams::nbits] = std::stoi(nbits);
-    }
+    /************************** HNSW Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::efConstruction, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::M, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::ef, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::m)) {
-    } else {
-        auto m = config_[milvus::knowhere::IndexParams::m].get<std::string>();
-        config_[milvus::knowhere::IndexParams::m] = std::stoi(m);
-    }
+    /************************** Annoy Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::n_trees, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::search_k, stoi_closure, std::nullopt);
 
-    /************************** NSG Parameter **************************/
-    if (!config_.contains(milvus::knowhere::IndexParams::knng)) {
-    } else {
-        auto knng = config_[milvus::knowhere::IndexParams::knng].get<std::string>();
-        config_[milvus::knowhere::IndexParams::knng] = std::stoi(knng);
-    }
+    /************************** PQ Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::PQM, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::search_length)) {
-    } else {
-        auto search_length = config_[milvus::knowhere::IndexParams::search_length].get<std::string>();
-        config_[milvus::knowhere::IndexParams::search_length] = std::stoi(search_length);
-    }
+    /************************** NGT Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::edge_size, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::out_degree)) {
-    } else {
-        auto out_degree = config_[milvus::knowhere::IndexParams::out_degree].get<std::string>();
-        config_[milvus::knowhere::IndexParams::out_degree] = std::stoi(out_degree);
-    }
+    /************************** NGT Search Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::epsilon, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::max_search_edges, stoi_closure, std::nullopt);
 
-    if (!config_.contains(milvus::knowhere::IndexParams::candidate)) {
-    } else {
-        auto candidate = config_[milvus::knowhere::IndexParams::candidate].get<std::string>();
-        config_[milvus::knowhere::IndexParams::candidate] = std::stoi(candidate);
-    }
+    /************************** NGT_PANNG Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::forcedly_pruned_edge_size, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::selectively_pruned_edge_size, stoi_closure, std::nullopt);
+
+    /************************** NGT_ONNG Params *****************************/
+    check_parameter<int>(milvus::knowhere::IndexParams::outgoing_edge_size, stoi_closure, std::nullopt);
+    check_parameter<int>(milvus::knowhere::IndexParams::incoming_edge_size, stoi_closure, std::nullopt);
+
+    /************************** Serialize Params *******************************/
+    check_parameter<int>(milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, stoi_closure, std::optional{4});
+}
 
-    /************************** Serialize *******************************/
-    if (!config_.contains(milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE)) {
-        config_[milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE] = 4;
+template <typename T>
+void
+IndexWrapper::check_parameter(const std::string& key, std::function<T(std::string)> fn, std::optional<T> default_v) {
+    if (!config_.contains(key)) {
+        if (default_v.has_value()) {
+            config_[key] = default_v.value();
+        }
     } else {
-        auto slice_size = config_[milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE].get<std::string>();
-        config_[milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE] = std::stoi(slice_size);
+        auto value = config_[key];
+        config_[key] = fn(value);
     }
 }
 

internal/core/src/indexbuilder/IndexWrapper.h

@@ -52,6 +52,12 @@ class IndexWrapper {
     void
     StoreRawData(const knowhere::DatasetPtr& dataset);
 
+    template <typename T>
+    void
+    check_parameter(const std::string& key,
+                    std::function<T(std::string)> fn,
+                    std::optional<T> default_v = std::nullopt);
+
  public:
     void
     BuildWithIds(const knowhere::DatasetPtr& dataset);

internal/core/src/indexbuilder/utils.h

@@ -25,14 +25,17 @@ NM_List() {
     static std::vector<std::string> ret{
         milvus::knowhere::IndexEnum::INDEX_FAISS_IVFFLAT,
         milvus::knowhere::IndexEnum::INDEX_NSG,
+        milvus::knowhere::IndexEnum::INDEX_RHNSWFlat,
     };
     return ret;
 }
 
 std::vector<std::string>
 BIN_List() {
-    static std::vector<std::string> ret{milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IDMAP,
-                                        milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IVFFLAT};
+    static std::vector<std::string> ret{
+        milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IDMAP,
+        milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IVFFLAT,
+    };
     return ret;
 }
 
@@ -40,7 +43,7 @@ std::vector<std::string>
 Need_ID_List() {
     static std::vector<std::string> ret{
         // milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IVFFLAT,
-        // milvus::knowhere::IndexEnum::INDEX_NSG
+        // milvus::knowhere::IndexEnum::INDEX_NSG,
     };
 
     return ret;
@@ -48,7 +51,9 @@ Need_ID_List() {
 
 std::vector<std::string>
 Need_BuildAll_list() {
-    static std::vector<std::string> ret{milvus::knowhere::IndexEnum::INDEX_NSG};
+    static std::vector<std::string> ret{
+        milvus::knowhere::IndexEnum::INDEX_NSG,
+    };
     return ret;
 }
 

internal/core/unittest/test_c_api.cpp

@@ -382,7 +382,7 @@ generate_collection_shema(std::string metric_type, std::string dim) {
 
     auto vec_field_schema = collection_schema.add_fields();
     vec_field_schema->set_name("fakevec");
-    vec_field_schema->set_fieldid(0);
+    vec_field_schema->set_fieldid(100);
     vec_field_schema->set_data_type(schema::DataType::VECTOR_FLOAT);
     auto metric_type_param = vec_field_schema->add_index_params();
     metric_type_param->set_key("metric_type");
@@ -394,7 +394,7 @@ generate_collection_shema(std::string metric_type, std::string dim) {
     auto other_field_schema = collection_schema.add_fields();
     ;
     other_field_schema->set_name("counter");
-    other_field_schema->set_fieldid(1);
+    other_field_schema->set_fieldid(101);
     other_field_schema->set_data_type(schema::DataType::INT64);
 
     std::string schema_string;

internal/core/unittest/test_index_wrapper.cpp

@@ -99,14 +99,105 @@ generate_conf(const milvus::knowhere::IndexType& index_type, const milvus::knowh
             {milvus::knowhere::Metric::TYPE, metric_type},
         };
     } else if (index_type == milvus::knowhere::IndexEnum::INDEX_NSG) {
-        return milvus::knowhere::Config{{milvus::knowhere::meta::DIM, DIM},
-                                        {milvus::knowhere::IndexParams::nlist, 163},
-                                        {milvus::knowhere::IndexParams::nprobe, 8},
-                                        {milvus::knowhere::IndexParams::knng, 20},
-                                        {milvus::knowhere::IndexParams::search_length, 40},
-                                        {milvus::knowhere::IndexParams::out_degree, 30},
-                                        {milvus::knowhere::IndexParams::candidate, 100},
-                                        {milvus::knowhere::Metric::TYPE, metric_type}};
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            {milvus::knowhere::IndexParams::nlist, 163},
+            {milvus::knowhere::IndexParams::nprobe, 8},
+            {milvus::knowhere::IndexParams::knng, 20},
+            {milvus::knowhere::IndexParams::search_length, 40},
+            {milvus::knowhere::IndexParams::out_degree, 30},
+            {milvus::knowhere::IndexParams::candidate, 100},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+        };
+#ifdef MILVUS_SUPPORT_SPTAG
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_SPTAG_KDT_RNT) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_SPTAG_BKT_RNT) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
+#endif
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_HNSW) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::IndexParams::M, 16},
+            {milvus::knowhere::IndexParams::efConstruction, 200},
+            {milvus::knowhere::IndexParams::ef, 200},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_ANNOY) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::IndexParams::n_trees, 4},
+            {milvus::knowhere::IndexParams::search_k, 100},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_RHNSWFlat) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::IndexParams::M, 16},
+            {milvus::knowhere::IndexParams::efConstruction, 200},
+            {milvus::knowhere::IndexParams::ef, 200},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_RHNSWPQ) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::IndexParams::M, 16},
+            {milvus::knowhere::IndexParams::efConstruction, 200},
+            {milvus::knowhere::IndexParams::ef, 200},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+            {milvus::knowhere::IndexParams::PQM, 8},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_RHNSWSQ) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::IndexParams::M, 16},
+            {milvus::knowhere::IndexParams::efConstruction, 200},
+            {milvus::knowhere::IndexParams::ef, 200},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_NGTPANNG) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::IndexParams::edge_size, 10},
+            {milvus::knowhere::IndexParams::epsilon, 0.1},
+            {milvus::knowhere::IndexParams::max_search_edges, 50},
+            {milvus::knowhere::IndexParams::forcedly_pruned_edge_size, 60},
+            {milvus::knowhere::IndexParams::selectively_pruned_edge_size, 30},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
+    } else if (index_type == milvus::knowhere::IndexEnum::INDEX_NGTONNG) {
+        return milvus::knowhere::Config{
+            {milvus::knowhere::meta::DIM, DIM},
+            // {milvus::knowhere::meta::TOPK, 10},
+            {milvus::knowhere::Metric::TYPE, metric_type},
+            {milvus::knowhere::IndexParams::edge_size, 20},
+            {milvus::knowhere::IndexParams::epsilon, 0.1},
+            {milvus::knowhere::IndexParams::max_search_edges, 50},
+            {milvus::knowhere::IndexParams::outgoing_edge_size, 5},
+            {milvus::knowhere::IndexParams::incoming_edge_size, 40},
+            {milvus::knowhere::INDEX_FILE_SLICE_SIZE_IN_MEGABYTE, 4},
+        };
     }
     return milvus::knowhere::Config();
 }
@@ -366,6 +457,17 @@ INSTANTIATE_TEST_CASE_P(
                       std::pair(milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IVFFLAT,
                                 milvus::knowhere::Metric::JACCARD),
                       std::pair(milvus::knowhere::IndexEnum::INDEX_FAISS_BIN_IDMAP, milvus::knowhere::Metric::JACCARD),
+#ifdef MILVUS_SUPPORT_SPTAG
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_SPTAG_KDT_RNT, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_SPTAG_BKT_RNT, milvus::knowhere::Metric::L2),
+#endif
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_HNSW, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_ANNOY, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_RHNSWFlat, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_RHNSWPQ, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_RHNSWSQ, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_NGTPANNG, milvus::knowhere::Metric::L2),
+                      std::pair(milvus::knowhere::IndexEnum::INDEX_NGTONNG, milvus::knowhere::Metric::L2),
                       std::pair(milvus::knowhere::IndexEnum::INDEX_NSG, milvus::knowhere::Metric::L2)));
 
 TEST_P(IndexWrapperTest, Constructor) {

internal/core/unittest/test_query.cpp

@@ -409,6 +409,7 @@ TEST(Query, FillSegment) {
         field->set_name("fakevec");
         field->set_is_primary_key(false);
         field->set_description("asdgfsagf");
+        field->set_fieldid(100);
         field->set_data_type(pb::schema::DataType::VECTOR_FLOAT);
         auto param = field->add_type_params();
         param->set_key("dim");
@@ -421,6 +422,7 @@ TEST(Query, FillSegment) {
     {
         auto field = proto.add_fields();
         field->set_name("the_key");
+        field->set_fieldid(101);
         field->set_is_primary_key(true);
         field->set_description("asdgfsagf");
         field->set_data_type(pb::schema::DataType::INT32);

internal/indexbuilder/index_test.go

@@ -181,6 +181,8 @@ func TestCIndex_Codec(t *testing.T) {
 
 		err = index.Delete()
 		assert.Equal(t, err, nil)
+		err = copyIndex.Delete()
+		assert.Equal(t, err, nil)
 	}
 }
 

internal/querynode/load_index_service_test.go

@@ -84,10 +84,11 @@ func TestLoadIndexService(t *testing.T) {
 	}
 
 	// create loadIndexClient
+	fieldID := UniqueID(100)
 	loadIndexChannelNames := Params.LoadIndexChannelNames
 	pulsarURL := Params.PulsarAddress
 	client := client.NewLoadIndexClient(node.queryNodeLoopCtx, pulsarURL, loadIndexChannelNames)
-	client.LoadIndex(indexPaths, segmentID, UniqueID(0), "vec", indexParams)
+	client.LoadIndex(indexPaths, segmentID, fieldID, "vec", indexParams)
 
 	// init message stream consumer and do checks
 	statsMs := msgstream.NewPulsarMsgStream(node.queryNodeLoopCtx, Params.StatsReceiveBufSize)
@@ -110,7 +111,7 @@ func TestLoadIndexService(t *testing.T) {
 			assert.Equal(t, ok, true)
 			assert.Equal(t, len(statsMsg.FieldStats), 1)
 			fieldStats0 := statsMsg.FieldStats[0]
-			assert.Equal(t, fieldStats0.FieldID, int64(0))
+			assert.Equal(t, fieldStats0.FieldID, fieldID)
 			assert.Equal(t, fieldStats0.CollectionID, collectionID)
 			assert.Equal(t, len(fieldStats0.IndexStats), 1)
 			indexStats0 := fieldStats0.IndexStats[0]

internal/querynode/meta_service_test.go

@@ -125,6 +125,7 @@ func TestMetaService_processCollectionCreate(t *testing.T) {
 	value := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -137,6 +138,7 @@ func TestMetaService_processCollectionCreate(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -190,6 +192,7 @@ func TestMetaService_processCreate(t *testing.T) {
 	msg1 := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -202,6 +205,7 @@ func TestMetaService_processCreate(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -278,6 +282,7 @@ func TestMetaService_processCollectionModify(t *testing.T) {
 	value := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -290,6 +295,7 @@ func TestMetaService_processCollectionModify(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -328,6 +334,7 @@ func TestMetaService_processCollectionModify(t *testing.T) {
 	newValue := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -340,6 +347,7 @@ func TestMetaService_processCollectionModify(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -382,6 +390,7 @@ func TestMetaService_processModify(t *testing.T) {
 	msg1 := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -394,6 +403,7 @@ func TestMetaService_processModify(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -446,6 +456,7 @@ func TestMetaService_processModify(t *testing.T) {
 	msg3 := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -458,6 +469,7 @@ func TestMetaService_processModify(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -536,6 +548,7 @@ func TestMetaService_processCollectionDelete(t *testing.T) {
 	value := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -548,6 +561,7 @@ func TestMetaService_processCollectionDelete(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <
@@ -582,6 +596,7 @@ func TestMetaService_processDelete(t *testing.T) {
 	msg1 := `schema: <
 				name: "test"
 				fields: <
+				fieldID:100
 				name: "vec"
 				data_type: VECTOR_FLOAT
 				type_params: <
@@ -594,6 +609,7 @@ func TestMetaService_processDelete(t *testing.T) {
 				>
 				>
 				fields: <
+				fieldID:101
 				name: "age"
 				data_type: INT32
 				type_params: <

internal/querynode/query_node_test.go

@@ -26,7 +26,7 @@ func setup() {
 
 func genTestCollectionMeta(collectionName string, collectionID UniqueID) *etcdpb.CollectionMeta {
 	fieldVec := schemapb.FieldSchema{
-		FieldID:      UniqueID(0),
+		FieldID:      UniqueID(100),
 		Name:         "vec",
 		IsPrimaryKey: false,
 		DataType:     schemapb.DataType_VECTOR_FLOAT,
@@ -45,7 +45,7 @@ func genTestCollectionMeta(collectionName string, collectionID UniqueID) *etcdpb
 	}
 
 	fieldInt := schemapb.FieldSchema{
-		FieldID:      UniqueID(1),
+		FieldID:      UniqueID(101),
 		Name:         "age",
 		IsPrimaryKey: false,
 		DataType:     schemapb.DataType_INT32,
@@ -66,6 +66,7 @@ func genTestCollectionMeta(collectionName string, collectionID UniqueID) *etcdpb
 		SegmentIDs:    []UniqueID{0},
 		PartitionTags: []string{"default"},
 	}
+
 	return &collectionMeta
 }