admin/milvus
1
0
Fork 0
mirror of https://gitee.com/milvus-io/milvus.git synced 2025-12-06 17:18:35 +08:00
Code Issues Packages Projects Releases Wiki Activity

test:add test cases for add field (#42472)

Browse Source 
issue: #42126

---------

Signed-off-by: qixuan <673771573@qq.com>
This commit is contained in:
qixuan 2025-06-11 17:06:39 +08:00 committed by GitHub
parent fb7f19dfa1
commit 3b2ed5815f
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 1409 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
tests/python_client/base/client_v2_base.py
View File

@ -545,7 +545,7 @@ class TestMilvusClientV2Base(Base):
index_name=index_name, index_name=index_name,
**kwargs).run() **kwargs).run()
return res, check_result return res, check_result
def wait_for_index_ready(self, client, collection_name, index_name, timeout=None, **kwargs): def wait_for_index_ready(self, client, collection_name, index_name, timeout=None, **kwargs):
timeout = TIMEOUT if timeout is None else timeout timeout = TIMEOUT if timeout is None else timeout
start_time = time.time() start_time = time.time()
@ -555,7 +555,7 @@ class TestMilvusClientV2Base(Base):
return True return True
time.sleep(2) time.sleep(2)
return False return False
@trace() @trace()
def list_indexes(self, client, collection_name, timeout=None, check_task=None, check_items=None, **kwargs): def list_indexes(self, client, collection_name, timeout=None, check_task=None, check_items=None, **kwargs):
timeout = TIMEOUT if timeout is None else timeout timeout = TIMEOUT if timeout is None else timeout
@ -919,7 +919,7 @@ class TestMilvusClientV2Base(Base):
@trace() @trace()
def alter_collection_properties(self, client, collection_name, properties, timeout=None, def alter_collection_properties(self, client, collection_name, properties, timeout=None,
check_task=None, check_items=None, **kwargs): check_task=None, check_items=None, **kwargs):
timeout = TIMEOUT if timeout is None else timeout timeout = TIMEOUT if timeout is None else timeout
kwargs.update({"timeout": timeout}) kwargs.update({"timeout": timeout})
@ -1103,23 +1103,12 @@ class TestMilvusClientV2Base(Base):
return res, check_result return res, check_result
@trace() @trace()
def create_field_schema(self, client, name, data_type, desc='', timeout=None, check_task=None, check_items=None, **kwargs): def add_collection_field(self, client, collection_name, field_name, data_type, desc="", timeout=None, check_task=None, check_items=None, **kwargs):
timeout = TIMEOUT if timeout is None else timeout timeout = TIMEOUT if timeout is None else timeout
kwargs.update({"timeout": timeout}) kwargs.update({"timeout": timeout})
func_name = sys._getframe().f_code.co_name func_name = sys._getframe().f_code.co_name
res, check = api_request([client.create_field_schema, name, data_type, desc], **kwargs) res, check = api_request([client.add_collection_field, collection_name, field_name, data_type, desc], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items, check,
**kwargs).run()
return res, check_result
@trace()
def add_collection_field(self, client, collection_name, field_schema, timeout=None, check_task=None, check_items=None, **kwargs):
timeout = TIMEOUT if timeout is None else timeout
kwargs.update({"timeout": timeout})
func_name = sys._getframe().f_code.co_name
res, check = api_request([client.add_collection_field, collection_name, field_schema], **kwargs)
check_result = ResponseChecker(res, func_name, check_task, check_items, check, check_result = ResponseChecker(res, func_name, check_task, check_items, check,
**kwargs).run() **kwargs).run()
return res, check_result return res, check_result

8
tests/python_client/check/func_check.py
View File

@ -289,6 +289,14 @@ class ResponseChecker:
for field in res["fields"]: for field in res["fields"]:
if field["name"] in nullable_fields: if field["name"] in nullable_fields:
assert field["nullable"] is True assert field["nullable"] is True
if check_items.get("add_fields", None) is not None:
add_fields = check_items.get("add_fields")
if not isinstance(add_fields, list):
log.error("add_fields should be a list including all the added fields name")
assert False
for field in res["fields"]:
if field["name"] in add_fields:
assert field["nullable"] is True
assert res["fields"][0]["is_primary"] is True assert res["fields"][0]["is_primary"] is True
assert res["fields"][0]["field_id"] == 100 and (res["fields"][0]["type"] == 5 or 21) assert res["fields"][0]["field_id"] == 100 and (res["fields"][0]["type"] == 5 or 21)
assert res["fields"][1]["field_id"] == 101 and (res["fields"][1]["type"] == 101 or 105) assert res["fields"][1]["field_id"] == 101 and (res["fields"][1]["type"] == 101 or 105)

48
tests/python_client/milvus_client/test_milvus_client_alter.py
View File

