mirror of https://github.com/milvus-io/milvus.git
935 lines
45 KiB
Go
935 lines
45 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)
|
|
|
|
schema := entity.NewSchema().WithField(
|
|
entity.NewField().WithName(common.DefaultInt64FieldName).WithDataType(entity.FieldTypeInt64).WithIsPrimaryKey(true)).WithField(
|
|
entity.NewField().WithName("vec").WithDataType(entity.FieldTypeFloatVector),
|
|
).WithName(collName)
|
|
err := mc.CreateCollection(ctx, client.NewCreateCollectionOption(collName, schema))
|
|
common.CheckErr(t, err, false, "dimension is not defined in field type params, check type param `dim` for vector field")
|
|
}
|
|
|
|
// 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, "the maximum length specified for a VarChar should be in (0, 65535]")
|
|
}
|
|
}
|
|
|
|
// 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, "the maximum length specified for a VarChar should be in (0, 65535]")
|
|
}
|
|
}
|
|
|
|
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)
|
|
}
|
|
}
|