Must create index before load (#19516)

Signed-off-by: Ncai.zhang <cai.zhang@zilliz.com>
Signed-off-by: Ncai.zhang <cai.zhang@zilliz.com>

internal/proto/query_coord.proto

@@ -96,6 +96,8 @@ message LoadCollectionRequest {
   int64 collectionID = 3;
   schema.CollectionSchema schema = 4;
   int32 replica_number = 5;
+  // fieldID -> indexID
+  map<int64, int64> field_indexID = 6;
 }
 
 message ReleaseCollectionRequest {
@@ -120,6 +122,8 @@ message LoadPartitionsRequest {
   repeated int64 partitionIDs = 4;
   schema.CollectionSchema schema = 5;
   int32 replica_number = 6;
+  // fieldID -> indexID
+  map<int64, int64> field_indexID = 7;
 }
 
 message ReleasePartitionsRequest {

internal/proxy/impl.go

@@ -430,6 +430,7 @@ func (node *Proxy) LoadCollection(ctx context.Context, request *milvuspb.LoadCol
 		Condition:             NewTaskCondition(ctx),
 		LoadCollectionRequest: request,
 		queryCoord:            node.queryCoord,
+		indexCoord:            node.indexCoord,
 	}
 
 	log.Debug("LoadCollection received",
@@ -1395,6 +1396,7 @@ func (node *Proxy) LoadPartitions(ctx context.Context, request *milvuspb.LoadPar
 		Condition:             NewTaskCondition(ctx),
 		LoadPartitionsRequest: request,
 		queryCoord:            node.queryCoord,
+		indexCoord:            node.indexCoord,
 	}
 
 	log.Debug(

internal/proxy/index_coord_mock_test.go

@@ -240,10 +240,12 @@ func NewIndexCoordMock() *IndexCoordMock {
 }
 
 type GetIndexStateFunc func(ctx context.Context, request *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error)
+type DescribeIndexFunc func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error)
 
 type mockIndexCoord struct {
 	types.IndexCoord
 	GetIndexStateFunc
+	DescribeIndexFunc
 }
 
 func (m *mockIndexCoord) GetIndexState(ctx context.Context, request *indexpb.GetIndexStateRequest) (*indexpb.GetIndexStateResponse, error) {
@@ -255,6 +257,15 @@ func (m *mockIndexCoord) GetIndexState(ctx context.Context, request *indexpb.Get
 	return nil, errors.New("mock")
 }
 
+func (m *mockIndexCoord) DescribeIndex(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+	if m.DescribeIndexFunc != nil {
+		log.Warn("DescribeIndexFunc not nil")
+		return m.DescribeIndexFunc(ctx, request)
+	}
+	log.Warn("DescribeIndexFunc nil")
+	return nil, errors.New("mock")
+}
+
 func newMockIndexCoord() *mockIndexCoord {
 	return &mockIndexCoord{}
 }

internal/proxy/rootcoord_mock_test.go

@@ -1126,7 +1126,6 @@ func (coord *RootCoordMock) AlterCollection(ctx context.Context, request *milvus
 
 type DescribeCollectionFunc func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error)
 type ShowPartitionsFunc func(ctx context.Context, request *milvuspb.ShowPartitionsRequest) (*milvuspb.ShowPartitionsResponse, error)
-type DescribeIndexFunc func(ctx context.Context, request *milvuspb.DescribeIndexRequest) (*milvuspb.DescribeIndexResponse, error)
 type ShowSegmentsFunc func(ctx context.Context, request *milvuspb.ShowSegmentsRequest) (*milvuspb.ShowSegmentsResponse, error)
 type DescribeSegmentsFunc func(ctx context.Context, request *rootcoordpb.DescribeSegmentsRequest) (*rootcoordpb.DescribeSegmentsResponse, error)
 type ImportFunc func(ctx context.Context, req *milvuspb.ImportRequest) (*milvuspb.ImportResponse, error)
@@ -1138,7 +1137,6 @@ type mockRootCoord struct {
 	types.RootCoord
 	DescribeCollectionFunc
 	ShowPartitionsFunc
-	DescribeIndexFunc
 	ShowSegmentsFunc
 	DescribeSegmentsFunc
 	ImportFunc

internal/proxy/task.go

@@ -26,20 +26,19 @@ import (
 	"github.com/golang/protobuf/proto"
 	"go.uber.org/zap"
 
+	"github.com/milvus-io/milvus-proto/go-api/commonpb"
+	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
+	"github.com/milvus-io/milvus-proto/go-api/schemapb"
 	"github.com/milvus-io/milvus/internal/common"
 	"github.com/milvus-io/milvus/internal/log"
 	"github.com/milvus-io/milvus/internal/metrics"
 	"github.com/milvus-io/milvus/internal/mq/msgstream"
-	"github.com/milvus-io/milvus/internal/types"
-
-	"github.com/milvus-io/milvus-proto/go-api/commonpb"
-	"github.com/milvus-io/milvus-proto/go-api/milvuspb"
-	"github.com/milvus-io/milvus-proto/go-api/schemapb"
 	"github.com/milvus-io/milvus/internal/proto/datapb"
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
 	"github.com/milvus-io/milvus/internal/proto/internalpb"
 	"github.com/milvus-io/milvus/internal/proto/planpb"
 	"github.com/milvus-io/milvus/internal/proto/querypb"
-
+	"github.com/milvus-io/milvus/internal/types"
 	"github.com/milvus-io/milvus/internal/util/timerecord"
 	"github.com/milvus-io/milvus/internal/util/trace"
 	"github.com/milvus-io/milvus/internal/util/typeutil"
@@ -1226,6 +1225,7 @@ type loadCollectionTask struct {
 	*milvuspb.LoadCollectionRequest
 	ctx        context.Context
 	queryCoord types.QueryCoord
+	indexCoord types.IndexCoord
 	result     *commonpb.Status
 
 	collectionID UniqueID
@@ -1299,6 +1299,33 @@ func (lct *loadCollectionTask) Execute(ctx context.Context) (err error) {
 	if err != nil {
 		return err
 	}
+	// check index
+	indexResponse, err := lct.indexCoord.DescribeIndex(ctx, &indexpb.DescribeIndexRequest{
+		CollectionID: collID,
+		IndexName:    "",
+	})
+	if err != nil {
+		return err
+	}
+	if indexResponse.Status.ErrorCode != commonpb.ErrorCode_Success {
+		return errors.New(indexResponse.Status.Reason)
+	}
+
+	hasVecIndex := false
+	fieldIndexIDs := make(map[int64]int64)
+	for _, index := range indexResponse.IndexInfos {
+		fieldIndexIDs[index.FieldID] = index.IndexID
+		for _, field := range collSchema.Fields {
+			if index.FieldID == field.FieldID && (field.DataType == schemapb.DataType_FloatVector || field.DataType == schemapb.DataType_BinaryVector) {
+				hasVecIndex = true
+			}
+		}
+	}
+	if !hasVecIndex {
+		errMsg := fmt.Sprintf("there is no vector index on collection: %s, please create index firstly", lct.LoadCollectionRequest.CollectionName)
+		log.Ctx(ctx).Error(errMsg)
+		return errors.New(errMsg)
+	}
 	request := &querypb.LoadCollectionRequest{
 		Base: &commonpb.MsgBase{
 			MsgType:   commonpb.MsgType_LoadCollection,
@@ -1310,6 +1337,7 @@ func (lct *loadCollectionTask) Execute(ctx context.Context) (err error) {
 		CollectionID:  collID,
 		Schema:        collSchema,
 		ReplicaNumber: lct.ReplicaNumber,
+		FieldIndexID:  fieldIndexIDs,
 	}
 	log.Debug("send LoadCollectionRequest to query coordinator", zap.String("role", typeutil.ProxyRole),
 		zap.Int64("msgID", request.Base.MsgID), zap.Int64("collectionID", request.CollectionID),
@@ -1422,6 +1450,7 @@ type loadPartitionsTask struct {
 	*milvuspb.LoadPartitionsRequest
 	ctx        context.Context
 	queryCoord types.QueryCoord
+	indexCoord types.IndexCoord
 	result     *commonpb.Status
 
 	collectionID UniqueID
@@ -1488,6 +1517,33 @@ func (lpt *loadPartitionsTask) Execute(ctx context.Context) error {
 	if err != nil {
 		return err
 	}
+	// check index
+	indexResponse, err := lpt.indexCoord.DescribeIndex(ctx, &indexpb.DescribeIndexRequest{
+		CollectionID: collID,
+		IndexName:    "",
+	})
+	if err != nil {
+		return err
+	}
+	if indexResponse.Status.ErrorCode != commonpb.ErrorCode_Success {
+		return errors.New(indexResponse.Status.Reason)
+	}
+
+	hasVecIndex := false
+	fieldIndexIDs := make(map[int64]int64)
+	for _, index := range indexResponse.IndexInfos {
+		fieldIndexIDs[index.FieldID] = index.IndexID
+		for _, field := range collSchema.Fields {
+			if index.FieldID == field.FieldID && (field.DataType == schemapb.DataType_FloatVector || field.DataType == schemapb.DataType_BinaryVector) {
+				hasVecIndex = true
+			}
+		}
+	}
+	if !hasVecIndex {
+		errMsg := fmt.Sprintf("there is no vector index on collection: %s, please create index firstly", lpt.LoadPartitionsRequest.CollectionName)
+		log.Ctx(ctx).Error(errMsg)
+		return errors.New(errMsg)
+	}
 	for _, partitionName := range lpt.PartitionNames {
 		partitionID, err := globalMetaCache.GetPartitionID(ctx, lpt.CollectionName, partitionName)
 		if err != nil {
@@ -1507,6 +1563,7 @@ func (lpt *loadPartitionsTask) Execute(ctx context.Context) error {
 		PartitionIDs:  partitionIDs,
 		Schema:        collSchema,
 		ReplicaNumber: lpt.ReplicaNumber,
+		FieldIndexID:  fieldIndexIDs,
 	}
 	lpt.result, err = lpt.queryCoord.LoadPartitions(ctx, request)
 	return err

internal/proxy/task_index.go

@@ -20,6 +20,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"strconv"
 
 	"go.uber.org/zap"
 
@@ -290,7 +291,7 @@ func (cit *createIndexTask) Execute(ctx context.Context) error {
 		zap.Any("indexParams", cit.req.GetExtraParams()))
 
 	if cit.req.GetIndexName() == "" {
-		cit.req.IndexName = Params.CommonCfg.DefaultIndexName
+		cit.req.IndexName = Params.CommonCfg.DefaultIndexName + "_" + strconv.FormatInt(cit.fieldSchema.GetFieldID(), 10)
 	}
 	var err error
 	req := &indexpb.CreateIndexRequest{

internal/proxy/task_test.go

@@ -27,6 +27,8 @@ import (
 	"testing"
 	"time"
 
+	"github.com/milvus-io/milvus/internal/proto/indexpb"
+
 	"github.com/milvus-io/milvus/internal/mocks"
 	"github.com/stretchr/testify/mock"
 
@@ -2203,3 +2205,197 @@ func Test_dropCollectionTask_PostExecute(t *testing.T) {
 	dct := &dropCollectionTask{}
 	assert.NoError(t, dct.PostExecute(context.Background()))
 }
+
+func Test_loadCollectionTask_Execute(t *testing.T) {
+	rc := newMockRootCoord()
+	qc := NewQueryCoordMock(withValidShardLeaders())
+	ic := newMockIndexCoord()
+
+	dbName := funcutil.GenRandomStr()
+	collectionName := funcutil.GenRandomStr()
+	collectionID := UniqueID(1)
+	//fieldName := funcutil.GenRandomStr()
+	indexName := funcutil.GenRandomStr()
+	ctx := context.Background()
+	indexID := int64(1000)
+
+	shardMgr := newShardClientMgr()
+	// failed to get collection id.
+	_ = InitMetaCache(ctx, rc, qc, shardMgr)
+
+	rc.DescribeCollectionFunc = func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
+		return &milvuspb.DescribeCollectionResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_Success,
+			},
+			Schema:         newTestSchema(),
+			CollectionID:   collectionID,
+			CollectionName: request.CollectionName,
+		}, nil
+	}
+
+	lct := &loadCollectionTask{
+		LoadCollectionRequest: &milvuspb.LoadCollectionRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   commonpb.MsgType_LoadCollection,
+				MsgID:     1,
+				Timestamp: 1,
+				SourceID:  1,
+				TargetID:  1,
+			},
+			DbName:         dbName,
+			CollectionName: collectionName,
+			ReplicaNumber:  1,
+		},
+		ctx:          ctx,
+		queryCoord:   qc,
+		indexCoord:   ic,
+		result:       nil,
+		collectionID: 0,
+	}
+
+	t.Run("indexcoord describe index error", func(t *testing.T) {
+		err := lct.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("indexcoord describe index not success", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_UnexpectedError,
+					Reason:    "fail reason",
+				},
+			}, nil
+		}
+
+		err := lct.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("no vector index", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_Success,
+				},
+				IndexInfos: []*indexpb.IndexInfo{
+					{
+						CollectionID:         collectionID,
+						FieldID:              100,
+						IndexName:            indexName,
+						IndexID:              indexID,
+						TypeParams:           nil,
+						IndexParams:          nil,
+						IndexedRows:          1025,
+						TotalRows:            1025,
+						State:                commonpb.IndexState_Finished,
+						IndexStateFailReason: "",
+						IsAutoIndex:          false,
+						UserIndexParams:      nil,
+					},
+				},
+			}, nil
+		}
+
+		err := lct.Execute(ctx)
+		assert.Error(t, err)
+	})
+}
+
+func Test_loadPartitionTask_Execute(t *testing.T) {
+	rc := newMockRootCoord()
+	qc := NewQueryCoordMock(withValidShardLeaders())
+	ic := newMockIndexCoord()
+
+	dbName := funcutil.GenRandomStr()
+	collectionName := funcutil.GenRandomStr()
+	collectionID := UniqueID(1)
+	//fieldName := funcutil.GenRandomStr()
+	indexName := funcutil.GenRandomStr()
+	ctx := context.Background()
+	indexID := int64(1000)
+
+	shardMgr := newShardClientMgr()
+	// failed to get collection id.
+	_ = InitMetaCache(ctx, rc, qc, shardMgr)
+
+	rc.DescribeCollectionFunc = func(ctx context.Context, request *milvuspb.DescribeCollectionRequest) (*milvuspb.DescribeCollectionResponse, error) {
+		return &milvuspb.DescribeCollectionResponse{
+			Status: &commonpb.Status{
+				ErrorCode: commonpb.ErrorCode_Success,
+			},
+			Schema:         newTestSchema(),
+			CollectionID:   collectionID,
+			CollectionName: request.CollectionName,
+		}, nil
+	}
+
+	lpt := &loadPartitionsTask{
+		LoadPartitionsRequest: &milvuspb.LoadPartitionsRequest{
+			Base: &commonpb.MsgBase{
+				MsgType:   commonpb.MsgType_LoadCollection,
+				MsgID:     1,
+				Timestamp: 1,
+				SourceID:  1,
+				TargetID:  1,
+			},
+			DbName:         dbName,
+			CollectionName: collectionName,
+			ReplicaNumber:  1,
+		},
+		ctx:          ctx,
+		queryCoord:   qc,
+		indexCoord:   ic,
+		result:       nil,
+		collectionID: 0,
+	}
+
+	t.Run("indexcoord describe index error", func(t *testing.T) {
+		err := lpt.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("indexcoord describe index not success", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_UnexpectedError,
+					Reason:    "fail reason",
+				},
+			}, nil
+		}
+
+		err := lpt.Execute(ctx)
+		assert.Error(t, err)
+	})
+
+	t.Run("no vector index", func(t *testing.T) {
+		ic.DescribeIndexFunc = func(ctx context.Context, request *indexpb.DescribeIndexRequest) (*indexpb.DescribeIndexResponse, error) {
+			return &indexpb.DescribeIndexResponse{
+				Status: &commonpb.Status{
+					ErrorCode: commonpb.ErrorCode_Success,
+				},
+				IndexInfos: []*indexpb.IndexInfo{
+					{
+						CollectionID:         collectionID,
+						FieldID:              100,
+						IndexName:            indexName,
+						IndexID:              indexID,
+						TypeParams:           nil,
+						IndexParams:          nil,
+						IndexedRows:          1025,
+						TotalRows:            1025,
+						State:                commonpb.IndexState_Finished,
+						IndexStateFailReason: "",
+						IsAutoIndex:          false,
+						UserIndexParams:      nil,
+					},
+				},
+			}, nil
+		}
+
+		err := lpt.Execute(ctx)
+		assert.Error(t, err)
+	})
+}

tests/python_client/base/client_base.py

@@ -169,7 +169,16 @@ class TestcaseBase(Base):
                 assert collection_w.num_entities == nb
             # This condition will be removed after auto index feature
             if not is_index:
+                if is_binary:
+                    collection_w.create_index(ct.default_binary_vec_field_name, ct.default_bin_flat_index)
+                else:
+                    collection_w.create_index(ct.default_float_vec_field_name, ct.default_flat_index)
                 collection_w.load()
+        elif not is_index:
+            if is_binary:
+                collection_w.create_index(ct.default_binary_vec_field_name, ct.default_bin_flat_index)
+            else:
+                collection_w.create_index(ct.default_float_vec_field_name, ct.default_flat_index)
 
         return collection_w, vectors, binary_raw_vectors, insert_ids, time_stamp
 
@@ -190,6 +199,7 @@ class TestcaseBase(Base):
         collection_w.insert(df_default)
         # flush
         collection_w.num_entities
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(partition_names=[partition_w.name, "_default"])
         return collection_w, partition_w, df_partition, df_default
 

tests/python_client/common/common_type.py

@@ -70,6 +70,9 @@ err_code = "err_code"
 err_msg = "err_msg"
 in_cluster_env = "IN_CLUSTER"
 
+default_flat_index = {"index_type": "FLAT", "params": {}, "metric_type": "L2"}
+default_bin_flat_index = {"index_type": "BIN_FLAT", "params": {}, "metric_type": "JACCARD"}
+
 """" List of parameters used to pass """
 get_invalid_strs = [
     [],

tests/python_client/requirements.txt

@@ -9,7 +9,7 @@ allure-pytest==2.7.0
 pytest-print==0.2.1
 pytest-level==0.1.1
 pytest-xdist==2.5.0
-pymilvus==2.2.0.dev44
+pymilvus==2.2.0.dev45
 pytest-rerunfailures==9.1.1
 git+https://github.com/Projectplace/pytest-tags
 ndg-httpsclient

tests/python_client/testcases/test_collection.py

@@ -1114,6 +1114,7 @@ class TestCollectionOperation(TestcaseBase):
         collection_w = self.init_collection_wrap()
         partition_w1 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         error = {ct.err_code: 5, ct.err_msg: f'load the partition after load collection is not supported'}
         partition_w1.load(check_task=CheckTasks.err_res,
@@ -1130,6 +1131,7 @@ class TestCollectionOperation(TestcaseBase):
         collection_w = self.init_collection_wrap()
         partition_w1 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         error = {ct.err_code: 1, ct.err_msg: f'releasing the partition after load collection is not supported'}
         partition_w1.release(check_task=CheckTasks.err_res,
@@ -1147,6 +1149,7 @@ class TestCollectionOperation(TestcaseBase):
         collection_w = self.init_collection_wrap(name=c_name, check_task=CheckTasks.check_collection_property,
                                                  check_items={exp_name: c_name, exp_schema: default_schema})
         collection_w.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.release()
 
@@ -2036,6 +2039,7 @@ class TestLoadCollection(TestcaseBase):
         """
         self._connect()
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.release()
 
@@ -2126,6 +2130,7 @@ class TestLoadCollection(TestcaseBase):
         insert_data = cf.gen_default_list_data()
         collection_w.insert(data=insert_data)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.release()
         collection_w.load()
@@ -2142,6 +2147,7 @@ class TestLoadCollection(TestcaseBase):
         insert_data = cf.gen_default_list_data()
         collection_w.insert(data=insert_data)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.load()
 
@@ -2156,6 +2162,7 @@ class TestLoadCollection(TestcaseBase):
         self._connect()
         c_name = cf.gen_unique_str()
         collection_wr = self.init_collection_wrap(name=c_name)
+        collection_wr.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_wr.load()
         collection_wr.release()
         collection_wr.drop()
@@ -2174,6 +2181,7 @@ class TestLoadCollection(TestcaseBase):
         self._connect()
         c_name = cf.gen_unique_str()
         collection_wr = self.init_collection_wrap(name=c_name)
+        collection_wr.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_wr.load()
         collection_wr.drop()
         error = {ct.err_code: 0,
@@ -2193,6 +2201,7 @@ class TestLoadCollection(TestcaseBase):
         data = cf.gen_default_list_data()
         collection_w.insert(data=data, partition_name=ct.default_tag)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         patition_w.load()
         collection_w.release()
 
@@ -2216,6 +2225,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         insert_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # load with non-number replicas
         error = {ct.err_code: 0, ct.err_msg: f"but expected one of: int, long"}
@@ -2234,6 +2244,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         insert_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         collection_w.load(replica_number=replicas)
         replicas = collection_w.get_replicas()[0]
@@ -2253,6 +2264,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         insert_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         error = {ct.err_code: 1, ct.err_msg: f"no enough nodes to create replicas"}
         collection_w.load(replica_number=3, check_task=CheckTasks.err_res, check_items=error)
@@ -2326,6 +2338,7 @@ class TestLoadCollection(TestcaseBase):
             insert_res, _ = collection_w.insert(df)
             assert collection_w.num_entities == (i + 1) * tmp_nb
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(replica_number=replica_number)
         replicas = collection_w.get_replicas()[0]
         assert len(replicas.groups) == replica_number
@@ -2356,6 +2369,7 @@ class TestLoadCollection(TestcaseBase):
         partition_w = self.init_partition_wrap(collection_w, ct.default_tag)
         partition_w.insert(df_2)
         assert collection_w.num_entities == ct.default_nb * 2
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         collection_w.load([partition_w.name], replica_number=2)
         for seg in self.utility_wrap.get_query_segment_info(collection_w.name)[0]:
@@ -2390,6 +2404,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # load with multi replica and insert growing data
         collection_w.load(replica_number=2)
@@ -2439,6 +2454,7 @@ class TestLoadCollection(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # load with multi replicas and insert growing data
         collection_w.load(replica_number=2)
@@ -2487,6 +2503,7 @@ class TestLoadCollection(TestcaseBase):
         mutation_res, _ = collection_w.insert(df)
         assert collection_w.num_entities == 5000
         total_sq_count = 20
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         collection_w.load(replica_number=3)
         for i in range(total_sq_count):
@@ -2535,6 +2552,7 @@ class TestReleaseAdvanced(TestcaseBase):
         collection_wr = self.init_collection_wrap(name=c_name)
         collection_wr.insert(data=data)
         assert collection_wr.num_entities == ct.default_nb
+        collection_wr.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_wr.load()
         search_res, _ = collection_wr.search(vectors, default_search_field, default_search_params,
                                              default_limit, _async=True)
@@ -2553,6 +2571,7 @@ class TestReleaseAdvanced(TestcaseBase):
         self._connect()
         partition_num = 1
         collection_w = self.init_collection_general(prefix, True, 10, partition_num, is_index=True)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         par = collection_w.partitions
         par_name = par[partition_num].name
         par[partition_num].load()
@@ -2578,6 +2597,7 @@ class TestReleaseAdvanced(TestcaseBase):
         self._connect()
         partition_num = 1
         collection_w = self.init_collection_general(prefix, True, 10, partition_num, is_index=True)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         par = collection_w.partitions
         par_name = par[partition_num].name
         par[partition_num].load()
@@ -2640,6 +2660,7 @@ class TestLoadPartition(TestcaseBase):
                                                  'which does not match the index type: BIN_IVF_FLAT'}
             collection_w.create_index(ct.default_binary_vec_field_name, binary_index,
                                       check_task=CheckTasks.err_res, check_items=error)
+            collection_w.create_index(ct.default_binary_vec_field_name, ct.default_bin_flat_index)
         else:
             collection_w.create_index(ct.default_binary_vec_field_name, binary_index)
         par = collection_w.partitions
@@ -2662,6 +2683,7 @@ class TestLoadPartition(TestcaseBase):
                                                check_items={"name": partition_name, "description": description,
                                                             "is_empty": True, "num_entities": 0}
                                                )
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         self.connection_wrap.remove_connection(ct.default_alias)
         res_list, _ = self.connection_wrap.list_connections()
@@ -2686,6 +2708,7 @@ class TestLoadPartition(TestcaseBase):
                                                check_items={"name": partition_name, "description": description,
                                                             "is_empty": True, "num_entities": 0}
                                                )
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         self.connection_wrap.remove_connection(ct.default_alias)
         res_list, _ = self.connection_wrap.list_connections()
@@ -2710,6 +2733,7 @@ class TestLoadPartition(TestcaseBase):
                                                check_items={"name": partition_name, "description": description,
                                                             "is_empty": True, "num_entities": 0}
                                                )
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.drop()
         error = {ct.err_code: 0, ct.err_msg: 'partitionID of partitionName:%s can not be find' % partition_name}
         partition_w.load(check_task=CheckTasks.err_res, check_items=error)

tests/python_client/testcases/test_compaction.py

@@ -235,6 +235,7 @@ class TestCompactionParams(TestcaseBase):
         collection_w.insert(cf.gen_default_dataframe_data(1, start=tmp_nb))
         assert collection_w.num_entities == tmp_nb + 1
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(ratio_expr, check_items=CheckTasks.check_query_empty)
 
@@ -261,6 +262,7 @@ class TestCompactionParams(TestcaseBase):
         collection_w.delete(ratio_expr)
         assert collection_w.num_entities == tmp_nb
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(ratio_expr, check_task=CheckTasks.check_query_empty)
 
@@ -288,6 +290,7 @@ class TestCompactionParams(TestcaseBase):
         collection_w.wait_for_compaction_completed()
         collection_w.get_compaction_plans(check_task=CheckTasks.check_delete_compact)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(expr, check_items=CheckTasks.check_query_empty)
 

tests/python_client/testcases/test_delete.py

@@ -229,6 +229,7 @@ class TestDeleteParams(TestcaseBase):
         partition_w = self.init_partition_wrap(collection_wrap=collection_w)
 
         # load collection and insert data to partition
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         df = cf.gen_default_dataframe_data(tmp_nb)
         partition_w.insert(df)
@@ -320,7 +321,7 @@ class TestDeleteOperation(TestcaseBase):
         expected: assert index and deleted id not in search result
         """
         # create collection, insert tmp_nb, flush and load
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=True)[0:2]
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_index=True)[0:2]
 
         # create index
         index_params = {"index_type": "IVF_SQ8",
@@ -398,6 +399,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -470,6 +472,7 @@ class TestDeleteOperation(TestcaseBase):
         collection_w.insert(df)
         assert collection_w.num_entities == tmp_nb
         del_res, _ = collection_w.delete(tmp_expr)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # Just one query res and search res, because de-dup
@@ -554,6 +557,7 @@ class TestDeleteOperation(TestcaseBase):
         # delete same id 0 from default_partition, and query on it get empty result
         collection_w.delete(tmp_expr, partition_name=ct.default_partition_name)
         assert collection_w.num_entities == tmp_nb * 2
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, partition_names=[ct.default_partition_name],
                            check_task=CheckTasks.check_query_empty)
@@ -624,6 +628,7 @@ class TestDeleteOperation(TestcaseBase):
         assert del_res.delete_count == 1
 
         # load and query with id
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -640,6 +645,7 @@ class TestDeleteOperation(TestcaseBase):
         # create collection
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
         # load collection and the queryNode watch the insertChannel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # insert data
         df = cf.gen_default_dataframe_data(tmp_nb)
@@ -667,6 +673,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load collection and queryNode subscribe channel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # delete ids and query
@@ -700,6 +707,7 @@ class TestDeleteOperation(TestcaseBase):
         log.info(f'Collection num entities: {collection_w.num_entities}')
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -726,6 +734,7 @@ class TestDeleteOperation(TestcaseBase):
         collection_w.insert(cf.gen_default_dataframe_data(nb=1, start=tmp_nb))
         log.info(collection_w.num_entities)
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -750,6 +759,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -768,6 +778,7 @@ class TestDeleteOperation(TestcaseBase):
         """
         # init collection and insert data without flush
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         df = cf.gen_default_dataframe_data(tmp_nb)
         collection_w.insert(df)
@@ -815,6 +826,7 @@ class TestDeleteOperation(TestcaseBase):
         log.debug(collection_w.num_entities)
 
         # load and query
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res = df.iloc[:1, :1].to_dict('records')
         collection_w.search(data=[df[ct.default_float_vec_field_name][0]], anns_field=ct.default_float_vec_field_name,
@@ -905,6 +917,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -944,6 +957,7 @@ class TestDeleteOperation(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(tmp_expr, check_task=CheckTasks.check_query_empty)
 
@@ -1010,6 +1024,7 @@ class TestDeleteOperation(TestcaseBase):
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix))
         df = cf.gen_default_dataframe_data(tmp_nb)
         insert_res, _ = collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         tt = self.utility_wrap.mkts_from_hybridts(insert_res.timestamp, milliseconds=0.)
@@ -1051,6 +1066,7 @@ class TestDeleteOperation(TestcaseBase):
         expr = f'{ct.default_int64_field_name} in {ids}'
         collection_w.delete(expr)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(expr, check_task=CheckTasks.check_query_empty)
         search_res, _ = collection_w.search(cf.gen_vectors(ct.default_nq, ct.default_dim),
@@ -1082,6 +1098,7 @@ class TestDeleteOperation(TestcaseBase):
             assert collection_w.num_entities == (i + 1) * segment_per_count
             ids.extend(res.primary_keys)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         expr = f'{ct.default_int64_field_name} in {ids}'
@@ -1123,7 +1140,7 @@ class TestDeleteString(TestcaseBase):
         expected: assert index and deleted id not in search result
         """
         # create collection, insert tmp_nb, flush and load
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=True,
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_index=True,
                                                              primary_field=ct.default_string_field_name)[0:2]
 
         # create index
@@ -1209,6 +1226,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1286,6 +1304,7 @@ class TestDeleteString(TestcaseBase):
         collection_w.insert(df)
         assert collection_w.num_entities == tmp_nb
         del_res, _ = collection_w.delete(default_string_expr)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # Just one query res and search res, because de-dup
@@ -1321,6 +1340,7 @@ class TestDeleteString(TestcaseBase):
         collection_w.delete(default_string_expr,
                             partition_name=ct.default_partition_name)
         assert collection_w.num_entities == tmp_nb * 2
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr, partition_names=[ct.default_partition_name],
                            check_task=CheckTasks.check_query_empty)
@@ -1350,6 +1370,7 @@ class TestDeleteString(TestcaseBase):
         assert del_res.delete_count == 1
 
         # load and query with id
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1368,6 +1389,7 @@ class TestDeleteString(TestcaseBase):
         schema = cf.gen_string_pk_default_collection_schema()
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix), schema=schema)
         # load collection and the queryNode watch the insertChannel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # insert data
         df = cf.gen_default_dataframe_data(tmp_nb)
@@ -1397,6 +1419,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load collection and queryNode subscribe channel
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # delete ids and query
@@ -1428,6 +1451,7 @@ class TestDeleteString(TestcaseBase):
         collection_w.insert(cf.gen_default_dataframe_data(nb=1, start=tmp_nb))
         log.info(collection_w.num_entities)
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1454,6 +1478,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1530,6 +1555,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1573,6 +1599,7 @@ class TestDeleteString(TestcaseBase):
         assert collection_w.num_entities == tmp_nb
 
         # load and query id 0
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_string_expr,
                            check_task=CheckTasks.check_query_empty)
@@ -1632,6 +1659,7 @@ class TestDeleteString(TestcaseBase):
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix), schema=schema)
         df = cf.gen_default_dataframe_data(tmp_nb)
         insert_res, _ = collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         tt = self.utility_wrap.mkts_from_hybridts(insert_res.timestamp, milliseconds=0.)
@@ -1676,6 +1704,7 @@ class TestDeleteString(TestcaseBase):
         expr = expr.replace("'", "\"")
         collection_w.delete(expr)
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(expr, check_task=CheckTasks.check_query_empty)
         search_res, _ = collection_w.search(cf.gen_vectors(ct.default_nq, ct.default_dim),
@@ -1723,6 +1752,7 @@ class TestDeleteString(TestcaseBase):
         log.debug(collection_w.num_entities)
 
         # load and query
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res = df.iloc[:1, 2:3].to_dict('records')
         default_search_params = {"metric_type": "L2", "params": {"nprobe": 16}}
@@ -1766,6 +1796,7 @@ class TestDeleteString(TestcaseBase):
         df[2] = [""for _ in range(nb)] 
 
         collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         assert collection_w.num_entities == nb
 

tests/python_client/testcases/test_e2e.py

@@ -41,6 +41,10 @@ class TestE2e(TestcaseBase):
         log.info(f"assert flush: {tt}, entities: {entities}")
 
         # search
+        _index_params = {"index_type": "IVF_SQ8", "params": {"nlist": 64}, "metric_type": "L2"}
+        index, _ = collection_w.create_index(field_name=ct.default_float_vec_field_name,
+                                             index_params=_index_params,
+                                             name=cf.gen_unique_str())
         collection_w.load()
         search_vectors = cf.gen_vectors(1, ct.default_dim)
         search_params = {"metric_type": "L2", "params": {"nprobe": 16}}

tests/python_client/testcases/test_index.py

@@ -1336,6 +1336,7 @@ class TestIndexString(TestcaseBase):
         index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
                                               default_string_index_params)
         cf.assert_equal_index(index, collection_w.indexes[0])
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index, index_name="vector_flat")
         collection_w.load()
         assert collection_w.num_entities == default_nb
 
