vectordb-bench 0.0.29__py3-none-any.whl → 1.0.0__py3-none-any.whl

vectordb_bench/backend/task_runner.py

@@ -6,15 +6,14 @@ from enum import Enum, auto
 import numpy as np
 import psutil
 
-from vectordb_bench.base import BaseModel
-from vectordb_bench.metric import Metric
-from vectordb_bench.models import PerformanceTimeoutError, TaskConfig, TaskStage
-
+from ..base import BaseModel
+from ..metric import Metric
+from ..models import PerformanceTimeoutError, TaskConfig, TaskStage
 from . import utils
-from .cases import Case, CaseLabel
+from .cases import Case, CaseLabel, StreamingPerformanceCase
 from .clients import MetricType, api
 from .data_source import DatasetSource
-from .runner import MultiProcessingSearchRunner, SerialInsertRunner, SerialSearchRunner
+from .runner import MultiProcessingSearchRunner, ReadWriteRunner, SerialInsertRunner, SerialSearchRunner
 
 log = logging.getLogger(__name__)
 
@@ -48,6 +47,7 @@ class CaseRunner(BaseModel):
     serial_search_runner: SerialSearchRunner | None = None
     search_runner: MultiProcessingSearchRunner | None = None
     final_search_runner: MultiProcessingSearchRunner | None = None
+    read_write_runner: ReadWriteRunner | None = None
 
     def __eq__(self, obj: any):
         if isinstance(obj, CaseRunner):