@ -170,7 +170,8 @@ class TestMilvusClientAlterCollection(TestMilvusClientV2Base):
class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base): class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
@pytest.mark.tags(CaseLabel.L0) @pytest.mark.tags(CaseLabel.L0)
def test_milvus_client_alter_collection_field_default(self): @pytest.mark.parametrize("add_field", [True, False])
def test_milvus_client_alter_collection_field_default(self, add_field):
""" """
target: test alter collection field before load target: test alter collection field before load
method: alter varchar field max length method: alter varchar field max length
@ -186,6 +187,7 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
str_field_name = 'title' str_field_name = 'title'
json_field_name = 'json_field' json_field_name = 'json_field'
array_field_name = 'tags' array_field_name = 'tags'
new_field_name = 'field_new'
max_length = 16 max_length = 16
schema.add_field(pk_field_name, DataType.VARCHAR, max_length=max_length, is_primary=True, auto_id=False) schema.add_field(pk_field_name, DataType.VARCHAR, max_length=max_length, is_primary=True, auto_id=False)
schema.add_field(vector_field_name, DataType.FLOAT_VECTOR, dim=dim, mmap_enabled=True) schema.add_field(vector_field_name, DataType.FLOAT_VECTOR, dim=dim, mmap_enabled=True)
@ -199,10 +201,15 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
index_type="IVF_FLAT", params={"nlist": 128}) index_type="IVF_FLAT", params={"nlist": 128})
index_params.add_index(field_name=str_field_name) index_params.add_index(field_name=str_field_name)
self.create_collection(client, collection_name, schema=schema, index_params=index_params) self.create_collection(client, collection_name, schema=schema, index_params=index_params)
check_items = {str_field_name: {"max_length": max_length, "mmap_enabled": True},
vector_field_name: {"mmap_enabled": True},
json_field_name: {"mmap_enabled": False}}
if add_field:
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.VARCHAR,
nullable=True, max_length=max_length)
check_items["field_new"] = {"max_length": max_length}
self.describe_collection(client, collection_name, check_task=CheckTasks.check_collection_fields_properties, self.describe_collection(client, collection_name, check_task=CheckTasks.check_collection_fields_properties,
check_items={str_field_name: {"max_length": max_length, "mmap_enabled": True}, check_items=check_items)
vector_field_name: {"mmap_enabled": True},
json_field_name: {"mmap_enabled": False}})
rng = np.random.default_rng(seed=19530) rng = np.random.default_rng(seed=19530)
rows = [{ rows = [{
@ -210,7 +217,9 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
vector_field_name: list(rng.random((1, dim))[0]), vector_field_name: list(rng.random((1, dim))[0]),
str_field_name: cf.gen_str_by_length(max_length), str_field_name: cf.gen_str_by_length(max_length),
json_field_name: {"number": i}, json_field_name: {"number": i},
array_field_name: [cf.gen_str_by_length(max_length) for _ in range(10)] array_field_name: [cf.gen_str_by_length(max_length) for _ in range(10)],
# add new field data (only when add_field is True)
**({"field_new": cf.gen_str_by_length(max_length)} if add_field else {})
} for i in range(ct.default_nb)] } for i in range(ct.default_nb)]
self.insert(client, collection_name, rows) self.insert(client, collection_name, rows)
@ -238,14 +247,21 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
self.alter_collection_field(client, collection_name, field_name=array_field_name, self.alter_collection_field(client, collection_name, field_name=array_field_name,
field_params={"element_type": DataType.INT64}, field_params={"element_type": DataType.INT64},
check_task=CheckTasks.err_res, check_items=error) check_task=CheckTasks.err_res, check_items=error)
check_items_new = {str_field_name: {"max_length": new_max_length, "mmap_enabled": False},
vector_field_name: {"mmap_enabled": False},
json_field_name: {"mmap_enabled": True},
array_field_name: {"max_length": new_max_length, "max_capacity": 20}}
if add_field:
self.alter_collection_field(client, collection_name, field_name="field_new",
field_params={"max_length": new_max_length})
check_items_new["field_new"] = {"max_length": new_max_length}
self.describe_collection(client, collection_name, check_task=CheckTasks.check_collection_fields_properties, self.describe_collection(client, collection_name, check_task=CheckTasks.check_collection_fields_properties,
check_items={str_field_name: {"max_length": new_max_length, "mmap_enabled": False}, check_items=check_items_new)
vector_field_name: {"mmap_enabled": False},
json_field_name: {"mmap_enabled": True},
array_field_name: {"max_length": new_max_length, "max_capacity": 20}})
# verify that cannot insert data with the old max_length # verify that cannot insert data with the old max_length
for alter_field in [pk_field_name, str_field_name, array_field_name]: fields_to_verify = [pk_field_name, str_field_name, array_field_name]
if add_field:
fields_to_verify.append(new_field_name)
for alter_field in fields_to_verify:
error = {ct.err_code: 999, ct.err_msg: f"length of varchar field {alter_field} exceeds max length"} error = {ct.err_code: 999, ct.err_msg: f"length of varchar field {alter_field} exceeds max length"}
if alter_field == array_field_name: if alter_field == array_field_name:
error = {ct.err_code: 999, error = {ct.err_code: 999,
@ -256,7 +272,8 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
str_field_name: cf.gen_str_by_length(max_length) if alter_field == str_field_name else f'ti_{i}', str_field_name: cf.gen_str_by_length(max_length) if alter_field == str_field_name else f'ti_{i}',
json_field_name: {"number": i}, json_field_name: {"number": i},
array_field_name: [cf.gen_str_by_length(max_length) for _ in array_field_name: [cf.gen_str_by_length(max_length) for _ in
range(10)] if alter_field == array_field_name else [f"tags_{j}" for j in range(10)] range(10)] if alter_field == array_field_name else [f"tags_{j}" for j in range(10)],
**({"field_new": cf.gen_str_by_length(max_length)} if add_field and alter_field == new_field_name else {})
} for i in range(ct.default_nb, ct.default_nb + 10)] } for i in range(ct.default_nb, ct.default_nb + 10)]
self.insert(client, collection_name, rows, check_task=CheckTasks.err_res, check_items=error) self.insert(client, collection_name, rows, check_task=CheckTasks.err_res, check_items=error)
@ -266,7 +283,8 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
vector_field_name: list(rng.random((1, dim))[0]), vector_field_name: list(rng.random((1, dim))[0]),
str_field_name: cf.gen_str_by_length(new_max_length), str_field_name: cf.gen_str_by_length(new_max_length),
json_field_name: {"number": i}, json_field_name: {"number": i},
array_field_name: [cf.gen_str_by_length(new_max_length) for _ in range(10)] array_field_name: [cf.gen_str_by_length(new_max_length) for _ in range(10)],
**({"field_new": cf.gen_str_by_length(new_max_length)} if add_field else {})
} for i in range(ct.default_nb, ct.default_nb + 10)] } for i in range(ct.default_nb, ct.default_nb + 10)]
self.insert(client, collection_name, rows) self.insert(client, collection_name, rows)
@ -282,7 +300,9 @@ class TestMilvusClientAlterCollectionField(TestMilvusClientV2Base):
check_task=CheckTasks.err_res, check_items=error) check_task=CheckTasks.err_res, check_items=error)
self.alter_collection_field(client, collection_name, field_name=pk_field_name, self.alter_collection_field(client, collection_name, field_name=pk_field_name,
field_params={"max_length": max_length}) field_params={"max_length": max_length})
if add_field:
self.alter_collection_field(client, collection_name, field_name=new_field_name,
field_params={"max_length": max_length})
res = self.query(client, collection_name, filter=f"{pk_field_name} in ['id_10', 'id_20']", res = self.query(client, collection_name, filter=f"{pk_field_name} in ['id_10', 'id_20']",
output_fields=["*"])[0] output_fields=["*"])[0]
assert (len(res)) == 2 assert (len(res)) == 2

179
tests/python_client/milvus_client/test_milvus_client_collection.py
View File

