vectordb-bench 0.0.22__py3-none-any.whl → 0.0.24__py3-none-any.whl

vectordb_bench/backend/clients/vespa/vespa.py

@@ -0,0 +1,249 @@
+import datetime
+import logging
+import math
+from collections.abc import Generator
+from contextlib import contextmanager
+
+from vespa import application
+
+from ..api import VectorDB
+from . import util
+from .config import VespaHNSWConfig
+
+log = logging.getLogger(__name__)
+
+
+class Vespa(VectorDB):
+    def __init__(
+        self,
+        dim: int,
+        db_config: dict[str, str],
+        db_case_config: VespaHNSWConfig | None = None,
+        collection_name: str = "VectorDBBenchCollection",
+        drop_old: bool = False,
+        **kwargs,
+    ) -> None:
+        self.dim = dim
+        self.db_config = db_config
+        self.case_config = db_case_config or VespaHNSWConfig()
+        self.schema_name = collection_name
+
+        client = self.deploy_http()
+        client.wait_for_application_up()
+
+        if drop_old:
+            try:
+                client.delete_all_docs("vectordbbench_content", self.schema_name)
+            except Exception:
+                drop_old = False
+                log.exception(f"Vespa client drop_old schema: {self.schema_name}")
+
+    @contextmanager
+    def init(self) -> Generator[None, None, None]:
+        """create and destory connections to database.
+        Why contextmanager:
+
+            In multiprocessing search tasks, vectordbbench might init
+            totally hundreds of thousands of connections with DB server.
+
+            Too many connections may drain local FDs or server connection resources.
+            If the DB client doesn't have `close()` method, just set the object to None.
+
+        Examples:
+            >>> with self.init():
+            >>>     self.insert_embeddings()
+        """
+        self.client = application.Vespa(self.db_config["url"], port=self.db_config["port"])
+        yield
+        self.client = None
+
+    def need_normalize_cosine(self) -> bool:
+        """Wheather this database need to normalize dataset to support COSINE"""
+        return False
+
+    def insert_embeddings(
+        self,
+        embeddings: list[list[float]],
+        metadata: list[int],
+        **kwargs,
+    ) -> tuple[int, Exception | None]:
+        """Insert the embeddings to the vector database. The default number of embeddings for
+        each insert_embeddings is 5000.
+
+        Args:
+            embeddings(list[list[float]]): list of embedding to add to the vector database.
+            metadatas(list[int]): metadata associated with the embeddings, for filtering.
+            **kwargs(Any): vector database specific parameters.
+
+        Returns:
+            int: inserted data count
+        """
+        assert self.client is not None
+
+        data = ({"id": str(i), "fields": {"id": i, "embedding": e}} for i, e in zip(metadata, embeddings, strict=True))
+        self.client.feed_iterable(data, self.schema_name)
+        return len(embeddings), None
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+    ) -> list[int]:
+        """Get k most similar embeddings to query vector.
+
+        Args:
+            query(list[float]): query embedding to look up documents similar to.
+            k(int): Number of most similar embeddings to return. Defaults to 100.
+            filters(dict, optional): filtering expression to filter the data while searching.
+
+        Returns:
+            list[int]: list of k most similar embeddings IDs to the query embedding.
+        """
+        assert self.client is not None
+
+        ef = self.case_config.ef
+        extra_ef = max(0, ef - k)
+        embedding_field = "embedding" if self.case_config.quantization_type == "none" else "embedding_binary"
+
+        yql = (
+            f"select id from {self.schema_name} where "  # noqa: S608
+            f"{{targetHits: {k}, hnsw.exploreAdditionalHits: {extra_ef}}}"
+            f"nearestNeighbor({embedding_field}, query_embedding)"
+        )
+
+        if filters:
+            id_filter = filters.get("id")
+            yql += f" and id >= {id_filter}"
+
+        query_embedding = query if self.case_config.quantization_type == "none" else util.binarize_tensor(query)
+
+        ranking = self.case_config.quantization_type
+
+        result = self.client.query({"yql": yql, "input.query(query_embedding)": query_embedding, "ranking": ranking})
+        return [child["fields"]["id"] for child in result.get_json()["root"]["children"]]
+
+    def optimize(self, data_size: int | None = None):
+        """optimize will be called between insertion and search in performance cases.
+
+        Should be blocked until the vectorDB is ready to be tested on
+        heavy performance cases.
+
+        Time(insert the dataset) + Time(optimize) will be recorded as "load_duration" metric
+        Optimize's execution time is limited, the limited time is based on cases.
+        """
+
+    @property
+    def application_package(self):
+        if getattr(self, "_application_package", None) is None:
+            self._application_package = self._create_application_package()
+        return self._application_package
+
+    def _create_application_package(self):
+        from vespa.package import (
+            HNSW,
+            ApplicationPackage,
+            Document,
+            Field,
+            RankProfile,
+            Schema,
+            Validation,
+            ValidationID,
+        )
+
+        fields = [
+            Field(
+                "id",
+                "int",
+                indexing=["summary", "attribute"],
+            ),
+            Field(
+                "embedding",
+                f"tensor<float>(x[{self.dim}])",
+                indexing=["summary", "attribute", "index"],
+                ann=HNSW(**self.case_config.index_param()),
+            ),
+        ]
+
+        if self.case_config.quantization_type == "binary":
+            fields.append(
+                Field(
+                    "embedding_binary",
+                    f"tensor<int8>(x[{math.ceil(self.dim / 8)}])",
+                    indexing=[
+                        "input embedding",
+                        # convert 32 bit float to 1 bit
+                        "binarize",
+                        # pack 8 bits into one int8
+                        "pack_bits",
+                        "summary",
+                        "attribute",
+                        "index",
+                    ],
+                    ann=HNSW(**{**self.case_config.index_param(), "distance_metric": "hamming"}),
+                    is_document_field=False,
+                )
+            )
+
+        tomorrow = datetime.date.today() + datetime.timedelta(days=1)
+
+        return ApplicationPackage(
+            "vectordbbench",
+            [
+                Schema(
+                    self.schema_name,
+                    Document(
+                        fields,
+                    ),
+                    rank_profiles=[
+                        RankProfile(
+                            name="none",
+                            first_phase="",
+                            inherits="default",
+                            inputs=[("query(query_embedding)", f"tensor<float>(x[{self.dim}])")],
+                        ),
+                        RankProfile(
+                            name="binary",
+                            first_phase="",
+                            inherits="default",
+                            inputs=[("query(query_embedding)", f"tensor<int8>(x[{math.ceil(self.dim / 8)}])")],
+                        ),
+                    ],
+                )
+            ],
+            validations=[
+                Validation(ValidationID.tensorTypeChange, until=tomorrow),
+                Validation(ValidationID.fieldTypeChange, until=tomorrow),
+            ],
+        )
+
+    def deploy_http(self) -> application.Vespa:
+        """
+        Deploy a Vespa application package via HTTP REST API.
+
+        Returns:
+            application.Vespa: The deployed Vespa application instance
+        """
+        import requests
+
+        url = self.db_config["url"] + ":19071/application/v2/tenant/default/prepareandactivate"
+        package_data = self.application_package.to_zip()
+        headers = {"Content-Type": "application/zip"}
+
+        try:
+            response = requests.post(url=url, data=package_data, headers=headers, timeout=10)
+
+            response.raise_for_status()
+            result = response.json()
+            return application.Vespa(
+                url=self.db_config["url"],
+                port=self.db_config["port"],
+                deployment_message=result.get("message"),
+                application_package=self.application_package,
+            )
+
+        except requests.exceptions.RequestException as e:
+            error_msg = f"Failed to deploy Vespa application: {e!s}"
+            if hasattr(e, "response") and e.response is not None:
+                error_msg += f" - Response: {e.response.text}"
+            raise RuntimeError(error_msg) from e

