vectordb-bench 0.0.13__py3-none-any.whl → 0.0.14__py3-none-any.whl

vectordb_bench/backend/clients/pinecone/pinecone.py

@@ -3,7 +3,7 @@
 import logging
 from contextlib import contextmanager
 from typing import Type
-
+import pinecone
 from ..api import VectorDB, DBConfig, DBCaseConfig, EmptyDBCaseConfig, IndexType
 from .config import PineconeConfig
 
@@ -11,7 +11,8 @@ from .config import PineconeConfig
 log = logging.getLogger(__name__)
 
 PINECONE_MAX_NUM_PER_BATCH = 1000
-PINECONE_MAX_SIZE_PER_BATCH = 2 * 1024 * 1024 # 2MB
+PINECONE_MAX_SIZE_PER_BATCH = 2 * 1024 * 1024  # 2MB
+
 
 class Pinecone(VectorDB):
     def __init__(
@@ -23,30 +24,25 @@ class Pinecone(VectorDB):
         **kwargs,
     ):
         """Initialize wrapper around the milvus vector database."""
-        self.index_name = db_config["index_name"]
-        self.api_key = db_config["api_key"]
-        self.environment = db_config["environment"]
-        self.batch_size = int(min(PINECONE_MAX_SIZE_PER_BATCH / (dim * 5), PINECONE_MAX_NUM_PER_BATCH))
-        # Pincone will make connections with server while import
-        # so place the import here.
-        import pinecone
-        pinecone.init(
-            api_key=self.api_key, environment=self.environment)
+        self.index_name = db_config.get("index_name", "")
+        self.api_key = db_config.get("api_key", "")
+        self.batch_size = int(
+            min(PINECONE_MAX_SIZE_PER_BATCH / (dim * 5), PINECONE_MAX_NUM_PER_BATCH)
+        )
+
+        pc = pinecone.Pinecone(api_key=self.api_key)
+        index = pc.Index(self.index_name)
+
         if drop_old:
-            list_indexes = pinecone.list_indexes()
-            if self.index_name in list_indexes:
-                index = pinecone.Index(self.index_name)
-                index_dim = index.describe_index_stats()["dimension"]
-                if (index_dim != dim):
-                    raise ValueError(
-                        f"Pinecone index {self.index_name} dimension mismatch, expected {index_dim} got {dim}")
-                log.info(
-                    f"Pinecone client delete old index: {self.index_name}")
-                index.delete(delete_all=True)
-                index.close()
-            else:
+            index_stats = index.describe_index_stats()
+            index_dim = index_stats["dimension"]
+            if index_dim != dim:
                 raise ValueError(
-                    f"Pinecone index {self.index_name} does not exist")
+                    f"Pinecone index {self.index_name} dimension mismatch, expected {index_dim} got {dim}"
+                )
+            for namespace in index_stats["namespaces"]:
+                log.info(f"Pinecone index delete namespace: {namespace}")
+                index.delete(delete_all=True, namespace=namespace)
 
         self._metadata_key = "meta"
 
@@ -59,13 +55,10 @@ class Pinecone(VectorDB):
         return EmptyDBCaseConfig
 
     @contextmanager
-    def init(self) -> None:
-        import pinecone
-        pinecone.init(
-            api_key=self.api_key, environment=self.environment)
-        self.index = pinecone.Index(self.index_name)
+    def init(self):
+        pc = pinecone.Pinecone(api_key=self.api_key)
+        self.index = pc.Index(self.index_name)
         yield
-        self.index.close()
 
     def ready_to_load(self):
         pass
@@ -83,11 +76,16 @@ class Pinecone(VectorDB):
         insert_count = 0
         try:
             for batch_start_offset in range(0, len(embeddings), self.batch_size):
-                batch_end_offset = min(batch_start_offset + self.batch_size, len(embeddings))
+                batch_end_offset = min(
+                    batch_start_offset + self.batch_size, len(embeddings)
+                )
                 insert_datas = []
                 for i in range(batch_start_offset, batch_end_offset):
-                    insert_data = (str(metadata[i]), embeddings[i], {
-                                self._metadata_key: metadata[i]})
+                    insert_data = (
+                        str(metadata[i]),
+                        embeddings[i],
+                        {self._metadata_key: metadata[i]},
+                    )
                     insert_datas.append(insert_data)
                 self.index.upsert(insert_datas)
                 insert_count += batch_end_offset - batch_start_offset
