vectordb-bench 0.0.30__py3-none-any.whl → 1.0.1__py3-none-any.whl

vectordb_bench/__init__.py

@@ -18,37 +18,16 @@ class config:
     DEFAULT_DATASET_URL = env.str("DEFAULT_DATASET_URL", AWS_S3_URL)
     DATASET_LOCAL_DIR = env.path("DATASET_LOCAL_DIR", "/tmp/vectordb_bench/dataset")
     NUM_PER_BATCH = env.int("NUM_PER_BATCH", 100)
+    TIME_PER_BATCH = 1  # 1s. for streaming insertion.
+    MAX_INSERT_RETRY = 5
+    MAX_SEARCH_RETRY = 5
+
+    LOAD_MAX_TRY_COUNT = 10
 
     DROP_OLD = env.bool("DROP_OLD", True)
     USE_SHUFFLED_DATA = env.bool("USE_SHUFFLED_DATA", True)
 
-    NUM_CONCURRENCY = env.list(
-        "NUM_CONCURRENCY",
-        [
-            1,
-            5,
-            10,
-            15,
-            20,
-            25,
-            30,
-            35,
-            40,
-            45,
-            50,
-            55,
-            60,
-            65,
-            70,
-            75,
-            80,
-            85,
-            90,
-            95,
-            100,
-        ],
-        subcast=int,
-    )
+    NUM_CONCURRENCY = env.list("NUM_CONCURRENCY", [1, 5, 10, 20, 30, 40, 60, 80], subcast=int)
 
     CONCURRENCY_DURATION = 30
 
@@ -68,6 +47,7 @@ class config:
 
     CAPACITY_TIMEOUT_IN_SECONDS = 24 * 3600  # 24h
     LOAD_TIMEOUT_DEFAULT = 24 * 3600  # 24h
+    LOAD_TIMEOUT_768D_100K = 24 * 3600  # 24h
     LOAD_TIMEOUT_768D_1M = 24 * 3600  # 24h
     LOAD_TIMEOUT_768D_10M = 240 * 3600  # 10d
     LOAD_TIMEOUT_768D_100M = 2400 * 3600  # 100d
@@ -75,7 +55,11 @@ class config:
     LOAD_TIMEOUT_1536D_500K = 24 * 3600  # 24h
     LOAD_TIMEOUT_1536D_5M = 240 * 3600  # 10d
 
+    LOAD_TIMEOUT_1024D_1M = 24 * 3600  # 24h
+    LOAD_TIMEOUT_1024D_10M = 240 * 3600  # 10d
+
     OPTIMIZE_TIMEOUT_DEFAULT = 24 * 3600  # 24h
+    OPTIMIZE_TIMEOUT_768D_100K = 24 * 3600  # 24h
     OPTIMIZE_TIMEOUT_768D_1M = 24 * 3600  # 24h
     OPTIMIZE_TIMEOUT_768D_10M = 240 * 3600  # 10d
     OPTIMIZE_TIMEOUT_768D_100M = 2400 * 3600  # 100d
@@ -83,6 +67,9 @@ class config:
     OPTIMIZE_TIMEOUT_1536D_500K = 24 * 3600  # 24h
     OPTIMIZE_TIMEOUT_1536D_5M = 240 * 3600  # 10d
 