vectordb_bench/backend/clients/weaviate_cloud/weaviate_cloud.py

@@ -99,7 +99,7 @@ class WeaviateCloud(VectorDB):
         embeddings: Iterable[list[float]],
         metadata: list[int],
         **kwargs,
-    ) -> (int, Exception):
+    ) -> tuple[int, Exception]:
         """Insert embeddings into Weaviate"""
         assert self.client.schema.exists(self.collection_name)
         insert_count = 0

vectordb_bench/cli/cli.py

@@ -1,9 +1,9 @@
 import logging
-import os
 import time
 from collections.abc import Callable
 from concurrent.futures import wait
 from datetime import datetime
+from pathlib import Path
 from pprint import pformat
 from typing import (
     Annotated,
@@ -38,18 +38,16 @@ except ImportError:
     from yaml import Loader
 
 
-def click_get_defaults_from_file(ctx, param, value):
+def click_get_defaults_from_file(ctx, param, value):  # noqa: ANN001, ARG001
     if value:
-        if os.path.exists(value):
-            input_file = value
-        else:
-            input_file = os.path.join(config.CONFIG_LOCAL_DIR, value)
+        input_file = value if Path.exists(value) else Path.join(config.CONFIG_LOCAL_DIR, value)
         try:
-            with open(input_file) as f:
-                _config: dict[str, dict[str, Any]] = load(f.read(), Loader=Loader)
+            with Path.open(input_file) as f:
+                _config: dict[str, dict[str, Any]] = load(f.read(), Loader=Loader)  # noqa: S506
                 ctx.default_map = _config.get(ctx.command.name, {})
         except Exception as e:
-            raise click.BadParameter(f"Failed to load config file: {e}")
+            msg = f"Failed to load config file: {e}"
+            raise click.BadParameter(msg) from e
     return value
 
 
@@ -68,12 +66,16 @@ def click_parameter_decorators_from_typed_dict(
 
 
     For clarity, the key names of the TypedDict will be used to determine the type hints for the input parameters.
-    The actual function parameters are controlled by the click.option definitions. You must manually ensure these are aligned in a sensible way!
+    The actual function parameters are controlled by the click.option definitions.
+    You must manually ensure these are aligned in a sensible way!
 
     Example:
     ```
     class CommonTypedDict(TypedDict):
-        z: Annotated[int, click.option("--z/--no-z", is_flag=True, type=bool, help="help z", default=True, show_default=True)]
+        z: Annotated[
+            int,
+            click.option("--z/--no-z", is_flag=True, type=bool, help="help z", default=True, show_default=True)
+        ]
         name: Annotated[str, click.argument("name", required=False, default="Jeff")]
 
     class FooTypedDict(CommonTypedDict):
@@ -91,14 +93,16 @@ def click_parameter_decorators_from_typed_dict(
     for _, t in get_type_hints(typed_dict, include_extras=True).items():
         assert get_origin(t) is Annotated
         if len(t.__metadata__) == 1 and t.__metadata__[0].__module__ == "click.decorators":
-            # happy path -- only accept Annotated[..., Union[click.option,click.argument,...]] with no additional metadata defined (len=1)
+            # happy path -- only accept Annotated[..., Union[click.option,click.argument,...]]
+            # with no additional metadata defined (len=1)
             decorators.append(t.__metadata__[0])
         else:
             raise RuntimeError(
-                "Click-TypedDict decorator parsing must only contain root type and a click decorator like click.option. See docstring",
+                "Click-TypedDict decorator parsing must only contain root type "
+                "and a click decorator like click.option. See docstring",
             )
 
-    def deco(f):
+    def deco(f):  # noqa: ANN001
         for dec in reversed(decorators):
             f = dec(f)
         return f
@@ -106,7 +110,7 @@ def click_parameter_decorators_from_typed_dict(
     return deco
 
 
-def click_arg_split(ctx: click.Context, param: click.core.Option, value):
+def click_arg_split(ctx: click.Context, param: click.core.Option, value):  # noqa: ANN001, ARG001
     """Will split a comma-separated list input into an actual list.
 
     Args:
@@ -145,8 +149,7 @@ def parse_task_stages(
     return stages
 
 
-# ruff: noqa
-def check_custom_case_parameters(ctx: any, param: any, value: any):
+def check_custom_case_parameters(ctx: any, param: any, value: any):  # noqa: ARG001
     if ctx.params.get("case_type") == "PerformanceCustomDataset" and value is None:
         raise click.BadParameter(
             """ Custom case parameters

vectordb_bench/cli/vectordbbench.py

@@ -1,5 +1,7 @@
 from ..backend.clients.alloydb.cli import AlloyDBScaNN
 from ..backend.clients.aws_opensearch.cli import AWSOpenSearch
+from ..backend.clients.clickhouse.cli import Clickhouse
+from ..backend.clients.mariadb.cli import MariaDBHNSW
 from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.milvus.cli import MilvusAutoIndex
 from ..backend.clients.pgdiskann.cli import PgDiskAnn
@@ -8,6 +10,8 @@ from ..backend.clients.pgvector.cli import PgVectorHNSW
 from ..backend.clients.pgvectorscale.cli import PgVectorScaleDiskAnn
 from ..backend.clients.redis.cli import Redis
 from ..backend.clients.test.cli import Test
+from ..backend.clients.tidb.cli import TiDB
+from ..backend.clients.vespa.cli import Vespa
 from ..backend.clients.weaviate_cloud.cli import Weaviate
 from ..backend.clients.zilliz_cloud.cli import ZillizAutoIndex
 from .cli import cli
@@ -25,6 +29,10 @@ cli.add_command(AWSOpenSearch)
 cli.add_command(PgVectorScaleDiskAnn)
 cli.add_command(PgDiskAnn)
 cli.add_command(AlloyDBScaNN)
+cli.add_command(MariaDBHNSW)
+cli.add_command(TiDB)
+cli.add_command(Clickhouse)
+cli.add_command(Vespa)
 
 
 if __name__ == "__main__":

vectordb_bench/frontend/config/dbCaseConfigs.py

@@ -173,6 +173,7 @@ CaseConfigParamInput_IndexType = CaseConfigInput(
             IndexType.GPU_IVF_FLAT.value,
             IndexType.GPU_IVF_PQ.value,
             IndexType.GPU_CAGRA.value,
+            IndexType.GPU_BRUTE_FORCE.value,
         ],
     },
 )
@@ -562,6 +563,7 @@ CaseConfigParamInput_Nlist = CaseConfigInput(
         IndexType.IVFSQ8.value,
         IndexType.GPU_IVF_FLAT.value,
         IndexType.GPU_IVF_PQ.value,
+        IndexType.GPU_BRUTE_FORCE.value,
     ],
 )
 
@@ -579,6 +581,7 @@ CaseConfigParamInput_Nprobe = CaseConfigInput(
         IndexType.IVFSQ8.value,
         IndexType.GPU_IVF_FLAT.value,
         IndexType.GPU_IVF_PQ.value,
+        IndexType.GPU_BRUTE_FORCE.value,
     ],
 )
 
@@ -703,6 +706,7 @@ CaseConfigParamInput_cache_dataset_on_device = CaseConfigInput(
         IndexType.GPU_CAGRA.value,
         IndexType.GPU_IVF_PQ.value,
         IndexType.GPU_IVF_FLAT.value,
+        IndexType.GPU_BRUTE_FORCE.value,
     ],
 )
 
@@ -720,6 +724,7 @@ CaseConfigParamInput_refine_ratio = CaseConfigInput(
         IndexType.GPU_CAGRA.value,
         IndexType.GPU_IVF_PQ.value,
         IndexType.GPU_IVF_FLAT.value,
+        IndexType.GPU_BRUTE_FORCE.value,
     ],
 )
 
@@ -818,6 +823,19 @@ CaseConfigParamInput_QuantizationRatio_PgVectoRS = CaseConfigInput(
     ],
 )
 
+CaseConfigParamInput_TableQuantizationType_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.tableQuantizationType,
+    inputType=InputType.Option,
+    inputConfig={
+        "options": ["none", "bit", "halfvec"],
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [
+        IndexType.HNSW.value,
+        IndexType.IVFFlat.value,
+    ],
+)
+
 CaseConfigParamInput_max_parallel_workers_PgVectorRS = CaseConfigInput(
     label=CaseConfigParamType.max_parallel_workers,
     displayLabel="Max parallel workers",
@@ -1040,6 +1058,61 @@ CaseConfigParamInput_NumCandidates_AliES = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_IndexType_MariaDB = CaseConfigInput(
+    label=CaseConfigParamType.IndexType,
+    inputHelp="Select Index Type",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            IndexType.HNSW.value,
+        ],
+    },
+)
+
+CaseConfigParamInput_StorageEngine_MariaDB = CaseConfigInput(
+    label=CaseConfigParamType.storage_engine,
+    inputHelp="Select Storage Engine",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": ["InnoDB", "MyISAM"],
+    },
+)
+
+CaseConfigParamInput_M_MariaDB = CaseConfigInput(
+    label=CaseConfigParamType.M,
+    inputHelp="M parameter in MHNSW vector indexing",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 3,
+        "max": 200,
+        "value": 6,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_EFSearch_MariaDB = CaseConfigInput(
+    label=CaseConfigParamType.ef_search,
+    inputHelp="mhnsw_ef_search",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 1,
+        "max": 10000,
+        "value": 20,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_CacheSize_MariaDB = CaseConfigInput(
+    label=CaseConfigParamType.max_cache_size,
+    inputHelp="mhnsw_max_cache_size",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 1048576,
+        "max": (1 << 53) - 1,
+        "value": 16 * 1024**3,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
 
 CaseConfigParamInput_MongoDBQuantizationType = CaseConfigInput(
     label=CaseConfigParamType.mongodb_quantization_type,
@@ -1061,6 +1134,47 @@ CaseConfigParamInput_MongoDBNumCandidatesRatio = CaseConfigInput(
 )
 
 
+CaseConfigParamInput_M_Vespa = CaseConfigInput(
+    label=CaseConfigParamType.M,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 4,
+        "max": 64,
+        "value": 16,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_IndexType_Vespa = CaseConfigInput(
+    label=CaseConfigParamType.IndexType,
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            IndexType.HNSW.value,
+        ],
+    },
+)
+
+CaseConfigParamInput_QuantizationType_Vespa = CaseConfigInput(
+    label=CaseConfigParamType.quantizationType,
+    inputType=InputType.Option,
+    inputConfig={
+        "options": ["none", "binary"],
+    },
+)
+
+CaseConfigParamInput_EFConstruction_Vespa = CaseConfigInput(
+    label=CaseConfigParamType.EFConstruction,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 8,
+        "max": 512,
+        "value": 200,
+    },
+    isDisplayed=lambda config: config[CaseConfigParamType.IndexType] == IndexType.HNSW.value,
+)
+
+
 MilvusLoadConfig = [
     CaseConfigParamInput_IndexType,
     CaseConfigParamInput_M,
@@ -1133,6 +1247,7 @@ PgVectorLoadingConfig = [
     CaseConfigParamInput_m,
     CaseConfigParamInput_EFConstruction_PgVector,
     CaseConfigParamInput_QuantizationType_PgVector,
+    CaseConfigParamInput_TableQuantizationType_PgVector,
     CaseConfigParamInput_maintenance_work_mem_PgVector,
     CaseConfigParamInput_max_parallel_workers_PgVector,
 ]
@@ -1144,6 +1259,7 @@ PgVectorPerformanceConfig = [
     CaseConfigParamInput_Lists_PgVector,
     CaseConfigParamInput_Probes_PgVector,
     CaseConfigParamInput_QuantizationType_PgVector,
+    CaseConfigParamInput_TableQuantizationType_PgVector,
     CaseConfigParamInput_maintenance_work_mem_PgVector,
     CaseConfigParamInput_max_parallel_workers_PgVector,
     CaseConfigParamInput_reranking_PgVector,
@@ -1252,6 +1368,29 @@ MongoDBPerformanceConfig = [
     CaseConfigParamInput_MongoDBNumCandidatesRatio,
 ]
 
+MariaDBLoadingConfig = [
+    CaseConfigParamInput_IndexType_MariaDB,
+    CaseConfigParamInput_StorageEngine_MariaDB,
+    CaseConfigParamInput_M_MariaDB,
+    CaseConfigParamInput_CacheSize_MariaDB,
+]
+MariaDBPerformanceConfig = [
+    CaseConfigParamInput_IndexType_MariaDB,
+    CaseConfigParamInput_StorageEngine_MariaDB,
+    CaseConfigParamInput_M_MariaDB,
+    CaseConfigParamInput_CacheSize_MariaDB,
+    CaseConfigParamInput_EFSearch_MariaDB,
+]
+
+VespaLoadingConfig = [
+    CaseConfigParamInput_IndexType_Vespa,
+    CaseConfigParamInput_QuantizationType_Vespa,
+    CaseConfigParamInput_M_Vespa,
+    CaseConfigParamInput_EF_Milvus,
+    CaseConfigParamInput_EFConstruction_Vespa,
+]
+VespaPerformanceConfig = VespaLoadingConfig
+
 CASE_CONFIG_MAP = {
     DB.Milvus: {
         CaseLabel.Load: MilvusLoadConfig,
@@ -1304,4 +1443,12 @@ CASE_CONFIG_MAP = {
         CaseLabel.Load: MongoDBLoadingConfig,
         CaseLabel.Performance: MongoDBPerformanceConfig,
     },
+    DB.MariaDB: {
+        CaseLabel.Load: MariaDBLoadingConfig,
+        CaseLabel.Performance: MariaDBPerformanceConfig,
+    },
+    DB.Vespa: {
+        CaseLabel.Load: VespaLoadingConfig,
+        CaseLabel.Performance: VespaPerformanceConfig,
+    },
 }

vectordb_bench/frontend/config/styles.py

@@ -47,6 +47,8 @@ DB_TO_ICON = {
     DB.Redis: "https://assets.zilliz.com/Redis_Cloud_74b8bfef39.png",
     DB.Chroma: "https://assets.zilliz.com/chroma_ceb3f06ed7.png",
     DB.AWSOpenSearch: "https://assets.zilliz.com/opensearch_1eee37584e.jpeg",
+    DB.TiDB: "https://img2.pingcap.com/forms/3/d/3d7fd5f9767323d6f037795704211ac44b4923d6.png",
+    DB.Vespa: "https://vespa.ai/vespa-content/uploads/2025/01/Vespa-symbol-green-rgb.png.webp",
 }
 
 # RedisCloud color: #0D6EFD
@@ -61,4 +63,6 @@ COLOR_MAP = {
     DB.PgVector.value: "#4C779A",
     DB.Redis.value: "#0D6EFD",
     DB.AWSOpenSearch.value: "#0DCAF0",
+    DB.TiDB.value: "#0D6EFD",
+    DB.Vespa.value: "#61d790",
 }

vectordb_bench/models.py

@@ -49,6 +49,7 @@ class CaseConfigParamType(Enum):
     probes = "probes"
     quantizationType = "quantization_type"
     quantizationRatio = "quantization_ratio"
+    tableQuantizationType = "table_quantization_type"
     reranking = "reranking"
     rerankingMetric = "reranking_metric"
     quantizedFetchLimit = "quantized_fetch_limit"
@@ -87,6 +88,8 @@ class CaseConfigParamType(Enum):
     preReorderingNumNeigbors = "pre_reordering_num_neighbors"
     numSearchThreads = "num_search_threads"
     maxNumPrefetchDatasets = "max_num_prefetch_datasets"
+    storage_engine = "storage_engine"
+    max_cache_size = "max_cache_size"
 
     # mongodb params
     mongodb_quantization_type = "quantization"
@@ -260,7 +263,6 @@ class TestResult(BaseModel):
                     )
             return TestResult.validate(test_result)
 
-    # ruff: noqa
     def display(self, dbs: list[DB] | None = None):
         filter_list = dbs if dbs and isinstance(dbs, list) else None
         sorted_results = sorted(
@@ -291,7 +293,7 @@ class TestResult(BaseModel):
         max_qps = 10 if max_qps < 10 else max_qps
         max_recall = 13 if max_recall < 13 else max_recall
 
-        LENGTH = (
+        LENGTH = (  # noqa: N806
             max_db,
             max_db_labels,
             max_case,
@@ -304,13 +306,13 @@ class TestResult(BaseModel):
             5,
         )
 
-        DATA_FORMAT = (
+        DATA_FORMAT = (  # noqa: N806
             f"%-{max_db}s | %-{max_db_labels}s %-{max_case}s %-{len(self.task_label)}s"
             f" | %-{max_load_dur}s %-{max_qps}s %-15s %-{max_recall}s %-14s"
             f" | %-5s"
         )
 
-        TITLE = DATA_FORMAT % (
+        TITLE = DATA_FORMAT % (  # noqa: N806
             "DB",
             "db_label",
             "case",
@@ -322,8 +324,8 @@ class TestResult(BaseModel):
             "max_load_count",
             "label",
         )
-        SPLIT = DATA_FORMAT % tuple(map(lambda x: "-" * x, LENGTH))
-        SUMMARY_FORMAT = ("Task summary: run_id=%s, task_label=%s") % (
+        SPLIT = DATA_FORMAT % tuple(map(lambda x: "-" * x, LENGTH))  # noqa: C417, N806
+        SUMMARY_FORMAT = ("Task summary: run_id=%s, task_label=%s") % (  # noqa: N806
             self.run_id[:5],
             self.task_label,
         )