@@ -1351,6 +1352,7 @@ class TestIndexString(TestcaseBase):
         collection_w = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(ct.default_nb)
         collection_w.insert(data=data)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index, index_name="vector_flat")
         collection_w.load()
         index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
                                               default_string_index_params)

tests/python_client/testcases/test_partition.py

@@ -264,6 +264,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w2 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
         partition_w2.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w1.load()
         error = {ct.err_code: 5, ct.err_msg: f'load the partition after load collection is not supported'}
         partition_w2.load(check_task=CheckTasks.err_res,
@@ -283,6 +284,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w1.insert(cf.gen_default_list_data())
         partition_w2.insert(cf.gen_default_list_data())
         partition_names = ["partition_w1", "partition_w2"]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(partition_names)
         collection_w.release(partition_names)
 
@@ -300,6 +302,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w2 = self.init_partition_wrap(collection_w)
         partition_w1.insert(cf.gen_default_list_data())
         partition_w2.insert(cf.gen_default_list_data())
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w1.load()
         partition_w1.release()
         partition_w2.load()
@@ -327,6 +330,7 @@ class TestPartitionParams(TestcaseBase):
 
         # load with non-number replicas
         error = {ct.err_code: 0, ct.err_msg: f"but expected one of: int, long"}
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load(replica_number=get_non_number_replicas, check_task=CheckTasks.err_res, check_items=error)
 
     @pytest.mark.tags(CaseLabel.L2)
@@ -344,6 +348,7 @@ class TestPartitionParams(TestcaseBase):
         partition_w.insert(cf.gen_default_list_data())
         assert partition_w.num_entities == ct.default_nb
 
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load(replica_number=replicas)
         p_replicas = partition_w.get_replicas()[0]
         assert len(p_replicas.groups) == 1
@@ -366,6 +371,7 @@ class TestPartitionParams(TestcaseBase):
 
         # load with 2 replicas
         error = {ct.err_code: 1, ct.err_msg: f"no enough nodes to create replicas"}
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load(replica_number=3, check_task=CheckTasks.err_res, check_items=error)
 
     @pytest.mark.tags(CaseLabel.ClusterOnly)
@@ -464,6 +470,7 @@ class TestPartitionParams(TestcaseBase):
         # create collection
 
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # create two partitions
         partition_w1 = self.init_partition_wrap(collection_w)
@@ -819,6 +826,7 @@ class TestPartitionOperations(TestcaseBase):
         """
         # create collection
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
 
         # create partition
         partition_name = cf.gen_unique_str(prefix)

tests/python_client/testcases/test_query.py

@@ -94,6 +94,7 @@ class TestQueryParams(TestcaseBase):
         """
         c_name = cf.gen_unique_str(prefix)
         collection_w = self.init_collection_wrap(name=c_name)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = collection_w.query(default_term_expr)
         assert len(res) == 0
@@ -115,6 +116,7 @@ class TestQueryParams(TestcaseBase):
         ids = insert_res[1].primary_keys
         pos = 5
         res = df.iloc[:pos, :1].to_dict('records')
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # query with all primary keys
@@ -163,6 +165,7 @@ class TestQueryParams(TestcaseBase):
         df.drop(ct.default_int64_field_name, axis=1, inplace=True)
         mutation_res, _ = collection_w.insert(data=df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         term_expr = f'{ct.default_int64_field_name} in [0, 1, 2]'
         res, _ = collection_w.query(term_expr)
@@ -250,6 +253,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # query by non_primary non_vector scalar field
@@ -283,6 +287,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # output bool field
@@ -327,6 +332,7 @@ class TestQueryParams(TestcaseBase):
         # int8 range [-128, 127] so when nb=1200, there are many repeated int8 values equal to 0
         for i in range(0, ct.default_nb, 256):
             res.extend(df.iloc[i:i + 1, :-1].to_dict('records'))
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         self.collection_wrap.query(term_expr, output_fields=["*"],
                                    check_task=CheckTasks.check_query_results, check_items={exp_res: res})
@@ -393,6 +399,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         values = df[field].tolist()
         pos = 100
@@ -414,6 +421,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == ct.default_nb
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         int64_values = df[ct.default_int64_field_name].tolist()
         term_expr = f'{ct.default_int64_field_name} not in {int64_values[pos:]}'
@@ -433,6 +441,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == 100
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         # random_values = [random.randint(0, ct.default_nb) for _ in range(4)]
@@ -454,6 +463,7 @@ class TestQueryParams(TestcaseBase):
         self.collection_wrap.construct_from_dataframe(cf.gen_unique_str(prefix), df,
                                                       primary_field=ct.default_int64_field_name)
         assert self.collection_wrap.num_entities == 50
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
 
         random_values = [i for i in range(10, 50)]
@@ -575,6 +585,7 @@ class TestQueryParams(TestcaseBase):
         assert collection_w.num_entities == ct.default_nb
         fields = [[ct.default_float_vec_field_name], [ct.default_int64_field_name, ct.default_float_vec_field_name]]
         res = df.loc[:1, [ct.default_int64_field_name, ct.default_float_vec_field_name]].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         for output_fields in fields:
             collection_w.query(default_term_expr, output_fields=output_fields,
@@ -603,6 +614,7 @@ class TestQueryParams(TestcaseBase):
         for vec_field in vec_fields:
             output_fields.append(vec_field.name)
         res = df.loc[:1, output_fields].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_term_expr, output_fields=output_fields,
                            check_task=CheckTasks.check_query_results,
@@ -631,6 +643,7 @@ class TestQueryParams(TestcaseBase):
         for vec_field in vec_fields:
             output_fields.append(vec_field.name)
         res = df.loc[:1, output_fields].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_term_expr, output_fields=output_fields,
                            check_task=CheckTasks.check_query_results,
@@ -740,6 +753,7 @@ class TestQueryParams(TestcaseBase):
 
         # query with output_fields=["*", float_vector)
         res = df.iloc[:2, :4].to_dict('records')
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.query(default_term_expr, output_fields=["*", ct.default_float_vec_field_name],
                            check_task=CheckTasks.check_query_results,
@@ -787,6 +801,7 @@ class TestQueryParams(TestcaseBase):
         """
         # init collection with fields: int64, float, float_vec
         collection_w = self.init_collection_general(prefix, insert_data=True, nb=100)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
 
         # query with invalid output_fields
@@ -806,6 +821,7 @@ class TestQueryParams(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         partition_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         res = df.iloc[:2, :1].to_dict('records')
         collection_w.query(default_term_expr, partition_names=[partition_w.name],
@@ -849,6 +865,7 @@ class TestQueryParams(TestcaseBase):
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
         partition_w = self.init_partition_wrap(collection_wrap=collection_w)
         assert partition_w.is_empty
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         res, _ = collection_w.query(default_term_expr, partition_names=[partition_w.name])
         assert len(res) == 0
@@ -861,6 +878,7 @@ class TestQueryParams(TestcaseBase):
         expected: raise exception
         """
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix))
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         partition_names = cf.gen_unique_str()
         error = {ct.err_code: 1, ct.err_msg: f'PartitonName: {partition_names} not found'}
@@ -954,6 +972,7 @@ class TestQueryParams(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         partition_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
         res = df.iloc[:2, :1].to_dict('records')
         query_params = {"offset": offset, "limit": 10}
@@ -971,6 +990,7 @@ class TestQueryParams(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res = df.iloc[:2, :1].to_dict('records')
         query_params = {"offset": offset, "limit": 10}
@@ -1203,6 +1223,7 @@ class TestQueryOperation(TestcaseBase):
         df[ct.default_int64_field_name] = 0
         mutation_res, _ = collection_w.insert(df)
         assert mutation_res.primary_keys == df[ct.default_int64_field_name].tolist()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         term_expr = f'{ct.default_int64_field_name} in {[0, 0, 0]}'
         res = df.iloc[:, :2].to_dict('records')
@@ -1218,7 +1239,7 @@ class TestQueryOperation(TestcaseBase):
                 3. query
         expected: query result is correct
         """
-        collection_w, vectors, binary_raw_vectors = self.init_collection_general(prefix, insert_data=True)[0:3]
+        collection_w, vectors, binary_raw_vectors = self.init_collection_general(prefix, insert_data=True, is_index=True)[0:3]
 
         default_field_name = ct.default_float_vec_field_name
         collection_w.create_index(default_field_name, default_index_params)
@@ -1285,10 +1306,11 @@ class TestQueryOperation(TestcaseBase):
         method: create index and specify vec field as output field
         expected: return primary field and vec field
         """
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_binary=True)[0:2]
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=True, is_binary=True, is_index=True)[0:2]
         fields = [ct.default_int64_field_name, ct.default_binary_vec_field_name]
         collection_w.create_index(ct.default_binary_vec_field_name, binary_index_params)
         assert collection_w.has_index()[0]
+        collection_w.load()
         res, _ = collection_w.query(default_term_expr, output_fields=[ct.default_binary_vec_field_name])
         assert res[0].keys() == set(fields)
 
@@ -1317,6 +1339,7 @@ class TestQueryOperation(TestcaseBase):
         assert collection_w.num_entities == ct.default_nb
 
         # load partition
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         partition_w.load()
 
         # query twice
@@ -1386,6 +1409,7 @@ class TestQueryOperation(TestcaseBase):
         import time
         collection_w = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
         # load collection
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         tmp_nb = 100
         df = cf.gen_default_dataframe_data(tmp_nb)
@@ -1561,6 +1585,7 @@ class TestqueryString(TestcaseBase):
         assert collection_w.num_entities == ct.default_nb * thread_num
 
         #Check data consistency after parallel insert
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         df_dict_list = []
         for df in df_list:
@@ -1585,7 +1610,7 @@ class TestqueryString(TestcaseBase):
         # 1. create a collection
         schema = cf.gen_string_pk_default_collection_schema()
         collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix), schema=schema)
