From 67747245f4030552e57476ef7f9776c159b131f2 Mon Sep 17 00:00:00 2001 From: ThreadDao Date: Fri, 5 Jul 2024 09:10:09 +0800 Subject: [PATCH] test: add test cases for gosdk v2 index (#34431) issue: #33419 - Add test cases for gosdk v2 index - Add sparse index for go client Signed-off-by: ThreadDao --- client/index/common.go | 4 + client/index/ivf.go | 4 +- client/index/scann.go | 4 +- client/index/sparse.go | 63 + tests/go_client/base/milvus_client.go | 4 +- tests/go_client/common/response_checker.go | 4 +- tests/go_client/go.mod | 4 +- tests/go_client/go.sum | 2 - tests/go_client/testcases/delete_test.go | 24 +- .../go_client/testcases/helper/data_helper.go | 2 +- tests/go_client/testcases/helper/helper.go | 2 + .../testcases/helper/index_helper.go | 73 +- tests/go_client/testcases/index_test.go | 1164 +++++++++++++++++ tests/go_client/testcases/query_test.go | 30 +- tests/go_client/testcases/search_test.go | 63 +- tests/go_client/testcases/upsert_test.go | 14 +- 16 files changed, 1375 insertions(+), 86 deletions(-) create mode 100644 client/index/sparse.go create mode 100644 tests/go_client/testcases/index_test.go diff --git a/client/index/common.go b/client/index/common.go index db3b3610c8..162e475ad3 100644 --- a/client/index/common.go +++ b/client/index/common.go @@ -51,6 +51,10 @@ const ( DISKANN IndexType = "DISKANN" SCANN IndexType = "SCANN" + // Sparse + SparseInverted IndexType = "SPARSE_INVERTED_INDEX" + SparseWAND IndexType = "SPARSE_WAND" + GPUIvfFlat IndexType = "GPU_IVF_FLAT" GPUIvfPQ IndexType = "GPU_IVF_PQ" diff --git a/client/index/ivf.go b/client/index/ivf.go index c60cac42c1..fb49f75ddd 100644 --- a/client/index/ivf.go +++ b/client/index/ivf.go @@ -101,7 +101,7 @@ func (idx ivfSQ8Index) Params() map[string]string { } func NewIvfSQ8Index(metricType MetricType, nlist int) Index { - return ivfPQIndex{ + return ivfSQ8Index{ baseIndex: baseIndex{ metricType: metricType, indexType: IvfSQ8, @@ -122,7 +122,7 @@ type binIvfFlat struct { func (idx binIvfFlat) Params() map[string]string { return map[string]string{ MetricTypeKey: string(idx.metricType), - IndexTypeKey: string(IvfSQ8), + IndexTypeKey: string(BinIvfFlat), ivfNlistKey: strconv.Itoa(idx.nlist), } } diff --git a/client/index/scann.go b/client/index/scann.go index 196145be4a..fe69b6cb0d 100644 --- a/client/index/scann.go +++ b/client/index/scann.go @@ -40,12 +40,12 @@ func (idx scannIndex) Params() map[string]string { } func NewSCANNIndex(metricType MetricType, nlist int, withRawData bool) Index { - return ivfFlatIndex{ + return scannIndex{ baseIndex: baseIndex{ metricType: metricType, indexType: SCANN, }, - nlist: nlist, + withRawData: withRawData, } } diff --git a/client/index/sparse.go b/client/index/sparse.go new file mode 100644 index 0000000000..0dec11200c --- /dev/null +++ b/client/index/sparse.go @@ -0,0 +1,63 @@ +package index + +import ( + "fmt" +) + +const ( + dropRatio = `drop_ratio_build` +) + +var _ Index = sparseInvertedIndex{} + +// IndexSparseInverted index type for SPARSE_INVERTED_INDEX +type sparseInvertedIndex struct { + baseIndex + dropRatio float64 +} + +func (idx sparseInvertedIndex) Params() map[string]string { + return map[string]string{ + MetricTypeKey: string(idx.metricType), + IndexTypeKey: string(SparseInverted), + dropRatio: fmt.Sprintf("%v", idx.dropRatio), + } +} + +func NewSparseInvertedIndex(metricType MetricType, dropRatio float64) Index { + return sparseInvertedIndex { + baseIndex: baseIndex{ + metricType: metricType, + indexType: SparseInverted, + }, + + dropRatio: dropRatio, + } +} + +var _ Index = sparseWANDIndex{} +type sparseWANDIndex struct { + baseIndex + dropRatio float64 +} + +func (idx sparseWANDIndex) Params() map[string]string { + return map[string]string{ + MetricTypeKey: string(idx.metricType), + IndexTypeKey: string(SparseWAND), + dropRatio: fmt.Sprintf("%v", idx.dropRatio), + } +} + +// IndexSparseWAND index type for SPARSE_WAND, weak-and +func NewSparseWANDIndex(metricType MetricType, dropRatio float64) Index { + return sparseWANDIndex { + baseIndex: baseIndex{ + metricType: metricType, + indexType: SparseWAND, + }, + + dropRatio: dropRatio, + } +} + diff --git a/tests/go_client/base/milvus_client.go b/tests/go_client/base/milvus_client.go index 911906219b..fd1b29f8d9 100644 --- a/tests/go_client/base/milvus_client.go +++ b/tests/go_client/base/milvus_client.go @@ -180,8 +180,8 @@ func (mc *MilvusClient) ListIndexes(ctx context.Context, option clientv2.ListInd // DescribeIndex Describe Index func (mc *MilvusClient) DescribeIndex(ctx context.Context, option clientv2.DescribeIndexOption, callOptions ...grpc.CallOption) (index.Index, error) { - index, err := mc.mClient.DescribeIndex(ctx, option, callOptions...) - return index, err + idx, err := mc.mClient.DescribeIndex(ctx, option, callOptions...) + return idx, err } // DropIndex Drop Index diff --git a/tests/go_client/common/response_checker.go b/tests/go_client/common/response_checker.go index cffb67ca39..bf75a468fe 100644 --- a/tests/go_client/common/response_checker.go +++ b/tests/go_client/common/response_checker.go @@ -33,7 +33,7 @@ func CheckErr(t *testing.T, actualErr error, expErrNil bool, expErrorMsg ...stri } } if !contains { - t.Fatalf("CheckErr failed, actualErr doesn contains any expErrorMsg, please check test cases!") + t.Fatalf("CheckErr failed, actualErr doesn't contains any expErrorMsg, actual msg:%s", actualErr) } } } @@ -175,4 +175,4 @@ func CheckQueryResult(t *testing.T, expColumns []column.Column, actualColumns [] log.Error("CheckQueryResult actualColumns no column", zap.String("name", expColumn.Name())) } } -} +} \ No newline at end of file diff --git a/tests/go_client/go.mod b/tests/go_client/go.mod index a044205f36..b6c465f9af 100644 --- a/tests/go_client/go.mod +++ b/tests/go_client/go.mod @@ -5,7 +5,7 @@ go 1.21 toolchain go1.21.10 require ( - github.com/milvus-io/milvus/client/v2 v2.0.0-20240703023208-fb61344dc9b5 + github.com/milvus-io/milvus/client/v2 v2.0.0-20240704083609-fcafdb6d5f68 github.com/milvus-io/milvus/pkg v0.0.2-0.20240317152703-17b4938985f3 github.com/quasilyte/go-ruleguard/dsl v0.3.22 github.com/stretchr/testify v1.9.0 @@ -14,7 +14,7 @@ require ( google.golang.org/grpc v1.64.0 ) -// replace github.com/milvus-io/milvus/client/v2 v2.0.0-20240703023208-fb61344dc9b5 => ../../../milvus/client +replace github.com/milvus-io/milvus/client/v2 v2.0.0-20240704083609-fcafdb6d5f68 => ../../../milvus/client require ( github.com/beorn7/perks v1.0.1 // indirect diff --git a/tests/go_client/go.sum b/tests/go_client/go.sum index 5a73cd41cb..9eab44f9d5 100644 --- a/tests/go_client/go.sum +++ b/tests/go_client/go.sum @@ -403,8 +403,6 @@ github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/le github.com/miekg/dns v1.0.14/go.mod h1:W1PPwlIAgtquWBMBEV9nkV9Cazfe8ScdGz/Lj7v3Nrg= github.com/milvus-io/milvus-proto/go-api/v2 v2.4.3 h1:KUSaWVePVlHMIluAXf2qmNffI1CMlGFLLiP+4iy9014= github.com/milvus-io/milvus-proto/go-api/v2 v2.4.3/go.mod h1:1OIl0v5PQeNxIJhCvY+K55CBUOYDZevw9g9380u1Wek= -github.com/milvus-io/milvus/client/v2 v2.0.0-20240703023208-fb61344dc9b5 h1:jsMriUhlv82KS34VV6y/SDpeL+MEWcO6nR4Ur1diEf8= -github.com/milvus-io/milvus/client/v2 v2.0.0-20240703023208-fb61344dc9b5/go.mod h1:13uL9ukc9KRK5ZtWqWwaORWlRccZLIysZzT6KUlOx+A= github.com/milvus-io/milvus/pkg v0.0.2-0.20240317152703-17b4938985f3 h1:ZBpRWhBa7FTFxW4YYVv9AUESoW1Xyb3KNXTzTqfkZmw= github.com/milvus-io/milvus/pkg v0.0.2-0.20240317152703-17b4938985f3/go.mod h1:jQ2BUZny1COsgv1Qbcv8dmbppW+V9J/c4YQZNb3EOm8= github.com/mitchellh/cli v1.0.0/go.mod h1:hNIlj7HEI86fIcpObd7a0FcrxTWetlwJDGcceTlRvqc= diff --git a/tests/go_client/testcases/delete_test.go b/tests/go_client/testcases/delete_test.go index 2e5728c771..6be0a8f4a4 100644 --- a/tests/go_client/testcases/delete_test.go +++ b/tests/go_client/testcases/delete_test.go @@ -28,7 +28,7 @@ func TestDelete(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load collection - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // delete with expr @@ -64,7 +64,7 @@ func TestDeleteVarcharPks(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load collection - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // delete varchar with pk @@ -101,7 +101,7 @@ func TestDeleteEmptyCollection(t *testing.T) { require.Equal(t, int64(1), delRes.DeleteCount) // delete complex expr from empty collection - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) comExpr := fmt.Sprintf("%s < 10", common.DefaultInt64FieldName) @@ -154,7 +154,7 @@ func TestDeleteComplexExprWithoutLoad(t *testing.T) { common.CheckErr(t, errDelete2, false, "collection not loaded") // index and load collection - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) res, err := mc.Query(ctx, client.NewQueryOption(schema.CollectionName).WithFilter(fmt.Sprintf("%s >= 0 ", common.DefaultInt64FieldName)). @@ -205,7 +205,7 @@ func TestDeleteVarcharEmptyIds(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load collection - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) exprQuery := "varchar != '' " @@ -274,7 +274,7 @@ func TestDeleteWithIds(t *testing.T) { _, err = mc.Insert(ctx, insertOpt) common.CheckErr(t, err, true) // index and load - hp.CollPrepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + hp.CollPrepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) hp.CollPrepare.Load(ctx, t, mc, hp.NewLoadParams(collName)) // delete with non-pk fields ids @@ -310,7 +310,7 @@ func TestDeleteDefaultPartitionName(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // delete with default params, actually delete from all partitions @@ -348,7 +348,7 @@ func TestDeleteEmptyPartitionName(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // delete with default params, actually delete from all partitions @@ -386,7 +386,7 @@ func TestDeletePartitionName(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // delete with default params, actually delete from all partitions @@ -489,7 +489,7 @@ func TestDeleteComplexExpr(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) log.Debug("TestDeleteComplexExpr", zap.Any("expr", exprLimit.expr)) @@ -518,7 +518,7 @@ func TestDeleteInvalidExpr(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) for _, _invalidExpr := range common.InvalidExpressions { @@ -541,7 +541,7 @@ func TestDeleteDuplicatedPks(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) // index and load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // delete diff --git a/tests/go_client/testcases/helper/data_helper.go b/tests/go_client/testcases/helper/data_helper.go index a43a56d851..4fa11bb708 100644 --- a/tests/go_client/testcases/helper/data_helper.go +++ b/tests/go_client/testcases/helper/data_helper.go @@ -249,7 +249,7 @@ func GenDefaultJSONData(nb int, option GenDataOption) [][]byte { return jsonValues } -// GenColumnData GenColumnDataOption +// GenColumnData GenColumnDataOption except dynamic column func GenColumnData(nb int, fieldType entity.FieldType, option GenDataOption) column.Column { dim := option.dim sparseMaxLen := option.sparseMaxLen diff --git a/tests/go_client/testcases/helper/helper.go b/tests/go_client/testcases/helper/helper.go index b3b0f770dd..4f14c10935 100644 --- a/tests/go_client/testcases/helper/helper.go +++ b/tests/go_client/testcases/helper/helper.go @@ -2,6 +2,7 @@ package helper import ( "context" + "github.com/stretchr/testify/require" "testing" "time" @@ -141,6 +142,7 @@ func (chainTask *CollectionPrepare) InsertData(ctx context.Context, t *testing.T } insertRes, err := mc.Insert(ctx, insertOpt) common.CheckErr(t, err, true) + require.Equal(t, option.nb, insertRes.IDs.Len()) return chainTask, insertRes } diff --git a/tests/go_client/testcases/helper/index_helper.go b/tests/go_client/testcases/helper/index_helper.go index e18c3280a7..19d9d9f122 100644 --- a/tests/go_client/testcases/helper/index_helper.go +++ b/tests/go_client/testcases/helper/index_helper.go @@ -3,7 +3,6 @@ package helper import ( "github.com/milvus-io/milvus/client/v2/entity" "github.com/milvus-io/milvus/client/v2/index" - "github.com/milvus-io/milvus/tests/go_client/common" ) func GetDefaultVectorIndex(fieldType entity.FieldType) index.Index { @@ -11,13 +10,11 @@ func GetDefaultVectorIndex(fieldType entity.FieldType) index.Index { case entity.FieldTypeFloatVector, entity.FieldTypeFloat16Vector, entity.FieldTypeBFloat16Vector: return index.NewHNSWIndex(entity.COSINE, 8, 200) case entity.FieldTypeBinaryVector: - return index.NewGenericIndex(common.DefaultBinaryVecFieldName, map[string]string{"nlist": "64", index.MetricTypeKey: "JACCARD", index.IndexTypeKey: "BIN_IVF_FLAT"}) - // return binary index + return index.NewBinIvfFlatIndex(entity.JACCARD, 64) case entity.FieldTypeSparseVector: - return index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.1", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_INVERTED_INDEX"}) + return index.NewSparseInvertedIndex(entity.IP, 0.1) default: - return nil - // return auto index + return index.NewAutoIndex(entity.COSINE) } } @@ -26,7 +23,7 @@ type IndexParams struct { FieldIndexMap map[string]index.Index } -func NewIndexParams(schema *entity.Schema) *IndexParams { +func TNewIndexParams(schema *entity.Schema) *IndexParams { return &IndexParams{ Schema: schema, } @@ -36,3 +33,65 @@ func (opt *IndexParams) TWithFieldIndex(mFieldIndex map[string]index.Index) *Ind opt.FieldIndexMap = mFieldIndex return opt } + +/* +utils func +*/ +var SupportFloatMetricType = []entity.MetricType{ + entity.L2, + entity.IP, + entity.COSINE, +} + +var SupportBinFlatMetricType = []entity.MetricType{ + entity.JACCARD, + entity.HAMMING, + entity.SUBSTRUCTURE, + entity.SUPERSTRUCTURE, +} + +var SupportBinIvfFlatMetricType = []entity.MetricType{ + entity.JACCARD, + entity.HAMMING, +} + +var UnsupportedSparseVecMetricsType = []entity.MetricType{ + entity.L2, + entity.COSINE, + entity.JACCARD, + entity.HAMMING, + entity.SUBSTRUCTURE, + entity.SUPERSTRUCTURE, +} + + +// GenAllFloatIndex gen all float vector index +func GenAllFloatIndex(metricType entity.MetricType) []index.Index { + nlist := 128 + var allFloatIndex []index.Index + + idxFlat := index.NewFlatIndex(metricType) + idxIvfFlat := index.NewIvfFlatIndex(metricType, nlist) + idxIvfSq8 := index.NewIvfSQ8Index(metricType, nlist) + idxIvfPq := index.NewIvfPQIndex(metricType, nlist, 16, 8) + idxHnsw := index.NewHNSWIndex(metricType, 8, 96) + idxScann := index.NewSCANNIndex(metricType, 16, true) + idxDiskAnn := index.NewDiskANNIndex(metricType) + allFloatIndex = append(allFloatIndex, idxFlat, idxIvfFlat, idxIvfSq8, idxIvfPq, idxHnsw, idxScann, idxDiskAnn) + + return allFloatIndex +} + +func SupportScalarIndexFieldType(field entity.FieldType) bool { + vectorFieldTypes := []entity.FieldType{ + entity.FieldTypeBinaryVector, entity.FieldTypeFloatVector, + entity.FieldTypeFloat16Vector, entity.FieldTypeBFloat16Vector, + entity.FieldTypeSparseVector, entity.FieldTypeJSON, + } + for _, vectorFieldType := range vectorFieldTypes { + if field == vectorFieldType { + return false + } + } + return true +} \ No newline at end of file diff --git a/tests/go_client/testcases/index_test.go b/tests/go_client/testcases/index_test.go new file mode 100644 index 0000000000..9604e5f854 --- /dev/null +++ b/tests/go_client/testcases/index_test.go @@ -0,0 +1,1164 @@ +package testcases + +import ( + "fmt" + "testing" + "time" + + "github.com/milvus-io/milvus/client/v2" + "github.com/milvus-io/milvus/client/v2/entity" + "github.com/milvus-io/milvus/client/v2/index" + "github.com/milvus-io/milvus/pkg/log" + "github.com/milvus-io/milvus/tests/go_client/common" + hp "github.com/milvus-io/milvus/tests/go_client/testcases/helper" + "github.com/stretchr/testify/require" + "go.uber.org/zap" +) + +func TestIndexVectorDefault(t *testing.T) { + t.Parallel() + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // index + for _, idx := range hp.GenAllFloatIndex(entity.L2) { + log.Debug("index", zap.String("name", idx.Name()), zap.Any("indexType", idx.IndexType()), zap.Any("params", idx.Params())) + for _, fieldName := range []string{common.DefaultFloat16VecFieldName, common.DefaultBFloat16VecFieldName, common.DefaultFloatVecFieldName} { + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, fieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, fieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, index.NewGenericIndex(fieldName, idx.Params()), descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, descIdx.Name())) + common.CheckErr(t, err, true) + } + } +} + +func TestIndexVectorIP(t *testing.T) { + t.Parallel() + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // index + for _, idx := range hp.GenAllFloatIndex(entity.IP) { + log.Debug("index", zap.String("name", idx.Name()), zap.Any("indexType", idx.IndexType()), zap.Any("params", idx.Params())) + for _, fieldName := range []string{common.DefaultFloat16VecFieldName, common.DefaultBFloat16VecFieldName, common.DefaultFloatVecFieldName} { + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, fieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(fieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, fieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) + } + } +} + +func TestIndexVectorCosine(t *testing.T) { + t.Parallel() + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // index + for _, idx := range hp.GenAllFloatIndex(entity.COSINE) { + log.Debug("index", zap.String("name", idx.Name()), zap.Any("indexType", idx.IndexType()), zap.Any("params", idx.Params())) + for _, fieldName := range []string{common.DefaultFloat16VecFieldName, common.DefaultBFloat16VecFieldName, common.DefaultFloatVecFieldName} { + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, fieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(fieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, fieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) + } + } +} + +func TestIndexAutoFloatVector(t *testing.T) { + t.Parallel() + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + + for _, invalidMt := range hp.SupportBinFlatMetricType { + idx := index.NewAutoIndex(invalidMt) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idx)) + common.CheckErr(t, err, false, fmt.Sprintf("float vector index does not support metric type: %s", invalidMt)) + } + // auto index with different metric type on float vec + for _, mt := range hp.SupportFloatMetricType { + idx := index.NewAutoIndex(mt) + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(common.DefaultFloatVecFieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) + } +} + +func TestIndexAutoBinaryVector(t *testing.T) { + t.Parallel() + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.VarcharBinary) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // auto index with different metric type on float vec + for _, unsupportedMt := range []entity.MetricType{entity.L2, entity.COSINE, entity.IP, entity.TANIMOTO, entity.SUPERSTRUCTURE, entity.SUBSTRUCTURE} { + idx := index.NewAutoIndex(unsupportedMt) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idx)) + common.CheckErr(t, err, false, fmt.Sprintf("binary vector index does not support metric type: %s", unsupportedMt), + "metric type SUPERSTRUCTURE not found or not supported, supported: [HAMMING JACCARD]", + "metric type SUBSTRUCTURE not found or not supported, supported: [HAMMING JACCARD]") + } + + // auto index with different metric type on binary vec + for _, mt := range hp.SupportBinIvfFlatMetricType { + idx := index.NewAutoIndex(mt) + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(common.DefaultBinaryVecFieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) + } +} + +func TestIndexAutoSparseVector(t *testing.T) { + t.Parallel() + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // auto index with different metric type on float vec + for _, unsupportedMt := range hp.UnsupportedSparseVecMetricsType { + idx := index.NewAutoIndex(unsupportedMt) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idx)) + common.CheckErr(t, err, false, "only IP is the supported metric type for sparse index") + } + + // auto index with different metric type on sparse vec + idx := index.NewAutoIndex(entity.IP) + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(common.DefaultSparseVecFieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) +} + +// test create auto index on all vector and scalar index +func TestCreateAutoIndexAllFields(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.AllFields) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + var expFields []string + var idx index.Index + for _, field := range schema.Fields { + if field.DataType == entity.FieldTypeArray || field.DataType == entity.FieldTypeJSON{ + idx = index.NewAutoIndex(entity.IP) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, false, fmt.Sprintf("create auto index on %s field is not supported", field.DataType)) + } else { + if field.DataType == entity.FieldTypeBinaryVector { + idx = index.NewAutoIndex(entity.JACCARD) + } else { + idx = index.NewAutoIndex(entity.IP) + } + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + // describe index + descIdx, descErr := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, field.Name)) + common.CheckErr(t, descErr, true) + require.EqualValues(t, index.NewGenericIndex(field.Name, idx.Params()), descIdx) + } + expFields = append(expFields, field.Name) + } + + // load -> search and output all vector fields + prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) + queryVec := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector) + searchRes, err := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, queryVec).WithANNSField(common.DefaultFloatVecFieldName).WithOutputFields([]string{"*"})) + common.CheckErr(t, err, true) + common.CheckOutputFields(t, expFields, searchRes[0].Fields) +} + +func TestIndexBinaryFlat(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.VarcharBinary) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index for all binary + for _, metricType := range hp.SupportBinFlatMetricType { + idx := index.NewBinFlatIndex(metricType) + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(common.DefaultBinaryVecFieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) + } +} + +func TestIndexBinaryIvfFlat(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.VarcharBinary) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index for all binary + for _, metricType := range hp.SupportBinIvfFlatMetricType { + idx := index.NewBinIvfFlatIndex(metricType, 32) + indexTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idx)) + common.CheckErr(t, err, true) + err = indexTask.Await(ctx) + common.CheckErr(t, err, true) + + expIdx := index.NewGenericIndex(common.DefaultBinaryVecFieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIdx, descIdx) + + // drop index + err = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, expIdx.Name())) + common.CheckErr(t, err, true) + } +} + +// test create binary index with unsupported metrics type +func TestCreateBinaryIndexNotSupportedMetricType(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.VarcharBinary) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create BinIvfFlat, BinFlat index with not supported metric type + invalidMetricTypes := []entity.MetricType{ + entity.L2, + entity.COSINE, + entity.IP, + entity.TANIMOTO, + } + for _, metricType := range invalidMetricTypes { + // create BinFlat + idxBinFlat := index.NewBinFlatIndex(metricType) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idxBinFlat)) + common.CheckErr(t, err, false, fmt.Sprintf("binary vector index does not support metric type: %v", metricType)) + } + + invalidMetricTypes2 := []entity.MetricType{ + entity.L2, + entity.COSINE, + entity.IP, + entity.TANIMOTO, + entity.SUBSTRUCTURE, + entity.SUPERSTRUCTURE, + } + + for _, metricType := range invalidMetricTypes2 { + // create BinIvfFlat index + idxBinIvfFlat := index.NewBinIvfFlatIndex(metricType, 64) + _, errIvf := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idxBinIvfFlat)) + common.CheckErr(t, errIvf, false, fmt.Sprintf("binary vector index does not support metric type: %s", metricType), + "supported: [HAMMING JACCARD]") + } +} + +func TestIndexInvalidMetricType(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + _, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + for _, mt := range []entity.MetricType{entity.HAMMING, entity.JACCARD, entity.TANIMOTO, entity.SUBSTRUCTURE, entity.SUPERSTRUCTURE} { + idxScann := index.NewSCANNIndex(mt, 64, true) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxScann)) + common.CheckErr(t, err, false, + fmt.Sprintf("float vector index does not support metric type: %s", mt)) + + idxFlat := index.NewFlatIndex(mt) + _, err1 := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxFlat)) + common.CheckErr(t, err1, false, + fmt.Sprintf("float vector index does not support metric type: %s", mt)) + } +} + +// Trie scalar Trie index only supported on varchar +func TestCreateTrieScalarIndex(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create Trie scalar index on varchar field + idx := index.NewTrieIndex() + for _, field := range schema.Fields { + if hp.SupportScalarIndexFieldType(field.DataType) { + if field.DataType == entity.FieldTypeVarChar { + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + // describe index + expIndex := index.NewGenericIndex(field.Name, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, field.Name)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIndex, descIdx) + } else { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, false, "TRIE are only supported on varchar field") + } + } + } +} + +// Sort scalar index only supported on numeric field +func TestCreateSortedScalarIndex(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) + + // create Trie scalar index on varchar field + idx := index.NewSortedIndex() + for _, field := range schema.Fields { + if hp.SupportScalarIndexFieldType(field.DataType) { + if field.DataType == entity.FieldTypeVarChar || field.DataType == entity.FieldTypeBool || + field.DataType == entity.FieldTypeJSON || field.DataType == entity.FieldTypeArray { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, false, "STL_SORT are only supported on numeric field") + } else { + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + // describe index + expIndex := index.NewGenericIndex(field.Name, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, field.Name)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIndex, descIdx) + } + } + } + // load -> search and output all fields + prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) + + queryVec := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector) + expr := fmt.Sprintf("%s > 10", common.DefaultInt64FieldName) + searchRes, err := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, queryVec).WithFilter(expr).WithOutputFields([]string{"*"})) + common.CheckErr(t, err, true) + expFields := make([]string, 0, len(schema.Fields)) + for _, field := range schema.Fields { + expFields = append(expFields, field.Name) + } + common.CheckOutputFields(t, expFields, searchRes[0].Fields) +} + +// create Inverted index for all scalar fields +func TestCreateInvertedScalarIndex(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) + + // create Trie scalar index on varchar field + idx := index.NewInvertedIndex() + for _, field := range schema.Fields { + if hp.SupportScalarIndexFieldType(field.DataType) { + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + // describe index + expIndex := index.NewGenericIndex(field.Name, idx.Params()) + _index, _ := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, field.Name)) + require.EqualValues(t, expIndex, _index) + } + } + // load -> search and output all fields + prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) + + queryVec := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector) + expr := fmt.Sprintf("%s > 10", common.DefaultInt64FieldName) + searchRes, err := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, queryVec).WithFilter(expr).WithOutputFields([]string{"*"})) + common.CheckErr(t, err, true) + expFields := make([]string, 0, len(schema.Fields)) + for _, field := range schema.Fields { + expFields = append(expFields, field.Name) + } + common.CheckOutputFields(t, expFields, searchRes[0].Fields) +} + +// test create index on vector field -> error +func TestCreateScalarIndexVectorField(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + for _, idx := range []index.Index{index.NewInvertedIndex(), index.NewSortedIndex(), index.NewTrieIndex()} { + for _, fieldName := range []string{common.DefaultFloatVecFieldName, common.DefaultBinaryVecFieldName, + common.DefaultBFloat16VecFieldName, common.DefaultFloat16VecFieldName} { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, fieldName, idx)) + common.CheckErr(t, err, false, "metric type not set for vector index") + } + } +} + +// test create scalar index with vector field name +func TestCreateIndexWithOtherFieldName(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.VarcharBinary) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index with vector field name as index name (vector field name is the vector default index name) + idx := index.NewInvertedIndex() + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultVarcharFieldName, idx).WithIndexName(common.DefaultBinaryVecFieldName)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + // describe index + expIndex := index.NewGenericIndex(common.DefaultBinaryVecFieldName, idx.Params()) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, expIndex, descIdx) + + // create index in binary field with default name + idxBinary := index.NewBinFlatIndex(entity.JACCARD) + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultBinaryVecFieldName, idxBinary)) + common.CheckErr(t, err, false, "CreateIndex failed: at most one distinct index is allowed per field") +} + +// create all scalar index on json field -> error +func TestCreateIndexJsonField(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecJSON) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create vector index on json field + idx := index.NewSCANNIndex(entity.L2, 8, false) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultJSONFieldName, idx).WithIndexName("json_index")) + common.CheckErr(t, err, false, "data type should be FloatVector, Float16Vector or BFloat16Vector") + + //create scalar index on json field + type scalarIndexError struct { + idx index.Index + errMsg string + } + inxError := []scalarIndexError{ + {index.NewInvertedIndex(), "INVERTED are not supported on JSON field"}, + {index.NewSortedIndex(), "STL_SORT are only supported on numeric field"}, + {index.NewTrieIndex(), "TRIE are only supported on varchar field"}, + } + for _, idxErr := range inxError { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultJSONFieldName, idxErr.idx).WithIndexName("json_index")) + common.CheckErr(t, err, false, idxErr.errMsg) + } +} + +// array field on supported array field +func TestCreateUnsupportedIndexArrayField(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecArray) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + type scalarIndexError struct { + idx index.Index + errMsg string + } + inxError := []scalarIndexError{ + {index.NewSortedIndex(), "STL_SORT are only supported on numeric field"}, + {index.NewTrieIndex(), "TRIE are only supported on varchar field"}, + } + + // create scalar and vector index on array field + vectorIdx := index.NewSCANNIndex(entity.L2, 10, false) + for _, idxErr := range inxError { + for _, field := range schema.Fields { + if field.DataType == entity.FieldTypeArray { + // create vector index + _, err1 := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, vectorIdx).WithIndexName("vector_index")) + common.CheckErr(t, err1, false, "data type should be FloatVector, Float16Vector or BFloat16Vector") + + // create scalar index + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idxErr.idx)) + common.CheckErr(t, err, false, idxErr.errMsg) + } + } + } +} + +// create inverted index on array field +func TestCreateInvertedIndexArrayField(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecArray) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) + + // create scalar and vector index on array field + for _, field := range schema.Fields { + if field.DataType == entity.FieldTypeArray { + log.Debug("array field", zap.String("name", field.Name), zap.Any("element type", field.ElementType)) + + // create scalar index + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, index.NewInvertedIndex())) + common.CheckErr(t, err, true) + } + } + + // load -> search and output all fields + prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) + queryVec := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector) + searchRes, errSearch := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, queryVec).WithConsistencyLevel(entity.ClStrong).WithOutputFields([]string{"*"})) + common.CheckErr(t, errSearch, true) + var expFields []string + for _, field := range schema.Fields { + expFields = append(expFields, field.Name) + } + common.CheckSearchResult(t, searchRes, common.DefaultNq, common.DefaultLimit) + common.CheckOutputFields(t, expFields, searchRes[0].Fields) +} + +// test create index without specify index name: default index name is field name +func TestCreateIndexWithoutName(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index + idx := index.NewHNSWIndex(entity.L2, 8, 96) + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + // describe index return index with default name + idxDesc, _ := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName)) + expIndex := index.NewGenericIndex(common.DefaultFloatVecFieldName, idx.Params()) + require.Equal(t, common.DefaultFloatVecFieldName, idxDesc.Name()) + require.EqualValues(t, expIndex, idxDesc) +} + +// test create index on same field twice +func TestCreateIndexDup(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption()) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // index dup + idxHnsw := index.NewHNSWIndex(entity.L2, 8, 96) + idxIvfSq8 := index.NewIvfSQ8Index(entity.L2, 128) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxHnsw)) + common.CheckErr(t, err, true) + + // describe index + _index, _ := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName)) + expIndex := index.NewGenericIndex(common.DefaultFloatVecFieldName, idxHnsw.Params()) + require.EqualValues(t, expIndex, _index) + + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxIvfSq8)) + common.CheckErr(t, err, false, "CreateIndex failed: at most one distinct index is allowed per field") +} + +func TestCreateIndexSparseVectorGeneric(t *testing.T) { + t.Parallel() + idxInverted := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.2", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_INVERTED_INDEX"}) + idxWand := index.NewGenericIndex(common.DefaultSparseVecFieldName, map[string]string{"drop_ratio_build": "0.3", index.MetricTypeKey: "IP", index.IndexTypeKey: "SPARSE_WAND"}) + + for _, idx := range []index.Index{idxInverted, idxWand} { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption().TWithSparseMaxLen(100)) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, index.NewGenericIndex(common.DefaultSparseVecFieldName, idx.Params()), descIdx) + } +} + +func TestCreateIndexSparseVector(t *testing.T) { + t.Parallel() + idxInverted1 := index.NewSparseInvertedIndex(entity.IP, 0.2) + idxWand1 := index.NewSparseWANDIndex(entity.IP, 0.3) + for _, idx := range []index.Index{idxInverted1, idxWand1} { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption().TWithSparseMaxLen(100)) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // describe index + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName)) + common.CheckErr(t, err, true) + require.EqualValues(t, index.NewGenericIndex(common.DefaultSparseVecFieldName, idx.Params()), descIdx) + } +} + +func TestCreateSparseIndexInvalidParams(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption().TWithSparseMaxLen(100)) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index with invalid metric type + for _, mt := range hp.UnsupportedSparseVecMetricsType { + idxInverted := index.NewSparseInvertedIndex(mt, 0.2) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idxInverted)) + common.CheckErr(t, err, false, "only IP is the supported metric type for sparse index") + + idxWand := index.NewSparseWANDIndex(mt, 0.2) + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idxWand)) + common.CheckErr(t, err, false, "only IP is the supported metric type for sparse index") + } + + // create index with invalid drop_ratio_build + for _, drb := range []float64{-0.3, 1.3} { + idxInverted := index.NewSparseInvertedIndex(entity.IP, drb) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idxInverted)) + common.CheckErr(t, err, false, "must be in range [0, 1)") + + idxWand := index.NewSparseWANDIndex(entity.IP, drb) + _, err1 := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idxWand)) + common.CheckErr(t, err1, false, "must be in range [0, 1)") + } +} + +// create sparse unsupported index: other vector index and scalar index and auto index +func TestCreateSparseUnsupportedIndex(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption().TWithSparseMaxLen(100)) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create unsupported vector index on sparse field + for _, idx := range hp.GenAllFloatIndex(entity.IP) { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idx)) + common.CheckErr(t, err, false, fmt.Sprintf("data type 104 can't build with this index %v", idx.IndexType())) + } + + // create scalar index on sparse vector + for _, idx := range []index.Index{ + index.NewTrieIndex(), + index.NewSortedIndex(), + index.NewInvertedIndex(), + } { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultSparseVecFieldName, idx)) + common.CheckErr(t, err, false, "metric type not set for vector index") + } +} + +// test new index by Generic index +func TestCreateIndexGeneric(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption().TWithSparseMaxLen(100)) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index + for _, field := range schema.Fields { + idx := index.NewGenericIndex(field.Name, map[string]string{index.IndexTypeKey: string(index.AUTOINDEX), index.MetricTypeKey: string(entity.COSINE)}) + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + common.CheckErr(t, err, true) + + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, field.Name)) + common.CheckErr(t, err, true) + require.EqualValues(t, index.NewGenericIndex(field.Name, idx.Params()), descIdx) + } +} + +// test create index with not exist index name and not exist field name +func TestIndexNotExistName(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + // create index with not exist collection + idx := index.NewHNSWIndex(entity.L2, 8, 96) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption("haha", common.DefaultFloatVecFieldName, idx)) + common.CheckErr(t, err, false, "collection not found") + + // create index with not exist field name + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + _, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + _, err1 := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, "aaa", idx)) + common.CheckErr(t, err1, false, "cannot create index on non-exist field: aaa") + + // describe index with not exist field name + _, errDesc := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, "aaa")) + common.CheckErr(t, errDesc, false, "index not found[indexName=aaa]") + + // drop index with not exist field name + errDrop := mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, "aaa")) + common.CheckErr(t, errDrop, true) +} + +// test create float / binary / sparse vector index on non-vector field +func TestCreateVectorIndexScalarField(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64VecAllScalar) + _, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // create index + for _, field := range schema.Fields { + if field.DataType < 100 { + // create float vector index on scalar field + for _, idx := range hp.GenAllFloatIndex(entity.COSINE) { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idx)) + common.CheckErr(t, err, false, "can't build hnsw in not vector type", + "data type should be FloatVector, Float16Vector or BFloat16Vector") + } + + // create binary vector index on scalar field + for _, idxBinary := range []index.Index{index.NewBinFlatIndex(entity.IP), index.NewBinIvfFlatIndex(entity.COSINE, 64)} { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idxBinary)) + common.CheckErr(t, err, false, "binary vector is only supported") + } + + // create sparse vector index on scalar field + for _, idxSparse := range []index.Index{index.NewSparseInvertedIndex(entity.IP, 0.2), index.NewSparseWANDIndex(entity.IP, 0.3)} { + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, field.Name, idxSparse)) + common.CheckErr(t, err, false, "only sparse float vector is supported for the specified index") + } + } + } +} + +// test create index with invalid params +func TestCreateIndexInvalidParams(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + _, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // invalid IvfFlat nlist [1, 65536] + errMsg := "nlist out of range: [1, 65536]" + for _, invalidNlist := range []int{0, -1, 65536 + 1} { + // IvfFlat + idxIvfFlat := index.NewIvfFlatIndex(entity.L2, invalidNlist) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxIvfFlat)) + common.CheckErr(t, err, false, errMsg) + // IvfSq8 + idxIvfSq8 := index.NewIvfSQ8Index(entity.L2, invalidNlist) + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxIvfSq8)) + common.CheckErr(t, err, false, errMsg) + // IvfPq + idxIvfPq := index.NewIvfPQIndex(entity.L2, invalidNlist, 16, 8) + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxIvfPq)) + common.CheckErr(t, err, false, errMsg) + // scann + idxScann := index.NewSCANNIndex(entity.L2, invalidNlist, true) + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxScann)) + common.CheckErr(t, err, false, errMsg) + } + + // invalid IvfPq params m dim ≡ 0 (mod m), nbits [1, 16] + t.Log("https://github.com/milvus-io/milvus/issues/34426") + /*for _, invalidNBits := range []int{0, 17} { + // IvfFlat + idxIvfPq := index.NewIvfPQIndex(entity.L2, 128, 8, invalidNBits) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxIvfPq)) + common.CheckErr(t, err, false, "nbits has to be in range [1, 16]") + }*/ + + // TODO unclear error message + idxIvfPq := index.NewIvfPQIndex(entity.L2, 128, 7, 8) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxIvfPq)) + common.CheckErr(t, err, false, "dimension must be able to be divided by `m`") + + // invalid Hnsw M [1, 2048], efConstruction [1, 2147483647] + for _, invalidM := range []int{0, 2049} { + // IvfFlat + idxHnsw := index.NewHNSWIndex(entity.L2, invalidM, 96) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxHnsw)) + common.CheckErr(t, err, false, "M out of range: [1, 2048]") + } + for _, invalidEfConstruction := range []int{0, 2147483647 + 1} { + // IvfFlat + idxHnsw := index.NewHNSWIndex(entity.L2, 8, invalidEfConstruction) + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxHnsw)) + common.CheckErr(t, err, false, "efConstruction out of range: [1, 2147483647]") + } +} + +// test create index with nil index +func TestCreateIndexNil(t *testing.T) { + t.Skip("Issue: https://github.com/milvus-io/milvus-sdk-go/issues/358") + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + _, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, nil)) + common.CheckErr(t, err, false, "invalid index") +} + +// test create index async true +func TestCreateIndexAsync(t *testing.T) { + t.Log("wait GetIndexState") + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64Vec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption().TWithSparseMaxLen(100)) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index + _, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, index.NewHNSWIndex(entity.L2, 8, 96))) + common.CheckErr(t, err, true) + + idx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName)) + log.Debug("describe index", zap.Any("descIdx", idx)) +} + +// create same index name on different vector field +func TestIndexMultiVectorDupName(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index with same indexName on different fields + idx := index.NewHNSWIndex(entity.COSINE, 8, 96) + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idx).WithIndexName("index_1")) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + + _, err = mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloat16VecFieldName, idx).WithIndexName("index_1")) + common.CheckErr(t, err, false, "CreateIndex failed: at most one distinct index is allowed per field") + + // create different index on same field + idxRe := index.NewIvfSQ8Index(entity.COSINE, 32) + _, errRe := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idxRe).WithIndexName("index_2")) + common.CheckErr(t, errRe, false, "CreateIndex failed: creating multiple indexes on same field is not supported") +} + +func TestDropIndex(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index with indexName + idxName := "index_1" + idx := index.NewHNSWIndex(entity.COSINE, 8, 96) + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idx).WithIndexName(idxName)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + + // describe index with fieldName -> not found + _, errNotFound := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName)) + common.CheckErr(t, errNotFound, false, "index not found") + + // describe index with index name -> ok + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, idxName)) + require.EqualValues(t, index.NewGenericIndex(idxName, idx.Params()), descIdx) + + // drop index with field name + errDrop := mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName)) + common.CheckErr(t, errDrop, true) + descIdx, err = mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, err, true) + require.EqualValues(t, index.NewGenericIndex(idxName, idx.Params()), descIdx) + + // drop index with index name + errDrop = mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, errDrop, true) + _idx, errDescribe := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, errDescribe, false, "index not found") + require.Nil(t, _idx) +} + +func TestDropIndexCreateIndexWithIndexName(t *testing.T) { + ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout) + mc := createDefaultMilvusClient(ctx, t) + + cp := hp.NewCreateCollectionParams(hp.Int64MultiVec) + prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, cp, hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) + + // insert + ip := hp.NewInsertParams(schema, common.DefaultNb) + prepare.InsertData(ctx, t, mc, ip, hp.TNewDataOption()) + prepare.FlushData(ctx, t, mc, schema.CollectionName) + + // create index with same indexName on different fields + // create index: index_1 on vector + idxName := "index_1" + idx := index.NewHNSWIndex(entity.COSINE, 8, 96) + idxTask, err := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, idx).WithIndexName(idxName)) + common.CheckErr(t, err, true) + err = idxTask.Await(ctx) + descIdx, err := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, err, true) + require.EqualValues(t, index.NewGenericIndex(idxName, idx.Params()), descIdx) + + // drop index + errDrop := mc.DropIndex(ctx, client.NewDropIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, errDrop, true) + _idx, errDescribe := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, errDescribe, false, "index not found") + require.Nil(t, _idx) + + // create new IP index + ipIdx := index.NewHNSWIndex(entity.IP, 8, 96) + idxTask, err2 := mc.CreateIndex(ctx, client.NewCreateIndexOption(schema.CollectionName, common.DefaultFloatVecFieldName, ipIdx).WithIndexName(idxName)) + common.CheckErr(t, err2, true) + err = idxTask.Await(ctx) + descIdx2, err2 := mc.DescribeIndex(ctx, client.NewDescribeIndexOption(schema.CollectionName, idxName)) + common.CheckErr(t, err2, true) + require.EqualValues(t, index.NewGenericIndex(idxName, ipIdx.Params()), descIdx2) +} diff --git a/tests/go_client/testcases/query_test.go b/tests/go_client/testcases/query_test.go index 0c6ba2a24f..91f88e90b8 100644 --- a/tests/go_client/testcases/query_test.go +++ b/tests/go_client/testcases/query_test.go @@ -27,7 +27,7 @@ func TestQueryDefault(t *testing.T) { // flush -> index -> load prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query @@ -47,7 +47,7 @@ func TestQueryVarcharPkDefault(t *testing.T) { _, insertRes := prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) // flush -> index -> load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query @@ -69,7 +69,7 @@ func TestQueryNotExistName(t *testing.T) { // create -> index -> load prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query with not existed partition @@ -110,7 +110,7 @@ func TestQueryPartition(t *testing.T) { // flush -> index -> load prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) expr := fmt.Sprintf("%s >= %d", common.DefaultInt64FieldName, 0) @@ -175,7 +175,7 @@ func TestQueryOutputFields(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(enableDynamic)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) expr := fmt.Sprintf("%s < %d", common.DefaultInt64FieldName, 10) @@ -245,7 +245,7 @@ func TestQueryOutputAllFieldsColumn(t *testing.T) { // create collection for _, isDynamic := range [2]bool{true, false} { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(isDynamic)) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // insert @@ -309,7 +309,7 @@ func TestQueryOutputAllFieldsRows(t *testing.T) { require.Equal(t, int64(common.DefaultNb), ids.InsertCount) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query output all fields -> output all fields, includes vector and $meta field @@ -329,7 +329,7 @@ func TestQueryOutputBinaryAndVarchar(t *testing.T) { mc := createDefaultMilvusClient(ctx, t) prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // insert @@ -366,7 +366,7 @@ func TestQueryOutputSparse(t *testing.T) { mc := createDefaultMilvusClient(ctx, t) prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // insert @@ -401,7 +401,7 @@ func TestQueryArrayDifferentLenBetweenRows(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecAllScalar), hp.TNewFieldsOption().TWithMaxCapacity(common.TestCapacity*2), hp.TNewSchemaOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // insert 2 batch with array capacity 100 and 200 @@ -449,7 +449,7 @@ func TestQueryJsonDynamicExpr(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query with different expr and count @@ -482,7 +482,7 @@ func TestQueryInvalidExpr(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 100), hp.TNewDataOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) for _, _invalidExpr := range common.InvalidExpressions { @@ -499,7 +499,7 @@ func TestQueryCountJsonDynamicExpr(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query with different expr and count @@ -571,7 +571,7 @@ func TestQueryArrayFieldExpr(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // create collection @@ -618,7 +618,7 @@ func TestQueryOutputInvalidOutputFieldCount(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(false)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // invalid expr diff --git a/tests/go_client/testcases/search_test.go b/tests/go_client/testcases/search_test.go index d6b243e004..6a4db4b62d 100644 --- a/tests/go_client/testcases/search_test.go +++ b/tests/go_client/testcases/search_test.go @@ -26,7 +26,7 @@ func TestSearchDefault(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search @@ -42,7 +42,7 @@ func TestSearchDefaultGrowing(t *testing.T) { // create -> index -> load -> insert prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) @@ -88,7 +88,7 @@ func TestSearchEmptyCollection(t *testing.T) { // create -> index -> load prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(enableDynamicField)) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) type mNameVec struct { @@ -116,7 +116,7 @@ func TestSearchEmptySparseCollection(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search @@ -152,7 +152,7 @@ func TestSearchPartitions(t *testing.T) { // flush -> FLAT index -> load prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultFloatVecFieldName: index.NewFlatIndex(entity.COSINE)})) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultFloatVecFieldName: index.NewFlatIndex(entity.COSINE)})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search with empty partition name []string{""} -> error @@ -192,7 +192,7 @@ func TestSearchEmptyOutputFields(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(dynamic)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 100), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) vectors := hp.GenSearchVectors(common.DefaultNq, common.DefaultDim, entity.FieldTypeFloatVector) @@ -222,7 +222,7 @@ func TestSearchNotExistOutputFields(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(enableDynamic)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search vector output fields not exist, part exist @@ -264,7 +264,7 @@ func TestSearchOutputAllFields(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // @@ -292,7 +292,7 @@ func TestSearchOutputBinaryPk(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // @@ -318,7 +318,7 @@ func TestSearchOutputSparse(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // @@ -344,7 +344,7 @@ func TestSearchInvalidVectorField(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) type invalidVectorFieldStruct struct { @@ -386,7 +386,7 @@ func TestSearchInvalidVectors(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64MultiVec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) type invalidVectorsStruct struct { @@ -426,7 +426,7 @@ func TestSearchEmptyInvalidVectors(t *testing.T) { mc := createDefaultMilvusClient(ctx, t) prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) type invalidVectorsStruct struct { @@ -462,7 +462,7 @@ func TestSearchNotMatchMetricType(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema). + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema). TWithFieldIndex(map[string]index.Index{common.DefaultFloatVecFieldName: index.NewHNSWIndex(entity.COSINE, 8, 200)})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) @@ -479,7 +479,7 @@ func TestSearchInvalidTopK(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) vectors := hp.GenSearchVectors(1, common.DefaultDim, entity.FieldTypeFloatVector) @@ -497,7 +497,7 @@ func TestSearchInvalidOffset(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) vectors := hp.GenSearchVectors(1, common.DefaultDim, entity.FieldTypeFloatVector) @@ -521,7 +521,7 @@ func TestSearchEfHnsw(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema). + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema). TWithFieldIndex(map[string]index.Index{common.DefaultFloatVecFieldName: index.NewHNSWIndex(entity.COSINE, 8, 200)})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) @@ -544,9 +544,8 @@ func TestSearchInvalidScannReorderK(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{ - common.DefaultFloatVecFieldName: index.NewSCANNIndex(entity.COSINE, 16, true), - })) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{ + common.DefaultFloatVecFieldName: index.NewSCANNIndex(entity.COSINE, 16, true)})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search with invalid reorder_k < topK @@ -566,7 +565,7 @@ func TestSearchScannAllMetricsWithRawData(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 500), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{ + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{ common.DefaultFloatVecFieldName: index.NewSCANNIndex(entity.COSINE, 16), })) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) @@ -590,7 +589,7 @@ func TestSearchExpr(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) type mExprExpected struct { @@ -622,7 +621,7 @@ func TestSearchInvalidExpr(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VecJSON), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search with invalid expr @@ -667,7 +666,7 @@ func TestSearchJsonFieldExpr(t *testing.T) { TWithEnableDynamicField(dynamicField)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search with jsonField expr key datatype and json data type mismatch @@ -691,7 +690,7 @@ func TestSearchDynamicFieldExpr(t *testing.T) { TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) exprs := []string{ @@ -753,7 +752,7 @@ func TestSearchArrayFieldExpr(t *testing.T) { TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) var capacity int64 = common.TestCapacity @@ -804,7 +803,7 @@ func TestSearchNotExistedExpr(t *testing.T) { TWithEnableDynamicField(isDynamic)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search with invalid expr @@ -832,7 +831,7 @@ func TestSearchMultiVectors(t *testing.T) { prepare.FlushData(ctx, t, mc, schema.CollectionName) flatIndex := index.NewFlatIndex(entity.L2) binIndex := index.NewGenericIndex(common.DefaultBinaryVecFieldName, map[string]string{"nlist": "64", index.MetricTypeKey: "JACCARD", index.IndexTypeKey: "BIN_IVF_FLAT"}) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{ + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{ common.DefaultFloatVecFieldName: flatIndex, common.DefaultFloat16VecFieldName: flatIndex, common.DefaultBFloat16VecFieldName: flatIndex, @@ -897,7 +896,7 @@ func TestSearchSparseVector(t *testing.T) { TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb*2), hp.TNewDataOption().TWithSparseMaxLen(128)) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultSparseVecFieldName: idx})) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultSparseVecFieldName: idx})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search @@ -931,7 +930,7 @@ func TestSearchInvalidSparseVector(t *testing.T) { TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption().TWithSparseMaxLen(128)) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultSparseVecFieldName: idx})) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultSparseVecFieldName: idx})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) _, errSearch := mc.Search(ctx, client.NewSearchOption(schema.CollectionName, common.DefaultLimit, []entity.Vector{}).WithConsistencyLevel(entity.ClStrong)) @@ -966,7 +965,7 @@ func TestSearchSparseVectorPagination(t *testing.T) { TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption().TWithSparseMaxLen(128)) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultSparseVecFieldName: idx})) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema).TWithFieldIndex(map[string]index.Index{common.DefaultSparseVecFieldName: idx})) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // search @@ -1000,7 +999,7 @@ func TestRangeSearchSparseVector(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64VarcharSparseVec), hp.TNewFieldsOption(), hp.TNewSchemaOption(). TWithEnableDynamicField(true)) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption().TWithSparseMaxLen(128)) prepare.FlushData(ctx, t, mc, schema.CollectionName) diff --git a/tests/go_client/testcases/upsert_test.go b/tests/go_client/testcases/upsert_test.go index 761af9784e..669781aa64 100644 --- a/tests/go_client/testcases/upsert_test.go +++ b/tests/go_client/testcases/upsert_test.go @@ -33,7 +33,7 @@ func TestUpsertAllFields(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.AllFields), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, 0), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) upsertNb := 200 @@ -111,7 +111,7 @@ func TestUpsertSparse(t *testing.T) { common.CheckErr(t, err, true) require.EqualValues(t, upsertNb, upsertRes.UpsertCount) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) expr := fmt.Sprintf("%s < %d", common.DefaultInt64FieldName, upsertNb) @@ -166,7 +166,7 @@ func TestUpsertVarcharPk(t *testing.T) { prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.VarcharBinary), hp.TNewFieldsOption(), hp.TNewSchemaOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) upsertNb := 10 @@ -219,7 +219,7 @@ func TestUpsertMultiPartitions(t *testing.T) { prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb).TWithPartitionName(parName), hp.TNewDataOption().TWithStart(common.DefaultNb)) prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // upsert new partition @@ -261,7 +261,7 @@ func TestUpsertSamePksManyTimes(t *testing.T) { // flush -> index -> load prepare.FlushData(ctx, t, mc, schema.CollectionName) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query and verify the updated entities @@ -380,7 +380,7 @@ func TestUpsertDynamicField(t *testing.T) { // create -> insert [0, 3000) -> flush -> index -> load prepare, schema := hp.CollPrepare.CreateCollection(ctx, t, mc, hp.NewCreateCollectionParams(hp.Int64Vec), hp.TNewFieldsOption(), hp.TNewSchemaOption().TWithEnableDynamicField(true)) prepare.InsertData(ctx, t, mc, hp.NewInsertParams(schema, common.DefaultNb), hp.TNewDataOption()) - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // verify that dynamic field exists @@ -432,7 +432,7 @@ func TestUpsertWithoutLoading(t *testing.T) { common.CheckErr(t, err, true) // index -> load - prepare.CreateIndex(ctx, t, mc, hp.NewIndexParams(schema)) + prepare.CreateIndex(ctx, t, mc, hp.TNewIndexParams(schema)) prepare.Load(ctx, t, mc, hp.NewLoadParams(schema.CollectionName)) // query and verify