@@ -63,6 +63,7 @@ class CaseRunner(BaseModel):
         c_dict = self.ca.dict(
             include={
                 "label": True,
+                "name": True,
                 "filters": True,
                 "dataset": {
                     "data": {
@@ -91,12 +92,13 @@ class CaseRunner(BaseModel):
             db_config=self.config.db_config.to_dict(),
             db_case_config=self.config.db_case_config,
             drop_old=drop_old,
+            with_scalar_labels=self.ca.with_scalar_labels,
         )
 
     def _pre_run(self, drop_old: bool = True):
         try:
             self.init_db(drop_old)
-            self.ca.dataset.prepare(self.dataset_source, filters=self.ca.filter_rate)
+            self.ca.dataset.prepare(self.dataset_source, filters=self.ca.filters)
         except ModuleNotFoundError as e:
             log.warning(f"pre run case error: please install client for db: {self.config.db}, error={e}")
             raise e from None
@@ -110,6 +112,8 @@ class CaseRunner(BaseModel):
             return self._run_capacity_case()
         if self.ca.label == CaseLabel.Performance:
             return self._run_perf_case(drop_old)
+        if self.ca.label == CaseLabel.Streaming:
+            return self._run_streaming_case()
         msg = f"unknown case type: {self.ca.label}"
         log.warning(msg)
         raise ValueError(msg)
@@ -127,6 +131,7 @@ class CaseRunner(BaseModel):
                 self.db,
                 self.ca.dataset,
                 self.normalize,
+                self.ca.filters,
                 self.ca.load_timeout,
             )
             count = runner.run_endlessness()
@@ -151,6 +156,8 @@ class CaseRunner(BaseModel):
                 if TaskStage.LOAD in self.config.stages:
                     _, load_dur = self._load_train_data()
                     build_dur = self._optimize()
+                    m.insert_duration = round(load_dur, 4)
+                    m.optimize_duration = round(build_dur, 4)
                     m.load_duration = round(load_dur + build_dur, 4)
                     log.info(
                         f"Finish loading the entire dataset into VectorDB,"
@@ -172,10 +179,6 @@ class CaseRunner(BaseModel):
                     ) = search_results
                 if TaskStage.SEARCH_SERIAL in self.config.stages:
                     search_results = self._serial_search()
-                    """
-                    m.recall = search_results.recall
-                    m.serial_latencies = search_results.serial_latencies
-                    """
                     m.recall, m.ndcg, m.serial_latency_p99 = search_results
 
         except Exception as e:
@@ -186,6 +189,19 @@ class CaseRunner(BaseModel):
             log.info(f"Performance case got result: {m}")
             return m
 
+    def _run_streaming_case(self) -> Metric:
+        log.info("Start streaming case")
+        try:
+            self._init_read_write_runner()
+            m = self.read_write_runner.run_read_write()
+        except Exception as e:
+            log.warning(f"Failed to run streaming case, reason = {e}")
+            traceback.print_exc()
+            raise e from None
+        else:
+            log.info(f"Streaming case got result: {m}")
+            return m
+
     @utils.time_it
     def _load_train_data(self):
         """Insert train data and get the insert_duration"""
@@ -194,6 +210,7 @@ class CaseRunner(BaseModel):
                 self.db,
                 self.ca.dataset,
                 self.normalize,
+                self.ca.filters,
                 self.ca.load_timeout,
             )
             runner.run()
@@ -207,7 +224,7 @@ class CaseRunner(BaseModel):
         calculate the recall, serial_latency_p99
 
         Returns:
-            tuple[float, float]: recall, serial_latency_p99
+            tuple[float, float, float]: recall, ndcg, serial_latency_p99
         """
         try:
             results, _ = self.serial_search_runner.run()
@@ -253,10 +270,12 @@ class CaseRunner(BaseModel):
                 raise e from None
 
     def _init_search_runner(self):
-        test_emb = np.stack(self.ca.dataset.test_data["emb"])
         if self.normalize:
+            test_emb = np.stack(self.ca.dataset.test_data)
             test_emb = test_emb / np.linalg.norm(test_emb, axis=1)[:, np.newaxis]
-        self.test_emb = test_emb.tolist()
+            self.test_emb = test_emb.tolist()
+        else:
+            self.test_emb = self.ca.dataset.test_data
 
         gt_df = self.ca.dataset.gt_data
 
@@ -279,6 +298,20 @@ class CaseRunner(BaseModel):
                 k=self.config.case_config.k,
             )
 
+    def _init_read_write_runner(self):
+        ca: StreamingPerformanceCase = self.ca
+        self.read_write_runner = ReadWriteRunner(
+            db=self.db,
+            dataset=ca.dataset,
+            insert_rate=ca.insert_rate,
+            search_stages=ca.search_stages,
+            optimize_after_write=ca.optimize_after_write,
+            read_dur_after_write=ca.read_dur_after_write,
+            concurrencies=ca.concurrencies,
+            k=self.config.case_config.k,
+            normalize=self.normalize,
+        )
+
     def stop(self):
         if self.search_runner:
             self.search_runner.stop()
@@ -316,12 +349,7 @@ class TaskRunner(BaseModel):
         fmt.append(DATA_FORMAT % ("-" * 11, "-" * 12, "-" * 20, "-" * 7, "-" * 7))
 
         for f in self.case_runners:
-            if f.ca.filter_rate != 0.0:
-                filters = f.ca.filter_rate
-            elif f.ca.filter_size != 0:
-                filters = f.ca.filter_size
-            else:
-                filters = "None"
+            filters = f.ca.filters.filter_rate
 
             ds_str = f"{f.ca.dataset.data.name}-{f.ca.dataset.data.label}-{utils.numerize(f.ca.dataset.data.size)}"
             fmt.append(

vectordb_bench/cli/batch_cli.py

@@ -0,0 +1,121 @@
+import logging
+import time
+from collections.abc import MutableMapping
+from concurrent.futures import wait
+from pathlib import Path
+from typing import Annotated, Any, TypedDict
+
+import click
+from click.testing import CliRunner
+from yaml import Loader, load
+
+from .. import config
+from ..cli.cli import (
+    cli,
+    click_parameter_decorators_from_typed_dict,
+)
+
+log = logging.getLogger(__name__)
+
+
+def click_get_defaults_from_file(ctx, param, value):  # noqa: ANN001, ARG001
+    if not value:
+        raise click.MissingParameter
+    path = Path(value)
+    input_file = path if path.exists() else Path(config.CONFIG_LOCAL_DIR, path)
+    try:
+        with input_file.open() as f:
+            _config: dict[str, list[dict[str, Any]]] = load(f.read(), Loader=Loader)  # noqa: S506
+            ctx.default_map = _config
+    except Exception as e:
+        msg = f"Failed to load batch config file: {e}"
+        raise click.BadParameter(msg) from e
+    return value
+
+
+class BatchCliTypedDict(TypedDict):
+    batch_config_file: Annotated[
+        bool,
+        click.option(
+            "--batch-config-file",
+            type=click.Path(),
+            callback=click_get_defaults_from_file,
+            is_eager=True,
+            expose_value=False,
+            help="Read batch configuration from yaml file",
+        ),
+    ]
+
+
+def build_sub_cmd_args(batch_config: MutableMapping[str, Any] | None):
+    bool_options = {
+        "drop_old": True,
+        "load": True,
+        "search_serial": True,
+        "search_concurrent": True,
+        "dry_run": False,
+        "custom_dataset_use_shuffled": True,
+        "custom_dataset_with_gt": True,
+    }
+
+    def format_option(key: str, value: Any):
+        opt_name = key.replace("_", "-")
+
+        if key in bool_options:
+            return format_bool_option(opt_name, value, skip=False)
+
+        if key.startswith("skip_"):
+            raw_key = key[5:]
+            raw_opt = raw_key.replace("_", "-")
+            return format_bool_option(raw_opt, value, skip=True, raw_key=raw_key)
+
+        return [f"--{opt_name}", str(value)]
+
+    def format_bool_option(opt_name: str, value: Any, skip: bool = False, raw_key: str | None = None):
+        if isinstance(value, bool):
+            if skip:
+                if bool_options.get(raw_key, False):
+                    return [f"--skip-{opt_name}"] if value else [f"--{opt_name}"]
+                return [f"--{opt_name}", str(value)]
+            if value:
+                return [f"--{opt_name}"]
+            if bool_options.get(opt_name.replace("-", "_"), False):
+                return [f"--skip-{opt_name}"]
+            return []
+        return [f"--{opt_name}", str(value)]
+
+    args_arr = []
+    for sub_cmd_key, sub_cmd_config_list in batch_config.items():
+        for sub_cmd_args in sub_cmd_config_list:
+            args = [sub_cmd_key]
+            for k, v in sub_cmd_args.items():
+                args.extend(format_option(k, v))
+            args_arr.append(args)
+
+    return args_arr
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(BatchCliTypedDict)
+def BatchCli():
+    ctx = click.get_current_context()
+    batch_config = ctx.default_map
+
+    runner = CliRunner()
+
+    args_arr = build_sub_cmd_args(batch_config)
+
+    for args in args_arr:
+        log.info(f"got batch config: {' '.join(args)}")
+
+    for args in args_arr:
+        result = runner.invoke(cli, args)
+        time.sleep(5)
+
+        from ..interface import global_result_future
+
+        if global_result_future:
+            wait([global_result_future])
+
+        if result.exception:
+            log.exception(f"failed to run sub command: {args[0]}", exc_info=result.exception)

vectordb_bench/cli/cli.py

@@ -110,7 +110,7 @@ def click_parameter_decorators_from_typed_dict(
     return deco
 
 
-def click_arg_split(ctx: click.Context, param: click.core.Option, value):  # noqa: ANN001, ARG001
+def click_arg_split(ctx: click.Context, param: click.core.Option, value: any):  # noqa: ARG001
     """Will split a comma-separated list input into an actual list.
 
     Args:
@@ -455,6 +455,22 @@ class HNSWFlavor3(HNSWBaseRequiredTypedDict):
     ]
 
 