@@ -101,7 +99,7 @@ class Pinecone(VectorDB):
         k: int = 100,
         filters: dict | None = None,
         timeout: int | None = None,
-    ) -> list[tuple[int, float]]:
+    ) -> list[int]:
         if filters is None:
             pinecone_filters = {}
         else:
@@ -111,9 +109,9 @@ class Pinecone(VectorDB):
                 top_k=k,
                 vector=query,
                 filter=pinecone_filters,
-            )['matches']
+            )["matches"]
         except Exception as e:
             print(f"Error querying index: {e}")
             raise e
-        id_res = [int(one_res['id']) for one_res in res]
+        id_res = [int(one_res["id"]) for one_res in res]
         return id_res

vectordb_bench/backend/clients/redis/cli.py

@@ -3,6 +3,9 @@ from typing import Annotated, TypedDict, Unpack
 import click
 from pydantic import SecretStr
 
+from .config import RedisHNSWConfig
+
+
 from ....cli.cli import (
     CommonTypedDict,
     HNSWFlavor2,
@@ -69,6 +72,11 @@ def Redis(**parameters: Unpack[RedisHNSWTypedDict]):
             ssl=parameters["ssl"],
             ssl_ca_certs=parameters["ssl_ca_certs"],
             cmd=parameters["cmd"],
+        ),        
+        db_case_config=RedisHNSWConfig(
+            M=parameters["m"],
+            efConstruction=parameters["ef_construction"],
+            ef=parameters["ef_runtime"],
         ),
         **parameters,
     )

vectordb_bench/backend/clients/redis/config.py

@@ -1,14 +1,45 @@
-from pydantic import SecretStr
-from ..api import DBConfig
+from pydantic import SecretStr, BaseModel
+from ..api import DBConfig, DBCaseConfig, MetricType, IndexType
 
 class RedisConfig(DBConfig):
-    password: SecretStr
+    password: SecretStr | None = None
     host: SecretStr
-    port: int = None 
+    port: int | None = None 
 
     def to_dict(self) -> dict:
         return {
             "host": self.host.get_secret_value(),
             "port": self.port,
-            "password": self.password.get_secret_value(),
-        }
+            "password": self.password.get_secret_value() if self.password is not None else None,
+        }
+        
+
+
+class RedisIndexConfig(BaseModel):
+    """Base config for milvus"""
+
+    metric_type: MetricType | None = None
+
+    def parse_metric(self) -> str:
+        if not self.metric_type:
+            return ""
+        return self.metric_type.value
+    
+class RedisHNSWConfig(RedisIndexConfig, DBCaseConfig):
+    M: int
+    efConstruction: int
+    ef: int | None = None
+    index: IndexType = IndexType.HNSW
+
+    def index_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "index_type": self.index.value,
+            "params": {"M": self.M, "efConstruction": self.efConstruction},
+        }
+
+    def search_param(self) -> dict:
+        return {
+            "metric_type": self.parse_metric(),
+            "params": {"ef": self.ef},
+        }

vectordb_bench/backend/runner/mp_runner.py

@@ -2,6 +2,7 @@ import time
 import traceback
 import concurrent
 import multiprocessing as mp
+import random
 import logging
 from typing import Iterable
 import numpy as np
@@ -46,7 +47,7 @@ class MultiProcessingSearchRunner:
             cond.wait()
 
         with self.db.init():
-            num, idx = len(test_data), 0
+            num, idx = len(test_data), random.randint(0, len(test_data) - 1)
 
             start_time = time.perf_counter()
             count = 0

vectordb_bench/cli/cli.py

@@ -17,6 +17,8 @@ from typing import (
     Any,
 )
 import click
+
+from vectordb_bench.backend.clients.api import MetricType
 from .. import config
 from ..backend.clients import DB
 from ..interface import benchMarkRunner, global_result_future