+    OPTIMIZE_TIMEOUT_1024D_1M = 24 * 3600  # 24h
+    OPTIMIZE_TIMEOUT_1024D_10M = 240 * 3600  # 10d
+
     def display(self) -> str:
         return [
             i

vectordb_bench/__main__.py

@@ -17,7 +17,7 @@ def run_streamlit():
     cmd = [
         "streamlit",
         "run",
-        f"{pathlib.Path(__file__).parent}/frontend/vdb_benchmark.py",
+        f"{pathlib.Path(__file__).parent}/frontend/vdbbench.py",
         "--logger.level",
         "info",
         "--theme.base",

vectordb_bench/backend/assembler.py

@@ -1,7 +1,8 @@
 import logging
 
-from vectordb_bench.backend.clients import EmptyDBCaseConfig
+from vectordb_bench.backend.clients import DB, EmptyDBCaseConfig
 from vectordb_bench.backend.data_source import DatasetSource
+from vectordb_bench.backend.filter import FilterOp
 from vectordb_bench.models import TaskConfig
 
 from .cases import CaseLabel
@@ -10,6 +11,13 @@ from .task_runner import CaseRunner, RunningStatus, TaskRunner
 log = logging.getLogger(__name__)
 
 
+class FilterNotSupportedError(ValueError):
+    """Raised when a filter type is not supported by a vector database."""
+
+    def __init__(self, db_name: str, filter_type: FilterOp):
+        super().__init__(f"{filter_type} Filter test is not supported by {db_name}.")
+
+
 class Assembler:
     @classmethod
     def assemble(cls, run_id: str, task: TaskConfig, source: DatasetSource) -> CaseRunner:
@@ -39,25 +47,30 @@ class Assembler:
         runners = [cls.assemble(run_id, task, source) for task in tasks]
         load_runners = [r for r in runners if r.ca.label == CaseLabel.Load]
         perf_runners = [r for r in runners if r.ca.label == CaseLabel.Performance]
+        streaming_runners = [r for r in runners if r.ca.label == CaseLabel.Streaming]
 
         # group by db
-        db2runner = {}
+        db2runner: dict[DB, list[CaseRunner]] = {}
         for r in perf_runners:
             db = r.config.db
             if db not in db2runner:
                 db2runner[db] = []
             db2runner[db].append(r)
 
-        # check dbclient installed
-        for k in db2runner:
-            _ = k.init_cls
+        # check
+        for db, runners in db2runner.items():
+            db_instance = db.init_cls
+            for runner in runners:
+                if not db_instance.filter_supported(runner.ca.filters):
+                    raise FilterNotSupportedError(db.value, runner.ca.filters.type)
 
         # sort by dataset size
         for _, runner in db2runner.items():
-            runner.sort(key=lambda x: x.ca.dataset.data.size)
+            runner.sort(key=lambda x: (x.ca.dataset.data.size, 0 if x.ca.filters.type == FilterOp.StrEqual else 1))
 
         all_runners = []
         all_runners.extend(load_runners)
+        all_runners.extend(streaming_runners)
         for v in db2runner.values():
             all_runners.extend(v)
 

vectordb_bench/backend/cases.py

@@ -1,14 +1,14 @@
+import json
 import logging
 from enum import Enum, auto
 
 from vectordb_bench import config
 from vectordb_bench.backend.clients.api import MetricType
+from vectordb_bench.backend.filter import Filter, FilterOp, IntFilter, LabelFilter, NonFilter, non_filter
 from vectordb_bench.base import BaseModel
-from vectordb_bench.frontend.components.custom.getCustomConfig import (
-    CustomDatasetConfig,
-)
+from vectordb_bench.frontend.components.custom.getCustomConfig import CustomDatasetConfig
 
-from .dataset import CustomDataset, Dataset, DatasetManager
+from .dataset import CustomDataset, Dataset, DatasetManager, DatasetWithSizeType
 
 log = logging.getLogger(__name__)
 
@@ -42,11 +42,18 @@ class CaseType(Enum):
     Performance1536D500K99P = 14
     Performance1536D5M99P = 15
 
+    Performance1024D1M = 17
+    Performance1024D10M = 20
+
     Performance1536D50K = 50
 
     Custom = 100
     PerformanceCustomDataset = 101
 
+    StreamingPerformanceCase = 200
+
+    LabelFilterPerformanceCase = 300
+
     def case_cls(self, custom_configs: dict | None = None) -> type["Case"]:
         if custom_configs is None:
             return type2case.get(self)()
@@ -68,6 +75,7 @@ class CaseType(Enum):
 class CaseLabel(Enum):
     Load = auto()
     Performance = auto()
+    Streaming = auto()
 
 
 class Case(BaseModel):
@@ -87,31 +95,37 @@ class Case(BaseModel):
     description: str
     dataset: DatasetManager
 
-    load_timeout: float | int
+    load_timeout: float | int | None = None
     optimize_timeout: float | int | None = None
 
     filter_rate: float | None = None
 
     @property
-    def filters(self) -> dict | None:
-        if self.filter_rate is not None:
-            target_id = round(self.filter_rate * self.dataset.data.size)
-            return {
-                "metadata": f">={target_id}",
-                "id": target_id,
-            }
+    def filters(self) -> Filter:
+        return non_filter
+
+    @property
+    def with_scalar_labels(self) -> bool:
+        return self.filters.type == FilterOp.StrEqual
+
+    def check_scalar_labels(self) -> None:
+        if self.with_scalar_labels and not self.dataset.data.with_scalar_labels:
+            msg = f"Case init failed: no scalar_labels data in current dataset ({self.dataset.data.full_name})"
+            raise ValueError(msg)
 
-        return None
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.check_scalar_labels()
 
 
-class CapacityCase(Case, BaseModel):
+class CapacityCase(Case):
     label: CaseLabel = CaseLabel.Load
     filter_rate: float | None = None
     load_timeout: float | int = config.CAPACITY_TIMEOUT_IN_SECONDS
     optimize_timeout: float | int | None = None
 
 
-class PerformanceCase(Case, BaseModel):
+class PerformanceCase(Case):
     label: CaseLabel = CaseLabel.Performance
     filter_rate: float | None = None
     load_timeout: float | int = config.LOAD_TIMEOUT_DEFAULT
@@ -147,6 +161,14 @@ class Performance768D10M(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_768D_10M
 
 
+class IntFilterPerformanceCase(PerformanceCase):
+    @property
+    def filters(self) -> Filter:
+        int_field = self.dataset.data.train_id_field
+        int_value = int(self.dataset.data.size * self.filter_rate)
+        return IntFilter(filter_rate=self.filter_rate, int_field=int_field, int_value=int_value)
+
+
 class Performance768D1M(PerformanceCase):
     case_id: CaseType = CaseType.Performance768D1M
     dataset: DatasetManager = Dataset.COHERE.manager(1_000_000)
@@ -158,7 +180,7 @@ class Performance768D1M(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_768D_1M
 
 
-class Performance768D10M1P(PerformanceCase):
+class Performance768D10M1P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance768D10M1P
     filter_rate: float | int | None = 0.01
     dataset: DatasetManager = Dataset.COHERE.manager(10_000_000)
@@ -170,7 +192,7 @@ class Performance768D10M1P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_768D_10M
 
 
-class Performance768D1M1P(PerformanceCase):
+class Performance768D1M1P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance768D1M1P
     filter_rate: float | int | None = 0.01
     dataset: DatasetManager = Dataset.COHERE.manager(1_000_000)
@@ -182,7 +204,7 @@ class Performance768D1M1P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_768D_1M
 
 
-class Performance768D10M99P(PerformanceCase):
+class Performance768D10M99P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance768D10M99P
     filter_rate: float | int | None = 0.99
     dataset: DatasetManager = Dataset.COHERE.manager(10_000_000)
@@ -194,7 +216,7 @@ class Performance768D10M99P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_768D_10M
 
 
-class Performance768D1M99P(PerformanceCase):
+class Performance768D1M99P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance768D1M99P
     filter_rate: float | int | None = 0.99
     dataset: DatasetManager = Dataset.COHERE.manager(1_000_000)
@@ -242,7 +264,7 @@ class Performance1536D5M(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_5M
 
 
-class Performance1536D500K1P(PerformanceCase):
+class Performance1536D500K1P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance1536D500K1P
     filter_rate: float | int | None = 0.01
     dataset: DatasetManager = Dataset.OPENAI.manager(500_000)
@@ -254,7 +276,7 @@ class Performance1536D500K1P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_500K
 
 
-class Performance1536D5M1P(PerformanceCase):
+class Performance1536D5M1P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance1536D5M1P
     filter_rate: float | int | None = 0.01
     dataset: DatasetManager = Dataset.OPENAI.manager(5_000_000)
@@ -266,7 +288,7 @@ class Performance1536D5M1P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_5M
 
 
-class Performance1536D500K99P(PerformanceCase):
+class Performance1536D500K99P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance1536D500K99P
     filter_rate: float | int | None = 0.99
     dataset: DatasetManager = Dataset.OPENAI.manager(500_000)
@@ -278,7 +300,7 @@ class Performance1536D500K99P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_500K
 
 
-class Performance1536D5M99P(PerformanceCase):
+class Performance1536D5M99P(IntFilterPerformanceCase):
     case_id: CaseType = CaseType.Performance1536D5M99P
     filter_rate: float | int | None = 0.99
     dataset: DatasetManager = Dataset.OPENAI.manager(5_000_000)
@@ -290,6 +312,30 @@ class Performance1536D5M99P(PerformanceCase):
     optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1536D_5M
 
 
+class Performance1024D1M(PerformanceCase):
+    case_id: CaseType = CaseType.Performance1024D1M
+    filter_rate: float | int | None = None
+    dataset: DatasetManager = Dataset.BIOASQ.manager(1_000_000)
+    name: str = "Search Performance Test (1M Dataset, 1024 Dim)"
+    description: str = """This case tests the search performance of a vector database with a medium 1M dataset
+    (<b>Bioasq 1M vectors</b>, 1024 dimensions), at varying parallel levels. Results will show index building time,
+    recall, and maximum QPS."""
+    load_timeout: float | int = config.LOAD_TIMEOUT_1024D_1M
+    optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1024D_1M
+
+
+class Performance1024D10M(PerformanceCase):
+    case_id: CaseType = CaseType.Performance1024D10M
+    filter_rate: float | int | None = None
+    dataset: DatasetManager = Dataset.BIOASQ.manager(10_000_000)
+    name: str = "Search Performance Test (10M Dataset, 1024 Dim)"
+    description: str = """This case tests the search performance of a vector database with a large 10M dataset
+    (<b>Bioasq 10M vectors</b>, 1024 dimensions), at varying parallel levels. Results will show index building time,
+    recall, and maximum QPS."""
+    load_timeout: float | int = config.LOAD_TIMEOUT_1024D_10M
+    optimize_timeout: float | int | None = config.OPTIMIZE_TIMEOUT_1024D_10M
+
+
 class Performance1536D50K(PerformanceCase):
     case_id: CaseType = CaseType.Performance1536D50K
     filter_rate: float | int | None = None
@@ -318,7 +364,10 @@ class PerformanceCustomDataset(PerformanceCase):
     case_id: CaseType = CaseType.PerformanceCustomDataset
     name: str = "Performance With Custom Dataset"
     description: str = ""
+    gt_file: str
     dataset: DatasetManager
+    label_percentage: float | None = None
+    use_filter: bool
 
     def __init__(
         self,
@@ -327,6 +376,8 @@ class PerformanceCustomDataset(PerformanceCase):
         load_timeout: float,
         optimize_timeout: float,
         dataset_config: dict,
+        label_percentage: float | None = None,
+        use_filter: bool = False,
         **kwargs,
     ):
         dataset_config = CustomDatasetConfig(**dataset_config)
@@ -339,16 +390,124 @@ class PerformanceCustomDataset(PerformanceCase):
             with_gt=dataset_config.with_gt,
             dir=dataset_config.dir,
             file_num=dataset_config.file_count,
+            train_file=dataset_config.train_name,
+            test_file=f"{dataset_config.test_name}.parquet",
+            train_id_field=dataset_config.train_id_name,
+            train_vector_field=dataset_config.train_col_name,
+            test_vector_field=dataset_config.test_col_name,
+            gt_neighbors_field=dataset_config.gt_col_name,
+            scalar_labels_file=f"{dataset_config.scalar_labels_name}.parquet",
         )
         super().__init__(
             name=name,
             description=description,
             load_timeout=load_timeout,
             optimize_timeout=optimize_timeout,
+            gt_file=f"{dataset_config.gt_name}.parquet",
             dataset=DatasetManager(data=dataset),
+            use_filter=use_filter,
+            label_percentage=label_percentage,
+        )
+
+    @property
+    def filters(self) -> Filter:
+        if self.use_filter is True:
+            return LabelFilter(label_percentage=self.label_percentage)
+        return NonFilter(gt_file_name=self.gt_file)
+
+
+class StreamingPerformanceCase(Case):
+    case_id: CaseType = CaseType.StreamingPerformanceCase
+    label: CaseLabel = CaseLabel.Streaming
+    dataset_with_size_type: DatasetWithSizeType
+    insert_rate: int
+    search_stages: list[float]
+    concurrencies: list[int]
+    optimize_after_write: bool = True
+    read_dur_after_write: int = 30
+
+    def __init__(
+        self,
+        dataset_with_size_type: DatasetWithSizeType | str = DatasetWithSizeType.CohereSmall.value,
+        insert_rate: int = 500,
+        search_stages: list[float] | str = (0.5, 0.8),
+        concurrencies: list[int] | str = (5, 10),
+        **kwargs,
+    ):
+        num_per_batch = config.NUM_PER_BATCH
+        if insert_rate % config.NUM_PER_BATCH != 0:
+            _insert_rate = max(
+                num_per_batch,
+                insert_rate // num_per_batch * num_per_batch,
+            )
+            log.warning(
+                f"[streaming_case init] insert_rate(={insert_rate}) should be "
+                f"divisible by NUM_PER_BATCH={num_per_batch}), reset to {_insert_rate}",
+            )
+            insert_rate = _insert_rate
+        if not isinstance(dataset_with_size_type, DatasetWithSizeType):
+            dataset_with_size_type = DatasetWithSizeType(dataset_with_size_type)
+        dataset = dataset_with_size_type.get_manager()
+        name = f"Streaming-Perf - {dataset_with_size_type.value}, {insert_rate} rows/s"
+        description = (
+            "This case tests the search performance of vector database while maintaining "
+            f"a fixed insertion speed. (dataset: {dataset_with_size_type.value})"
+        )
+
+        if isinstance(search_stages, str):
+            search_stages = json.loads(search_stages)
+        if isinstance(concurrencies, str):
+            concurrencies = json.loads(concurrencies)
+
+        super().__init__(
+            name=name,
+            description=description,
+            dataset=dataset,
+            dataset_with_size_type=dataset_with_size_type,
+            insert_rate=insert_rate,
+            search_stages=search_stages,
+            concurrencies=concurrencies,
+            **kwargs,
         )
 
 
+class LabelFilterPerformanceCase(PerformanceCase):
+    case_id: CaseType = CaseType.LabelFilterPerformanceCase
+    dataset_with_size_type: DatasetWithSizeType
+    label_percentage: float
+
+    def __init__(
+        self,
+        dataset_with_size_type: DatasetWithSizeType | str,
+        label_percentage: float,
+        **kwargs,
+    ):
+        if not isinstance(dataset_with_size_type, DatasetWithSizeType):
+            dataset_with_size_type = DatasetWithSizeType(dataset_with_size_type)
+        name = f"Label-Filter-{label_percentage*100:.1f}% - {dataset_with_size_type.value}"
+        description = f"Label-Filter-{label_percentage*100:.1f}% Performance Test ({dataset_with_size_type.value})"
+        dataset = dataset_with_size_type.get_manager()
+        load_timeout = dataset_with_size_type.get_load_timeout()
+        optimize_timeout = dataset_with_size_type.get_optimize_timeout()
+        filters = LabelFilter(label_percentage=label_percentage)
+        filter_rate = filters.filter_rate
+        super().__init__(
+            name=name,
+            description=description,
+            dataset=dataset,
+            load_timeout=load_timeout,
+            optimize_timeout=optimize_timeout,
+            filter_rate=filter_rate,
+            dataset_with_size_type=dataset_with_size_type,
+            label_percentage=label_percentage,
+            **kwargs,
+        )
+
+    @property
+    def filters(self) -> Filter:
+        return LabelFilter(label_percentage=self.label_percentage)
+
+
 type2case = {
     CaseType.CapacityDim960: CapacityDim960,
     CaseType.CapacityDim128: CapacityDim128,
@@ -365,6 +524,10 @@ type2case = {
     CaseType.Performance1536D5M1P: Performance1536D5M1P,
     CaseType.Performance1536D500K99P: Performance1536D500K99P,
     CaseType.Performance1536D5M99P: Performance1536D5M99P,
+    CaseType.Performance1024D1M: Performance1024D1M,
+    CaseType.Performance1024D10M: Performance1024D10M,
     CaseType.Performance1536D50K: Performance1536D50K,
     CaseType.PerformanceCustomDataset: PerformanceCustomDataset,
+    CaseType.StreamingPerformanceCase: StreamingPerformanceCase,
+    CaseType.LabelFilterPerformanceCase: LabelFilterPerformanceCase,
 }

vectordb_bench/backend/clients/__init__.py

@@ -47,6 +47,7 @@ class DB(Enum):
     Clickhouse = "Clickhouse"
     Vespa = "Vespa"
     LanceDB = "LanceDB"
+    OceanBase = "OceanBase"
 
     @property
     def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901, PLR0915
@@ -151,6 +152,11 @@ class DB(Enum):
 
             return MongoDB
 
+        if self == DB.OceanBase:
+            from .oceanbase.oceanbase import OceanBase
+
+            return OceanBase
+
         if self == DB.MariaDB:
             from .mariadb.mariadb import MariaDB
 
@@ -282,6 +288,11 @@ class DB(Enum):
 
             return MongoDBConfig
 
+        if self == DB.OceanBase:
+            from .oceanbase.config import OceanBaseConfig
+
+            return OceanBaseConfig
+
         if self == DB.MariaDB:
             from .mariadb.config import MariaDBConfig
 
@@ -394,6 +405,11 @@ class DB(Enum):
 
             return MongoDBIndexConfig
 
+        if self == DB.OceanBase:
+            from .oceanbase.config import _oceanbase_case_config
+
+            return _oceanbase_case_config.get(index_type)
+
         if self == DB.MariaDB:
             from .mariadb.config import _mariadb_case_config
 

vectordb_bench/backend/clients/api.py

@@ -4,6 +4,8 @@ from enum import Enum
 
 from pydantic import BaseModel, SecretStr, validator
 
+from vectordb_bench.backend.filter import Filter, FilterOp
+
 
 class MetricType(str, Enum):
     L2 = "L2"
@@ -17,6 +19,7 @@ class MetricType(str, Enum):
 class IndexType(str, Enum):
     HNSW = "HNSW"
     HNSW_SQ = "HNSW_SQ"
+    HNSW_BQ = "HNSW_BQ"
     HNSW_PQ = "HNSW_PQ"
     HNSW_PRQ = "HNSW_PRQ"
     DISKANN = "DISKANN"
@@ -28,6 +31,9 @@ class IndexType(str, Enum):
     Flat = "FLAT"
     AUTOINDEX = "AUTOINDEX"
     ES_HNSW = "hnsw"
+    ES_HNSW_INT8 = "int8_hnsw"
+    ES_HNSW_INT4 = "int4_hnsw"
+    ES_HNSW_BBQ = "bbq_hnsw"
     ES_IVFFlat = "ivfflat"
     GPU_IVF_FLAT = "GPU_IVF_FLAT"
     GPU_BRUTE_FORCE = "GPU_BRUTE_FORCE"
@@ -125,6 +131,21 @@ class VectorDB(ABC):
         >>>     milvus.search_embedding()
     """
 
+    "The filtering types supported by the VectorDB Client, default only non-filter"
+    supported_filter_types: list[FilterOp] = [FilterOp.NonFilter]
+
+    @classmethod
+    def filter_supported(cls, filters: Filter) -> bool:
+        """Ensure that the filters are supported before testing filtering cases."""
+        return filters.type in cls.supported_filter_types
+
+    def prepare_filter(self, filters: Filter):
+        """The vector database is allowed to pre-prepare different filter conditions
+        to reduce redundancy during the testing process.
+
+        (All search tests in a case use consistent filtering conditions.)"""
+        return
+
     @abstractmethod
     def __init__(
         self,
@@ -175,6 +196,7 @@ class VectorDB(ABC):
         self,
         embeddings: list[list[float]],
         metadata: list[int],
+        labels_data: list[str] | None = None,
         **kwargs,
     ) -> tuple[int, Exception]:
         """Insert the embeddings to the vector database. The default number of embeddings for
@@ -195,7 +217,6 @@ class VectorDB(ABC):
         self,
         query: list[float],
         k: int = 100,
-        filters: dict | None = None,
     ) -> list[int]:
         """Get k most similar embeddings to query vector.