+class HNSWFlavor4(HNSWBaseRequiredTypedDict):
+    ef_search: Annotated[
+        int | None,
+        click.option("--ef-search", type=int, help="hnsw ef-search", required=True),
+    ]
+    index_type: Annotated[
+        str | None,
+        click.option(
+            "--index-type",
+            type=click.Choice(["HNSW", "HNSW_SQ", "HNSW_BQ"], case_sensitive=False),
+            help="Type of index to use. Supported values: HNSW, HNSW_SQ, HNSW_BQ",
+            required=True,
+        ),
+    ]
+
+
 class IVFFlatTypedDict(TypedDict):
     lists: Annotated[int | None, click.option("--lists", type=int, help="ivfflat lists")]
     probes: Annotated[int | None, click.option("--probes", type=int, help="ivfflat probes")]
@@ -471,6 +487,48 @@ class IVFFlatTypedDictN(TypedDict):
     ]
 
 
+class OceanBaseIVFTypedDict(TypedDict):
+    index_type: Annotated[
+        str | None,
+        click.option(
+            "--index-type",
+            type=click.Choice(["IVF_FLAT", "IVF_SQ8", "IVF_PQ"], case_sensitive=False),
+            help="Type of index to use. Supported values: IVF_FLAT, IVF_SQ8, IVF_PQ",
+            required=True,
+        ),
+    ]
+    nlist: Annotated[
+        int | None,
+        click.option("--nlist", "nlist", type=int, help="Number of cluster centers", required=True),
+    ]
+    sample_per_nlist: Annotated[
+        int | None,
+        click.option(
+            "--sample_per_nlist",
+            "sample_per_nlist",
+            type=int,
+            help="The cluster centers are calculated by total sampling sample_per_nlist * nlist vectors",
+            required=True,
+        ),
+    ]
+    ivf_nprobes: Annotated[
+        int | None,
+        click.option(
+            "--ivf_nprobes",
+            "ivf_nprobes",
+            type=str,
+            help="How many clustering centers to search during the query",
+            required=True,
+        ),
+    ]
+    m: Annotated[
+        int | None,
+        click.option(
+            "--m", "m", type=int, help="The number of sub-vectors that each data vector is divided into during IVF-PQ"
+        ),
+    ]
+
+
 @click.group()
 def cli(): ...
 