@@ -147,6 +149,37 @@ def parse_task_stages(
     return stages
 
 
+def check_custom_case_parameters(ctx, param, value):
+    if ctx.params.get("case_type") == "PerformanceCustomDataset":
+        if value is None:
+            raise click.BadParameter("Custom case parameters\
+                                     \n--custom-case-name\n--custom-dataset-name\n--custom-dataset-dir\n--custom-dataset-size \
+                                     \n--custom-dataset-dim\n--custom-dataset-file-count\n are required")
+    return value
+
+
+def get_custom_case_config(parameters: dict) -> dict:
+    custom_case_config = {}
+    if parameters["case_type"] == "PerformanceCustomDataset":
+        custom_case_config = {
+            "name": parameters["custom_case_name"],
+            "description": parameters["custom_case_description"],
+            "load_timeout": parameters["custom_case_load_timeout"],
+            "optimize_timeout": parameters["custom_case_optimize_timeout"],
+            "dataset_config": {
+                "name": parameters["custom_dataset_name"],
+                "dir": parameters["custom_dataset_dir"],
+                "size": parameters["custom_dataset_size"],
+                "dim": parameters["custom_dataset_dim"],
+                "metric_type": parameters["custom_dataset_metric_type"],
+                "file_count": parameters["custom_dataset_file_count"],
+                "use_shuffled": parameters["custom_dataset_use_shuffled"],
+                "with_gt": parameters["custom_dataset_with_gt"],
+            }
+        }
+    return custom_case_config
+
+
 log = logging.getLogger(__name__)
 
 
@@ -205,6 +238,7 @@ class CommonTypedDict(TypedDict):
         click.option(
             "--case-type",
             type=click.Choice([ct.name for ct in CaseType if ct.name != "Custom"]),
+            is_eager=True,
             default="Performance1536D50K",
             help="Case type",
         ),
@@ -258,6 +292,108 @@ class CommonTypedDict(TypedDict):
             callback=lambda *args: list(map(int, click_arg_split(*args))),
         ),
     ]
+    custom_case_name: Annotated[
+        str,
+        click.option(
+            "--custom-case-name",
+            help="Custom dataset case name",
+            callback=check_custom_case_parameters,
+        )
+    ]
+    custom_case_description: Annotated[
+        str,
+        click.option(
+            "--custom-case-description",
+            help="Custom dataset case description",
+            default="This is a customized dataset.",
+            show_default=True,
+        )
+    ]
+    custom_case_load_timeout: Annotated[
+        int,
+        click.option(
+            "--custom-case-load-timeout",
+            help="Custom dataset case load timeout",
+            default=36000,
+            show_default=True,
+        )
+    ]
+    custom_case_optimize_timeout: Annotated[
+        int,
+        click.option(
+            "--custom-case-optimize-timeout",
+            help="Custom dataset case optimize timeout",
+            default=36000,
+            show_default=True,
+        )
+    ]
+    custom_dataset_name: Annotated[
+        str,
+        click.option(
+            "--custom-dataset-name",
+            help="Custom dataset name",
+            callback=check_custom_case_parameters,
+        ),
+    ]
+    custom_dataset_dir: Annotated[
+        str,
+        click.option(
+            "--custom-dataset-dir",
+            help="Custom dataset directory",
+            callback=check_custom_case_parameters,
+        ),
+    ]
+    custom_dataset_size: Annotated[
+        int,
+        click.option(
+            "--custom-dataset-size",
+            help="Custom dataset size",
+            callback=check_custom_case_parameters,
+        ),
+    ]
+    custom_dataset_dim: Annotated[
+        int,
+        click.option(
+            "--custom-dataset-dim",
+            help="Custom dataset dimension",
+            callback=check_custom_case_parameters,
+        ),
+    ]
+    custom_dataset_metric_type: Annotated[
+        str,
+        click.option(
+            "--custom-dataset-metric-type",
+            help="Custom dataset metric type",
+            default=MetricType.COSINE.name,
+            show_default=True,
+        ),
+    ]
+    custom_dataset_file_count: Annotated[
+        int,
+        click.option(
+            "--custom-dataset-file-count",
+            help="Custom dataset file count",
+            callback=check_custom_case_parameters,
+        ),
+    ]
+    custom_dataset_use_shuffled: Annotated[
+        bool,
+        click.option(
+            "--custom-dataset-use-shuffled/--skip-custom-dataset-use-shuffled",
+            help="Custom dataset use shuffled",
+            default=False,
+            show_default=True,
+        ),
+    ]
+    custom_dataset_with_gt: Annotated[
+        bool,
+        click.option(
+            "--custom-dataset-with-gt/--skip-custom-dataset-with-gt",
+            help="Custom dataset with ground truth",
+            default=True,
+            show_default=True,
+        ),
+    ]
 
 
 class HNSWBaseTypedDict(TypedDict):