-        
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         
         nb = 3000
@@ -1612,7 +1637,7 @@ class TestqueryString(TestcaseBase):
         expected: query successfully
         """
         # 1.  create a collection
-        collection_w, vectors = self.init_collection_general(prefix, insert_data=False)[0:2]
+        collection_w, vectors = self.init_collection_general(prefix, insert_data=False, is_index=True)[0:2]
         
         nb = 3000
         df = cf.gen_default_list_data(nb)
@@ -1620,11 +1645,10 @@ class TestqueryString(TestcaseBase):
 
         collection_w.insert(df)
         assert collection_w.num_entities == nb
-        collection_w.load()
         
         collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
         assert collection_w.has_index()[0]
-
+        collection_w.load()
         
         output_fields = [default_int_field_name, default_float_field_name, default_string_field_name]
         

tests/python_client/testcases/test_search.py

@@ -415,6 +415,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
 
         # 3. search with expression
         log.info("test_search_with_expression: searching with expression: %s" % expression)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         expression = expression.replace("&&", "and").replace("||", "or")
         vectors = [[random.random() for _ in range(dim)] for _ in range(default_nq)]
@@ -561,6 +562,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         # 1. initialize with data
         partition_num = 1
         collection_w = self.init_collection_general(prefix, True, 10, partition_num, is_index=True)[0]
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         par = collection_w.partitions
         par_name = par[partition_num].name
         par[partition_num].load()
@@ -600,6 +602,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
                             check_items={"err_code": 1,
                                          "err_msg": err_msg})
         # 3. search collection without data after load
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.search(vectors[:default_nq], default_search_field, default_search_params,
                             default_limit, default_search_exp,
@@ -633,6 +636,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         collection_w = self.init_collection_general(prefix, partition_num=1)[0]
         par = collection_w.partitions
         # 2. search collection without data after load
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         collection_w.search(vectors[:default_nq], default_search_field, default_search_params,
                             default_limit, default_search_exp,
@@ -667,6 +671,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         deleted_par_name = par[partition_num].name
         collection_w.drop_partition(deleted_par_name)
         log.info("test_search_partition_deleted: deleted a partition")
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # 3. search after delete partitions
         log.info("test_search_partition_deleted: searching deleted partition")
@@ -718,7 +723,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         expected: raise exception and report the error
         """
         # 1. initialize with data
