mirror of
https://gitee.com/milvus-io/milvus.git
synced 2026-01-06 02:42:53 +08:00
05b6ea1351
The error message was malformated or missing some meta info, say field name. This PR recitfies some message format and add field name in error message when type param check fails. --------- Signed-off-by: Congqi Xia <congqi.xia@zilliz.com>
937 lines
46 KiB
Go
937 lines
46 KiB
Go
package testcases
|
|
|
|
import (
|
|
"fmt"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"go.uber.org/zap"
|
|
|
|
"github.com/milvus-io/milvus/client/v2/entity"
|
|
client "github.com/milvus-io/milvus/client/v2/milvusclient"
|
|
"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"
|
|
)
|
|
|
|
var prefix = "collection"
|
|
|
|
// test create default floatVec and binaryVec collection
|
|
func TestCreateCollection(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
for _, collectionFieldsType := range []hp.CollectionFieldsType{hp.Int64Vec, hp.VarcharBinary, hp.Int64VarcharSparseVec, hp.AllFields} {
|
|
fields := hp.FieldsFact.GenFieldsForCollection(collectionFieldsType, hp.TNewFieldsOption())
|
|
schema := hp.GenSchema(hp.TNewSchemaOption().TWithFields(fields))
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(schema.CollectionName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// has collections and verify
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
|
|
// list collections and verify
|
|
collections, err := mc.ListCollections(ctx, client.NewListCollectionOption())
|
|
common.CheckErr(t, err, true)
|
|
require.Contains(t, collections, schema.CollectionName)
|
|
}
|
|
}
|
|
|
|
func TestCreateAutoIdCollectionField(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)
|
|
varcharField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithIsAutoID(true).WithMaxLength(common.MaxLength)
|
|
for _, pkField := range []*entity.Field{int64Field, varcharField} {
|
|
// pk field with name
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, coll.Schema.AutoID)
|
|
require.True(t, coll.Schema.Fields[0].AutoID)
|
|
|
|
// insert
|
|
vecColumn := hp.GenColumnData(common.DefaultNb, vecField.DataType, *hp.TNewDataOption())
|
|
_, err = mc.Insert(ctx, client.NewColumnBasedInsertOption(schema.CollectionName, vecColumn))
|
|
common.CheckErr(t, err, true)
|
|
}
|
|
}
|
|
|
|
// create collection and specify shard num
|
|
func TestCreateCollectionShards(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)
|
|
for _, shard := range []int32{-1, 0, 2, 16} {
|
|
// pk field with name
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema).WithShardNum(shard))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
if shard < 1 {
|
|
shard = 1
|
|
}
|
|
require.Equal(t, shard, coll.ShardNum)
|
|
}
|
|
}
|
|
|
|
// test create auto collection with schema
|
|
func TestCreateAutoIdCollectionSchema(t *testing.T) {
|
|
t.Skip("waiting for valid AutoId from schema params")
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
for _, pkFieldType := range []entity.FieldType{entity.FieldTypeVarChar, entity.FieldTypeInt64} {
|
|
pkField := entity.NewField().WithName("pk").WithDataType(pkFieldType).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
|
|
// pk field with name
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithAutoID(true)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
log.Info("schema autoID", zap.Bool("schemaAuto", coll.Schema.AutoID))
|
|
log.Info("field autoID", zap.Bool("fieldAuto", coll.Schema.Fields[0].AutoID))
|
|
|
|
// insert
|
|
vecColumn := hp.GenColumnData(common.DefaultNb, vecField.DataType, *hp.TNewDataOption())
|
|
_, err = mc.Insert(ctx, client.NewColumnBasedInsertOption(schema.CollectionName, vecColumn))
|
|
common.CheckErr(t, err, false, "field pk not passed")
|
|
}
|
|
}
|
|
|
|
// test create auto collection with collection option
|
|
func TestCreateAutoIdCollection(t *testing.T) {
|
|
t.Skip("waiting for valid AutoId from collection option")
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
for _, pkFieldType := range []entity.FieldType{entity.FieldTypeVarChar, entity.FieldTypeInt64} {
|
|
pkField := entity.NewField().WithName("pk").WithDataType(pkFieldType).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
|
|
// pk field with name
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema).WithAutoID(true))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
log.Info("schema autoID", zap.Bool("schemaAuto", coll.Schema.AutoID))
|
|
log.Info("field autoID", zap.Bool("fieldAuto", coll.Schema.Fields[0].AutoID))
|
|
|
|
// insert
|
|
vecColumn := hp.GenColumnData(common.DefaultNb, vecField.DataType, *hp.TNewDataOption())
|
|
_, err = mc.Insert(ctx, client.NewColumnBasedInsertOption(schema.CollectionName, vecColumn))
|
|
common.CheckErr(t, err, false, "field pk not passed")
|
|
}
|
|
}
|
|
|
|
func TestCreateJsonCollection(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
pkField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
jsonField := entity.NewField().WithName(common.DefaultJSONFieldName).WithDataType(entity.FieldTypeJSON)
|
|
|
|
// pk field with name
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithField(jsonField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
}
|
|
|
|
func TestCreateArrayCollections(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
pkField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField)
|
|
|
|
for _, eleType := range hp.GetAllArrayElementType() {
|
|
arrayField := entity.NewField().WithName(hp.GetFieldNameByElementType(eleType)).WithDataType(entity.FieldTypeArray).WithElementType(eleType).WithMaxCapacity(common.MaxCapacity)
|
|
if eleType == entity.FieldTypeVarChar {
|
|
arrayField.WithMaxLength(common.MaxLength)
|
|
}
|
|
schema.WithField(arrayField)
|
|
}
|
|
|
|
// pk field with name
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
}
|
|
|
|
// test create collection with partition key not supported field type
|
|
func TestCreateCollectionPartitionKey(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
|
|
for _, fieldType := range []entity.FieldType{entity.FieldTypeVarChar, entity.FieldTypeInt64} {
|
|
partitionKeyField := entity.NewField().WithName("par_key").WithDataType(fieldType).WithIsPartitionKey(true).WithMaxLength(common.TestMaxLen)
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField).WithField(partitionKeyField)
|
|
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
|
|
for _, field := range coll.Schema.Fields {
|
|
if field.Name == "par_key" {
|
|
require.True(t, field.IsPartitionKey)
|
|
}
|
|
}
|
|
|
|
// verify partitions
|
|
partitions, err := mc.ListPartitions(ctx, client.NewListPartitionOption(collName))
|
|
require.Len(t, partitions, common.DefaultPartitionNum)
|
|
common.CheckErr(t, err, true)
|
|
}
|
|
}
|
|
|
|
// test create partition key collection WithPartitionNum
|
|
func TestCreateCollectionPartitionKeyNumPartition(t *testing.T) {
|
|
t.Skip("Waiting for WithPartitionNum")
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
partitionKeyField := entity.NewField().WithName("par_key").WithDataType(entity.FieldTypeInt64).WithIsPartitionKey(true)
|
|
t.Parallel()
|
|
|
|
for _, numPartition := range []int64{1, 128, 64, 4096} {
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField).WithField(partitionKeyField)
|
|
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify partitions num
|
|
partitions, err := mc.ListPartitions(ctx, client.NewListPartitionOption(collName))
|
|
require.Len(t, partitions, int(numPartition))
|
|
common.CheckErr(t, err, true)
|
|
}
|
|
}
|
|
|
|
func TestCreateCollectionDynamicSchema(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
pkField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithDynamicFieldEnabled(true)
|
|
// pk field with name
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, coll.Schema.EnableDynamicField)
|
|
|
|
// insert dynamic
|
|
columnOption := *hp.TNewDataOption()
|
|
varcharColumn := hp.GenColumnData(common.DefaultNb, entity.FieldTypeVarChar, columnOption)
|
|
vecColumn := hp.GenColumnData(common.DefaultNb, entity.FieldTypeFloatVector, columnOption)
|
|
dynamicData := hp.GenDynamicColumnData(0, common.DefaultNb)
|
|
_, err = mc.Insert(ctx, client.NewColumnBasedInsertOption(schema.CollectionName, varcharColumn, vecColumn).WithColumns(dynamicData...))
|
|
common.CheckErr(t, err, true)
|
|
}
|
|
|
|
func TestCreateCollectionDynamic(t *testing.T) {
|
|
t.Skip("waiting for dynamicField alignment")
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
pkField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField)
|
|
// pk field with name
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema).WithDynamicSchema(true))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(schema.CollectionName))
|
|
log.Info("collection dynamic", zap.Bool("collectionSchema", coll.Schema.EnableDynamicField))
|
|
common.CheckErr(t, err, true)
|
|
// require.True(t, coll.Schema.Fields[0].IsDynamic)
|
|
|
|
// insert dynamic
|
|
columnOption := *hp.TNewDataOption()
|
|
varcharColumn := hp.GenColumnData(common.DefaultNb, entity.FieldTypeVarChar, columnOption)
|
|
vecColumn := hp.GenColumnData(common.DefaultNb, entity.FieldTypeFloatVector, columnOption)
|
|
dynamicData := hp.GenDynamicColumnData(0, common.DefaultNb)
|
|
_, err = mc.Insert(ctx, client.NewColumnBasedInsertOption(schema.CollectionName, varcharColumn, vecColumn).WithColumns(dynamicData...))
|
|
common.CheckErr(t, err, false, "field dynamicNumber does not exist")
|
|
}
|
|
|
|
func TestCreateCollectionAllFields(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName)
|
|
|
|
// gen all fields except sparse vector
|
|
fields := hp.FieldsFactory{}.GenFieldsForCollection(hp.AllFields, hp.TNewFieldsOption())
|
|
for _, field := range fields {
|
|
schema.WithField(field)
|
|
}
|
|
|
|
// pk field with name
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
}
|
|
|
|
func TestCreateCollectionSparseVector(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
sparseVecField := entity.NewField().WithName(common.DefaultSparseVecFieldName).WithDataType(entity.FieldTypeSparseVector)
|
|
pkField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true).WithMaxLength(common.MaxLength)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(sparseVecField)
|
|
// pk field with name
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema).WithDynamicSchema(true))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
has, err := mc.HasCollection(ctx, client.NewHasCollectionOption(schema.CollectionName))
|
|
common.CheckErr(t, err, true)
|
|
require.True(t, has)
|
|
}
|
|
|
|
func TestCreateCollectionWithValidFieldName(t *testing.T) {
|
|
t.Parallel()
|
|
// connect
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// create collection with valid field name
|
|
for _, name := range common.GenValidNames() {
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
// pk field with name
|
|
pkField := entity.NewField().WithName(name).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// verify field name
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
require.Equal(t, name, coll.Schema.Fields[0].Name)
|
|
}
|
|
}
|
|
|
|
func genDefaultSchema() *entity.Schema {
|
|
int64Pk := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
varchar := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithMaxLength(common.TestMaxLen)
|
|
floatVec := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
binaryVec := entity.NewField().WithName(common.DefaultBinaryVecFieldName).WithDataType(entity.FieldTypeBinaryVector).WithDim(common.DefaultDim)
|
|
|
|
schema := entity.NewSchema().WithField(int64Pk).WithField(varchar).WithField(floatVec).WithField(binaryVec)
|
|
return schema
|
|
}
|
|
|
|
// create collection with valid name
|
|
func TestCreateCollectionWithValidName(t *testing.T) {
|
|
t.Parallel()
|
|
// connect
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
for _, name := range common.GenValidNames() {
|
|
schema := genDefaultSchema().WithName(name)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(name, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
collections, err := mc.ListCollections(ctx, client.NewListCollectionOption())
|
|
common.CheckErr(t, err, true)
|
|
require.Contains(t, collections, name)
|
|
|
|
err = mc.DropCollection(ctx, client.NewDropCollectionOption(name))
|
|
common.CheckErr(t, err, true)
|
|
}
|
|
}
|
|
|
|
// create collection with invalid field name
|
|
func TestCreateCollectionWithInvalidFieldName(t *testing.T) {
|
|
t.Parallel()
|
|
// connect
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// create collection with invalid field name
|
|
for _, invalidName := range common.GenInvalidNames() {
|
|
log.Debug("TestCreateCollectionWithInvalidFieldName", zap.String("fieldName", invalidName))
|
|
pkField := entity.NewField().WithName(invalidName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName("vec").WithDataType(entity.FieldTypeFloatVector).WithDim(128)
|
|
schema := entity.NewSchema().WithName("aaa").WithField(pkField).WithField(vecField)
|
|
collOpt := client.NewCreateCollectionOption("aaa", schema)
|
|
|
|
err := mc.CreateCollection(ctx, collOpt)
|
|
common.CheckErr(t, err, false, "field name should not be empty",
|
|
"The first character of a field name must be an underscore or letter",
|
|
"Field name cannot only contain numbers, letters, and underscores",
|
|
"The length of a field name must be less than 255 characters",
|
|
"Field name can only contain numbers, letters, and underscores")
|
|
}
|
|
}
|
|
|
|
// create collection with invalid collection name: invalid str, schemaName isn't equal to collectionName, schema name is empty
|
|
func TestCreateCollectionWithInvalidCollectionName(t *testing.T) {
|
|
t.Parallel()
|
|
// connect
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// create collection and schema no name
|
|
schema := genDefaultSchema()
|
|
err2 := mc.CreateCollection(ctx, client.NewCreateCollectionOption("", schema))
|
|
common.CheckErr(t, err2, false, "collection name should not be empty")
|
|
|
|
// create collection with invalid schema name
|
|
for _, invalidName := range common.GenInvalidNames() {
|
|
log.Debug("TestCreateCollectionWithInvalidCollectionName", zap.String("collectionName", invalidName))
|
|
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(invalidName, schema))
|
|
common.CheckErr(t, err, false, "collection name should not be empty",
|
|
"the first character of a collection name must be an underscore or letter",
|
|
"collection name can only contain numbers, letters and underscores",
|
|
fmt.Sprintf("the length of a collection name must be less than %d characters", common.MaxCollectionNameLen))
|
|
}
|
|
}
|
|
|
|
// create collection missing pk field or vector field
|
|
func TestCreateCollectionInvalidFields(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
type invalidFieldsStruct struct {
|
|
fields []*entity.Field
|
|
errMsg string
|
|
}
|
|
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
pkField2 := entity.NewField().WithName("pk").WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
varcharField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar)
|
|
stringField := entity.NewField().WithName("str").WithDataType(entity.FieldTypeString)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
noneField := entity.NewField().WithName("none").WithDataType(entity.FieldTypeNone)
|
|
invalidFields := []invalidFieldsStruct{
|
|
{fields: []*entity.Field{pkField}, errMsg: "schema does not contain vector field"},
|
|
{fields: []*entity.Field{vecField}, errMsg: "primary key is not specified"},
|
|
{fields: []*entity.Field{pkField, pkField2, vecField}, errMsg: "there are more than one primary key"},
|
|
{fields: []*entity.Field{pkField, vecField, noneField}, errMsg: "data type None is not valid"},
|
|
{fields: []*entity.Field{pkField, vecField, stringField}, errMsg: "string data type not supported yet, please use VarChar type instead"},
|
|
{fields: []*entity.Field{pkField, vecField, varcharField}, errMsg: "type param(max_length) should be specified for varChar field"},
|
|
}
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
for _, invalidField := range invalidFields {
|
|
schema := entity.NewSchema().WithName(collName)
|
|
for _, field := range invalidField.fields {
|
|
schema.WithField(field)
|
|
}
|
|
collOpt := client.NewCreateCollectionOption(collName, schema)
|
|
err := mc.CreateCollection(ctx, collOpt)
|
|
common.CheckErr(t, err, false, invalidField.errMsg)
|
|
}
|
|
}
|
|
|
|
// create autoID or not collection with non-int64 and non-varchar field
|
|
func TestCreateCollectionInvalidAutoPkField(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// create collection with autoID true or not
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
for _, autoId := range [2]bool{true, false} {
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
// pk field type: non-int64 and non-varchar
|
|
for _, fieldType := range hp.GetInvalidPkFieldType() {
|
|
invalidPkField := entity.NewField().WithName("pk").WithDataType(fieldType).WithIsPrimaryKey(true)
|
|
schema := entity.NewSchema().WithName(collName).WithField(vecField).WithField(invalidPkField).WithAutoID(autoId)
|
|
errNonInt64Field := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, errNonInt64Field, false, "the data type of primary key should be Int64 or VarChar")
|
|
}
|
|
}
|
|
}
|
|
|
|
// test create collection with duplicate field name
|
|
func TestCreateCollectionDuplicateField(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// duplicate field
|
|
pkField := entity.NewField().WithName("id").WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true)
|
|
pkField2 := entity.NewField().WithName("id").WithDataType(entity.FieldTypeVarChar)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
|
|
// two vector fields have same name
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithField(vecField)
|
|
errDupField := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, errDupField, false, "duplicated field name")
|
|
|
|
// two named "id" fields, one is pk field and other is scalar field
|
|
schema2 := entity.NewSchema().WithName(collName).WithField(pkField).WithField(pkField2).WithField(vecField).WithAutoID(true)
|
|
errDupField2 := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema2))
|
|
common.CheckErr(t, errDupField2, false, "duplicated field name")
|
|
}
|
|
|
|
// test create collection with partition key not supported field type
|
|
func TestCreateCollectionInvalidPartitionKeyType(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout*2)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
for _, fieldType := range hp.GetInvalidPartitionKeyFieldType() {
|
|
log.Debug("TestCreateCollectionInvalidPartitionKeyType", zap.Any("partitionKeyFieldType", fieldType))
|
|
partitionKeyField := entity.NewField().WithName("parKey").WithDataType(fieldType).WithIsPartitionKey(true)
|
|
if fieldType == entity.FieldTypeArray {
|
|
partitionKeyField.WithElementType(entity.FieldTypeInt64)
|
|
}
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField).WithField(partitionKeyField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "the data type of partition key should be Int64 or VarChar")
|
|
}
|
|
}
|
|
|
|
// partition key field cannot be primary field, d can only be one partition key field
|
|
func TestCreateCollectionPartitionKeyPk(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsPartitionKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "the partition key field must not be primary field")
|
|
}
|
|
|
|
// can only be one partition key field
|
|
func TestCreateCollectionPartitionKeyNum(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
pkField1 := entity.NewField().WithName("pk_1").WithDataType(entity.FieldTypeInt64).WithIsPartitionKey(true)
|
|
pkField2 := entity.NewField().WithName("pk_2").WithDataType(entity.FieldTypeVarChar).WithMaxLength(common.TestMaxLen).WithIsPartitionKey(true)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField).WithField(pkField1).WithField(pkField2)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "there are more than one partition key")
|
|
}
|
|
|
|
func TestPartitionKeyInvalidNumPartition(t *testing.T) {
|
|
t.Skip("Waiting for num partition")
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// prepare field and schema
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
pkField1 := entity.NewField().WithName("partitionKeyField").WithDataType(entity.FieldTypeInt64).WithIsPartitionKey(true)
|
|
|
|
// schema
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField).WithField(pkField1)
|
|
invalidNumPartitionStruct := []struct {
|
|
numPartitions int64
|
|
errMsg string
|
|
}{
|
|
{common.MaxPartitionNum + 1, "exceeds max configuration (1024)"},
|
|
{-1, "the specified partitions should be greater than 0 if partition key is used"},
|
|
}
|
|
for _, npStruct := range invalidNumPartitionStruct {
|
|
// create collection with num partitions
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, npStruct.errMsg)
|
|
}
|
|
}
|
|
|
|
// test create collection with multi auto id
|
|
func TestCreateCollectionMultiAutoId(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)).WithField(
|
|
entity.NewField().WithName("dupInt").WithDataType(entity.FieldTypeInt64).WithIsAutoID(true)).WithField(
|
|
entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim),
|
|
).WithName(collName)
|
|
errMultiAuto := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, errMultiAuto, false, "only one field can speficy AutoID with true")
|
|
}
|
|
|
|
// test create collection with different autoId between pk field and schema
|
|
func TestCreateCollectionInconsistentAutoId(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
for _, autoId := range []bool{true, false} {
|
|
log.Debug("TestCreateCollectionInconsistentAutoId", zap.Bool("autoId", autoId))
|
|
collName := common.GenRandomString(prefix, 6)
|
|
// field and schema have opposite autoID
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(autoId)).WithField(
|
|
entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim),
|
|
).WithName(collName).WithAutoID(!autoId)
|
|
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
// describe collection
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
require.EqualValues(t, autoId, coll.Schema.AutoID)
|
|
for _, field := range coll.Schema.Fields {
|
|
if field.Name == common.DefaultInt64FieldName {
|
|
require.EqualValues(t, autoId, coll.Schema.Fields[0].AutoID)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// create collection with field or schema description
|
|
func TestCreateCollectionDescription(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
// gen field with description
|
|
pkDesc := "This is pk field"
|
|
schemaDesc := "This is schema"
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithDescription(pkDesc)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithDescription(schemaDesc)
|
|
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, true)
|
|
|
|
coll, err := mc.DescribeCollection(ctx, client.NewDescribeCollectionOption(collName))
|
|
common.CheckErr(t, err, true)
|
|
require.EqualValues(t, schemaDesc, coll.Schema.Description)
|
|
for _, field := range coll.Schema.Fields {
|
|
if field.Name == common.DefaultInt64FieldName {
|
|
require.Equal(t, pkDesc, field.Description)
|
|
} else {
|
|
require.Empty(t, field.Description)
|
|
}
|
|
}
|
|
}
|
|
|
|
// test invalid dim of binary field
|
|
func TestCreateBinaryCollectionInvalidDim(t *testing.T) {
|
|
t.Parallel()
|
|
type invalidDimStruct struct {
|
|
dim int64
|
|
errMsg string
|
|
}
|
|
|
|
invalidDims := []invalidDimStruct{
|
|
{dim: 10, errMsg: "should be multiple of 8"},
|
|
{dim: 0, errMsg: "should be in range 2 ~ 32768"},
|
|
{dim: 1, errMsg: "should be in range 2 ~ 32768"},
|
|
{dim: common.MaxDim * 9, errMsg: "binary vector dimension should be in range 2 ~ 262144"},
|
|
{dim: common.MaxDim*8 + 1, errMsg: "binary vector dimension should be multiple of 8"},
|
|
}
|
|
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
for _, invalidDim := range invalidDims {
|
|
log.Debug("TestCreateBinaryCollectionInvalidDim", zap.Int64("dim", invalidDim.dim))
|
|
collName := common.GenRandomString(prefix, 6)
|
|
// field and schema have opposite autoID
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).WithField(
|
|
entity.NewField().WithName(common.DefaultBinaryVecFieldName).WithDataType(entity.FieldTypeBinaryVector).WithDim(invalidDim.dim),
|
|
).WithName(collName)
|
|
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, invalidDim.errMsg)
|
|
}
|
|
}
|
|
|
|
// test invalid dim of float vector
|
|
func TestCreateFloatCollectionInvalidDim(t *testing.T) {
|
|
t.Parallel()
|
|
type invalidDimStruct struct {
|
|
dim string
|
|
errMsg string
|
|
}
|
|
|
|
invalidDims := []invalidDimStruct{
|
|
{dim: "0", errMsg: "should be in range 2 ~ 32768"},
|
|
{dim: "1", errMsg: "should be in range 2 ~ 32768"},
|
|
{dim: "", errMsg: "invalid syntax"},
|
|
{dim: "中文", errMsg: "invalid syntax"},
|
|
{dim: "%$#", errMsg: "invalid syntax"},
|
|
{dim: fmt.Sprintf("%d", common.MaxDim+1), errMsg: "float vector dimension should be in range 2 ~ 32768"},
|
|
}
|
|
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
for _, vecType := range []entity.FieldType{entity.FieldTypeFloatVector, entity.FieldTypeFloat16Vector, entity.FieldTypeBFloat16Vector} {
|
|
for _, invalidDim := range invalidDims {
|
|
log.Debug("TestCreateBinaryCollectionInvalidDim", zap.String("dim", invalidDim.dim))
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).WithField(
|
|
entity.NewField().WithName("pk").WithDataType(vecType).WithTypeParams(entity.TypeParamDim, invalidDim.dim),
|
|
).WithName(collName)
|
|
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, invalidDim.errMsg)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCreateVectorWithoutDim(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
vecFieldName := "vec"
|
|
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).WithField(
|
|
entity.NewField().WithName(vecFieldName).WithDataType(entity.FieldTypeFloatVector),
|
|
).WithName(collName)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, fmt.Sprintf("dimension is not defined in field type params of field %s, check type param `dim` for vector field", vecFieldName))
|
|
}
|
|
|
|
// specify dim for sparse vector -> error
|
|
func TestCreateCollectionSparseVectorWithDim(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).WithField(
|
|
entity.NewField().WithName("sparse").WithDataType(entity.FieldTypeSparseVector).WithDim(common.DefaultDim),
|
|
).WithName(collName)
|
|
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "dim should not be specified for sparse vector field sparse")
|
|
}
|
|
|
|
func TestCreateArrayFieldInvalidCapacity(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
arrayField := entity.NewField().WithName(common.DefaultArrayFieldName).WithDataType(entity.FieldTypeArray).WithElementType(entity.FieldTypeFloat)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithField(arrayField)
|
|
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "type param(max_capacity) should be specified for array field")
|
|
|
|
// invalid Capacity
|
|
for _, invalidCapacity := range []int64{-1, 0, common.MaxCapacity + 1} {
|
|
arrayField.WithMaxCapacity(invalidCapacity)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "the maximum capacity specified for a Array should be in (0, 4096]")
|
|
}
|
|
}
|
|
|
|
// test create collection varchar array with invalid max length
|
|
func TestCreateVarcharArrayInvalidLength(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
arrayVarcharField := entity.NewField().WithName(common.DefaultArrayFieldName).WithDataType(entity.FieldTypeArray).WithElementType(entity.FieldTypeVarChar).WithMaxCapacity(100)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithField(arrayVarcharField)
|
|
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "type param(max_length) should be specified for varChar field")
|
|
// invalid Capacity
|
|
for _, invalidLength := range []int64{-1, 0, common.MaxLength + 1} {
|
|
arrayVarcharField.WithMaxLength(invalidLength)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, fmt.Sprintf("the maximum length specified for a VarChar field(%s) should be in (0, 65535], but got %d instead: invalid parameter", arrayVarcharField.Name, invalidLength))
|
|
}
|
|
}
|
|
|
|
// test create collection varchar array with invalid max length
|
|
func TestCreateVarcharInvalidLength(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
|
|
varcharField := entity.NewField().WithName(common.DefaultVarcharFieldName).WithDataType(entity.FieldTypeVarChar).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
|
|
schema := entity.NewSchema().WithName(collName).WithField(varcharField).WithField(vecField)
|
|
// create collection
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "type param(max_length) should be specified for varChar field")
|
|
// invalid Capacity
|
|
for _, invalidLength := range []int64{-1, 0, common.MaxLength + 1} {
|
|
varcharField.WithMaxLength(invalidLength)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, fmt.Sprintf("the maximum length specified for a VarChar field(%s) should be in (0, 65535], but got %d instead", varcharField.Name, invalidLength))
|
|
}
|
|
}
|
|
|
|
func TestCreateArrayNotSupportedFieldType(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
// not supported ElementType: Array, Json, FloatVector, BinaryVector
|
|
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
for _, fieldType := range []entity.FieldType{entity.FieldTypeArray, entity.FieldTypeJSON, entity.FieldTypeBinaryVector, entity.FieldTypeFloatVector} {
|
|
field := entity.NewField().WithName("array").WithDataType(entity.FieldTypeArray).WithElementType(fieldType)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField).WithField(vecField).WithField(field)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, fmt.Sprintf("element type %s is not supported", fieldType.Name()))
|
|
}
|
|
}
|
|
|
|
// the num of vector fields > default limit=4
|
|
func TestCreateMultiVectorExceed(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
pkField := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)
|
|
schema := entity.NewSchema().WithName(collName).WithField(pkField)
|
|
for i := 0; i < common.MaxVectorFieldNum+1; i++ {
|
|
vecField := entity.NewField().WithName(fmt.Sprintf("vec_%d", i)).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
schema.WithField(vecField)
|
|
}
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, fmt.Sprintf("maximum vector field's number should be limited to %d", common.MaxVectorFieldNum))
|
|
}
|
|
|
|
// func TestCreateCollection(t *testing.T) {}
|
|
func TestCreateCollectionInvalidShards(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
vecField := entity.NewField().WithName(common.DefaultFloatVecFieldName).WithDataType(entity.FieldTypeFloatVector).WithDim(common.DefaultDim)
|
|
int64Field := entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true).WithIsAutoID(true)
|
|
for _, shard := range []int32{common.MaxShardNum + 1} {
|
|
// pk field with name
|
|
collName := common.GenRandomString(prefix, 6)
|
|
schema := entity.NewSchema().WithName(collName).WithField(int64Field).WithField(vecField)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema).WithShardNum(shard))
|
|
common.CheckErr(t, err, false, fmt.Sprintf("maximum shards's number should be limited to %d", common.MaxShardNum))
|
|
}
|
|
}
|
|
|
|
func TestCreateCollectionInvalid(t *testing.T) {
|
|
ctx := hp.CreateContext(t, time.Second*common.DefaultTimeout)
|
|
mc := createDefaultMilvusClient(ctx, t)
|
|
|
|
collName := common.GenRandomString(prefix, 6)
|
|
type mSchemaErr struct {
|
|
schema *entity.Schema
|
|
errMsg string
|
|
}
|
|
vecField := entity.NewField().WithName("vec").WithDataType(entity.FieldTypeFloatVector).WithDim(8)
|
|
mSchemaErrs := []mSchemaErr{
|
|
{schema: nil, errMsg: "schema does not contain vector field"},
|
|
{schema: entity.NewSchema().WithField(vecField), errMsg: "primary key is not specified"}, // no pk field
|
|
{schema: entity.NewSchema().WithField(vecField).WithField(entity.NewField()), errMsg: "primary key is not specified"},
|
|
{schema: entity.NewSchema().WithField(vecField).WithField(entity.NewField().WithIsPrimaryKey(true)), errMsg: "the data type of primary key should be Int64 or VarChar"},
|
|
{schema: entity.NewSchema().WithField(vecField).WithField(entity.NewField().WithIsPrimaryKey(true).WithDataType(entity.FieldTypeVarChar)), errMsg: "field name should not be empty"},
|
|
}
|
|
for _, mSchema := range mSchemaErrs {
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, mSchema.schema))
|
|
common.CheckErr(t, err, false, mSchema.errMsg)
|
|
}
|
|
}
|