vectordb_bench/cli/vectordbbench.py

@@ -5,17 +5,20 @@ from ..backend.clients.lancedb.cli import LanceDB
 from ..backend.clients.mariadb.cli import MariaDBHNSW
 from ..backend.clients.memorydb.cli import MemoryDB
 from ..backend.clients.milvus.cli import MilvusAutoIndex
+from ..backend.clients.oceanbase.cli import OceanBaseHNSW, OceanBaseIVF
 from ..backend.clients.pgdiskann.cli import PgDiskAnn
 from ..backend.clients.pgvecto_rs.cli import PgVectoRSHNSW, PgVectoRSIVFFlat
 from ..backend.clients.pgvector.cli import PgVectorHNSW
 from ..backend.clients.pgvectorscale.cli import PgVectorScaleDiskAnn
 from ..backend.clients.qdrant_cloud.cli import QdrantCloud
+from ..backend.clients.qdrant_local.cli import QdrantLocal
 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 .batch_cli import BatchCli
 from .cli import cli
 
 cli.add_command(PgVectorHNSW)
@@ -31,12 +34,16 @@ cli.add_command(AWSOpenSearch)
 cli.add_command(PgVectorScaleDiskAnn)
 cli.add_command(PgDiskAnn)
 cli.add_command(AlloyDBScaNN)
+cli.add_command(OceanBaseHNSW)
+cli.add_command(OceanBaseIVF)
 cli.add_command(MariaDBHNSW)
 cli.add_command(TiDB)
 cli.add_command(Clickhouse)
 cli.add_command(Vespa)
 cli.add_command(LanceDB)
 cli.add_command(QdrantCloud)
+cli.add_command(QdrantLocal)
+cli.add_command(BatchCli)
 
 
 if __name__ == "__main__":

vectordb_bench/config-files/batch_sample_config.yml

@@ -0,0 +1,17 @@
+pgvectorhnsw:
+  - db_label: pgConfigTest
+    user_name: vectordbbench
+    db_name:  vectordbbench
+    host: localhost
+    m: 16
+    ef_construction: 128
+    ef_search: 128
+milvushnsw:
+  - skip_search_serial: True
+    case_type: Performance1536D50K
+    uri: http://localhost:19530
+    m: 16
+    ef_construction: 128
+    ef_search: 128
+    drop_old: False
+    load: False

vectordb_bench/frontend/components/check_results/data.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from dataclasses import asdict
-from vectordb_bench.metric import isLowerIsBetterMetric
+from vectordb_bench.metric import QPS_METRIC, isLowerIsBetterMetric
 from vectordb_bench.models import CaseResult, ResultLabel
 
 