-        collection_w = self.init_collection_general(prefix, True)[0]
+        collection_w = self.init_collection_general(prefix, True, is_index=True)[0]
         # 2. create index
         default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
         collection_w.create_index("float_vector", default_index)
@@ -739,7 +744,7 @@ class TestCollectionSearchInvalid(TestcaseBase):
         expected: raise exception and report the error
         """
         # 1. initialize with binary data
-        collection_w = self.init_collection_general(prefix, True, is_binary=True)[0]
+        collection_w = self.init_collection_general(prefix, True, is_binary=True, is_index=True)[0]
         # 2. create index
         default_index = {"index_type": "BIN_IVF_FLAT", "params": {"nlist": 128}, "metric_type": "JACCARD"}
         collection_w.create_index("binary_vector", default_index)
@@ -1123,6 +1128,7 @@ class TestCollectionSearch(TestcaseBase):
         entity_num = nb - deleted_entity_num
         collection_w.drop_partition(par[partition_num].name)
         log.info("test_search_before_after_delete: deleted a partition")
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # 4. search non-deleted part after delete partitions
         log.info("test_search_before_after_delete: searching after deleting partitions")
@@ -1181,6 +1187,7 @@ class TestCollectionSearch(TestcaseBase):
         # 2. insert data
         insert_ids = cf.insert_data(collection_w, nb, auto_id=auto_id, dim=dim)[3]
         # 3. load data
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # 4. flush and load
         collection_w.num_entities
@@ -1261,6 +1268,7 @@ class TestCollectionSearch(TestcaseBase):
         collection_w.insert(dataframe)
 
         # 2. load and search
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         vectors = [[random.random() for _ in range(dim)] for _ in range(default_nq)]
         collection_w.search(vectors[:default_nq], default_search_field,
@@ -1284,7 +1292,7 @@ class TestCollectionSearch(TestcaseBase):
         """
         # 1. connect, create collection and insert data
         self._connect()
