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

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,7 @@
 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.pgdiskann.cli import PgDiskAnn
 from ..backend.clients.redis.cli import Redis
 from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.test.cli import Test
@@ -8,7 +10,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 +22,8 @@ cli.add_command(Test)
 cli.add_command(ZillizAutoIndex)
 cli.add_command(MilvusAutoIndex)
 cli.add_command(AWSOpenSearch)
+cli.add_command(PgVectorScaleDiskAnn)
+cli.add_command(PgDiskAnn)
 
 
 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/components/run_test/caseSelector.py

@@ -110,6 +110,12 @@ def caseConfigSetting(st, dbToCaseClusterConfigs, uiCaseItem: UICaseItem, active
                         value=config.inputConfig["value"],
                         help=config.inputHelp,
                     )
+                elif config.inputType == InputType.Bool:
+                    caseConfig[config.label] = column.checkbox(
+                        config.displayLabel if config.displayLabel else config.label.value,
+                        value=config.inputConfig["value"],
+                        help=config.inputHelp,
+                    )
                 k += 1
         if k == 0:
             columns[1].write("Auto")

vectordb_bench/frontend/config/dbCaseConfigs.py

@@ -3,7 +3,7 @@ import typing
 from pydantic import BaseModel
 from vectordb_bench.backend.cases import CaseLabel, CaseType
 from vectordb_bench.backend.clients import DB
-from vectordb_bench.backend.clients.api import IndexType
+from vectordb_bench.backend.clients.api import IndexType, MetricType
 from vectordb_bench.frontend.components.custom.getCustomConfig import get_custom_configs
 
 from vectordb_bench.models import CaseConfig, CaseConfigParamType
@@ -149,6 +149,7 @@ class InputType(IntEnum):
     Number = 20002
     Option = 20003
     Float = 20004
+    Bool = 20005
 
 
 class CaseConfigInput(BaseModel):
@@ -180,6 +181,16 @@ CaseConfigParamInput_IndexType = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_IndexType_PgDiskANN = CaseConfigInput(
+    label=CaseConfigParamType.IndexType,
+    inputHelp="Select Index Type",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            IndexType.DISKANN.value,
+        ],
+    },
+)
 
 CaseConfigParamInput_IndexType_PgVectorScale = CaseConfigInput(
     label=CaseConfigParamType.IndexType,
@@ -205,6 +216,42 @@ CaseConfigParamInput_storage_layout = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_max_neighbors = CaseConfigInput(
+    label=CaseConfigParamType.max_neighbors,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 10,
+        "max": 300,
+        "value": 32,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.DISKANN.value,
+)
+
+CaseConfigParamInput_l_value_ib = CaseConfigInput(
+    label=CaseConfigParamType.l_value_ib,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 10,
+        "max": 300,
+        "value": 50,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.DISKANN.value,
+)
+
+CaseConfigParamInput_l_value_is = CaseConfigInput(
+    label=CaseConfigParamType.l_value_is,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 10,
+        "max": 300,
+        "value": 40,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.DISKANN.value,
+)
+
 CaseConfigParamInput_num_neighbors = CaseConfigInput(
     label=CaseConfigParamType.num_neighbors,
     inputType=InputType.Number,
@@ -360,6 +407,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 +816,19 @@ CaseConfigParamInput_QuantizationType_PgVectoRS = CaseConfigInput(
     ],
 )
 
+CaseConfigParamInput_QuantizationType_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.quantizationType,
+    inputType=InputType.Option,
+    inputConfig={
+        "options": ["none", "bit", "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,
@@ -775,6 +866,46 @@ CaseConfigParamInput_ZillizLevel = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_reranking_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.reranking,
+    inputType=InputType.Bool,
+    displayLabel="Enable Reranking",
+    inputHelp="Enable if you want to use reranking while performing \
+        similarity search in binary quantization",
+    inputConfig={
+        "value": False,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.quantizationType, None)
+    == "bit"
+)
+
+CaseConfigParamInput_quantized_fetch_limit_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.quantizedFetchLimit,
+    displayLabel="Quantized vector fetch limit",
+    inputHelp="Limit top-k vectors using the quantized vector comparison --bound by ef_search",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 20,
+        "max": 1000,
+        "value": 200,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.quantizationType, None)
+    == "bit" and config.get(CaseConfigParamType.reranking, False)
+)
+
+
+CaseConfigParamInput_reranking_metric_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.rerankingMetric,
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            metric.value for metric in MetricType if metric.value not in ["HAMMING", "JACCARD"]
+        ],
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.quantizationType, None)
+    == "bit" and config.get(CaseConfigParamType.reranking, False)
+)
+
 MilvusLoadConfig = [
     CaseConfigParamInput_IndexType,
     CaseConfigParamInput_M,
@@ -826,11 +957,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,8 +980,12 @@ PgVectorPerformanceConfig = [
     CaseConfigParamInput_EFSearch_PgVector,
     CaseConfigParamInput_Lists_PgVector,
     CaseConfigParamInput_Probes_PgVector,
+    CaseConfigParamInput_QuantizationType_PgVector,
     CaseConfigParamInput_maintenance_work_mem_PgVector,
     CaseConfigParamInput_max_parallel_workers_PgVector,
+    CaseConfigParamInput_reranking_PgVector,
+    CaseConfigParamInput_reranking_metric_PgVector,
+    CaseConfigParamInput_quantized_fetch_limit_PgVector,
 ]
 
 PgVectoRSLoadingConfig = [
@@ -889,6 +1032,19 @@ PgVectorScalePerformanceConfig = [
     CaseConfigParamInput_query_search_list_size,
 ]
 
+PgDiskANNLoadConfig = [
+    CaseConfigParamInput_IndexType_PgDiskANN,
+    CaseConfigParamInput_max_neighbors,
+    CaseConfigParamInput_l_value_ib,
+]
+
+PgDiskANNPerformanceConfig = [
+    CaseConfigParamInput_IndexType_PgDiskANN,
+    CaseConfigParamInput_max_neighbors,
+    CaseConfigParamInput_l_value_ib,
+    CaseConfigParamInput_l_value_is,
+]
+
 CASE_CONFIG_MAP = {
     DB.Milvus: {
         CaseLabel.Load: MilvusLoadConfig,
@@ -905,6 +1061,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,
@@ -917,4 +1077,8 @@ CASE_CONFIG_MAP = {
         CaseLabel.Load: PgVectorScaleLoadingConfig,
         CaseLabel.Performance: PgVectorScalePerformanceConfig,
     },
+    DB.PgDiskANN: {
+        CaseLabel.Load: PgDiskANNLoadConfig,
+        CaseLabel.Performance: PgDiskANNPerformanceConfig,
+    },
 }

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
 
@@ -47,6 +47,9 @@ class CaseConfigParamType(Enum):
     probes = "probes"
     quantizationType = "quantization_type"
     quantizationRatio = "quantization_ratio"
+    reranking = "reranking"
+    rerankingMetric = "reranking_metric"
+    quantizedFetchLimit = "quantized_fetch_limit"
     m = "m"
     nbits = "nbits"
     intermediate_graph_degree = "intermediate_graph_degree"
@@ -64,6 +67,9 @@ class CaseConfigParamType(Enum):
     max_parallel_workers = "max_parallel_workers"
     storage_layout = "storage_layout"
     num_neighbors = "num_neighbors"
+    max_neighbors = "max_neighbors"
+    l_value_ib = "l_value_ib"
+    l_value_is = "l_value_is"
     search_list_size = "search_list_size"
     max_alpha = "max_alpha"
     num_dimensions = "num_dimensions"
@@ -163,16 +169,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(),
             )