@ -199,6 +199,172 @@ class TestMilvusClientCollectionInvalid(TestMilvusClientV2Base):
self.create_collection(client, collection_name, schema=schema, self.create_collection(client, collection_name, schema=schema,
check_task=CheckTasks.err_res, check_items=error) check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_as_primary(self):
"""
target: test fast create collection with add new field as primary
method: create collection name with add new field as primary
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
dim, field_name = 8, "field_new"
error = {ct.err_code: 1100, ct.err_msg: f"not support to add pk field, "
f"field name = {field_name}: invalid parameter"}
self.create_collection(client, collection_name, dim)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.INT64,
nullable=True, is_primary=True, check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_as_auto_id(self):
"""
target: test fast create collection with add new field as auto id
method: create collection name with add new field as auto id
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
dim, field_name = 8, "field_new"
error = {ct.err_code: 1, ct.err_msg: f"The auto_id can only be specified on the primary key field"}
self.create_collection(client, collection_name, dim)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.INT64,
nullable=True, auto_id=True, check_task=CheckTasks.err_res,
check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_with_disable_nullable(self):
"""
target: test fast create collection with add new field as nullable false
method: create collection name with add new field as nullable false
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
dim, field_name = 8, "field_new"
error = {ct.err_code: 1100, ct.err_msg: f"added field must be nullable, please check it, "
f"field name = {field_name}: invalid parameter"}
self.create_collection(client, collection_name, dim)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.INT64,
nullable=False, check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_as_partition_ley(self):
"""
target: test fast create collection with add new field as partition key
method: create collection name with add new field as partition key
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
dim, field_name = 8, "field_new"
error = {ct.err_code: 1100, ct.err_msg: f"not support to add partition key field, "
f"field name = {field_name}: invalid parameter"}
self.create_collection(client, collection_name, dim)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.INT64,
nullable=True, is_partition_key=True,
check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_exceed_max_length(self):
"""
target: test fast create collection with add new field with exceed max length
method: create collection name with add new field with exceed max length
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
dim, field_name = 8, "field_new"
error = {ct.err_code: 1100, ct.err_msg: f"the maximum length specified for the field({field_name}) "
f"should be in (0, 65535], but got 65536 instead: invalid parameter"}
self.create_collection(client, collection_name, dim)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.VARCHAR,
nullable=True, max_length=65536, check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_as_cluster_key(self):
"""
target: test fast create collection with add new field as cluster key
method: create collection with add new field as cluster key(already has cluster key)
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
field_name = "field_new"
error = {ct.err_code: 1100, ct.err_msg: f"already has another clutering key field, "
f"field name: {field_name}: invalid parameter"}
schema = self.create_schema(client)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=default_dim)
schema.add_field(default_string_field_name, DataType.VARCHAR, max_length=64, is_clustering_key=True)
self.create_collection(client, collection_name, schema=schema)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.INT64,
nullable=True, is_clustering_key=True,
check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_same_other_name(self):
"""
target: test fast create collection with add new field as other same name
method: create collection with add new field as other same name
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
error = {ct.err_code: 1100, ct.err_msg: f"duplicate field name: {default_string_field_name}: invalid parameter"}
schema = self.create_schema(client)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=default_dim)
schema.add_field(default_string_field_name, DataType.VARCHAR, max_length=64, is_clustering_key=True)
self.create_collection(client, collection_name, schema=schema)
collections = self.list_collections(client)[0]
assert collection_name in collections
self.add_collection_field(client, collection_name, field_name=default_string_field_name,
data_type=DataType.VARCHAR, nullable=True, max_length=64,
check_task=CheckTasks.err_res, check_items=error)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_collection_add_field_exceed_max_field_number(self):
"""
target: test fast create collection with add new field with exceed max field number
method: create collection name with add new field with exceed max field number
expected: raise exception
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
dim, field_name = 8, "field_new"
error = {ct.err_code: 1100, ct.err_msg: f"The number of fields has reached the maximum value 64: "
f"invalid parameter"}
self.create_collection(client, collection_name, dim)
collections = self.list_collections(client)[0]
assert collection_name in collections
for i in range(62):
self.add_collection_field(client, collection_name, field_name=f"{field_name}_{i}",
data_type=DataType.VARCHAR, nullable=True, max_length=64)
self.add_collection_field(client, collection_name, field_name=field_name, data_type=DataType.VARCHAR,
nullable=True, max_length=64, check_task=CheckTasks.err_res, check_items=error)
class TestMilvusClientCollectionValid(TestMilvusClientV2Base): class TestMilvusClientCollectionValid(TestMilvusClientV2Base):
""" Test case of create collection interface """ """ Test case of create collection interface """
@ -279,7 +445,8 @@ class TestMilvusClientCollectionValid(TestMilvusClientV2Base):
@pytest.mark.tags(CaseLabel.L0) @pytest.mark.tags(CaseLabel.L0)
@pytest.mark.parametrize("nullable", [True, False]) @pytest.mark.parametrize("nullable", [True, False])
@pytest.mark.parametrize("vector_type", [DataType.FLOAT_VECTOR, DataType.INT8_VECTOR]) @pytest.mark.parametrize("vector_type", [DataType.FLOAT_VECTOR, DataType.INT8_VECTOR])
def test_milvus_client_collection_self_creation_default(self, nullable, vector_type): @pytest.mark.parametrize("add_field", [True, False])
def test_milvus_client_collection_self_creation_default(self, nullable, vector_type, add_field):
""" """
target: test self create collection normal case target: test self create collection normal case
method: create collection method: create collection
@ -311,6 +478,12 @@ class TestMilvusClientCollectionValid(TestMilvusClientV2Base):
"vector_name": "embeddings"} "vector_name": "embeddings"}
if nullable: if nullable:
check_items["nullable_fields"] = ["nullable_field", "array_field"] check_items["nullable_fields"] = ["nullable_field", "array_field"]
if add_field:
self.add_collection_field(client, collection_name, field_name="field_new_int64", data_type=DataType.INT64,
nullable=True, is_cluster_key=True)
self.add_collection_field(client, collection_name, field_name="field_new_var", data_type=DataType.VARCHAR,
nullable=True, default_vaule="field_new_var", max_length=64)
check_items["add_fields"] = ["field_new_int64", "field_new_var"]
self.describe_collection(client, collection_name, self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property, check_task=CheckTasks.check_describe_collection_property,
check_items=check_items) check_items=check_items)
@ -1208,7 +1381,7 @@ class TestMilvusClientCollectionPropertiesInvalid(TestMilvusClientV2Base):
self.alter_collection_properties(client, alter_name, properties, self.alter_collection_properties(client, alter_name, properties,
check_task=CheckTasks.err_res, check_task=CheckTasks.err_res,
check_items=error) check_items=error)
@pytest.mark.tags(CaseLabel.L2) @pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("properties", [""]) @pytest.mark.parametrize("properties", [""])
def test_milvus_client_alter_collection_properties_invalid_properties(self, properties): def test_milvus_client_alter_collection_properties_invalid_properties(self, properties):
@ -1250,7 +1423,7 @@ class TestMilvusClientCollectionPropertiesInvalid(TestMilvusClientV2Base):
self.drop_collection_properties(client, drop_name, properties, self.drop_collection_properties(client, drop_name, properties,
check_task=CheckTasks.err_res, check_task=CheckTasks.err_res,
check_items=error) check_items=error)
@pytest.mark.tags(CaseLabel.L2) @pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("property_keys", ["", {}, []]) @pytest.mark.parametrize("property_keys", ["", {}, []])
def test_milvus_client_drop_collection_properties_invalid_properties(self, property_keys): def test_milvus_client_drop_collection_properties_invalid_properties(self, property_keys):

61
tests/python_client/milvus_client/test_milvus_client_compact.py
View File