-        collection_w = self.init_collection_general(prefix, False, dim=dim)[0]
+        collection_w = self.init_collection_general(prefix, False, dim=dim, is_index=True)[0]
         dataframe = cf.gen_default_dataframe_data(dim=dim, start=-1500)
         collection_w.insert(dataframe)
 
@@ -1391,6 +1399,7 @@ class TestCollectionSearch(TestcaseBase):
         collection_w = self.init_collection_wrap(name=name, shards_num=shards_num)
         dataframe = cf.gen_default_dataframe_data()
         collection_w.insert(dataframe)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
         collection_w.search(vectors[:default_nq], default_search_field,
@@ -1788,10 +1797,10 @@ class TestCollectionSearch(TestcaseBase):
         collection_w.create_partition(partition_name=partition_name, description="search partition empty")
         par = collection_w.partitions
         log.info("test_search_index_partition_empty: partitions: %s" % par)
-        collection_w.load()
         # 3. create index
         default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
         collection_w.create_index("float_vector", default_index)
+        collection_w.load()
         # 4. search the empty partition
         log.info("test_search_index_partition_empty: searching %s "
                  "entities through empty partition" % default_limit)
@@ -2137,7 +2146,7 @@ class TestCollectionSearch(TestcaseBase):
         collection_w, _vectors, _, insert_ids = self.init_collection_general(prefix, True, nb,
                                                                              is_all_data_type=True,
                                                                              auto_id=auto_id,
-                                                                             dim=dim)[0:4]
+                                                                             dim=dim, is_index=True)[0:4]
 
         # 2. create index
         index_param = {"index_type": "IVF_FLAT", "metric_type": "L2", "params": {"nlist": 100}}