@@ -22,8 +22,7 @@ def getFilterTasks(
     filterTasks = [
         task
         for task in tasks
-        if task.task_config.db_name in dbNames
-        and task.task_config.case_config.case_id.case_cls(task.task_config.case_config.custom_case).name in caseNames
+        if task.task_config.db_name in dbNames and task.task_config.case_config.case_name in caseNames
     ]
     return filterTasks
 
@@ -35,17 +34,22 @@ def mergeTasks(tasks: list[CaseResult]):
         db = task.task_config.db.value
         db_label = task.task_config.db_config.db_label or ""
         version = task.task_config.db_config.version or ""
-        case = task.task_config.case_config.case_id.case_cls(task.task_config.case_config.custom_case)
+        case = task.task_config.case_config.case
+        case_name = case.name
+        dataset_name = case.dataset.data.full_name
+        filter_rate = case.filter_rate
         dbCaseMetricsMap[db_name][case.name] = {
             "db": db,
             "db_label": db_label,
             "version": version,
+            "dataset_name": dataset_name,
+            "filter_rate": filter_rate,
             "metrics": mergeMetrics(
-                dbCaseMetricsMap[db_name][case.name].get("metrics", {}),
+                dbCaseMetricsMap[db_name][case_name].get("metrics", {}),
                 asdict(task.metrics),
             ),
             "label": getBetterLabel(
-                dbCaseMetricsMap[db_name][case.name].get("label", ResultLabel.FAILED),
+                dbCaseMetricsMap[db_name][case_name].get("label", ResultLabel.FAILED),
                 task.label,
             ),
         }
@@ -59,12 +63,16 @@ def mergeTasks(tasks: list[CaseResult]):
             db_label = metricInfo["db_label"]
             version = metricInfo["version"]
             label = metricInfo["label"]
+            dataset_name = metricInfo["dataset_name"]
+            filter_rate = metricInfo["filter_rate"]
             if label == ResultLabel.NORMAL:
                 mergedTasks.append(
                     {
                         "db_name": db_name,
                         "db": db,
                         "db_label": db_label,
+                        "dataset_name": dataset_name,
+                        "filter_rate": filter_rate,
                         "version": version,
                         "case_name": case_name,
                         "metricsSet": set(metrics.keys()),
@@ -77,12 +85,9 @@ def mergeTasks(tasks: list[CaseResult]):
     return mergedTasks, failedTasks
 
 
+# for same db-label, we use the results with the highest qps
 def mergeMetrics(metrics_1: dict, metrics_2: dict) -> dict:
-    metrics = {**metrics_1}
-    for key, value in metrics_2.items():
-        metrics[key] = getBetterMetric(key, value, metrics[key]) if key in metrics else value
-
-    return metrics
+    return metrics_1 if metrics_1.get(QPS_METRIC, 0) > metrics_2.get(QPS_METRIC, 0) else metrics_2
 
 
 def getBetterMetric(metric, value_1, value_2):

vectordb_bench/frontend/components/check_results/filters.py

@@ -1,14 +1,19 @@
 from vectordb_bench.backend.cases import Case
+from vectordb_bench.backend.dataset import DatasetWithSizeType
+from vectordb_bench.backend.filter import FilterOp
 from vectordb_bench.frontend.components.check_results.data import getChartData
-from vectordb_bench.frontend.components.check_results.expanderStyle import initSidebarExanderStyle
+from vectordb_bench.frontend.components.check_results.expanderStyle import (
+    initSidebarExanderStyle,
+)
 from vectordb_bench.frontend.config.dbCaseConfigs import CASE_NAME_ORDER
-from vectordb_bench.frontend.config.styles import *
+from vectordb_bench.frontend.config.styles import SIDEBAR_CONTROL_COLUMNS
 import streamlit as st
+from typing import Callable
 
 from vectordb_bench.models import CaseResult, TestResult
 
 
-def getshownData(results: list[TestResult], st):
+def getshownData(st, results: list[TestResult], filter_type: FilterOp = FilterOp.NonFilter, **kwargs):
     # hide the nav
     st.markdown(
         "<style> div[data-testid='stSidebarNav'] {display: none;} </style>",
@@ -17,15 +22,20 @@ def getshownData(results: list[TestResult], st):
 
     st.header("Filters")
 
-    shownResults = getshownResults(results, st)
-    showDBNames, showCaseNames = getShowDbsAndCases(shownResults, st)
+    shownResults = getshownResults(st, results, **kwargs)
+    showDBNames, showCaseNames = getShowDbsAndCases(st, shownResults, filter_type)
 
     shownData, failedTasks = getChartData(shownResults, showDBNames, showCaseNames)
 
     return shownData, failedTasks, showCaseNames
 
 
-def getshownResults(results: list[TestResult], st) -> list[CaseResult]:
+def getshownResults(
+    st,
+    results: list[TestResult],
+    case_results_filter: Callable[[CaseResult], bool] = lambda x: True,
+    **kwargs,
+) -> list[CaseResult]:
     resultSelectOptions = [
         result.task_label if result.task_label != result.run_id else f"res-{result.run_id[:4]}" for result in results
     ]
@@ -41,23 +51,18 @@ def getshownResults(results: list[TestResult], st) -> list[CaseResult]:
     )
     selectedResult: list[CaseResult] = []
     for option in selectedResultSelectedOptions:
-        result = results[resultSelectOptions.index(option)].results
-        selectedResult += result
+        case_results = results[resultSelectOptions.index(option)].results
+        selectedResult += [r for r in case_results if case_results_filter(r)]
 
     return selectedResult
 
 
-def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[str]]:
+def getShowDbsAndCases(st, result: list[CaseResult], filter_type: FilterOp) -> tuple[list[str], list[str]]:
     initSidebarExanderStyle(st)
-    allDbNames = list(set({res.task_config.db_name for res in result}))
+    case_results = [res for res in result if res.task_config.case_config.case.filters.type == filter_type]
+    allDbNames = list(set({res.task_config.db_name for res in case_results}))
     allDbNames.sort()
-    allCases: list[Case] = [
-        res.task_config.case_config.case_id.case_cls(res.task_config.case_config.custom_case) for res in result
-    ]
-    allCaseNameSet = set({case.name for case in allCases})
-    allCaseNames = [case_name for case_name in CASE_NAME_ORDER if case_name in allCaseNameSet] + [
-        case_name for case_name in allCaseNameSet if case_name not in CASE_NAME_ORDER
-    ]
+    allCases: list[Case] = [res.task_config.case_config.case for res in case_results]
 
     # DB Filter
     dbFilterContainer = st.container()
@@ -67,15 +72,38 @@ def getShowDbsAndCases(result: list[CaseResult], st) -> tuple[list[str], list[st
         allDbNames,
         col=1,
     )
+    showCaseNames = []
+
+    if filter_type == FilterOp.NonFilter:
+        allCaseNameSet = set({case.name for case in allCases})
+        allCaseNames = [case_name for case_name in CASE_NAME_ORDER if case_name in allCaseNameSet] + [
+            case_name for case_name in allCaseNameSet if case_name not in CASE_NAME_ORDER
+        ]
+
+        # Case Filter
+        caseFilterContainer = st.container()
+        showCaseNames = filterView(
+            caseFilterContainer,
+            "Case Filter",
+            [caseName for caseName in allCaseNames],
+            col=1,
+        )
 
-    # Case Filter
-    caseFilterContainer = st.container()
-    showCaseNames = filterView(
-        caseFilterContainer,
-        "Case Filter",
-        [caseName for caseName in allCaseNames],
-        col=1,
-    )
+    if filter_type == FilterOp.StrEqual:
+        container = st.container()
+        datasetWithSizeTypes = [dataset_with_size_type for dataset_with_size_type in DatasetWithSizeType]
+        showDatasetWithSizeTypes = filterView(
+            container,
+            "Case Filter",
+            datasetWithSizeTypes,
+            col=1,
+            optionLables=[v.value for v in datasetWithSizeTypes],
+        )
+        datasets = [dataset_with_size_type.get_manager() for dataset_with_size_type in showDatasetWithSizeTypes]
+        showCaseNames = list(set([case.name for case in allCases if case.dataset in datasets]))
+
+    if filter_type == FilterOp.NumGE:
+        raise NotImplementedError
 
     return showDBNames, showCaseNames
 

vectordb_bench/frontend/components/check_results/headerIcon.py

@@ -4,19 +4,22 @@ from vectordb_bench.frontend.config.styles import HEADER_ICON
 def drawHeaderIcon(st):
     st.markdown(
         f"""
-<div class="headerIconContainer"></div>
+    <a href="/vdb_benchmark" target="_self">
+        <div class="headerIconContainer"></div>
+    </a>
 
-<style>
-.headerIconContainer {{
-    position: absolute;
-    top: -50px;
-    height: 50px;
-    width: 100%;
-    border-bottom: 2px solid #E8EAEE;
-    background-image: url({HEADER_ICON});
-    background-repeat: no-repeat;
-}}
-</style
-""",
+    <style>
+    .headerIconContainer {{
+        position: relative;
+        top: 0px;
+        height: 50px;
+        width: 100%;
+        border-bottom: 2px solid #E8EAEE;
+        background-image: url({HEADER_ICON});
+        background-repeat: no-repeat;
+        cursor: pointer; 
+    }}
+    </style>
+    """,
         unsafe_allow_html=True,
     )