@@ -343,6 +479,7 @@ def run(
                 concurrency_duration=parameters["concurrency_duration"],
                 num_concurrency=[int(s) for s in parameters["num_concurrency"]],
             ),
+            custom_case=parameters.get("custom_case", {}),
         ),
         stages=parse_task_stages(
             (

vectordb_bench/cli/vectordbbench.py

@@ -1,5 +1,6 @@
 from ..backend.clients.pgvector.cli import PgVectorHNSW
 from ..backend.clients.pgvecto_rs.cli import PgVectoRSHNSW, PgVectoRSIVFFlat
+from ..backend.clients.pgvectorscale.cli import PgVectorScaleDiskAnn
 from ..backend.clients.redis.cli import Redis
 from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.test.cli import Test
@@ -8,7 +9,6 @@ from ..backend.clients.zilliz_cloud.cli import ZillizAutoIndex
 from ..backend.clients.milvus.cli import MilvusAutoIndex
 from ..backend.clients.aws_opensearch.cli import AWSOpenSearch
 
-
 from .cli import cli
 
 cli.add_command(PgVectorHNSW)
@@ -21,6 +21,7 @@ cli.add_command(Test)
 cli.add_command(ZillizAutoIndex)
 cli.add_command(MilvusAutoIndex)
 cli.add_command(AWSOpenSearch)
+cli.add_command(PgVectorScaleDiskAnn)
 
 
 if __name__ == "__main__":

vectordb_bench/frontend/components/check_results/charts.py

@@ -1,5 +1,7 @@
 from vectordb_bench.backend.cases import Case
-from vectordb_bench.frontend.components.check_results.expanderStyle import initMainExpanderStyle
+from vectordb_bench.frontend.components.check_results.expanderStyle import (
+    initMainExpanderStyle,
+)
 from vectordb_bench.metric import metricOrder, isLowerIsBetterMetric, metricUnitMap
 from vectordb_bench.frontend.config.styles import *
 from vectordb_bench.models import ResultLabel
@@ -11,7 +13,7 @@ def drawCharts(st, allData, failedTasks, caseNames: list[str]):
     for caseName in caseNames:
         chartContainer = st.expander(caseName, True)
         data = [data for data in allData if data["case_name"] == caseName]
-        drawChart(data, chartContainer)
+        drawChart(data, chartContainer, key_prefix=caseName)
 
         errorDBs = failedTasks[caseName]
         showFailedDBs(chartContainer, errorDBs)
@@ -35,7 +37,7 @@ def showFailedText(st, text, dbs):
         )
 
 
-def drawChart(data, st):
+def drawChart(data, st, key_prefix: str):
     metricsSet = set()
     for d in data:
         metricsSet = metricsSet.union(d["metricsSet"])
@@ -43,7 +45,8 @@ def drawChart(data, st):
 
     for i, metric in enumerate(showMetrics):
         container = st.container()
-        drawMetricChart(data, metric, container)
+        key = f"{key_prefix}-{metric}"
+        drawMetricChart(data, metric, container, key=key)
 
 
 def getLabelToShapeMap(data):
@@ -75,7 +78,7 @@ def getLabelToShapeMap(data):
     return labelToShapeMap
 
 
-def drawMetricChart(data, metric, st):
+def drawMetricChart(data, metric, st, key: str):
     dataWithMetric = [d for d in data if d.get(metric, 0) > 1e-7]
     # dataWithMetric = data
     if len(dataWithMetric) == 0:
@@ -161,4 +164,4 @@ def drawMetricChart(data, metric, st):
         ),
     )
 
-    chart.plotly_chart(fig, use_container_width=True)
+    chart.plotly_chart(fig, use_container_width=True, key=key)

vectordb_bench/frontend/components/concurrent/charts.py

@@ -22,7 +22,7 @@ def drawChartsByCase(allData, showCaseNames: list[str], st):
             for caseData in caseDataList
             for i in range(len(caseData["conc_num_list"]))
         ]
-        drawChart(data, chartContainer)
+        drawChart(data, chartContainer, key=f"{caseName}-qps-p99")
 
 
 def getRange(metric, data, padding_multipliers):
@@ -36,7 +36,7 @@ def getRange(metric, data, padding_multipliers):
     return rangeV
 
 