@@ -2289,6 +2298,7 @@ class TestCollectionSearch(TestcaseBase):
             filter_ids.extend(_id)
 
         #3. search with expression
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         expression = "int64_1 <= int64_2"
         vectors = [[random.random() for _ in range(dim)] for _ in range(default_nq)]
@@ -2824,6 +2834,7 @@ class TestCollectionSearch(TestcaseBase):
         dataframe = pd.DataFrame({ct.default_int64_field_name: int_values,
                                   field_name1: int_values, field_name2: float_vec_values})
         collection_w.insert(dataframe)
+        collection_w.create_index(field_name2, index_params=ct.default_flat_index)
         collection_w.load()
         vectors = [[random.random() for _ in range(dim)] for _ in range(nq)]
         collection_w.search(vectors[:nq], field_name2, default_search_params,
@@ -2880,7 +2891,7 @@ class TestCollectionSearch(TestcaseBase):
         self._connect()
         collection_w, _, _, insert_ids = self.init_collection_general(prefix, False, nb,
                                                                       auto_id=auto_id,
-                                                                      dim=dim)[0:4]
+                                                                      dim=dim, is_index=True)[0:4]
         collection_w.create_partition(partition_name)
         insert_ids = cf.insert_data(collection_w, nb, auto_id=auto_id, dim=dim)[3]
         collection_w.create_index(default_search_field, default_index_params, index_name=index_name)