@ -136,7 +136,8 @@ class TestMilvusClientCompactValid(TestMilvusClientV2Base):
""" """
@pytest.mark.tags(CaseLabel.L1) @pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_compact_normal(self, is_clustering): @pytest.mark.parametrize("add_field", [True, False])
def test_milvus_client_compact_normal(self, is_clustering, add_field):
""" """
target: test hybrid search with default normal case (2 vector fields) target: test hybrid search with default normal case (2 vector fields)
method: create connection, collection, insert and hybrid search method: create connection, collection, insert and hybrid search
@ -163,6 +164,14 @@ class TestMilvusClientCompactValid(TestMilvusClientV2Base):
default_vector_field_name+"new": list(rng.random((1, default_dim))[0]), default_vector_field_name+"new": list(rng.random((1, default_dim))[0]),
default_string_field_name: str(i)} for i in range(10*default_nb)] default_string_field_name: str(i)} for i in range(10*default_nb)]
self.insert(client, collection_name, rows) self.insert(client, collection_name, rows)
if add_field and not is_clustering:
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.INT64,
nullable=True, is_clustering_key=True)
rows_new = [
{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_vector_field_name+"new": list(rng.random((1, default_dim))[0]),
default_string_field_name: str(i)} for i in range(10*default_nb, 11*default_nb)]
self.insert(client, collection_name, rows_new)
self.flush(client, collection_name) self.flush(client, collection_name)
# 3. compact # 3. compact
compact_id = self.compact(client, collection_name, is_clustering=is_clustering)[0] compact_id = self.compact(client, collection_name, is_clustering=is_clustering)[0]
@ -265,4 +274,54 @@ class TestMilvusClientCompactValid(TestMilvusClientV2Base):
if time.time() - start > cost: if time.time() - start > cost:
raise Exception(1, f"Compact after index cost more than {cost}s") raise Exception(1, f"Compact after index cost more than {cost}s")
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_compact_with_added_field(self):
"""
target: test clustering compaction with added field as cluster key
method: create connection, collection, insert, add field, insert and compact
expected: successfully
"""
client = self._client()
collection_name = cf.gen_unique_str(prefix)
dim = 128
# 1. create collection
schema = self.create_schema(client, enable_dynamic_field=False)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=dim)
schema.add_field(default_vector_field_name+"new", DataType.FLOAT_VECTOR, dim=dim)
schema.add_field(default_string_field_name, DataType.VARCHAR, max_length=64, is_partition_key=True)
index_params = self.prepare_index_params(client)[0]
index_params.add_index(default_vector_field_name, metric_type="COSINE")
index_params.add_index(default_vector_field_name+"new", metric_type="L2")
self.create_collection(client, collection_name, dimension=dim, schema=schema, index_params=index_params)
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [
{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_vector_field_name+"new": list(rng.random((1, default_dim))[0]),
default_string_field_name: str(i)} for i in range(10*default_nb)]
self.insert(client, collection_name, rows)
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.INT64,
nullable=True, is_clustering_key=True)
# 3. insert new field after add field
rows_new = [
{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_vector_field_name+"new": list(rng.random((1, default_dim))[0]),default_string_field_name: str(i),
"field_new": random.randint(1, 1000)} for i in range(10*default_nb, 11*default_nb)]
self.insert(client, collection_name, rows_new)
self.flush(client, collection_name)
# 4. compact
compact_id = self.compact(client, collection_name, is_clustering=True)[0]
cost = 180
start = time.time()
while True:
time.sleep(1)
res = self.get_compaction_state(client, compact_id, is_clustering=True)[0]
if res == "Completed":
break
if time.time() - start > cost:
raise Exception(1, f"Compact after index cost more than {cost}s")
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)

23
tests/python_client/milvus_client/test_milvus_client_delete.py
View File

@ -221,7 +221,8 @@ class TestMilvusClientDeleteValid(TestMilvusClientV2Base):
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1) @pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_delete_with_filters_partition(self): @pytest.mark.parametrize("add_field", [True, False])
def test_milvus_client_delete_with_filters_partition(self, add_field):
""" """
target: test delete (high level api) target: test delete (high level api)
method: create connection, collection, insert delete, and search method: create connection, collection, insert delete, and search
@ -234,14 +235,28 @@ class TestMilvusClientDeleteValid(TestMilvusClientV2Base):
# 2. insert # 2. insert
default_nb = 1000 default_nb = 1000
rng = np.random.default_rng(seed=19530) rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]), rows = [
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)] {
default_primary_key_field_name: i,
default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0,
default_string_field_name: str(i),
**({"field_new": "default"} if add_field else {})
}
for i in range(default_nb)
]
if add_field:
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.VARCHAR,
nullable=True, max_length=64)
pks = self.insert(client, collection_name, rows)[0] pks = self.insert(client, collection_name, rows)[0]
# 3. get partition lists # 3. get partition lists
partition_names = self.list_partitions(client, collection_name) partition_names = self.list_partitions(client, collection_name)
# 4. delete # 4. delete
delete_num = 3 delete_num = 3
self.delete(client, collection_name, filter=f"id < {delete_num}", partition_names=partition_names) filter = f"id < {delete_num} "
if add_field:
filter += "and field_new == 'default'"
self.delete(client, collection_name, filter=filter, partition_names=partition_names)
# 5. search # 5. search
vectors_to_search = rng.random((1, default_dim)) vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)] insert_ids = [i for i in range(default_nb)]

10
tests/python_client/milvus_client/test_milvus_client_hybrid_search.py
View File

@ -367,6 +367,16 @@ class TestMilvusClientHybridSearchValid(TestMilvusClientV2Base):
"ids": insert_ids, "ids": insert_ids,
"limit": default_limit, "limit": default_limit,
"pk_name": default_primary_key_field_name}) "pk_name": default_primary_key_field_name})
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.INT64,
nullable=True, max_length=100)
self.hybrid_search(client, collection_name, [sub_search1, sub_search2], ranker, limit=default_limit,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"limit": default_limit,
"pk_name": default_primary_key_field_name})
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1) @pytest.mark.tags(CaseLabel.L1)

19
tests/python_client/milvus_client/test_milvus_client_index.py
View File

