mirror of
https://gitee.com/milvus-io/milvus.git
synced 2024-12-05 05:18:52 +08:00
1965 lines
88 KiB
Python
1965 lines
88 KiB
Python
from time import sleep
|
|
import pytest
|
|
import copy
|
|
|
|
from base.client_base import TestcaseBase
|
|
from base.index_wrapper import ApiIndexWrapper
|
|
from utils.util_log import test_log as log
|
|
from common import common_func as cf
|
|
from common import common_type as ct
|
|
from common.common_type import CaseLabel, CheckTasks
|
|
from common.code_mapping import CollectionErrorMessage as clem
|
|
from common.code_mapping import IndexErrorMessage as iem
|
|
|
|
from utils.util_pymilvus import *
|
|
from common.constants import *
|
|
from pymilvus.exceptions import MilvusException
|
|
|
|
prefix = "index"
|
|
default_schema = cf.gen_default_collection_schema()
|
|
default_field_name = ct.default_float_vec_field_name
|
|
default_index_params = {"index_type": "IVF_SQ8", "metric_type": "COSINE", "params": {"nlist": 64}}
|
|
default_autoindex_params = {"index_type": "AUTOINDEX", "metric_type": "IP"}
|
|
|
|
# copied from pymilvus
|
|
uid = "test_index"
|
|
# BUILD_TIMEOUT = 300
|
|
field_name = default_float_vec_field_name
|
|
binary_field_name = default_binary_vec_field_name
|
|
default_string_field_name = ct.default_string_field_name
|
|
index_name1 = cf.gen_unique_str("float")
|
|
index_name2 = cf.gen_unique_str("varhar")
|
|
index_name3 = cf.gen_unique_str("binary")
|
|
default_string_index_params = {}
|
|
default_binary_schema = cf.gen_default_binary_collection_schema()
|
|
default_binary_index_params = {"index_type": "BIN_IVF_FLAT", "metric_type": "JACCARD", "params": {"nlist": 64}}
|
|
# query = gen_search_vectors_params(field_name, default_entities, default_top_k, 1)
|
|
default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
|
|
default_ip_index_params = {"index_type": "IVF_FLAT", "metric_type": "IP", "params": {"nlist": 64}}
|
|
default_nq = ct.default_nq
|
|
default_limit = ct.default_limit
|
|
default_search_exp = "int64 >= 0"
|
|
default_search_field = ct.default_float_vec_field_name
|
|
default_search_params = ct.default_search_params
|
|
default_search_ip_params = ct.default_search_ip_params
|
|
default_search_binary_params = ct.default_search_binary_params
|
|
default_nb = ct.default_nb
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestIndexParams(TestcaseBase):
|
|
""" Test case of index interface """
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("collection", [None, "coll"])
|
|
def test_index_non_collection(self, collection):
|
|
"""
|
|
target: test index with None collection
|
|
method: input none collection object
|
|
expected: raise exception
|
|
"""
|
|
self._connect()
|
|
self.index_wrap.init_index(collection, default_field_name, default_index_params, check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 0, ct.err_msg: clem.CollectionType})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("field_name", ct.get_invalid_strs)
|
|
def test_index_field_name_invalid(self, field_name):
|
|
"""
|
|
target: test index with error field name
|
|
method: input field name
|
|
expected: raise exception
|
|
"""
|
|
collection_name = cf.gen_unique_str(prefix)
|
|
|
|
collection_w = self.init_collection_wrap(name=collection_name)
|
|
|
|
log.error(iem.WrongFieldName % str(field_name))
|
|
self.index_wrap.init_index(collection_w.collection, field_name, default_index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: iem.WrongFieldName % str(field_name)})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_field_name_not_existed(self):
|
|
"""
|
|
target: test index with error field name
|
|
method: input field name not created
|
|
expected: raise exception
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
f_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
self.index_wrap.init_index(collection_w.collection, f_name, default_index_params, check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: f"cannot create index on non-existed field: {f_name}"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
@pytest.mark.parametrize("index_type", ct.get_invalid_strs)
|
|
def test_index_type_invalid(self, index_type):
|
|
"""
|
|
target: test index with error index type
|
|
method: input invalid index type
|
|
expected: raise exception
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
index_params = copy.deepcopy(default_index_params)
|
|
index_params["index_type"] = index_type
|
|
if not isinstance(index_params["index_type"], str):
|
|
msg = "must be str"
|
|
else:
|
|
msg = "Invalid index_type"
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: msg})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_type_not_supported(self):
|
|
"""
|
|
target: test index with error index type
|
|
method: input unsupported index type
|
|
expected: raise exception
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
index_params = copy.deepcopy(default_index_params)
|
|
index_params["index_type"] = "IVFFFFFFF"
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: ""})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_params_invalid(self, get_invalid_index_params):
|
|
"""
|
|
target: test index with error index params
|
|
method: input invalid index params
|
|
expected: raise exception
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
index_params = get_invalid_index_params
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: ""})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("index_name", ["_1ndeX", "In_t0"])
|
|
def test_index_naming_rules(self, index_name):
|
|
"""
|
|
target: test index naming rules
|
|
method: 1. connect milvus
|
|
2. Create a collection
|
|
3. Create an index with an index_name which uses all the supported elements in the naming rules
|
|
expected: Index create successfully
|
|
"""
|
|
self._connect()
|
|
collection_w = self.init_collection_wrap()
|
|
collection_w.create_index(default_field_name, default_index_params, index_name=index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
assert collection_w.indexes[0].index_name == index_name
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("index_name", ["_1ndeX", "In_0"])
|
|
def test_index_same_index_name_two_fields(self, index_name):
|
|
"""
|
|
target: test index naming rules
|
|
method: 1. connect milvus
|
|
2. Create a collection with more than 3 fields
|
|
3. Create two indexes on two fields with the same index name
|
|
expected: raise exception
|
|
"""
|
|
self._connect()
|
|
collection_w = self.init_collection_wrap()
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params,
|
|
index_name=index_name)
|
|
self.index_wrap.init_index(collection_w.collection, ct.default_int64_field_name, default_index_params,
|
|
index_name=index_name,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "CreateIndex failed: index already exist, "
|
|
"but parameters are inconsistent"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
# @pytest.mark.xfail(reason="issue 19181")
|
|
@pytest.mark.parametrize("get_invalid_index_name", ["1nDex", "$in4t", "12 s", "(中文)"])
|
|
def test_index_name_invalid(self, get_invalid_index_name):
|
|
"""
|
|
target: test index with error index name
|
|
method: input invalid index name
|
|
expected: raise exception
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
index_name = get_invalid_index_name
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params,
|
|
index_name=get_invalid_index_name,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "Invalid index name"})
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestIndexOperation(TestcaseBase):
|
|
""" Test case of index interface """
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_create_with_different_indexes(self):
|
|
"""
|
|
target: test create index on one field, with two different type of index
|
|
method: create two different indexes
|
|
expected: only latest index can be created for a collection
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params)
|
|
error = {ct.err_code: 1, ct.err_msg: f"CreateIndex failed: index already exists"}
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index,
|
|
check_task=CheckTasks.err_res, check_items=error)
|
|
|
|
assert len(collection_w.indexes) == 1
|
|
assert collection_w.indexes[0].params["index_type"] == default_index_params["index_type"]
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_create_indexes_for_different_fields(self):
|
|
"""
|
|
target: Test create indexes for different fields
|
|
method: create two different indexes with default index name
|
|
expected: create successfully
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, True, is_index=False)[0]
|
|
default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
|
|
collection_w.create_index(default_field_name, default_index)
|
|
collection_w.create_index(ct.default_int64_field_name, {})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_create_on_scalar_field(self):
|
|
"""
|
|
target: Test create index on scalar field
|
|
method: create index on scalar field and load
|
|
expected: raise exception
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, True, is_index=False)[0]
|
|
collection_w.create_index(ct.default_int64_field_name, {})
|
|
collection_w.load(check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: "there is no vector index on collection, "
|
|
"please create index firstly"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_collection_empty(self):
|
|
"""
|
|
target: test index with empty collection
|
|
method: Index on empty collection
|
|
expected: no exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params)
|
|
# TODO: assert index
|
|
cf.assert_equal_index(index, collection_w.collection.indexes[0])
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("index_param", [default_index_params])
|
|
def test_index_params(self, index_param):
|
|
"""
|
|
target: test index with all index type/params
|
|
method: input valid params
|
|
expected: no exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
index_params = index_param
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, index_params)
|
|
# TODO: assert index
|
|
cf.assert_equal_index(index, collection_w.collection.indexes[0])
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_params_flush(self):
|
|
"""
|
|
target: test index with all index type/params
|
|
method: input valid params
|
|
expected: no exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
# flush
|
|
collection_w.num_entities
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params)
|
|
# TODO: assert index
|
|
cf.assert_equal_index(index, collection_w.collection.indexes[0])
|
|
assert collection_w.num_entities == ct.default_nb
|
|
|
|
# TODO: not support
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason='not supported')
|
|
def test_index_name_dup(self):
|
|
"""
|
|
target: test index with duplicate index name
|
|
method: create index with existed index name create by `collection.create_index`
|
|
expected: no exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
index_name = ct.default_index_name
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
collection_w.collection.create_index(default_field_name, default_index_params, index_name=index_name)
|
|
self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: ""})
|
|
|
|
# TODO: server not supported
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason='not supported')
|
|
def test_index_field_names(self):
|
|
"""
|
|
target: test index on one field, with two indexes
|
|
method: create index with two different indexes
|
|
expected: no exception raised
|
|
"""
|
|
pass
|
|
|
|
# TODO: server not supported
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason='not supported')
|
|
def test_index_fields(self):
|
|
"""
|
|
target: test index on two fields, with the same name
|
|
method: create the same index name with two different fields
|
|
expected: exception raised
|
|
"""
|
|
pass
|
|
|
|
# TODO: server not supported
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason='not supported')
|
|
def test_index_fields_B(self):
|
|
"""
|
|
target: test index on two fields, with the different name
|
|
method: create the different index with two different fields
|
|
expected: no exception raised
|
|
"""
|
|
pass
|
|
|
|
# TODO: server not supported
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason='not supported')
|
|
def test_index_field_names_eq_maximum(self):
|
|
"""
|
|
target: test index on one field, with the different names, num of the names equal to the maximum num supported
|
|
method: create the different indexes
|
|
expected: no exception raised
|
|
"""
|
|
pass
|
|
|
|
# TODO: server not supported
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason='not supported')
|
|
def test_index_field_names_more_maximum(self):
|
|
"""
|
|
target: test index on one field, with the different names, num of the names more than the maximum num supported
|
|
method: create the different indexes
|
|
expected: exception raised
|
|
"""
|
|
pass
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_drop_index(self):
|
|
"""
|
|
target: test index.drop
|
|
method: create index by `index`, and then drop it
|
|
expected: no exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params)
|
|
cf.assert_equal_index(index, collection_w.collection.indexes[0])
|
|
self.index_wrap.drop()
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
# TODO #7372
|
|
def test_index_drop_repeatedly(self):
|
|
"""
|
|
target: test index.drop
|
|
method: create index by `index`, and then drop it twice
|
|
expected: exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
_, _ = self.index_wrap.init_index(collection_w.collection, default_field_name, default_index_params)
|
|
self.index_wrap.drop()
|
|
self.index_wrap.drop()
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestIndexAdvanced(TestcaseBase):
|
|
""" Test case of index interface """
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_index_drop_multi_collections(self):
|
|
"""
|
|
target: test index.drop
|
|
method: create indexes by `index`, and then drop it, assert there is one index left
|
|
expected: exception raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
c_name_2 = cf.gen_unique_str(prefix)
|
|
cw = self.init_collection_wrap(name=c_name)
|
|
cw2 = self.init_collection_wrap(name=c_name_2)
|
|
iw_2 = ApiIndexWrapper()
|
|
self.index_wrap.init_index(cw.collection, default_field_name, default_index_params)
|
|
index_2, _ = iw_2.init_index(cw2.collection, default_field_name, default_index_params)
|
|
self.index_wrap.drop()
|
|
assert cf.assert_equal_index(index_2, cw2.collection.indexes[0])
|
|
assert len(cw.collection.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
@pytest.mark.skip(reason='TODO')
|
|
def test_index_drop_during_inserting(self):
|
|
"""
|
|
target: test index.drop during inserting
|
|
method: create indexes by `index`, and then drop it during inserting entities, make sure async insert
|
|
expected: no exception raised, insert success
|
|
"""
|
|
pass
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
@pytest.mark.skip(reason='TODO')
|
|
def test_index_drop_during_searching(self):
|
|
"""
|
|
target: test index.drop during searching
|
|
method: create indexes by `index`, and then drop it during searching, make sure async search
|
|
expected: no exception raised, search success
|
|
"""
|
|
pass
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
@pytest.mark.skip(reason='TODO')
|
|
def test_index_recovery_after_restart(self):
|
|
"""
|
|
target: test index still existed after server restart
|
|
method: create index by `index`, and then restart server, assert index existed
|
|
expected: index in collection.indexes
|
|
"""
|
|
pass
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
@pytest.mark.skip(reason='TODO')
|
|
def test_index_building_after_restart(self):
|
|
"""
|
|
target: index can still build if not finished before server restart
|
|
method: create index by `index`, and then restart server, assert server is indexing
|
|
expected: index build finished after server restart
|
|
"""
|
|
pass
|
|
|
|
"""
|
|
******************************************************************
|
|
The following classes are copied from pymilvus test
|
|
******************************************************************
|
|
"""
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestNewIndexBase(TestcaseBase):
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test `create_index` function
|
|
******************************************************************
|
|
"""
|
|
|
|
@pytest.fixture(
|
|
scope="function",
|
|
params=gen_simple_index()
|
|
)
|
|
def get_simple_index(self, request):
|
|
log.info(request.param)
|
|
return copy.deepcopy(request.param)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_new(self, get_simple_index):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, shards_num=1)
|
|
data = cf.gen_default_list_data(nb=5000)
|
|
collection_w.insert(data=data)
|
|
log.debug(collection_w.num_entities)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.skip(reason="The scenario in this case is not existed for each RPC is limited to 64 MB")
|
|
def test_annoy_index(self):
|
|
# The strange thing is that the indexnode crash is only reproduced when nb is 50000 and dim is 512
|
|
nb = 50000
|
|
dim = 512
|
|
|
|
fields = [cf.gen_int64_field(), cf.gen_float_vec_field(dim=dim)]
|
|
schema = cf.gen_collection_schema(fields, primary_field=ct.default_int64_field_name)
|
|
collection_w = self.init_collection_wrap(name=cf.gen_unique_str(), schema=schema)
|
|
|
|
# use python random to generate the data as usual doesn't reproduce
|
|
data = [[i for i in range(nb)], np.random.random([nb, dim]).tolist()]
|
|
collection_w.insert(data)
|
|
log.debug(collection_w.num_entities)
|
|
|
|
index_params = {"index_type": "ANNOY", "metric_type": "IP", "params": {"n_trees": 10}}
|
|
index_wrapper = ApiIndexWrapper()
|
|
index, _ = index_wrapper.init_index(collection_w.collection, ct.default_float_vec_field_name, index_params)
|
|
assert index.params == index_params
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_non_existed_field(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index on other field
|
|
expected: error raised
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_int8_field_name, default_index_params,
|
|
index_name=ct.default_index_name,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "cannot create index on non-existed field: int8"}
|
|
)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_no_vectors(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params,
|
|
index_name=ct.default_index_name)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_partition(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection, create partition, and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
collection_w = self.init_collection_wrap()
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
data = cf.gen_default_list_data()
|
|
ins_res, _ = partition_w.insert(data)
|
|
assert len(ins_res.primary_keys) == len(data[0])
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_partition_flush(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection, create partition, and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
collection_w = self.init_collection_wrap()
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
data = cf.gen_default_list_data(default_nb)
|
|
partition_w.insert(data)
|
|
assert collection_w.num_entities == default_nb
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_without_connect(self):
|
|
"""
|
|
target: test create index without connection
|
|
method: create collection and add entities in it, check if added successfully
|
|
expected: raise exception
|
|
"""
|
|
self._connect()
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
self.connection_wrap.remove_connection(ct.default_alias)
|
|
res_list, _ = self.connection_wrap.list_connections()
|
|
assert ct.default_alias not in res_list
|
|
collection_w.create_index(ct.default_float_vec_field_name, ct.default_index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: "should create connect first"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_search_with_query_vectors(self):
|
|
"""
|
|
target: test create index interface, search with more query vectors
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
self._connect()
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
collection_w.load()
|
|
vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
|
|
collection_w.search(vectors[:default_nq], default_search_field,
|
|
default_search_params, default_limit,
|
|
default_search_exp)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_multithread(self):
|
|
"""
|
|
target: test create index interface with multiprocess
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
|
|
def build(collection_w):
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
|
|
threads_num = 8
|
|
threads = []
|
|
for i in range(threads_num):
|
|
t = MyThread(target=build, args=(collection_w,))
|
|
threads.append(t)
|
|
t.start()
|
|
time.sleep(0.2)
|
|
for t in threads:
|
|
t.join()
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_insert_flush(self, get_simple_index):
|
|
"""
|
|
target: test create index
|
|
method: create collection and create index, add entities in it
|
|
expected: create index ok, and count correct
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_same_index_repeatedly(self):
|
|
"""
|
|
target: check if index can be created repeatedly, with the same create_index params
|
|
method: create index after index have been built
|
|
expected: return code success, and search ok
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_different_name(self):
|
|
"""
|
|
target: check if index can be created repeatedly, with the same create_index params
|
|
method: create index after index have been built
|
|
expected: raise error
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params, index_name="a")
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params, index_name="b",
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "CreateIndex failed: creating multiple indexes on same field is not supported"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_repeatedly_new(self):
|
|
"""
|
|
target: check if index can be created repeatedly, with the different create_index params
|
|
method: create another index with different index_params after index have been built
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
index_prams = [default_index, {"metric_type": "L2", "index_type": "IVF_SQ8", "params": {"nlist": 1024}}]
|
|
for index in index_prams:
|
|
index_name = cf.gen_unique_str("name")
|
|
collection_w.create_index(default_float_vec_field_name, index, index_name=index_name)
|
|
collection_w.load()
|
|
collection_w.release()
|
|
collection_w.drop_index(index_name=index_name)
|
|
assert len(collection_w.collection.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_ip(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_no_vectors_ip(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params,
|
|
index_name=ct.default_index_name)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_partition_ip(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection, create partition, and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
collection_w = self.init_collection_wrap()
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
data = cf.gen_default_list_data(default_nb)
|
|
ins_res, _ = partition_w.insert(data)
|
|
assert len(ins_res.primary_keys) == len(data[0])
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_partition_flush_ip(self):
|
|
"""
|
|
target: test create index
|
|
method: create collection and create index, add entities in it
|
|
expected: create index ok, and count correct
|
|
"""
|
|
collection_w = self.init_collection_wrap()
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
data = cf.gen_default_list_data(default_nb)
|
|
partition_w.insert(data)
|
|
assert collection_w.num_entities == default_nb
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_search_with_query_vectors_ip(self):
|
|
"""
|
|
target: test create index interface, search with more query vectors
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
self._connect()
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
collection_w.load()
|
|
vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
|
|
collection_w.search(vectors[:default_nq], default_search_field,
|
|
default_search_ip_params, default_limit,
|
|
default_search_exp)
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_multithread_ip(self):
|
|
"""
|
|
target: test create index interface with multiprocess
|
|
method: create collection and add entities in it, create index
|
|
expected: return success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
|
|
def build(collection_w):
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
|
|
threads_num = 8
|
|
threads = []
|
|
for i in range(threads_num):
|
|
t = MyThread(target=build, args=(collection_w,))
|
|
threads.append(t)
|
|
t.start()
|
|
time.sleep(0.2)
|
|
for t in threads:
|
|
t.join()
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_no_vectors_insert_ip(self):
|
|
"""
|
|
target: test create index interface when there is no vectors in collection,
|
|
and does not affect the subsequent process
|
|
method: create collection and add no vectors in it, and then create index,
|
|
add entities in it
|
|
expected: return insert suceess
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_same_index_repeatedly_ip(self):
|
|
"""
|
|
target: check if index can be created repeatedly, with the same create_index params
|
|
method: create index after index have been built
|
|
expected: return code success, and search ok
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params)
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_different_name_ip(self):
|
|
"""
|
|
target: check if index can be created repeatedly, with the same create_index params
|
|
method: create index after index have been built
|
|
expected: raise error
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params, index_name="a")
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params, index_name="b",
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "CreateIndex failed: creating multiple indexes on same field is not supported"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
def test_create_different_index_repeatedly_ip(self):
|
|
"""
|
|
target: check if index can be created repeatedly, with the different create_index params
|
|
method: create another index with different index_params after index have been built
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
index_prams = [default_ip_index_params,
|
|
{"metric_type": "IP", "index_type": "IVF_SQ8", "params": {"nlist": 1024}}]
|
|
for index in index_prams:
|
|
index_name = cf.gen_unique_str("name")
|
|
collection_w.create_index(default_float_vec_field_name, index, index_name=index_name)
|
|
collection_w.release()
|
|
collection_w.drop_index(index_name=index_name)
|
|
assert len(collection_w.collection.indexes) == 0
|
|
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test `drop_index` function
|
|
******************************************************************
|
|
"""
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
def test_drop_index(self, get_simple_index):
|
|
"""
|
|
target: test drop index interface
|
|
method: create collection and add entities in it, create index, call drop index
|
|
expected: return code 0, and default index param
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
# TODO #7372
|
|
def test_drop_index_repeatedly(self, get_simple_index):
|
|
"""
|
|
target: test drop index repeatedly
|
|
method: create index, call drop index, and drop again
|
|
expected: return code 0
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index_without_connect(self):
|
|
"""
|
|
target: test drop index without connection
|
|
method: drop index, and check if drop successfully
|
|
expected: raise exception
|
|
"""
|
|
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params,
|
|
index_name=ct.default_index_name)
|
|
self.connection_wrap.remove_connection(ct.default_alias)
|
|
collection_w.drop_index(index_name=ct.default_index_name, check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 0, ct.err_msg: "should create connect first."})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_drop_index_repeatedly(self, get_simple_index):
|
|
"""
|
|
target: test create / drop index repeatedly, use the same index params
|
|
method: create index, drop index, four times
|
|
expected: return code 0
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
for i in range(4):
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index_ip(self, get_simple_index):
|
|
"""
|
|
target: test drop index interface
|
|
method: create collection and add entities in it, create index, call drop index
|
|
expected: return code 0, and default index param
|
|
"""
|
|
get_simple_index["metric_type"] = "IP"
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index_repeatedly_ip(self, get_simple_index):
|
|
"""
|
|
target: test drop index repeatedly
|
|
method: create index, call drop index, and drop again
|
|
expected: return code 0
|
|
"""
|
|
get_simple_index["metric_type"] = "IP"
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index_without_connect_ip(self):
|
|
"""
|
|
target: test drop index without connection
|
|
method: drop index, and check if drop successfully
|
|
expected: raise exception
|
|
"""
|
|
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_ip_index_params,
|
|
index_name=ct.default_index_name)
|
|
self.connection_wrap.remove_connection(ct.default_alias)
|
|
collection_w.drop_index(index_name=ct.default_index_name, check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 0, ct.err_msg: "should create connect first."})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_drop_index_repeatedly_ip(self, get_simple_index):
|
|
"""
|
|
target: test create / drop index repeatedly, use the same index params
|
|
method: create index, drop index, four times
|
|
expected: return code 0
|
|
"""
|
|
get_simple_index["metric_type"] = "IP"
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
if get_simple_index["index_type"] != "FLAT":
|
|
for i in range(4):
|
|
collection_w.create_index(ct.default_float_vec_field_name, get_simple_index,
|
|
index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
def test_create_PQ_without_nbits(self):
|
|
"""
|
|
target: test create PQ index
|
|
method: create PQ index without nbits
|
|
expected: create successfully
|
|
"""
|
|
PQ_index = {"index_type": "IVF_PQ", "params": {"nlist": 128, "m": 16}, "metric_type": "L2"}
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
collection_w.create_index(ct.default_float_vec_field_name, PQ_index, index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index_collection_not_create_ip(self):
|
|
"""
|
|
target: test drop index interface when index not created
|
|
method: create collection and add entities in it, create index
|
|
expected: return code not equals to 0, drop index failed
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
collection_w.drop_index(index_name=default_field_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_collection_with_after_load(self):
|
|
"""
|
|
target: Test that index files are not lost after loading
|
|
method: create collection and add entities in it, create index, flush and load
|
|
expected: load and search successfully
|
|
"""
|
|
collection_w = self.init_collection_wrap(cf.gen_unique_str(prefix))
|
|
nums = 20
|
|
tmp_nb = 5000
|
|
for i in range(nums):
|
|
df = cf.gen_default_dataframe_data(nb=tmp_nb, start=i * tmp_nb)
|
|
insert_res, _ = collection_w.insert(df)
|
|
assert collection_w.num_entities == (i + 1) * tmp_nb
|
|
collection_w.create_index(ct.default_float_vec_field_name, default_index_params)
|
|
collection_w.load()
|
|
vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
|
|
search_res, _ = collection_w.search(vectors, default_search_field, default_search_params, default_limit)
|
|
assert len(search_res[0]) == ct.default_limit
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestNewIndexBinary(TestcaseBase):
|
|
|
|
def get_simple_index(self, request):
|
|
log.info(request.param)
|
|
return copy.deepcopy(request.param)
|
|
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test `create_index` function
|
|
******************************************************************
|
|
"""
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
def test_create_index(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
collection_w.insert(data=df)
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name=binary_field_name)
|
|
assert collection_w.has_index(index_name=binary_field_name)[0] == True
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
def test_create_index_partition(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection, create partition, and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
ins_res, _ = partition_w.insert(df)
|
|
assert len(ins_res.primary_keys) == len(df)
|
|
collection_w.create_index(default_binary_vec_field_name, default_binary_index_params,
|
|
index_name=binary_field_name)
|
|
assert collection_w.has_index(index_name=binary_field_name)[0] == True
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
def test_create_index_search_with_query_vectors(self):
|
|
"""
|
|
target: test create index interface, search with more query vectors
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
collection_w.insert(data=df)
|
|
collection_w.create_index(default_binary_vec_field_name, default_binary_index_params,
|
|
index_name=binary_field_name)
|
|
collection_w.load()
|
|
_, vectors = cf.gen_binary_vectors(default_nq, default_dim)
|
|
collection_w.search(vectors[:default_nq], binary_field_name,
|
|
default_search_binary_params, default_limit,
|
|
default_search_exp)
|
|
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_invalid_metric_type_binary(self):
|
|
"""
|
|
target: test create index interface with invalid metric type
|
|
method: add entities into binary collection, flush, create index with L2 metric type.
|
|
expected: return create_index failure
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
binary_index_params = {'index_type': 'BIN_IVF_FLAT', 'metric_type': 'L2', 'params': {'nlist': 64}}
|
|
collection_w.create_index(default_binary_vec_field_name, binary_index_params,
|
|
index_name=binary_field_name, check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "Invalid metric_type: L2, which does not match the index type: BIN_IVF_FLAT"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
@pytest.mark.parametrize("metric_type", ["L2", "IP", "COSINE", "JACCARD", "HAMMING", "TANIMOTO"])
|
|
def test_create_binary_index_HNSW(self, metric_type):
|
|
"""
|
|
target: test create binary index hnsw
|
|
method: create binary index hnsw
|
|
expected: succeed
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
binary_index_params = {'index_type': 'HNSW', "M": '18', "efConstruction": '240', 'metric_type': metric_type}
|
|
if metric_type == "TANIMOTO":
|
|
collection_w.create_index(default_binary_vec_field_name, binary_index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "metric type not found or not supported"})
|
|
else:
|
|
collection_w.create_index(default_binary_vec_field_name, binary_index_params)
|
|
assert collection_w.index()[0].params == binary_index_params
|
|
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test `drop_index` function
|
|
******************************************************************
|
|
"""
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index(self):
|
|
"""
|
|
target: test drop index interface
|
|
method: create collection and add entities in it, create index, call drop index
|
|
expected: return code 0, and default index param
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
collection_w.insert(data=df)
|
|
collection_w.create_index(default_binary_vec_field_name, default_binary_index_params,
|
|
index_name=binary_field_name)
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=binary_field_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
def test_drop_index_partition(self):
|
|
"""
|
|
target: test drop index interface
|
|
method: create collection, create partition and add entities in it,
|
|
create index on collection, call drop collection index
|
|
expected: return code 0, and default index param
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
ins_res, _ = partition_w.insert(df)
|
|
assert len(ins_res.primary_keys) == len(df)
|
|
collection_w.create_index(default_binary_vec_field_name, default_binary_index_params,
|
|
index_name=binary_field_name)
|
|
assert collection_w.has_index(index_name=binary_field_name)[0] == True
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.drop_index(index_name=binary_field_name)
|
|
assert collection_w.has_index(index_name=binary_field_name)[0] == False
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestIndexInvalid(TestcaseBase):
|
|
"""
|
|
Test create / describe / drop index interfaces with invalid collection names
|
|
"""
|
|
|
|
@pytest.fixture(
|
|
scope="function",
|
|
params=gen_invalid_strs()
|
|
)
|
|
def get_collection_name(self, request):
|
|
yield request.param
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
def test_create_index_with_invalid_collection_name(self, connect, get_collection_name):
|
|
"""
|
|
target: test create index interface for invalid scenario
|
|
method: create index with invalid collection name
|
|
expected: raise exception
|
|
"""
|
|
collection_name = get_collection_name
|
|
with pytest.raises(Exception) as e:
|
|
connect.create_index(collection_name, field_name, default_index)
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_index_with_invalid_collection_name(self, connect, get_collection_name):
|
|
"""
|
|
target: test drop index interface for invalid scenario
|
|
method: drop index with invalid collection name
|
|
expected: raise exception
|
|
"""
|
|
collection_name = get_collection_name
|
|
with pytest.raises(Exception) as e:
|
|
connect.drop_index(collection_name)
|
|
|
|
@pytest.fixture(
|
|
scope="function",
|
|
params=gen_invalid_index()
|
|
)
|
|
def get_index(self, request):
|
|
yield request.param
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_with_invalid_index_params(self, connect, collection, get_index):
|
|
"""
|
|
target: test create index interface for invalid scenario
|
|
method: create index with invalid index params
|
|
expected: raise exception
|
|
"""
|
|
log.info(get_index)
|
|
with pytest.raises(Exception) as e:
|
|
connect.create_index(collection, field_name, get_index)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_drop_index_without_release(self):
|
|
"""
|
|
target: test drop index after load without release
|
|
method: 1. create a collection and build an index then load
|
|
2. drop the index
|
|
expected: raise exception
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, True, is_index=False)[0]
|
|
default_index = {"index_type": "IVF_FLAT", "params": {"nlist": 128}, "metric_type": "L2"}
|
|
collection_w.create_index("float_vector", default_index)
|
|
collection_w.load()
|
|
collection_w.drop_index(check_task=CheckTasks.err_res,
|
|
check_items={"err_code": 1,
|
|
"err_msg": "index cannot be dropped, collection is "
|
|
"loaded, please release it first"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("n_trees", [-1, 1025, 'a', {34}])
|
|
def test_annoy_index_with_invalid_params(self, n_trees):
|
|
"""
|
|
target: test create index with invalid params
|
|
method: 1. set annoy index param n_trees out of range [1, 1024]
|
|
2. set annoy index param n_trees type invalid(not int)
|
|
expected: raise exception
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, True, is_index=False)[0]
|
|
index_annoy = {"index_type": "ANNOY", "params": {"n_trees": n_trees}, "metric_type": "L2"}
|
|
collection_w.create_index("float_vector", index_annoy,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={"err_code": 1,
|
|
"err_msg": "invalid index params"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_json(self):
|
|
"""
|
|
target: test create index on json fields
|
|
method: 1.create collection, and create index
|
|
expected: create index raise an error
|
|
"""
|
|
collection_w, _, _, insert_ids = self.init_collection_general(prefix, True,
|
|
dim=ct.default_dim, is_index=False)[0:4]
|
|
collection_w.create_index(ct.default_json_field_name, index_params=ct.default_flat_index,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "create index on json field is not supported"})
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestNewIndexAsync(TestcaseBase):
|
|
@pytest.fixture(scope="function", params=[False, True])
|
|
def _async(self, request):
|
|
yield request.param
|
|
|
|
def call_back(self):
|
|
assert True
|
|
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test `create_index` function
|
|
******************************************************************
|
|
"""
|
|
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
def test_create_index(self, _async):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
res, _ = collection_w.create_index(ct.default_float_vec_field_name, default_index_params,
|
|
index_name=ct.default_index_name, _async=_async)
|
|
if _async:
|
|
res.done()
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
def test_create_index_drop(self, _async):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
res, _ = collection_w.create_index(ct.default_float_vec_field_name, default_index_params,
|
|
index_name=ct.default_index_name, _async=_async)
|
|
|
|
# load and search
|
|
if _async:
|
|
res.done()
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.load()
|
|
vectors_s = [[random.random() for _ in range(ct.default_dim)] for _ in range(ct.default_nq)]
|
|
search_res, _ = collection_w.search(vectors_s[:ct.default_nq], ct.default_float_vec_field_name,
|
|
ct.default_search_params, ct.default_limit)
|
|
assert len(search_res) == ct.default_nq
|
|
assert len(search_res[0]) == ct.default_limit
|
|
|
|
collection_w.release()
|
|
if _async:
|
|
res.done()
|
|
assert collection_w.indexes[0].params == default_index_params
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
# @pytest.mark.timeout(BUILD_TIMEOUT)
|
|
def test_create_index_callback(self):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
res, _ = collection_w.create_index(ct.default_float_vec_field_name, default_index_params,
|
|
index_name=ct.default_index_name, _async=True,
|
|
_callback=self.call_back())
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestIndexString(TestcaseBase):
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test create index about string
|
|
******************************************************************
|
|
"""
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_with_string_field(self):
|
|
"""
|
|
target: test create index with string field is not primary
|
|
method: 1.create collection and insert data
|
|
2.only create an index with string field is not primary
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
|
|
default_string_index_params)
|
|
cf.assert_equal_index(index, collection_w.indexes[0])
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_with_string_before_load(self):
|
|
"""
|
|
target: test create index with string field before load
|
|
method: 1.create collection and insert data
|
|
2.create an index with string field before load
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(ct.default_nb)
|
|
collection_w.insert(data=data)
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
|
|
default_string_index_params)
|
|
cf.assert_equal_index(index, collection_w.indexes[0])
|
|
collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index, index_name="vector_flat")
|
|
collection_w.load()
|
|
assert collection_w.num_entities == default_nb
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_load_after_create_index_with_string(self):
|
|
"""
|
|
target: test load after create index with string field
|
|
method: 1.create collection and insert data
|
|
2.collection load after create index with string field
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(ct.default_nb)
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(ct.default_float_vec_field_name, index_params=ct.default_flat_index, index_name="vector_flat")
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
|
|
default_string_index_params)
|
|
collection_w.load()
|
|
cf.assert_equal_index(index, collection_w.indexes[0])
|
|
assert collection_w.num_entities == default_nb
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_with_string_field_is_primary(self):
|
|
"""
|
|
target: test create index with string field is primary
|
|
method: 1.create collection
|
|
2.insert data
|
|
3.only create an index with string field is primary
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
schema = cf.gen_string_pk_default_collection_schema()
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=schema)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
|
|
default_string_index_params)
|
|
cf.assert_equal_index(index, collection_w.indexes[0])
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_or_not_with_string_field(self):
|
|
"""
|
|
target: test create index, half of the string fields are indexed and half are not
|
|
method: 1.create collection
|
|
2.insert data
|
|
3.half of the indexes are created and half are not in the string fields
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
string_fields = [cf.gen_string_field(name="test_string")]
|
|
schema = cf.gen_schema_multi_string_fields(string_fields)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=schema)
|
|
df = cf.gen_dataframe_multi_string_fields(string_fields=string_fields)
|
|
collection_w.insert(df)
|
|
self.index_wrap.init_index(collection_w.collection, default_string_field_name, default_string_index_params)
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_index_with_same_index_name(self):
|
|
"""
|
|
target: test create index with different fields use same index name
|
|
method: 1.create collection
|
|
2.insert data
|
|
3.only create index with different fields use same index name
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name=index_name2)
|
|
collection_w.create_index(default_float_vec_field_name, default_index_params,
|
|
index_name=index_name2,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1, ct.err_msg: "CreateIndex failed"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_different_index_fields(self):
|
|
"""
|
|
target: test create index with different fields
|
|
method: 1.create collection
|
|
2.insert data
|
|
3.create different indexes with string and float vector field
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(default_float_vec_field_name, default_index_params, index_name=index_name1)
|
|
assert collection_w.has_index(index_name=index_name1)[0] == True
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name=index_name2)
|
|
assert collection_w.has_index(index_name=index_name2)[0] == True
|
|
assert len(collection_w.indexes) == 2
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_create_different_index_binary_fields(self):
|
|
"""
|
|
target: testing the creation of indexes with string and binary fields
|
|
method: 1.create collection
|
|
2.insert data
|
|
3.create different indexes with string and binary vector field
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
collection_w.insert(data=df)
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name=index_name2)
|
|
assert collection_w.has_index(index_name=index_name2)[0] == True
|
|
collection_w.create_index(default_binary_vec_field_name, default_binary_index_params, index_name=index_name3)
|
|
assert collection_w.has_index(index_name=index_name3)[0] == True
|
|
assert len(collection_w.indexes) == 2
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_drop_index_with_string_field(self):
|
|
"""
|
|
target: test drop index with string field
|
|
method: 1.create collection and insert data
|
|
2.create index and use index.drop() drop index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_string_field_name,
|
|
default_string_index_params)
|
|
cf.assert_equal_index(index, collection_w.indexes[0])
|
|
self.index_wrap.drop()
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_collection_drop_index_with_string(self):
|
|
"""
|
|
target: test drop index with string field
|
|
method: 1.create collection and insert data
|
|
2.create index and uses collection.drop_index () drop index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name=index_name2)
|
|
collection_w.drop_index(index_name=index_name2)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
def test_index_with_string_field_empty(self):
|
|
"""
|
|
target: test drop index with string field
|
|
method: 1.create collection and insert data
|
|
2.create index and uses collection.drop_index () drop index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
|
|
nb = 3000
|
|
data = cf.gen_default_list_data(nb)
|
|
data[2] = [""for _ in range(nb)]
|
|
collection_w.insert(data=data)
|
|
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name=index_name2)
|
|
assert collection_w.has_index(index_name=index_name2)[0] == True
|
|
collection_w.drop_index(index_name=index_name2)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestIndexDiskann(TestcaseBase):
|
|
"""
|
|
******************************************************************
|
|
The following cases are used to test create index about diskann
|
|
******************************************************************
|
|
"""
|
|
@pytest.fixture(scope="function", params=[False, True])
|
|
def _async(self, request):
|
|
yield request.param
|
|
|
|
def call_back(self):
|
|
assert True
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_with_diskann_normal(self):
|
|
"""
|
|
target: test create index with diskann
|
|
method: 1.create collection and insert data
|
|
2.create diskann index , then load data
|
|
3.search successfully
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
index, _ = self.index_wrap.init_index(collection_w.collection, default_float_vec_field_name, ct.default_diskann_index)
|
|
log.info(self.index_wrap.params)
|
|
cf.assert_equal_index(index, collection_w.indexes[0])
|
|
collection_w.load()
|
|
vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
|
|
search_res, _ = collection_w.search(vectors[:default_nq], default_search_field,
|
|
ct.default_diskann_search_params, default_limit,
|
|
default_search_exp,
|
|
check_task=CheckTasks.check_search_results,
|
|
check_items={"nq": default_nq,
|
|
"limit": default_limit})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_with_max_dim(self):
|
|
"""
|
|
target: test create index with diskann
|
|
method: 1.create collection, when the max dim of the vector is 32768
|
|
2.create diskann index
|
|
expected: create index raise an error
|
|
"""
|
|
dim = 32768
|
|
c_name = cf.gen_unique_str(prefix)
|
|
fields = [cf.gen_int64_field(is_primary=True), cf.gen_float_field(), cf.gen_string_field(),
|
|
cf.gen_float_vec_field(dim=dim)]
|
|
schema = cf.gen_collection_schema(fields=fields)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=schema)
|
|
collection_w.create_index(default_float_vec_field_name, ct.default_diskann_index)
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_index_with_diskann_callback(self, _async):
|
|
"""
|
|
target: test create index with diskann
|
|
method: 1.create collection and insert data
|
|
2.create diskann index ,then load
|
|
3.search
|
|
expected: create index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
res, _ = collection_w.create_index(ct.default_float_vec_field_name, ct.default_diskann_index,
|
|
index_name=ct.default_index_name, _async=_async,
|
|
_callback=self.call_back())
|
|
|
|
if _async:
|
|
res.done()
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.load()
|
|
vectors = [[random.random() for _ in range(default_dim)] for _ in range(default_nq)]
|
|
search_res, _ = collection_w.search(vectors[:default_nq], default_search_field,
|
|
ct.default_diskann_search_params, default_limit,
|
|
default_search_exp,
|
|
check_task=CheckTasks.check_search_results,
|
|
check_items={"nq": default_nq,
|
|
"limit": default_limit})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_diskann_index_drop_with_async(self, _async):
|
|
"""
|
|
target: test create index interface
|
|
method: create collection and add entities in it, create diskann index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
res, _ = collection_w.create_index(ct.default_float_vec_field_name, ct.default_diskann_index,
|
|
index_name=ct.default_index_name, _async=_async)
|
|
if _async:
|
|
res.done()
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.release()
|
|
collection_w.drop_index(index_name=ct.default_index_name)
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_diskann_index_with_partition(self):
|
|
"""
|
|
target: test create index with diskann
|
|
method: 1.create collection , partition and insert data to partition
|
|
2.create diskann index ,then load
|
|
expected: create index successfully
|
|
"""
|
|
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_schema)
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
df = cf.gen_default_list_data(ct.default_nb)
|
|
ins_res, _ = partition_w.insert(df)
|
|
assert len(ins_res.primary_keys) == ct.default_nb
|
|
collection_w.create_index(default_float_vec_field_name, ct.default_diskann_index,
|
|
index_name=field_name)
|
|
collection_w.load()
|
|
assert collection_w.has_index(index_name=field_name)[0] is True
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.release()
|
|
collection_w.drop_index(index_name=field_name)
|
|
assert collection_w.has_index(index_name=field_name)[0] is False
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_diskann_index_with_normal(self):
|
|
"""
|
|
target: test drop diskann index normal
|
|
method: 1.create collection and insert data
|
|
2.create index and uses collection.drop_index () drop index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
collection_w.create_index(default_float_vec_field_name, ct.default_diskann_index, index_name=index_name1)
|
|
collection_w.load()
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.release()
|
|
collection_w.drop_index(index_name=index_name1)
|
|
assert collection_w.has_index(index_name=index_name1)[0] == False
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_diskann_index_and_create_again(self):
|
|
"""
|
|
target: test drop diskann index normal
|
|
method: 1.create collection and insert data
|
|
2.create index and uses collection.drop_index () drop index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
collection_w.create_index(default_field_name, ct.default_diskann_index)
|
|
collection_w.load()
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.release()
|
|
collection_w.drop_index()
|
|
assert len(collection_w.indexes) == 0
|
|
collection_w.create_index(default_field_name, ct.default_diskann_index)
|
|
assert len(collection_w.indexes) == 1
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_more_than_three_index(self):
|
|
"""
|
|
target: test create diskann index
|
|
method: 1.create collection and insert data
|
|
2.create different index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data()
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
collection_w.create_index(default_float_vec_field_name, ct.default_diskann_index, index_name="a")
|
|
assert collection_w.has_index(index_name="a")[0] == True
|
|
collection_w.create_index(default_string_field_name, default_string_index_params, index_name="b")
|
|
assert collection_w.has_index(index_name="b")[0] == True
|
|
default_params = {}
|
|
collection_w.create_index("float", default_params, index_name="c")
|
|
assert collection_w.has_index(index_name="c")[0] == True
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_drop_diskann_index_with_partition(self):
|
|
"""
|
|
target: test drop diskann index normal
|
|
method: 1.create collection and insert data
|
|
2.create diskann index and uses collection.drop_index () drop index
|
|
expected: drop index successfully
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_schema)
|
|
partition_name = cf.gen_unique_str(prefix)
|
|
partition_w = self.init_partition_wrap(collection_w, partition_name)
|
|
assert collection_w.has_partition(partition_name)[0]
|
|
df = cf.gen_default_list_data()
|
|
ins_res, _ = partition_w.insert(df)
|
|
collection_w.create_index(default_float_vec_field_name, ct.default_diskann_index)
|
|
collection_w.load()
|
|
assert len(collection_w.indexes) == 1
|
|
collection_w.release()
|
|
collection_w.drop_index()
|
|
assert len(collection_w.indexes) == 0
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_diskann_index_with_binary(self):
|
|
"""
|
|
target: test create diskann index with binary
|
|
method: 1.create collection and insert binary data
|
|
2.create diskann index
|
|
expected: report an error
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=default_binary_schema)
|
|
df, _ = cf.gen_default_binary_dataframe_data()
|
|
collection_w.insert(data=df)
|
|
collection_w.create_index(default_binary_vec_field_name, ct.default_diskann_index, index_name=binary_field_name,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "field data type BinaryVector don't support the index build type DISKANN"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_diskann_index_multithread(self):
|
|
"""
|
|
target: test create index interface with multiprocess
|
|
method: create collection and add entities in it, create diskann index
|
|
expected: return search success
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
collection_w = self.init_collection_wrap(name=c_name)
|
|
data = cf.gen_default_list_data(default_nb)
|
|
collection_w.insert(data=data)
|
|
assert collection_w.num_entities == default_nb
|
|
|
|
def build(collection_w):
|
|
|
|
collection_w.create_index(ct.default_float_vec_field_name, ct.default_diskann_index)
|
|
|
|
threads_num = 10
|
|
threads = []
|
|
for i in range(threads_num):
|
|
t = MyThread(target=build, args=(collection_w,))
|
|
threads.append(t)
|
|
t.start()
|
|
time.sleep(0.2)
|
|
for t in threads:
|
|
t.join()
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("dim", [1, 2, 8, 16, 24, 31])
|
|
def test_create_index_with_small_dim(self, dim):
|
|
"""
|
|
target: test create index with diskann
|
|
method: 1.create collection, when the dim of the vector Less than 32
|
|
2.create diskann index
|
|
expected: create index raise an error
|
|
"""
|
|
c_name = cf.gen_unique_str(prefix)
|
|
fields = [cf.gen_int64_field(is_primary=True), cf.gen_float_field(), cf.gen_string_field(),
|
|
cf.gen_float_vec_field(dim=dim)]
|
|
schema = cf.gen_collection_schema(fields=fields)
|
|
collection_w = self.init_collection_wrap(name=c_name, schema=schema)
|
|
collection_w.create_index(default_float_vec_field_name, ct.default_diskann_index,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={ct.err_code: 1,
|
|
ct.err_msg: "invalid index params"})
|
|
|
|
|
|
@pytest.mark.tags(CaseLabel.GPU)
|
|
class TestAutoIndex(TestcaseBase):
|
|
""" Test case of Auto index """
|
|
|
|
@pytest.mark.tags(CaseLabel.L0)
|
|
def test_create_autoindex_with_no_params(self):
|
|
"""
|
|
target: test create auto index with no params
|
|
method: create index with only one field name
|
|
expected: create successfully
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, is_index=False)[0]
|
|
collection_w.create_index(field_name)
|
|
actual_index_params = collection_w.index()[0].params
|
|
assert default_autoindex_params == actual_index_params
|
|
|
|
@pytest.mark.tags(CaseLabel.L1)
|
|
@pytest.mark.parametrize("index_params", cf.gen_autoindex_params())
|
|
def test_create_autoindex_with_params(self, index_params):
|
|
"""
|
|
target: test create auto index with params
|
|
method: create index with different params
|
|
expected: create successfully
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, is_index=False)[0]
|
|
collection_w.create_index(field_name, index_params)
|
|
actual_index_params = collection_w.index()[0].params
|
|
log.info(collection_w.index()[0].params)
|
|
expect_autoindex_params = copy.copy(default_autoindex_params)
|
|
if index_params.get("index_type"):
|
|
if index_params["index_type"] != 'AUTOINDEX':
|
|
expect_autoindex_params = index_params
|
|
if index_params.get("metric_type"):
|
|
expect_autoindex_params["metric_type"] = index_params["metric_type"]
|
|
assert actual_index_params == expect_autoindex_params
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_autoindex_with_invalid_params(self):
|
|
"""
|
|
target: test create auto index with invalid params
|
|
method: create index with invalid params
|
|
expected: raise exception
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, is_index=False)[0]
|
|
index_params = {"metric_type": "L2", "nlist": "1024", "M": "100"}
|
|
collection_w.create_index(field_name, index_params,
|
|
check_task=CheckTasks.err_res,
|
|
check_items={"err_code": 1,
|
|
"err_msg": "only metric type can be "
|
|
"passed when use AutoIndex"})
|
|
|
|
@pytest.mark.tags(CaseLabel.L2)
|
|
def test_create_autoindex_on_binary_vectors(self):
|
|
"""
|
|
target: test create auto index on binary vectors
|
|
method: create index on binary vectors
|
|
expected: raise exception
|
|
"""
|
|
collection_w = self.init_collection_general(prefix, is_binary=True, is_index=False)[0]
|
|
collection_w.create_index(binary_field_name, {})
|
|
actual_index_params = collection_w.index()[0].params
|
|
assert default_autoindex_params == actual_index_params
|