@@ -2966,7 +2977,7 @@ class TestSearchBase(TestcaseBase):
         partition_name = "search_partition_empty"
         collection_w.create_partition(partition_name=partition_name, description="search partition empty")
         par = collection_w.partitions
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         if params.get("m"):
             if (dim % params["m"]) != 0:
@@ -3014,7 +3025,7 @@ class TestSearchBase(TestcaseBase):
         # 2. create patition
         partition_name = ct.default_partition_name
         par = collection_w.partitions
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         if params.get("m"):
             if (dim % params["m"]) != 0:
@@ -3132,7 +3143,7 @@ class TestSearchBase(TestcaseBase):
         partition_name = "search_partition_empty"
         collection_w.create_partition(partition_name=partition_name, description="search partition empty")
         par = collection_w.partitions
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         default_index = {"index_type": index, "params": params, "metric_type": "IP"}
         collection_w.create_index("float_vector", default_index)
@@ -3173,7 +3184,7 @@ class TestSearchBase(TestcaseBase):
         vectors = [[random.random() for _ in range(dim)] for _ in range(nq)]
         # 2. create patition
         par_name = collection_w.partitions[0].name
-        collection_w.load()
+        # collection_w.load()
         # 3. create different index
         default_index = {"index_type": index, "params": params, "metric_type": "IP"}
         collection_w.create_index("float_vector", default_index)