@ -395,7 +395,8 @@ class TestMilvusClientIndexValid(TestMilvusClientV2Base):
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2) @pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_index_auto_index(self, numeric_index, varchar_index, metric_type): @pytest.mark.parametrize("add_field", [True, False])
def test_milvus_client_index_auto_index(self, numeric_index, varchar_index, metric_type, add_field):
""" """
target: test index with autoindex on both scalar and vector field target: test index with autoindex on both scalar and vector field
method: create connection, collection, insert and search method: create connection, collection, insert and search
@ -415,6 +416,11 @@ class TestMilvusClientIndexValid(TestMilvusClientV2Base):
schema.add_field(ct.default_bool_field_name, DataType.BOOL) schema.add_field(ct.default_bool_field_name, DataType.BOOL)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=default_dim) schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=default_dim)
self.create_collection(client, collection_name, schema=schema, consistency_level="Strong") self.create_collection(client, collection_name, schema=schema, consistency_level="Strong")
if add_field:
self.add_collection_field(client, collection_name, field_name="field_int", data_type=DataType.INT32,
nullable=True)
self.add_collection_field(client, collection_name, field_name="field_varchar", data_type=DataType.VARCHAR,
nullable=True, max_length=64)
self.release_collection(client, collection_name) self.release_collection(client, collection_name)
self.drop_index(client, collection_name, "vector") self.drop_index(client, collection_name, "vector")
res = self.list_indexes(client, collection_name)[0] res = self.list_indexes(client, collection_name)[0]
@ -431,6 +437,9 @@ class TestMilvusClientIndexValid(TestMilvusClientV2Base):
index_params.add_index(field_name=ct.default_bool_field_name, index_type="", metric_type=metric_type) index_params.add_index(field_name=ct.default_bool_field_name, index_type="", metric_type=metric_type)
index_params.add_index(field_name=default_string_field_name, index_type=varchar_index, metric_type=metric_type) index_params.add_index(field_name=default_string_field_name, index_type=varchar_index, metric_type=metric_type)
index_params.add_index(field_name=default_primary_key_field_name, index_type=numeric_index, metric_type=metric_type) index_params.add_index(field_name=default_primary_key_field_name, index_type=numeric_index, metric_type=metric_type)
if add_field:
index_params.add_index(field_name="field_int", index_type=numeric_index, metric_type=metric_type)
index_params.add_index(field_name="field_varchar", index_type=varchar_index, metric_type=metric_type)
# 3. create index # 3. create index
self.create_index(client, collection_name, index_params) self.create_index(client, collection_name, index_params)
# 4. drop index # 4. drop index
@ -443,6 +452,9 @@ class TestMilvusClientIndexValid(TestMilvusClientV2Base):
self.drop_index(client, collection_name, ct.default_bool_field_name) self.drop_index(client, collection_name, ct.default_bool_field_name)
self.drop_index(client, collection_name, default_string_field_name) self.drop_index(client, collection_name, default_string_field_name)
self.drop_index(client, collection_name, default_primary_key_field_name) self.drop_index(client, collection_name, default_primary_key_field_name)
if add_field:
self.drop_index(client, collection_name, "field_int")
self.drop_index(client, collection_name, "field_varchar")
# 5. create index # 5. create index
self.create_index(client, collection_name, index_params) self.create_index(client, collection_name, index_params)
# 6. insert # 6. insert
@ -451,7 +463,10 @@ class TestMilvusClientIndexValid(TestMilvusClientV2Base):
ct.default_int32_field_name: np.int32(i), ct.default_int16_field_name: np.int16(i), ct.default_int32_field_name: np.int32(i), ct.default_int16_field_name: np.int16(i),
ct.default_int8_field_name: np.int8(i), default_float_field_name: i * 1.0, ct.default_int8_field_name: np.int8(i), default_float_field_name: i * 1.0,
ct.default_double_field_name: np.double(i), ct.default_bool_field_name: np.bool_(i), ct.default_double_field_name: np.double(i), ct.default_bool_field_name: np.bool_(i),
default_string_field_name: str(i)} for i in range(default_nb)] default_string_field_name: str(i),
**({"field_int": 10} if add_field else {}),
**({"field_varchar": "default"} if add_field else {})
} for i in range(default_nb)]
self.insert(client, collection_name, rows) self.insert(client, collection_name, rows)
# 7. load collection # 7. load collection
self.load_collection(client, collection_name) self.load_collection(client, collection_name)

195
tests/python_client/milvus_client/test_milvus_client_insert.py
View File

@ -25,6 +25,7 @@ default_search_field = ct.default_float_vec_field_name
default_search_params = ct.default_search_params default_search_params = ct.default_search_params
default_primary_key_field_name = "id" default_primary_key_field_name = "id"
default_vector_field_name = "vector" default_vector_field_name = "vector"
default_dynamic_field_name = "field_new"
default_float_field_name = ct.default_float_field_name default_float_field_name = ct.default_float_field_name
default_bool_field_name = ct.default_bool_field_name default_bool_field_name = ct.default_bool_field_name
default_string_field_name = ct.default_string_field_name default_string_field_name = ct.default_string_field_name
@ -507,6 +508,144 @@ class TestMilvusClientInsertValid(TestMilvusClientV2Base):
if self.has_collection(client, collection_name)[0]: if self.has_collection(client, collection_name)[0]:
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("default_value", ["a" * 64, "aa"])
def test_milvus_client_insert_with_added_field(self, default_value):
"""
target: test search (high level api) normal case
method: create connection, collection, insert, add field, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
dim = 8
# 1. create collection
schema = self.create_schema(client, enable_dynamic_field=False)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, max_length=64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=dim)
schema.add_field(default_string_field_name, DataType.VARCHAR, max_length=64, is_partition_key=True)
schema.add_field(default_float_field_name, DataType.FLOAT, nullable=True)
index_params = self.prepare_index_params(client)[0]
index_params.add_index(default_vector_field_name, metric_type="COSINE")
self.create_collection(client, collection_name, dimension=dim, schema=schema, index_params=index_params)
# 2. insert before add field
vectors = cf.gen_vectors(default_nb * 2, dim, vector_data_type=DataType.FLOAT_VECTOR)
rows = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
results = self.insert(client, collection_name, rows)[0]
assert results['insert_count'] == default_nb
# 3. add new field
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.VARCHAR,
nullable=True, default_value=default_value, max_length=64)
vectors_to_search = [vectors[0]]
insert_ids = [i for i in range(default_nb)]
# 4. check old dynamic data search is not impacted after add new field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 5. insert data(old + new field)
rows_t = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i),
"field_new": "field_new"} for i in range(default_nb, default_nb * 2)]
results = self.insert(client, collection_name, rows_t)[0]
assert results['insert_count'] == default_nb
insert_ids_after_add_field = [i for i in range(default_nb, default_nb * 2)]
# 6. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter=f'field_new=="{default_value}"',
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter=f"field_new=='field_new'",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids_after_add_field,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_insert_with_old_and_added_field(self):
"""
target: test search (high level api) normal case
method: create connection, collection, insert, add field, insert old/new field and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
dim = 8
# 1. create collection
schema = self.create_schema(client, enable_dynamic_field=False)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, max_length=64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=dim)
schema.add_field(default_string_field_name, DataType.VARCHAR, max_length=64, is_partition_key=True)
schema.add_field(default_float_field_name, DataType.FLOAT, nullable=True)
index_params = self.prepare_index_params(client)[0]
index_params.add_index(default_vector_field_name, metric_type="COSINE")
self.create_collection(client, collection_name, dimension=dim, schema=schema, index_params=index_params)
# 2. insert before add field
vectors = cf.gen_vectors(default_nb * 3, dim, vector_data_type=DataType.FLOAT_VECTOR)
rows = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
results = self.insert(client, collection_name, rows)[0]
assert results['insert_count'] == default_nb
# 3. add new field
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.VARCHAR,
nullable=True, max_length=64)
vectors_to_search = [vectors[0]]
insert_ids = [i for i in range(default_nb)]
# 4. check old dynamic data search is not impacted after add new field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 5. insert data(old field)
rows_old = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0,
default_string_field_name: str(i)} for i in range(default_nb, default_nb * 2)]
results = self.insert(client, collection_name, rows_old)[0]
assert results['insert_count'] == default_nb
insert_ids_with_old_field = [i for i in range(default_nb, default_nb * 2)]
# 6. insert data(new field)
rows_new = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i),
"field_new": "field_new"} for i in range(default_nb * 2, default_nb * 3)]
results = self.insert(client, collection_name, rows_new)[0]
assert results['insert_count'] == default_nb
insert_ids_with_new_field = [i for i in range(default_nb * 2, default_nb * 3)]
# 7. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter=f'field_new is null',
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids + insert_ids_with_old_field,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter=f"field_new=='field_new'",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids_with_new_field,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
class TestMilvusClientUpsertInvalid(TestMilvusClientV2Base): class TestMilvusClientUpsertInvalid(TestMilvusClientV2Base):
""" Test case of search interface """ """ Test case of search interface """
@ -1024,6 +1163,62 @@ class TestMilvusClientUpsertValid(TestMilvusClientV2Base):
if self.has_collection(client, collection_name)[0]: if self.has_collection(client, collection_name)[0]:
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_upsert_with_added_field(self):
"""
target: test upsert (high level api) normal case
method: create connection, collection, insert, add field, upsert and search
expected: upsert/search successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Strong")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert before add field
vectors = cf.gen_vectors(default_nb * 3, default_dim, vector_data_type=DataType.FLOAT_VECTOR)
rows = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
results = self.insert(client, collection_name, rows)[0]
assert results['insert_count'] == default_nb
# 3. add new field
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.VARCHAR,
nullable=True, max_length=64)
half_default_nb = int (default_nb/2)
rows = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i),
"field_new": "default"} for i in range(half_default_nb)]
results = self.upsert(client, collection_name, rows)[0]
assert results['upsert_count'] == half_default_nb
vectors_to_search = [vectors[0]]
insert_ids = [i for i in range(half_default_nb)]
insert_ids_with_new_field = [i for i in range(half_default_nb, default_nb)]
# 4. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter=f'field_new is null',
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids_with_new_field,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter=f"field_new=='default'",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
class TestMilvusClientInsertJsonPathIndexValid(TestMilvusClientV2Base): class TestMilvusClientInsertJsonPathIndexValid(TestMilvusClientV2Base):
""" Test case of insert interface """ """ Test case of insert interface """

43
tests/python_client/milvus_client/test_milvus_client_query.py
View File

@ -159,6 +159,49 @@ class TestMilvusClientQueryValid(TestMilvusClientV2Base):
default_float_field_name, default_string_field_name} default_float_field_name, default_string_field_name}
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
def test_milvus_client_query_output_fields_dynamic_name(self):
"""
target: test query (high level api) normal case
method: create connection, collection, insert, add field name(same as dynamic name) and query
expected: query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
dim = 8
# 1. create collection
schema = self.create_schema(client, enable_dynamic_field=True)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, max_length=64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=dim)
schema.add_field(default_float_field_name, DataType.FLOAT, nullable=True)
index_params = self.prepare_index_params(client)[0]
index_params.add_index(default_vector_field_name, metric_type="COSINE")
self.create_collection(client, collection_name, dimension=dim, schema=schema, index_params=index_params)
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.add_collection_field(client, collection_name, field_name=default_string_field_name,
data_type=DataType.VARCHAR, nullable=True, default_value="default", max_length=64)
for row in rows:
row[default_string_field_name] = "default"
# 3. query using ids
self.query(client, collection_name, ids=[i for i in range(default_nb)],
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 4. query using filter
res = self.query(client, collection_name, filter=default_search_exp,
output_fields=[f'$meta["{default_string_field_name}"]'],
check_task=CheckTasks.check_query_results,
check_items={exp_res: [{"id": item["id"]} for item in rows],
"with_vec": True,
"pk_name": default_primary_key_field_name})[0]
assert set(res[0].keys()) == {default_primary_key_field_name}
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1) @pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_query_output_fields_all(self): def test_milvus_client_query_output_fields_all(self):
""" """