-def drawChart(data, st):
+def drawChart(data, st, key: str):
     if len(data) == 0:
         return
 
@@ -73,7 +73,4 @@ def drawChart(data, st):
     fig.update_yaxes(range=yrange, title_text="QPS")
     fig.update_traces(textposition="bottom right", texttemplate="conc-%{text:,.4~r}")
 
-    st.plotly_chart(
-        fig,
-        use_container_width=True,
-    )
+    st.plotly_chart(fig, use_container_width=True, key=key)

vectordb_bench/frontend/config/dbCaseConfigs.py

@@ -360,6 +360,37 @@ CaseConfigParamInput_EFConstruction_ES = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_EFConstruction_AWSOpensearch = CaseConfigInput(
+    label=CaseConfigParamType.EFConstruction,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 100,
+        "max": 1024,
+        "value": 256,
+    },
+)
+
+CaseConfigParamInput_M_AWSOpensearch = CaseConfigInput(
+    label=CaseConfigParamType.M,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 4,
+        "max": 64,
+        "value": 16,
+    },
+)
+
+CaseConfigParamInput_EF_SEARCH_AWSOpensearch = CaseConfigInput(
+    label=CaseConfigParamType.ef_search,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 100,
+        "max": 1024,
+        "value": 256,
+    },
+)
+
+
 CaseConfigParamInput_maintenance_work_mem_PgVector = CaseConfigInput(
     label=CaseConfigParamType.maintenance_work_mem,
     inputHelp="Recommended value: 1.33x the index size, not to exceed the available free memory."
@@ -738,6 +769,19 @@ CaseConfigParamInput_QuantizationType_PgVectoRS = CaseConfigInput(
     ],
 )
 