@@ -3196,7 +3207,7 @@ class TestSearchBase(TestcaseBase):
         self._connect()
 
         collection_w, _, _, insert_ids, time_stamp = self.init_collection_general(prefix, True,
-                                                                                  ct.default_nq, is_index=True)[0:5]
+                                                                                  ct.default_nq)[0:5]
         vectors = [[random.random() for _ in range(ct.default_dim)] for _ in range(nq)]
 
         collection_w.load()
@@ -3591,7 +3602,7 @@ class  TestsearchString(TestcaseBase):
         """
         # 1. initialize with data
         collection_w, _, _, insert_ids = \
-            self.init_collection_general(prefix, True, auto_id=auto_id, dim=default_dim)[0:4]
+            self.init_collection_general(prefix, True, auto_id=auto_id, dim=default_dim, is_index=True)[0:4]
         index_param = {"index_type": "IVF_FLAT", "metric_type": "L2", "params": {"nlist": 100}}
         collection_w.create_index("float_vector", index_param, index_name="a")
         index_param_two ={}
@@ -3625,7 +3636,9 @@ class  TestsearchString(TestcaseBase):
         expected: assert index and deleted id not in search result
         """
         # create collection, insert tmp_nb, flush and load
-        collection_w, vectors, _, insert_ids = self.init_collection_general(prefix, insert_data=True, primary_field=ct.default_string_field_name)[0:4]
+        collection_w, vectors, _, insert_ids = self.init_collection_general(prefix, insert_data=True,
+                                                                            primary_field=ct.default_string_field_name,
+                                                                            is_index=True)[0:4]
 
         # create index
         index_params_one = {"index_type": "IVF_SQ8", "metric_type": "L2", "params": {"nlist": 64}}
@@ -3705,7 +3718,7 @@ class  TestsearchString(TestcaseBase):
         """
         # 1. initialize with data
         collection_w, _, _, _= \
-            self.init_collection_general(prefix, False, primary_field=ct.default_int64_field_name)[0:4]
+            self.init_collection_general(prefix, False, primary_field=ct.default_int64_field_name, is_index=True)[0:4]
 
         nb = 3000
         data = cf.gen_default_list_data(nb)

tests/python_client/testcases/test_utility.py

@@ -213,6 +213,7 @@ class TestUtilityParams(TestcaseBase):
         c_name = cf.gen_unique_str(prefix)
         df = cf.gen_default_dataframe_data()
         self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name)
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         error = {ct.err_code: 1, ct.err_msg: "Invalid collection name: {}".format(invalid_c_name)}
         self.utility_wrap.loading_progress(invalid_c_name, check_task=CheckTasks.err_res, check_items=error)
@@ -228,6 +229,7 @@ class TestUtilityParams(TestcaseBase):
         c_name = cf.gen_unique_str(prefix)
         df = cf.gen_default_dataframe_data()
         self.collection_wrap.construct_from_dataframe(c_name, df, primary_field=ct.default_int64_field_name)
+        self.collection_wrap.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         self.collection_wrap.load()
         error = {ct.err_code: 1, ct.err_msg: "describe collection failed: can't find collection"}
         self.utility_wrap.loading_progress("not_existed_name", check_task=CheckTasks.err_res, check_items=error)
@@ -677,7 +679,7 @@ class TestUtilityBase(TestcaseBase):
         cw = self.init_collection_wrap(name=c_name)
         data = cf.gen_default_list_data(nb)
         cw.insert(data=data)
-        error = {ct.err_code: 25, ct.err_msg: "index not exist"}
+        error = {ct.err_code: 25, ct.err_msg: "there is no index on collection"}
         self.utility_wrap.index_building_progress(c_name, check_task=CheckTasks.err_res, check_items=error)
 
     @pytest.mark.tags(CaseLabel.L1)
@@ -810,6 +812,7 @@ class TestUtilityBase(TestcaseBase):
         df = cf.gen_default_dataframe_data()
         collection_w.insert(df)
         assert collection_w.num_entities == ct.default_nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(_async=True)
         res, _ = self.utility_wrap.loading_progress(collection_w.name)
         loading_int = cf.percent_to_int(res[loading_progress])
@@ -826,6 +829,7 @@ class TestUtilityBase(TestcaseBase):
         expected: 0 entities is loaded
         """
         collection_w = self.init_collection_wrap()
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = self.utility_wrap.loading_progress(collection_w.name)
         exp_res = {loading_progress: '100%'}
@@ -932,6 +936,7 @@ class TestUtilityBase(TestcaseBase):
         """
         self._connect()
         cw = self.init_collection_wrap(name=cf.gen_unique_str(prefix))
+        cw.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         cw.load()
         self.utility_wrap.wait_for_loading_complete(cw.name)
         res, _ = self.utility_wrap.loading_progress(cw.name)
@@ -950,6 +955,7 @@ class TestUtilityBase(TestcaseBase):
         df = cf.gen_default_dataframe_data(nb)
         collection_w.insert(df, timeout=60)
         assert collection_w.num_entities == nb
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(_async=True)
         self.utility_wrap.wait_for_loading_complete(collection_w.name)
         res, _ = self.utility_wrap.loading_progress(collection_w.name)
@@ -1414,11 +1420,13 @@ class TestUtilityAdvanced(TestcaseBase):
         """
         c_name = cf.gen_unique_str(prefix)
         collection_w = self.init_collection_wrap(name=c_name)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
         assert len(res) == 0
 
     @pytest.mark.tags(CaseLabel.L1)
+    @pytest.mark.skip("index must created before load, but create_index will trigger flush")
     def test_get_sealed_query_segment_info(self):
         """
         target: test getting sealed query segment info of collection without index
@@ -1432,6 +1440,7 @@ class TestUtilityAdvanced(TestcaseBase):
         df = cf.gen_default_dataframe_data(nb)
         collection_w.insert(df)
         collection_w.num_entities
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
         assert len(res) == 0
@@ -1531,6 +1540,7 @@ class TestUtilityAdvanced(TestcaseBase):
         collection_w.num_entities
         # get growing segments
         collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # prepare load balance params
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
@@ -1568,6 +1578,7 @@ class TestUtilityAdvanced(TestcaseBase):
         collection_w.num_entities
         # get growing segments
         collection_w.insert(df)
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load()
         # prepare load balance params
         res, _ = self.utility_wrap.get_query_segment_info(c_name)
@@ -1681,6 +1692,7 @@ class TestUtilityAdvanced(TestcaseBase):
         collection_w.insert(df)
         # get sealed segments
         collection_w.num_entities
+        collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index)
         collection_w.load(replica_number=2)
         # get growing segments
         collection_w.insert(df)