838
tests/python_client/milvus_client/test_milvus_client_search.py
View File

@ -1,3 +1,5 @@
import time
import pytest import pytest
from base.client_v2_base import TestMilvusClientV2Base from base.client_v2_base import TestMilvusClientV2Base
@ -28,6 +30,7 @@ default_search_field = ct.default_float_vec_field_name
default_search_params = ct.default_search_params default_search_params = ct.default_search_params
default_primary_key_field_name = "id" default_primary_key_field_name = "id"
default_vector_field_name = "vector" default_vector_field_name = "vector"
default_dynamic_field_name = "field_new"
default_float_field_name = ct.default_float_field_name default_float_field_name = ct.default_float_field_name
default_bool_field_name = ct.default_bool_field_name default_bool_field_name = ct.default_bool_field_name
default_string_field_name = ct.default_string_field_name default_string_field_name = ct.default_string_field_name
@ -1653,7 +1656,11 @@ class TestMilvusClientSearchValid(TestMilvusClientV2Base):
""" """
@pytest.mark.tags(CaseLabel.L0) @pytest.mark.tags(CaseLabel.L0)
def test_milvus_client_search_query_default(self): @pytest.mark.parametrize("new_field_data_type", [DataType.INT64, DataType.INT8, DataType.INT16, DataType.INT32,
DataType.FLOAT, DataType.DOUBLE, DataType.BOOL, DataType.VARCHAR,
DataType.ARRAY, DataType.JSON])
@pytest.mark.parametrize("is_flush", [True, False])
def test_milvus_client_search_query_default(self, new_field_data_type, is_flush):
""" """
target: test search (high level api) normal case target: test search (high level api) normal case
method: create connection, collection, insert and search method: create connection, collection, insert and search
@ -1694,6 +1701,727 @@ class TestMilvusClientSearchValid(TestMilvusClientV2Base):
check_items={exp_res: rows, check_items={exp_res: rows,
"with_vec": True, "with_vec": True,
"pk_name": default_primary_key_field_name}) "pk_name": default_primary_key_field_name})
# 5. add field
if new_field_data_type == DataType.ARRAY:
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
element_type=DataType.INT64, max_capacity=12, max_length=64, nullable=True)
else:
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, max_length=100)
if is_flush:
self.flush(client, collection_name)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = None
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is not null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is not null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1)
@pytest.mark.parametrize("new_field_data_type", [DataType.INT64, DataType.INT8, DataType.INT16, DataType.INT32])
@pytest.mark.parametrize("is_flush", [True])
@pytest.mark.skip(reason="issue #42629")
def test_milvus_client_search_query_add_new_field_with_default_value_int(self, new_field_data_type, is_flush):
"""
target: test search with add field using default value
method: create connection, collection, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
self.using_database(client, "default")
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Bounded")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.flush(client, collection_name)
# assert self.num_entities(client, collection_name)[0] == default_nb
# 3. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 4. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 5. add field
if new_field_data_type == DataType.INT8:
field_type = np.int8
elif new_field_data_type == DataType.INT16:
field_type = np.int16
elif new_field_data_type == DataType.INT32:
field_type = np.int32
elif new_field_data_type == DataType.INT64:
field_type = np.int64
else:
raise Exception(f"Unsupported type {new_field_data_type}")
default_value = field_type(1)
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, default_value=default_value)
if is_flush:
self.flush(client, collection_name)
time.sleep(5)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = field_type(1)
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new == 1",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new == 1",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("new_field_data_type", [DataType.FLOAT, DataType.DOUBLE])
@pytest.mark.parametrize("is_flush", [True, False])
def test_milvus_client_search_query_add_new_field_with_default_value_float(self, new_field_data_type, is_flush):
"""
target: test search with add field using default value
method: create connection, collection, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
self.using_database(client, "default")
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Bounded")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.flush(client, collection_name)
# assert self.num_entities(client, collection_name)[0] == default_nb
# 3. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 4. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 5. add field
default_value = 1.0
if new_field_data_type == DataType.FLOAT:
default_value = np.float32(1.0)
elif new_field_data_type == DataType.DOUBLE:
default_value = np.float64(1.0)
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, default_value=default_value)
if is_flush:
self.flush(client, collection_name)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = default_value
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new == 1",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new == 1",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("new_field_data_type", [DataType.BOOL])
@pytest.mark.parametrize("is_flush", [True, False])
def test_milvus_client_search_query_add_new_field_with_default_value_bool(self, new_field_data_type, is_flush):
"""
target: test search with add field using default value
method: create connection, collection, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
self.using_database(client, "default")
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Bounded")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.flush(client, collection_name)
# assert self.num_entities(client, collection_name)[0] == default_nb
# 3. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 4. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 5. add field
default_value = True
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, default_value=default_value)
if is_flush:
self.flush(client, collection_name)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = default_value
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new == True",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new == True",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("new_field_data_type", [DataType.VARCHAR])
@pytest.mark.parametrize("is_flush", [True, False])
def test_milvus_client_search_query_add_new_field_with_default_value_varchar(self, new_field_data_type, is_flush):
"""
target: test search with add field using default value
method: create connection, collection, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
self.using_database(client, "default")
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Bounded")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.flush(client, collection_name)
# assert self.num_entities(client, collection_name)[0] == default_nb
# 3. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 4. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 5. add field
default_value = "1"
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, max_length=100, default_value=default_value)
if is_flush:
self.flush(client, collection_name)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = default_value
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new >='0'",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new >='0'",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("new_field_data_type", [DataType.JSON])
@pytest.mark.parametrize("is_flush", [True, False])
def test_milvus_client_search_query_add_new_field_with_default_value_json(self, new_field_data_type, is_flush):
"""
target: test search with add field using default value
method: create connection, collection, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
self.using_database(client, "default")
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Bounded")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.flush(client, collection_name)
# assert self.num_entities(client, collection_name)[0] == default_nb
# 3. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 4. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 5. add field
default_value = None
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, max_length=100, default_value=default_value)
if is_flush:
self.flush(client, collection_name)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = default_value
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is not null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is not null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("new_field_data_type", [DataType.ARRAY])
@pytest.mark.parametrize("is_flush", [True, False])
def test_milvus_client_search_query_add_new_field_with_default_value_array(self, new_field_data_type, is_flush):
"""
target: test search with add field using default value
method: create connection, collection, insert and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
self.using_database(client, "default")
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Bounded")
collections = self.list_collections(client)[0]
assert collection_name in collections
self.describe_collection(client, collection_name,
check_task=CheckTasks.check_describe_collection_property,
check_items={"collection_name": collection_name,
"dim": default_dim,
"consistency_level": 0})
# 2. insert
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
self.insert(client, collection_name, rows)
self.flush(client, collection_name)
# assert self.num_entities(client, collection_name)[0] == default_nb
# 3. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 4. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 5. add field
default_value = None
self.add_collection_field(client, collection_name, field_name="field_new", data_type=new_field_data_type,
nullable=True, element_type=DataType.INT64, max_capacity=12, max_length=100, default_value=default_value)
if is_flush:
self.flush(client, collection_name)
# 6. check the old search is not impacted after add field
self.search(client, collection_name, vectors_to_search,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
# 7. check the old query is not impacted after add field
for row in rows:
row["field_new"] = default_value
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 8. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is not null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 9. query filtered with the new field
self.query(client, collection_name, filter="field_new is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter="field_new is not null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name)
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1)
@pytest.mark.parametrize("new_field_name", [default_dynamic_field_name, "new_field"])
def test_milvus_client_search_query_enable_dynamic_and_add_field(self, new_field_name):
"""
target: test search (high level api) normal case
method: create connection, collection, insert, add field(same as dynamic and different as dynamic) and search
expected: search/query successfully
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
dim = 8
# 1. create collection
schema = self.create_schema(client, enable_dynamic_field=True)[0]
schema.add_field(default_primary_key_field_name, DataType.INT64, max_length=64, is_primary=True, auto_id=False)
schema.add_field(default_vector_field_name, DataType.FLOAT_VECTOR, dim=dim)
schema.add_field(default_string_field_name, DataType.VARCHAR, max_length=64, is_partition_key=True)
schema.add_field(default_float_field_name, DataType.FLOAT, nullable=True)
index_params = self.prepare_index_params(client)[0]
index_params.add_index(default_vector_field_name, metric_type="COSINE")
self.create_collection(client, collection_name, dimension=dim, schema=schema, index_params=index_params)
# 2. insert
vectors = cf.gen_vectors(default_nb, dim, vector_data_type=DataType.FLOAT_VECTOR)
rows = [{default_primary_key_field_name: i, default_vector_field_name: vectors[i],
default_float_field_name: i * 1.0, default_string_field_name: str(i),
default_dynamic_field_name: 1} for i in range(default_nb)]
results = self.insert(client, collection_name, rows)[0]
assert results['insert_count'] == default_nb
# 3. add new field same as dynamic field name
default_value = 1
self.add_collection_field(client, collection_name, field_name=new_field_name, data_type=DataType.INT64,
nullable=True, default_value=default_value)
vectors_to_search = [vectors[0]]
insert_ids = [i for i in range(default_nb)]
# 4. check old dynamic data search is not impacted after add new field
self.search(client, collection_name, vectors_to_search, limit=default_limit,
filter=f'$meta["{default_dynamic_field_name}"] == 1',
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"limit": default_limit,
"pk_name": default_primary_key_field_name})
# 5. check old dynamic data query is not impacted after add new field
for row in rows:
row[new_field_name] = default_value
self.query(client, collection_name, filter=f'$meta["{default_dynamic_field_name}"] == 1',
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name,
"vector_type": DataType.FLOAT_VECTOR})
# 6. search filtered with the new field
self.search(client, collection_name, vectors_to_search,
filter=f"{new_field_name} == 1",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter=f"{new_field_name} is null",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
# 7. query filtered with the new field
self.query(client, collection_name, filter=f"{new_field_name} == 1",
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows,
"with_vec": True,
"pk_name": default_primary_key_field_name})
self.query(client, collection_name, filter=f"{new_field_name} is null",
check_task=CheckTasks.check_query_results,
check_items={exp_res: [],
"pk_name": default_primary_key_field_name})
self.release_collection(client, collection_name) self.release_collection(client, collection_name)
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@ -1959,6 +2687,80 @@ class TestMilvusClientSearchValid(TestMilvusClientV2Base):
"pk_name": default_primary_key_field_name}) "pk_name": default_primary_key_field_name})
self.drop_collection(client, collection_name) self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_delete_after_add_field(self):
"""
target: test delete (high level api)
method: create connection, collection, insert delete, and search
expected: search/query successfully without deleted data
"""
client = self._client()
collection_name = cf.gen_collection_name_by_testcase_name()
# 1. create collection
self.create_collection(client, collection_name, default_dim, consistency_level="Strong")
# 2. insert
default_nb = 1000
rng = np.random.default_rng(seed=19530)
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i)} for i in range(default_nb)]
pks = self.insert(client, collection_name, rows)[0]
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.INT64,
nullable=True, max_length=100)
for row in rows:
row["field_new"] = None
# 3. delete
delete_num = 3
self.delete(client, collection_name, ids=[i for i in range(delete_num)])
# 4. search
vectors_to_search = rng.random((1, default_dim))
insert_ids = [i for i in range(default_nb)]
for insert_id in range(delete_num):
if insert_id in insert_ids:
insert_ids.remove(insert_id)
limit = default_nb - delete_num
self.search(client, collection_name, vectors_to_search, limit=default_nb,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": limit})
# 5. query
self.query(client, collection_name, filter=default_search_exp,
check_task=CheckTasks.check_query_results,
check_items={exp_res: rows[delete_num:],
"with_vec": True,
"pk_name": default_primary_key_field_name})
# 6. insert to the new added field
rows = [{default_primary_key_field_name: i, default_vector_field_name: list(rng.random((1, default_dim))[0]),
default_float_field_name: i * 1.0, default_string_field_name: str(i), "field_new": i} for i in range(delete_num)]
pks = self.insert(client, collection_name, rows)[0]
# 7. flush
self.flush(client, collection_name)
limit = default_nb
insert_ids = [i for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search, limit=default_nb,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": limit})
# 8. delete
self.delete(client, collection_name, filter=f"field_new >=0 and field_new <={delete_num}")
for insert_id in range(delete_num):
if insert_id in insert_ids:
insert_ids.remove(insert_id)
limit = default_nb - delete_num
self.search(client, collection_name, vectors_to_search, limit=default_nb,
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": limit})
self.drop_collection(client, collection_name)
@pytest.mark.tags(CaseLabel.L1) @pytest.mark.tags(CaseLabel.L1)
def test_milvus_client_delete_with_filters(self): def test_milvus_client_delete_with_filters(self):
""" """
@ -2039,7 +2841,8 @@ class TestMilvusClientSearchValid(TestMilvusClientV2Base):
self.insert(client, collection_name, rows) self.insert(client, collection_name, rows)
self.flush(client, collection_name) self.flush(client, collection_name)
self.load_collection(client, collection_name) self.load_collection(client, collection_name)
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.VARCHAR,
nullable=True, max_length=100)
# 3. search # 3. search
search_vector = list(rng.random((1, dim))[0]) search_vector = list(rng.random((1, dim))[0])
search_params = {'hints': "iterative_filter", search_params = {'hints': "iterative_filter",
@ -2182,6 +2985,35 @@ class TestMilvusClientSearchNullExpr(TestMilvusClientV2Base):
"ids": insert_ids, "ids": insert_ids,
"pk_name": default_primary_key_field_name, "pk_name": default_primary_key_field_name,
"limit": limit}) "limit": limit})
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.JSON,
nullable=True, max_length=100)
self.search(client, collection_name, vectors_to_search,
filter=null_expr,
consistency_level="Strong",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": limit})
insert_ids = [str(i) for i in range(default_nb)]
self.search(client, collection_name, vectors_to_search,
filter="field_new is null",
consistency_level="Strong",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"ids": insert_ids,
"pk_name": default_primary_key_field_name,
"limit": default_limit})
self.search(client, collection_name, vectors_to_search,
filter="field_new is not null",
consistency_level="Strong",
check_task=CheckTasks.check_search_results,
check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search),
"pk_name": default_primary_key_field_name,
"limit": 0})
@pytest.mark.tags(CaseLabel.L2) @pytest.mark.tags(CaseLabel.L2)
@pytest.mark.parametrize("nullable", [True, False]) @pytest.mark.parametrize("nullable", [True, False])
@ -3357,7 +4189,7 @@ class TestMilvusClientSearchJsonPathIndex(TestMilvusClientV2Base):
check_items={"enable_milvus_client_api": True, check_items={"enable_milvus_client_api": True,
"nq": len(vectors_to_search), "nq": len(vectors_to_search),
"ids": insert_ids, "ids": insert_ids,
"pk_name": default_primary_key_field_name, "pk_name": default_primary_key_field_name,
"limit": 1}) "limit": 1})
expr = f"{json_field_name} == {default_nb + 5}" expr = f"{json_field_name} == {default_nb + 5}"
insert_ids = [default_nb + 5] insert_ids = [default_nb + 5]

6
tests/python_client/milvus_client/test_milvus_client_search_iterator.py
View File

@ -666,7 +666,8 @@ class TestMilvusClientSearchIteratorValid(TestMilvusClientV2Base):
@pytest.mark.tags(CaseLabel.L0) @pytest.mark.tags(CaseLabel.L0)
@pytest.mark.parametrize("metric_type", ct.dense_metrics) @pytest.mark.parametrize("metric_type", ct.dense_metrics)
def test_milvus_client_search_iterator_default(self, metric_type): @pytest.mark.parametrize("add_field", [True, False])
def test_milvus_client_search_iterator_default(self, metric_type, add_field):
""" """
target: test search iterator (high level api) normal case target: test search iterator (high level api) normal case
method: create connection, collection, insert and search iterator method: create connection, collection, insert and search iterator
@ -710,6 +711,9 @@ class TestMilvusClientSearchIteratorValid(TestMilvusClientV2Base):
check_items={"nq": 1, "limit": limit, check_items={"nq": 1, "limit": limit,
"enable_milvus_client_api": True, "enable_milvus_client_api": True,
"pk_name": default_primary_key_field_name})[0] "pk_name": default_primary_key_field_name})[0]
if add_field:
self.add_collection_field(client, collection_name, field_name="field_new", data_type=DataType.INT64,
nullable=True, max_length=100)
for limit in [batch_size - 3, batch_size, batch_size * 2, -1]: for limit in [batch_size - 3, batch_size, batch_size * 2, -1]:
if metric_type != "L2": if metric_type != "L2":
radius = res[0][limit // 2].get('distance', 0) - 0.1 # pick a radius to make sure there exists results radius = res[0][limit // 2].get('distance', 0) - 0.1 # pick a radius to make sure there exists results

4
tests/python_client/requirements.txt
View File

@ -28,8 +28,8 @@ pytest-parallel
pytest-random-order pytest-random-order
# pymilvus # pymilvus
pymilvus==2.6.0rc123 pymilvus==2.6.0rc139
pymilvus[bulk_writer]==2.6.0rc123 pymilvus[bulk_writer]==2.6.0rc139
# for protobuf # for protobuf
protobuf==5.27.2 protobuf==5.27.2