+CaseConfigParamInput_QuantizationType_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.quantizationType,
+    inputType=InputType.Option,
+    inputConfig={
+        "options": ["none", "halfvec"],
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [
+        IndexType.HNSW.value,
+        IndexType.IVFFlat.value,
+    ],
+)
+
 CaseConfigParamInput_QuantizationRatio_PgVectoRS = CaseConfigInput(
     label=CaseConfigParamType.quantizationRatio,
     inputType=InputType.Option,
@@ -826,11 +870,19 @@ ESPerformanceConfig = [
     CaseConfigParamInput_NumCandidates_ES,
 ]
 
+AWSOpensearchLoadingConfig = [CaseConfigParamInput_EFConstruction_AWSOpensearch, CaseConfigParamInput_M_AWSOpensearch]
+AWSOpenSearchPerformanceConfig = [
+    CaseConfigParamInput_EFConstruction_AWSOpensearch,
+    CaseConfigParamInput_M_AWSOpensearch,
+    CaseConfigParamInput_EF_SEARCH_AWSOpensearch,
+]
+
 PgVectorLoadingConfig = [
     CaseConfigParamInput_IndexType_PgVector,
     CaseConfigParamInput_Lists_PgVector,
     CaseConfigParamInput_m,
     CaseConfigParamInput_EFConstruction_PgVector,
+    CaseConfigParamInput_QuantizationType_PgVector,
     CaseConfigParamInput_maintenance_work_mem_PgVector,
     CaseConfigParamInput_max_parallel_workers_PgVector,
 ]
@@ -841,6 +893,7 @@ PgVectorPerformanceConfig = [
     CaseConfigParamInput_EFSearch_PgVector,
     CaseConfigParamInput_Lists_PgVector,
     CaseConfigParamInput_Probes_PgVector,
+    CaseConfigParamInput_QuantizationType_PgVector,
     CaseConfigParamInput_maintenance_work_mem_PgVector,
     CaseConfigParamInput_max_parallel_workers_PgVector,
 ]
@@ -905,6 +958,10 @@ CASE_CONFIG_MAP = {
         CaseLabel.Load: ESLoadingConfig,
         CaseLabel.Performance: ESPerformanceConfig,
     },
+    DB.AWSOpenSearch: {
+        CaseLabel.Load: AWSOpensearchLoadingConfig,
+        CaseLabel.Performance: AWSOpenSearchPerformanceConfig,
+    },
     DB.PgVector: {
         CaseLabel.Load: PgVectorLoadingConfig,
         CaseLabel.Performance: PgVectorPerformanceConfig,

vectordb_bench/frontend/pages/quries_per_dollar.py

@@ -1,10 +1,17 @@
 import streamlit as st
 from vectordb_bench.frontend.components.check_results.footer import footer
-from vectordb_bench.frontend.components.check_results.expanderStyle import initMainExpanderStyle
+from vectordb_bench.frontend.components.check_results.expanderStyle import (
+    initMainExpanderStyle,
+)
 from vectordb_bench.frontend.components.check_results.priceTable import priceTable
-from vectordb_bench.frontend.components.check_results.stPageConfig import initResultsPageConfig
+from vectordb_bench.frontend.components.check_results.stPageConfig import (
+    initResultsPageConfig,
+)
 from vectordb_bench.frontend.components.check_results.headerIcon import drawHeaderIcon
-from vectordb_bench.frontend.components.check_results.nav import NavToResults, NavToRunTest
+from vectordb_bench.frontend.components.check_results.nav import (
+    NavToResults,
+    NavToRunTest,
+)
 from vectordb_bench.frontend.components.check_results.charts import drawMetricChart
 from vectordb_bench.frontend.components.check_results.filters import getshownData
 from vectordb_bench.frontend.components.get_results.saveAsImage import getResults
@@ -16,7 +23,7 @@ from vectordb_bench.metric import QURIES_PER_DOLLAR_METRIC
 def main():
     # set page config
     initResultsPageConfig(st)
-    
+
     # header
     drawHeaderIcon(st)
 
@@ -57,7 +64,8 @@ def main():
                 dataWithMetric.append(d)
         if len(dataWithMetric) > 0:
             chartContainer = st.expander(caseName, True)
-            drawMetricChart(data, metric, chartContainer)
+            key = f"{caseName}-{metric}"
+            drawMetricChart(data, metric, chartContainer, key=key)
 
     # footer
     footer(st.container())

vectordb_bench/frontend/vdb_benchmark.py

@@ -1,8 +1,13 @@
 import streamlit as st
 from vectordb_bench.frontend.components.check_results.footer import footer
-from vectordb_bench.frontend.components.check_results.stPageConfig import initResultsPageConfig
+from vectordb_bench.frontend.components.check_results.stPageConfig import (
+    initResultsPageConfig,
+)
 from vectordb_bench.frontend.components.check_results.headerIcon import drawHeaderIcon
-from vectordb_bench.frontend.components.check_results.nav import NavToQuriesPerDollar, NavToRunTest
+from vectordb_bench.frontend.components.check_results.nav import (
+    NavToQuriesPerDollar,
+    NavToRunTest,
+)
 from vectordb_bench.frontend.components.check_results.charts import drawCharts
 from vectordb_bench.frontend.components.check_results.filters import getshownData
 from vectordb_bench.frontend.components.get_results.saveAsImage import getResults
@@ -20,7 +25,10 @@ def main():
     allResults = benchMarkRunner.get_results()
 
     st.title("Vector Database Benchmark")
-    st.caption("Note that all testing was completed in July 2023, except for the times already noted.")
+    st.caption(
+        "Except for zillizcloud-v2024.1, which was tested in _January 2024_, all other tests were completed before _August 2023_."
+    )
+    st.caption("All tested milvus are in _standalone_ mode.")
 
     # results selector and filter
     resultSelectorContainer = st.sidebar.container()

vectordb_bench/models.py

@@ -1,6 +1,6 @@
 import logging
 import pathlib
-from datetime import date
+from datetime import date, datetime
 from enum import Enum, StrEnum, auto
 from typing import List, Self
 
@@ -163,16 +163,20 @@ class TestResult(BaseModel):
     results: list[CaseResult]
 
     file_fmt: str = "result_{}_{}_{}.json"  # result_20230718_statndard_milvus.json
+    timestamp: float = 0.0
 
     def flush(self):
         db2case = self.get_db_results()
-
+        timestamp = datetime.combine(date.today(), datetime.min.time()).timestamp()
         result_root = config.RESULTS_LOCAL_DIR
         for db, result in db2case.items():
             self.write_db_file(
                 result_dir=result_root.joinpath(db.value),
                 partial=TestResult(
-                    run_id=self.run_id, task_label=self.task_label, results=result
+                    run_id=self.run_id,
+                    task_label=self.task_label,
+                    results=result,
+                    timestamp=timestamp,
                 ),
                 db=db.value.lower(),
             )