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

vectordb_bench/__init__.py

@@ -6,7 +6,7 @@ import environs
 from . import log_util
 
 env = environs.Env()
-env.read_env(".env", False)
+env.read_env(path=".env", recurse=False)
 
 
 class config:
@@ -52,6 +52,8 @@ class config:
 
     CONCURRENCY_DURATION = 30
 
+    CONCURRENCY_TIMEOUT = 3600
+
     RESULTS_LOCAL_DIR = env.path(
         "RESULTS_LOCAL_DIR",
         pathlib.Path(__file__).parent.joinpath("results"),

vectordb_bench/backend/clients/__init__.py

@@ -45,9 +45,10 @@ class DB(Enum):
     TiDB = "TiDB"
     Clickhouse = "Clickhouse"
     Vespa = "Vespa"
+    LanceDB = "LanceDB"
 
     @property
-    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901
+    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901, PLR0915
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.milvus import Milvus
@@ -164,11 +165,16 @@ class DB(Enum):
 
             return Vespa
 
+        if self == DB.LanceDB:
+            from .lancedb.lancedb import LanceDB
+
+            return LanceDB
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 
     @property
-    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912, C901
+    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912, C901, PLR0915
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.config import MilvusConfig
@@ -285,6 +291,11 @@ class DB(Enum):
 
             return VespaConfig
 
+        if self == DB.LanceDB:
+            from .lancedb.config import LanceDBConfig
+
+            return LanceDBConfig
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 
@@ -382,6 +393,11 @@ class DB(Enum):
 
             return VespaHNSWConfig
 
+        if self == DB.LanceDB:
+            from .lancedb.config import _lancedb_case_config
+
+            return _lancedb_case_config.get(index_type)
+
         # DB.Pinecone, DB.Chroma, DB.Redis
         return EmptyDBCaseConfig
 

vectordb_bench/backend/clients/api.py

@@ -34,6 +34,7 @@ class IndexType(str, Enum):
     GPU_IVF_PQ = "GPU_IVF_PQ"
     GPU_CAGRA = "GPU_CAGRA"
     SCANN = "scann"
+    NONE = "NONE"
 
 
 class SQType(str, Enum):

vectordb_bench/backend/clients/clickhouse/cli.py

@@ -51,6 +51,7 @@ def Clickhouse(**parameters: Unpack[ClickhouseHNSWTypedDict]):
         db=DB.Clickhouse,
         db_config=ClickhouseConfig(
             db_label=parameters["db_label"],
+            user=parameters["user"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             host=parameters["host"],
             port=parameters["port"],

vectordb_bench/backend/clients/clickhouse/clickhouse.py

@@ -106,7 +106,7 @@ class Clickhouse(VectorDB):
                     query = f"""
                         ALTER TABLE {self.db_config["database"]}.{self.table_name}
                         ADD INDEX {self._index_name} {self._vector_field}
-                        TYPE vector_similarity('hnsw', '{self.index_param["metric_type"]}',
+                        TYPE vector_similarity('hnsw', '{self.index_param["metric_type"]}',{self.dim},
                         '{self.index_param["quantization"]}',
                         {self.index_param["params"]["M"]}, {self.index_param["params"]["efConstruction"]})
                         GRANULARITY {self.index_param["granularity"]}
@@ -115,7 +115,7 @@ class Clickhouse(VectorDB):
                     query = f"""
                         ALTER TABLE {self.db_config["database"]}.{self.table_name}
                         ADD INDEX {self._index_name} {self._vector_field}
-                        TYPE vector_similarity('hnsw', '{self.index_param["metric_type"]}')
+                        TYPE vector_similarity('hnsw', '{self.index_param["metric_type"]}', {self.dim})
                         GRANULARITY {self.index_param["granularity"]}
                         """
                 self.conn.command(cmd=query)
@@ -186,7 +186,7 @@ class Clickhouse(VectorDB):
             "vector_field": self._vector_field,
             "schema": self.db_config["database"],
             "table": self.table_name,
-            "gt": filters.get("id"),
+            "gt": 0 if filters is None else filters.get("id", 0),
             "k": k,
             "metric_type": self.search_param["metric_type"],
             "query": query,

vectordb_bench/backend/clients/clickhouse/config.py

@@ -16,7 +16,7 @@ class ClickhouseConfigDict(TypedDict):
 
 
 class ClickhouseConfig(DBConfig):
-    user_name: str = "clickhouse"
+    user: str = "clickhouse"
     password: SecretStr
     host: str = "localhost"
     port: int = 8123
@@ -29,7 +29,7 @@ class ClickhouseConfig(DBConfig):
             "host": self.host,
             "port": self.port,
             "database": self.db_name,
-            "user": self.user_name,
+            "user": self.user,
             "password": pwd_str,
             "secure": self.secure,
         }

vectordb_bench/backend/clients/lancedb/cli.py

@@ -0,0 +1,92 @@
+from typing import Annotated, Unpack
+
+import click
+from pydantic import SecretStr
+
+from ....cli.cli import (
+    CommonTypedDict,
+    cli,
+    click_parameter_decorators_from_typed_dict,
+    run,
+)
+from .. import DB
+from ..api import IndexType
+
+
+class LanceDBTypedDict(CommonTypedDict):
+    uri: Annotated[
+        str,
+        click.option("--uri", type=str, help="URI connection string", required=True),
+    ]
+    token: Annotated[
+        str | None,
+        click.option("--token", type=str, help="Authentication token", required=False),
+    ]
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDB(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get("NONE")(),
+        **parameters,
+    )
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDBAutoIndex(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get(IndexType.AUTOINDEX)(),
+        **parameters,
+    )
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDBIVFPQ(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get(IndexType.IVFPQ)(),
+        **parameters,
+    )
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(LanceDBTypedDict)
+def LanceDBHNSW(**parameters: Unpack[LanceDBTypedDict]):
+    from .config import LanceDBConfig, _lancedb_case_config
+
+    run(
+        db=DB.LanceDB,
+        db_config=LanceDBConfig(
+            db_label=parameters["db_label"],
+            uri=parameters["uri"],
+            token=SecretStr(parameters["token"]) if parameters.get("token") else None,
+        ),
+        db_case_config=_lancedb_case_config.get(IndexType.HNSW)(),
+        **parameters,
+    )

vectordb_bench/backend/clients/lancedb/config.py

@@ -0,0 +1,103 @@
+from pydantic import BaseModel, SecretStr
+
+from ..api import DBCaseConfig, DBConfig, IndexType, MetricType
+
+
+class LanceDBConfig(DBConfig):
+    """LanceDB connection configuration."""
+
+    db_label: str
+    uri: str
+    token: SecretStr | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "uri": self.uri,
+            "token": self.token.get_secret_value() if self.token else None,
+        }
+
+
+class LanceDBIndexConfig(BaseModel, DBCaseConfig):
+    index: IndexType = IndexType.IVFPQ
+    metric_type: MetricType = MetricType.L2
+    num_partitions: int = 0
+    num_sub_vectors: int = 0
+    nbits: int = 8  # Must be 4 or 8
+    sample_rate: int = 256
+    max_iterations: int = 50
+
+    def index_param(self) -> dict:
+        if self.index not in [
+            IndexType.IVFPQ,
+            IndexType.HNSW,
+            IndexType.AUTOINDEX,
+            IndexType.NONE,
+        ]:
+            msg = f"Index type {self.index} is not supported for LanceDB!"
+            raise ValueError(msg)
+
+        # See https://lancedb.github.io/lancedb/python/python/#lancedb.table.Table.create_index
+        params = {
+            "metric": self.parse_metric(),
+            "num_bits": self.nbits,
+            "sample_rate": self.sample_rate,
+            "max_iterations": self.max_iterations,
+        }
+
+        if self.num_partitions > 0:
+            params["num_partitions"] = self.num_partitions
+        if self.num_sub_vectors > 0:
+            params["num_sub_vectors"] = self.num_sub_vectors
+
+        return params
+
+    def search_param(self) -> dict:
+        pass
+
+    def parse_metric(self) -> str:
+        if self.metric_type in [MetricType.L2, MetricType.COSINE]:
+            return self.metric_type.value.lower()
+        if self.metric_type in [MetricType.IP, MetricType.DP]:
+            return "dot"
+        msg = f"Metric type {self.metric_type} is not supported for LanceDB!"
+        raise ValueError(msg)
+
+
+class LanceDBNoIndexConfig(LanceDBIndexConfig):
+    index: IndexType = IndexType.NONE
+
+    def index_param(self) -> dict:
+        return {}
+
+
+class LanceDBAutoIndexConfig(LanceDBIndexConfig):
+    index: IndexType = IndexType.AUTOINDEX
+
+    def index_param(self) -> dict:
+        return {}
+
+
+class LanceDBHNSWIndexConfig(LanceDBIndexConfig):
+    index: IndexType = IndexType.HNSW
+    m: int = 0
+    ef_construction: int = 0
+
+    def index_param(self) -> dict:
+        params = LanceDBIndexConfig.index_param(self)
+
+        # See https://lancedb.github.io/lancedb/python/python/#lancedb.index.HnswSq
+        params["index_type"] = "IVF_HNSW_SQ"
+        if self.m > 0:
+            params["m"] = self.m
+        if self.ef_construction > 0:
+            params["ef_construction"] = self.ef_construction
+
+        return params
+
+
+_lancedb_case_config = {
+    IndexType.IVFPQ: LanceDBIndexConfig,
+    IndexType.AUTOINDEX: LanceDBAutoIndexConfig,
+    IndexType.HNSW: LanceDBHNSWIndexConfig,
+    IndexType.NONE: LanceDBNoIndexConfig,
+}

vectordb_bench/backend/clients/lancedb/lancedb.py

@@ -0,0 +1,97 @@
+import logging
+from contextlib import contextmanager
+
+import lancedb
+import pyarrow as pa
+from lancedb.pydantic import LanceModel
+
+from ..api import IndexType, VectorDB
+from .config import LanceDBConfig, LanceDBIndexConfig
+
+log = logging.getLogger(__name__)
+
+
+class VectorModel(LanceModel):
+    id: int
+    vector: list[float]
+
+
+class LanceDB(VectorDB):
+    def __init__(
+        self,
+        dim: int,
+        db_config: LanceDBConfig,
+        db_case_config: LanceDBIndexConfig,
+        collection_name: str = "vector_bench_test",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.name = "LanceDB"
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.table_name = collection_name
+        self.dim = dim
+        self.uri = db_config["uri"]
+
+        db = lancedb.connect(self.uri)
+
+        if drop_old:
+            try:
+                db.drop_table(self.table_name)
+            except Exception as e:
+                log.warning(f"Failed to drop table {self.table_name}: {e}")
+
+        try:
+            db.open_table(self.table_name)
+        except Exception:
+            schema = pa.schema(
+                [pa.field("id", pa.int64()), pa.field("vector", pa.list_(pa.float64(), list_size=self.dim))]
+            )
+            db.create_table(self.table_name, schema=schema, mode="overwrite")
+
+    @contextmanager
+    def init(self):
+        self.db = lancedb.connect(self.uri)
+        self.table = self.db.open_table(self.table_name)
+        yield
+        self.db = None
+        self.table = None
+
+    def insert_embeddings(
+        self,
+        embeddings: list[list[float]],
+        metadata: list[int],
+    ) -> tuple[int, Exception | None]:
+        try:
+            data = [{"id": meta, "vector": emb} for meta, emb in zip(metadata, embeddings, strict=False)]
+            self.table.add(data)
+            return len(metadata), None
+        except Exception as e:
+            log.warning(f"Failed to insert data into LanceDB table ({self.table_name}), error: {e}")
+            return 0, e
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+    ) -> list[int]:
+        if filters:
+            results = (
+                self.table.search(query)
+                .select(["id"])
+                .where(f"id >= {filters['id']}", prefilter=True)
+                .limit(k)
+                .to_list()
+            )
+        else:
+            results = self.table.search(query).select(["id"]).limit(k).to_list()
+        return [int(result["id"]) for result in results]
+
+    def optimize(self, data_size: int | None = None):
+        if self.table and hasattr(self, "case_config") and self.case_config.index != IndexType.NONE:
+            log.info(f"Creating index for LanceDB table ({self.table_name})")
+            self.table.create_index(**self.case_config.index_param())
+            # Better recall with IVF_PQ (though still bad) but breaks HNSW: https://github.com/lancedb/lancedb/issues/2369
+            if self.case_config.index in (IndexType.IVFPQ, IndexType.AUTOINDEX):
+                self.table.optimize()

vectordb_bench/backend/clients/qdrant_cloud/cli.py

@@ -0,0 +1,43 @@
+from typing import Annotated, Unpack
+
+import click
+from pydantic import SecretStr
+
+from ....cli.cli import (
+    CommonTypedDict,
+    cli,
+    click_parameter_decorators_from_typed_dict,
+    run,
+)
+from .. import DB
+
+
+class QdrantTypedDict(CommonTypedDict):
+    url: Annotated[
+        str,
+        click.option("--url", type=str, help="URL connection string", required=True),
+    ]
+    api_key: Annotated[
+        str | None,
+        click.option("--api-key", type=str, help="API key for authentication", required=False),
+    ]
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(QdrantTypedDict)
+def QdrantCloud(**parameters: Unpack[QdrantTypedDict]):
+    from .config import QdrantConfig, QdrantIndexConfig
+
+    config_params = {
+        "db_label": parameters["db_label"],
+        "url": SecretStr(parameters["url"]),
+    }
+
+    config_params["api_key"] = SecretStr(parameters["api_key"]) if parameters["api_key"] else None
+
+    run(
+        db=DB.QdrantCloud,
+        db_config=QdrantConfig(**config_params),
+        db_case_config=QdrantIndexConfig(),
+        **parameters,
+    )

vectordb_bench/backend/clients/qdrant_cloud/config.py

@@ -6,14 +6,14 @@ from ..api import DBCaseConfig, DBConfig, MetricType
 # Allowing `api_key` to be left empty, to ensure compatibility with the open-source Qdrant.
 class QdrantConfig(DBConfig):
     url: SecretStr
-    api_key: SecretStr
+    api_key: SecretStr | None = None
 
     def to_dict(self) -> dict:
-        api_key = self.api_key.get_secret_value()
-        if len(api_key) > 0:
+        api_key_value = self.api_key.get_secret_value() if self.api_key else None
+        if api_key_value:
             return {
                 "url": self.url.get_secret_value(),
-                "api_key": self.api_key.get_secret_value(),
+                "api_key": api_key_value,
                 "prefer_grpc": True,
             }
         return {

vectordb_bench/backend/runner/mp_runner.py

@@ -5,10 +5,12 @@ import random
 import time
 import traceback
 from collections.abc import Iterable
+from multiprocessing.queues import Queue
 
 import numpy as np
 
 from ... import config
+from ...models import ConcurrencySlotTimeoutError
 from ..clients import api
 
 NUM_PER_BATCH = config.NUM_PER_BATCH
@@ -28,16 +30,18 @@ class MultiProcessingSearchRunner:
         self,
         db: api.VectorDB,
         test_data: list[list[float]],
-        k: int = 100,
+        k: int = config.K_DEFAULT,
         filters: dict | None = None,
         concurrencies: Iterable[int] = config.NUM_CONCURRENCY,
-        duration: int = 30,
+        duration: int = config.CONCURRENCY_DURATION,
+        concurrency_timeout: int = config.CONCURRENCY_TIMEOUT,
     ):
         self.db = db
         self.k = k
         self.filters = filters
         self.concurrencies = concurrencies
         self.duration = duration
+        self.concurrency_timeout = concurrency_timeout
 
         self.test_data = test_data
         log.debug(f"test dataset columns: {len(test_data)}")
@@ -114,9 +118,7 @@ class MultiProcessingSearchRunner:
                         log.info(f"Start search {self.duration}s in concurrency {conc}, filters: {self.filters}")
                         future_iter = [executor.submit(self.search, self.test_data, q, cond) for i in range(conc)]
                         # Sync all processes
-                        while q.qsize() < conc:
-                            sleep_t = conc if conc < 10 else 10
-                            time.sleep(sleep_t)
+                        self._wait_for_queue_fill(q, size=conc)
 
                         with cond:
                             cond.notify_all()
@@ -160,6 +162,15 @@ class MultiProcessingSearchRunner:
             conc_latency_avg_list,
         )
 
+    def _wait_for_queue_fill(self, q: Queue, size: int):
+        wait_t = 0
+        while q.qsize() < size:
+            sleep_t = size if size < 10 else 10
+            wait_t += sleep_t
+            if wait_t > self.concurrency_timeout > 0:
+                raise ConcurrencySlotTimeoutError
+            time.sleep(sleep_t)
+
     def run(self) -> float:
         """
         Returns:

vectordb_bench/backend/task_runner.py

@@ -275,6 +275,7 @@ class CaseRunner(BaseModel):
                 filters=self.ca.filters,
                 concurrencies=self.config.case_config.concurrency_search_config.num_concurrency,
                 duration=self.config.case_config.concurrency_search_config.concurrency_duration,
+                concurrency_timeout=self.config.case_config.concurrency_search_config.concurrency_timeout,
                 k=self.config.case_config.k,
             )
 

vectordb_bench/cli/cli.py

@@ -17,10 +17,9 @@ from typing import (
 import click
 from yaml import load
 
-from vectordb_bench.backend.clients.api import MetricType
-
 from .. import config
 from ..backend.clients import DB
+from ..backend.clients.api import MetricType
 from ..interface import benchmark_runner, global_result_future
 from ..models import (
     CaseConfig,
@@ -303,6 +302,17 @@ class CommonTypedDict(TypedDict):
             callback=lambda *args: list(map(int, click_arg_split(*args))),
         ),
     ]
+    concurrency_timeout: Annotated[
+        int,
+        click.option(
+            "--concurrency-timeout",
+            type=int,
+            default=config.CONCURRENCY_TIMEOUT,
+            show_default=True,
+            help="Timeout (in seconds) to wait for a concurrency slot before failing. "
+            "Set to a negative value to wait indefinitely.",
+        ),
+    ]
     custom_case_name: Annotated[
         str,
         click.option(
@@ -405,6 +415,7 @@ class CommonTypedDict(TypedDict):
             show_default=True,
         ),
     ]
+    task_label: Annotated[str, click.option("--task-label", help="Task label")]
 
 
 class HNSWBaseTypedDict(TypedDict):
@@ -489,6 +500,7 @@ def run(
             concurrency_search_config=ConcurrencySearchConfig(
                 concurrency_duration=parameters["concurrency_duration"],
                 num_concurrency=[int(s) for s in parameters["num_concurrency"]],
+                concurrency_timeout=parameters["concurrency_timeout"],
             ),
             custom_case=get_custom_case_config(parameters),
         ),
@@ -499,10 +511,11 @@ def run(
             parameters["search_concurrent"],
         ),
     )
+    task_label = parameters["task_label"]
 
     log.info(f"Task:\n{pformat(task)}\n")
     if not parameters["dry_run"]:
-        benchmark_runner.run([task])
+        benchmark_runner.run([task], task_label)
         time.sleep(5)
         if global_result_future:
             wait([global_result_future])

vectordb_bench/cli/vectordbbench.py

@@ -1,6 +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.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
@@ -8,6 +9,7 @@ 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.redis.cli import Redis
 from ..backend.clients.test.cli import Test
 from ..backend.clients.tidb.cli import TiDB
@@ -33,6 +35,8 @@ cli.add_command(MariaDBHNSW)
 cli.add_command(TiDB)
 cli.add_command(Clickhouse)
 cli.add_command(Vespa)
+cli.add_command(LanceDB)
+cli.add_command(QdrantCloud)
 
 
 if __name__ == "__main__":

vectordb_bench/frontend/components/run_test/dbConfigSetting.py

@@ -36,21 +36,27 @@ def dbConfigSettingItem(st, activeDb: DB):
     columns = st.columns(DB_CONFIG_SETTING_COLUMNS)
 
     dbConfigClass = activeDb.config_cls
-    properties = dbConfigClass.schema().get("properties")
+    schema = dbConfigClass.schema()
+    property_items = schema.get("properties").items()
+    required_fields = set(schema.get("required", []))
     dbConfig = {}
     idx = 0
 
     # db config (unique)
-    for key, property in properties.items():
+    for key, property in property_items:
         if key not in dbConfigClass.common_short_configs() and key not in dbConfigClass.common_long_configs():
             column = columns[idx % DB_CONFIG_SETTING_COLUMNS]
             idx += 1
-            dbConfig[key] = column.text_input(
+            input_value = column.text_input(
                 key,
-                key="%s-%s" % (activeDb.name, key),
+                key=f"{activeDb.name}-{key}",
                 value=property.get("default", ""),
                 type="password" if inputIsPassword(key) else "default",
+                placeholder="optional" if key not in required_fields else None,
             )
+            if key in required_fields or input_value:
+                dbConfig[key] = input_value
+
     # db config (common short labels)
     for key in dbConfigClass.common_short_configs():
         column = columns[idx % DB_CONFIG_SETTING_COLUMNS]

vectordb_bench/frontend/config/dbCaseConfigs.py

@@ -1491,6 +1491,127 @@ VespaLoadingConfig = [
 ]
 VespaPerformanceConfig = VespaLoadingConfig
 
+CaseConfigParamInput_IndexType_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.IndexType,
+    inputHelp="AUTOINDEX = IVFPQ with default parameters",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            IndexType.NONE.value,
+            IndexType.AUTOINDEX.value,
+            IndexType.IVFPQ.value,
+            IndexType.HNSW.value,
+        ],
+    },
+)
+
+CaseConfigParamInput_num_partitions_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.num_partitions,
+    displayLabel="Number of Partitions",
+    inputHelp="Number of partitions (clusters) for IVF_PQ. Default (when 0): sqrt(num_rows)",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 10000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_num_sub_vectors_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.num_sub_vectors,
+    displayLabel="Number of Sub-vectors",
+    inputHelp="Number of sub-vectors for PQ. Default (when 0): dim/16 or dim/8",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_num_bits_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.nbits,
+    displayLabel="Number of Bits",
+    inputHelp="Number of bits per sub-vector.",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [4, 8],
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_sample_rate_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.sample_rate,
+    displayLabel="Sample Rate",
+    inputHelp="Sample rate for training. Higher values are more accurate but slower",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 16,
+        "max": 1024,
+        "value": 256,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_max_iterations_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.max_iterations,
+    displayLabel="Max Iterations",
+    inputHelp="Maximum iterations for k-means clustering",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 10,
+        "max": 200,
+        "value": 50,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.IVFPQ.value
+    or config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_m_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.m,
+    displayLabel="m",
+    inputHelp="m parameter in HNSW",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+CaseConfigParamInput_ef_construction_LanceDB = CaseConfigInput(
+    label=CaseConfigParamType.ef_construction,
+    displayLabel="ef_construction",
+    inputHelp="ef_construction parameter in HNSW",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1000,
+        "value": 0,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None) == IndexType.HNSW.value,
+)
+
+LanceDBLoadConfig = [
+    CaseConfigParamInput_IndexType_LanceDB,
+    CaseConfigParamInput_num_partitions_LanceDB,
+    CaseConfigParamInput_num_sub_vectors_LanceDB,
+    CaseConfigParamInput_num_bits_LanceDB,
+    CaseConfigParamInput_sample_rate_LanceDB,
+    CaseConfigParamInput_max_iterations_LanceDB,
+    CaseConfigParamInput_m_LanceDB,
+    CaseConfigParamInput_ef_construction_LanceDB,
+]
+
+LanceDBPerformanceConfig = LanceDBLoadConfig
+
 CASE_CONFIG_MAP = {
     DB.Milvus: {
         CaseLabel.Load: MilvusLoadConfig,
@@ -1551,4 +1672,8 @@ CASE_CONFIG_MAP = {
         CaseLabel.Load: VespaLoadingConfig,
         CaseLabel.Performance: VespaPerformanceConfig,
     },
+    DB.LanceDB: {
+        CaseLabel.Load: LanceDBLoadConfig,
+        CaseLabel.Performance: LanceDBPerformanceConfig,
+    },
 }

vectordb_bench/frontend/config/styles.py

@@ -49,6 +49,7 @@ DB_TO_ICON = {
     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",
+    DB.LanceDB: "https://raw.githubusercontent.com/lancedb/lancedb/main/docs/src/assets/logo.png",
 }
 
 # RedisCloud color: #0D6EFD

vectordb_bench/models.py

@@ -12,6 +12,7 @@ from .backend.clients import (
     DB,
     DBCaseConfig,
     DBConfig,
+    EmptyDBCaseConfig,
 )
 from .base import BaseModel
 from .metric import Metric
@@ -29,6 +30,11 @@ class PerformanceTimeoutError(TimeoutError):
         super().__init__("Performance case optimize timeout")
 
 
+class ConcurrencySlotTimeoutError(TimeoutError):
+    def __init__(self):
+        super().__init__("Timeout while waiting for a concurrency slot to become available")
+
+
 class CaseConfigParamType(Enum):
     """
     Value will be the key of CaseConfig.params and displayed in UI
@@ -96,6 +102,9 @@ class CaseConfigParamType(Enum):
     maxNumPrefetchDatasets = "max_num_prefetch_datasets"
     storage_engine = "storage_engine"
     max_cache_size = "max_cache_size"
+    num_partitions = "num_partitions"
+    num_sub_vectors = "num_sub_vectors"
+    sample_rate = "sample_rate"
 
     # mongodb params
     mongodb_quantization_type = "quantization"
@@ -109,6 +118,7 @@ class CustomizedCase(BaseModel):
 class ConcurrencySearchConfig(BaseModel):
     num_concurrency: list[int] = config.NUM_CONCURRENCY
     concurrency_duration: int = config.CONCURRENCY_DURATION
+    concurrency_timeout: int = config.CONCURRENCY_TIMEOUT
 
 
 class CaseConfig(BaseModel):
@@ -247,13 +257,19 @@ class TestResult(BaseModel):
                 test_result["task_label"] = test_result["run_id"]
 
             for case_result in test_result["results"]:
-                task_config = case_result.get("task_config")
-                db = DB(task_config.get("db"))
+                task_config = case_result["task_config"]
+                db = DB(task_config["db"])
 
                 task_config["db_config"] = db.config_cls(**task_config["db_config"])
-                task_config["db_case_config"] = db.case_config_cls(
-                    index_type=task_config["db_case_config"].get("index", None),
-                )(**task_config["db_case_config"])
+
+                # Safely instantiate DBCaseConfig (fallback to EmptyDBCaseConfig on None)
+                raw_case_cfg = task_config.get("db_case_config") or {}
+                index_value = raw_case_cfg.get("index", None)
+                try:
+                    task_config["db_case_config"] = db.case_config_cls(index_type=index_value)(**raw_case_cfg)
+                except Exception:
+                    log.exception(f"Couldn't get class for index '{index_value}' ({full_path})")
+                    task_config["db_case_config"] = EmptyDBCaseConfig(**raw_case_cfg)
 
                 case_result["task_config"] = task_config
 

{vectordb_bench-0.0.27.dist-info → vectordb_bench-0.0.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectordb-bench
-Version: 0.0.27
+Version: 0.0.29
 Summary: VectorDBBench is not just an offering of benchmark results for mainstream vector databases and cloud services, it's your go-to tool for the ultimate performance and cost-effectiveness comparison. Designed with ease-of-use in mind, VectorDBBench is devised to help users, even non-professionals, reproduce results or test new systems, making the hunt for the optimal choice amongst a plethora of cloud services and open-source vector databases a breeze.
 Author-email: XuanYang-cn <xuan.yang@zilliz.com>
 Project-URL: repository, https://github.com/zilliztech/VectorDBBench
@@ -52,6 +52,7 @@ Requires-Dist: mariadb; extra == "all"
 Requires-Dist: PyMySQL; extra == "all"
 Requires-Dist: clickhouse-connect; extra == "all"
 Requires-Dist: pyvespa; extra == "all"
+Requires-Dist: lancedb; extra == "all"
 Provides-Extra: qdrant
 Requires-Dist: qdrant-client; extra == "qdrant"
 Provides-Extra: pinecone
@@ -87,15 +88,17 @@ Provides-Extra: clickhouse
 Requires-Dist: clickhouse-connect; extra == "clickhouse"
 Provides-Extra: vespa
 Requires-Dist: pyvespa; extra == "vespa"
+Provides-Extra: lancedb
+Requires-Dist: lancedb; extra == "lancedb"
 Dynamic: license-file
 
-# VectorDBBench: A Benchmark Tool for VectorDB
+# VectorDBBench(VDBBench): A Benchmark Tool for VectorDB
 
 [![version](https://img.shields.io/pypi/v/vectordb-bench.svg?color=blue)](https://pypi.org/project/vectordb-bench/)
 [![Downloads](https://pepy.tech/badge/vectordb-bench)](https://pepy.tech/project/vectordb-bench)
 
 ## What is VectorDBBench
-VectorDBBench is not just an offering of benchmark results for mainstream vector databases and cloud services, it's your go-to tool for the ultimate performance and cost-effectiveness comparison. Designed with ease-of-use in mind, VectorDBBench is devised to help users, even non-professionals, reproduce results or test new systems, making the hunt for the optimal choice amongst a plethora of cloud services and open-source vector databases a breeze.
+VectorDBBench(VDBBench) is not just an offering of benchmark results for mainstream vector databases and cloud services, it's your go-to tool for the ultimate performance and cost-effectiveness comparison. Designed with ease-of-use in mind, VectorDBBench is devised to help users, even non-professionals, reproduce results or test new systems, making the hunt for the optimal choice amongst a plethora of cloud services and open-source vector databases a breeze.
 
 Understanding the importance of user experience, we provide an intuitive visual interface. This not only empowers users to initiate benchmarks at ease, but also to view comparative result reports, thereby reproducing benchmark results effortlessly.
 To add more relevance and practicality, we provide cost-effectiveness reports particularly for cloud services. This allows for a more realistic and applicable benchmarking process.
@@ -205,6 +208,10 @@ Options:
   --num-concurrency TEXT          Comma-separated list of concurrency values
                                   to test during concurrent search  [default:
                                   1,10,20]
+  --concurrency-timeout INTEGER   Timeout (in seconds) to wait for a
+                                  concurrency slot before failing. Set to a
+                                  negative value to wait indefinitely.
+                                  [default: 3600]
   --user-name TEXT                Db username  [required]
   --password TEXT                 Db password  [required]
   --host TEXT                     Db host  [required]
@@ -291,7 +298,8 @@ Options:
   # Memory Management
   --cb-threshold TEXT             k-NN Memory circuit breaker threshold
 
-  --help                          Show this message and exit.```
+  --help                          Show this message and exit.
+  ```
 
 #### Using a configuration file.
 
@@ -358,13 +366,13 @@ pip install -e '.[pinecone]'
 ```
 ### Run test server
 ```
-$ python -m vectordb_bench
+python -m vectordb_bench
 ```
 
 OR:
 
 ```shell
-$ init_bench
+init_bench
 ```
 
 OR:
@@ -381,13 +389,13 @@ After reopen the repository in container, run `python -m vectordb_bench` in the
 
 ### Check coding styles
 ```shell
-$ make lint
+make lint
 ```
 
 To fix the coding styles automatically
 
 ```shell
-$ make format
+make format
 ```
 
 ## How does it work?

{vectordb_bench-0.0.27.dist-info → vectordb_bench-0.0.29.dist-info}/RECORD

@@ -1,20 +1,20 @@
-vectordb_bench/__init__.py,sha256=d5psAfISw9F6PFL2xPlSYUKKFDw7ifQm7g3LWC8_yUA,2375
+vectordb_bench/__init__.py,sha256=PBGSIdgzof6UMeWbgjFUjTRgUcbu0Tg5njbGo0oU88g,2420
 vectordb_bench/__main__.py,sha256=cyYbVSU-zA1AgzneGKcRRuzR4ftRDr9sIi9Ei9NZnhI,858
 vectordb_bench/base.py,sha256=AgavIF0P9ku_RmCRk1KKziba-wI4ZpA2aJvjJzNhRSs,129
 vectordb_bench/interface.py,sha256=XaCjTgUeI17uVjsgOauPeVlkvnkuCyQOWyOaWhrgCt8,9811
 vectordb_bench/log_util.py,sha256=wDNaU_JBBOfKi_Z4vq7LDa0kOlLjoNNzDX3VZQn_Dxo,3239
 vectordb_bench/metric.py,sha256=pj-AxQHyIRHTaJY-wTIkTbC6TqEqMzt3kcEmMWEv71w,2063
-vectordb_bench/models.py,sha256=VCnmfvAr7Grtbe6EsixCq9aVdc2F14RBHXO7uJppuB4,11497
+vectordb_bench/models.py,sha256=b-DaUopaf6qwuuEbl9wAHKZjuosmOi6gpebYz6iWvBU,12221
 vectordb_bench/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/backend/assembler.py,sha256=6GInRT7yBgfTaIPmo-XMkYX4pA8PJQmjMQInynwaunE,2047
 vectordb_bench/backend/cases.py,sha256=obDdY6g3p9Z2fog7qDwLLDuRMwo3LGQKMHsP66QZd2M,16296
 vectordb_bench/backend/data_source.py,sha256=bfa_Zg4O9fRP2ENmVZ_2-NISKozoFN-TocyxOlw1JtE,5524
 vectordb_bench/backend/dataset.py,sha256=lH2Q01AEJxA-sYfZHzH2BM019mwuy9mB_i0VLhIgDJ8,9020
 vectordb_bench/backend/result_collector.py,sha256=mpROVdZ-HChKBVyMV5TZ5v7YGRb69bvfT7Gezn5F5sY,819
-vectordb_bench/backend/task_runner.py,sha256=vlaXB0_25-G9w1Lj-F0SrvJzhXT7ceDWGIb2aKRXukU,11488
+vectordb_bench/backend/task_runner.py,sha256=HYZ5B9-qOKAKmrsk-nwVhmXEddf451o4P3xQuSiCTt8,11595
 vectordb_bench/backend/utils.py,sha256=R6THuJdZhiQYSSJTqv0Uegl2B20taV_QjwvFrun2yxE,1949
-vectordb_bench/backend/clients/__init__.py,sha256=M7qjlpe_65OJKttYXItC8szczqzCm_vptM-7XGtL_HA,10128
-vectordb_bench/backend/clients/api.py,sha256=m-vEypHJZrSMr5Di5zs3ImOSzVV2O5imMM3jfUAQmSs,6516
+vectordb_bench/backend/clients/__init__.py,sha256=4P4Y7qOIYBJqJENsfMNzD5L0C651ypcPr05M1-ph0LU,10549
+vectordb_bench/backend/clients/api.py,sha256=3AfO-EPNzosaIBfYX3U9HeOMO7Uw0muOZ0x4cqqSH34,6534
 vectordb_bench/backend/clients/aliyun_elasticsearch/aliyun_elasticsearch.py,sha256=7yPYaWoHeHNxDMtpReGXsdEPFD1e4vQblFor7TmLq5o,770
 vectordb_bench/backend/clients/aliyun_elasticsearch/config.py,sha256=d9RCgfCgauKvy6z9ig_wBormgwiGtkh8POyoHloHnJA,505
 vectordb_bench/backend/clients/aliyun_opensearch/aliyun_opensearch.py,sha256=rwa4rtbbP2Kaczh7Bf0bc_lE_sGG5w9PhtfdFu7rQNs,13237
@@ -28,11 +28,14 @@ vectordb_bench/backend/clients/aws_opensearch/config.py,sha256=9meXQUOVFlk3UOAhv
 vectordb_bench/backend/clients/aws_opensearch/run.py,sha256=Ry5aAlielWjq0hx7LnbdShfOwzZhz3Gq9WYu5U43x9s,5001
 vectordb_bench/backend/clients/chroma/chroma.py,sha256=Aqo6AlSWd0TG0SR4cr9AEoLzXtOJ5VNhbIucHnm8NxY,3619
 vectordb_bench/backend/clients/chroma/config.py,sha256=8nXpPdecQ5HrNqcsQwAVgacSz6uLgI-BI7v4tB8CeDk,347
-vectordb_bench/backend/clients/clickhouse/cli.py,sha256=9tnDE9e1I-Mul40FAzFG8lViYyeXXgjV3dNDpikhEwg,2017
-vectordb_bench/backend/clients/clickhouse/clickhouse.py,sha256=nRTFE5KQn-_juKrtI546rbbqn1INqPNDNKrpeuHpdlI,8904
-vectordb_bench/backend/clients/clickhouse/config.py,sha256=Bd2fqpaJU5YcPKTNOL0mzEFWpaoVyxVt_21-Jb_tHKk,2659
+vectordb_bench/backend/clients/clickhouse/cli.py,sha256=6I0AwUOrqfjQbN_3aSTJHUYE-PAAMAQ4AIZC_8GqoEw,2054
+vectordb_bench/backend/clients/clickhouse/clickhouse.py,sha256=1i-64mzluloJ3fXT7J3_HXzkUtJ4re7HwuRwiqtGOck,8956
+vectordb_bench/backend/clients/clickhouse/config.py,sha256=-waHUHrT9WwuSNjHYE7T5j8s8RTsHNTDFuzmqT4nQWI,2649
 vectordb_bench/backend/clients/elastic_cloud/config.py,sha256=_5Cz3__CbMU7zCizkhK1pGhH3TLJacn8efVueUZ0lnQ,1573
 vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py,sha256=FSslLDH2Yi9ZdUwaCbKC_IXxFbMvW-L1xB3YMU08MVI,5448
+vectordb_bench/backend/clients/lancedb/cli.py,sha256=j5eqb-_CSWF1rdxAj2Byut6albHEj0JF51wCruaJsu8,2688
+vectordb_bench/backend/clients/lancedb/config.py,sha256=Udd39FrYmIa9ZztmfAC0BLj0rBaPv3yd9XaF5VkCziU,2950
+vectordb_bench/backend/clients/lancedb/lancedb.py,sha256=9hFHtj_Ry44nVY1vX9FSnB_WAL6ih86Rx2qFiZgEkX0,3148
 vectordb_bench/backend/clients/mariadb/cli.py,sha256=nqV9V-gOSKGQ1y6VmxOMxGz0a3jz860Va55x7JBcuPk,2727
 vectordb_bench/backend/clients/mariadb/config.py,sha256=DNxo0i1c0wIfii78Luv9GeOFq-74yvkkg3Np9sNUyFI,1870
 vectordb_bench/backend/clients/mariadb/mariadb.py,sha256=O2PY7pP3dYdp-aTOQLDVckdNabCZscw5Xup7Z8LnWIg,7137
@@ -58,7 +61,8 @@ vectordb_bench/backend/clients/pgvectorscale/config.py,sha256=ZMcRQPyCMzMJLXw56z
 vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py,sha256=NONFdcE-b-mt6GsRTru6UbMMu8iqX8PfRF43fY_AODw,10136
 vectordb_bench/backend/clients/pinecone/config.py,sha256=hzPX1lxDpYI9IdpNs7RYB1vAn2uMlCw9NH4FonQEmfQ,294
 vectordb_bench/backend/clients/pinecone/pinecone.py,sha256=SeJ-XnuIZxFDYhgO8FlRNYN65lPXDW2HEQuu5s5Na5Q,3591
-vectordb_bench/backend/clients/qdrant_cloud/config.py,sha256=b6VTClgvF-mvD8TZ9rOHyBZPKz9C0HykvzB_cz-kZqk,1073
+vectordb_bench/backend/clients/qdrant_cloud/cli.py,sha256=QoJ8t76mJmXrj-VJYn6-Atc1EryFhAApvtWUxei0wuo,1095
+vectordb_bench/backend/clients/qdrant_cloud/config.py,sha256=UWFctRQ03suEyASlbSg76dEi0s58tp5ERE-d5A9LuLg,1098
 vectordb_bench/backend/clients/qdrant_cloud/qdrant_cloud.py,sha256=VvE96WlEqbXCytwUGxLGt8AbuRvu1psF1weydb8MW_4,5431
 vectordb_bench/backend/clients/redis/cli.py,sha256=tFLXzNyvh_GYUZihqMvj65C5vBKPVVAYIXtbzGaVCcU,2167
 vectordb_bench/backend/clients/redis/config.py,sha256=xVSVC6xjjAKsiwJuJoLguCGhiiUT9w13Db_Up5ZqljY,1241
@@ -80,14 +84,14 @@ vectordb_bench/backend/clients/zilliz_cloud/cli.py,sha256=3_eD3ZG-FeTw1cenhbBFni
 vectordb_bench/backend/clients/zilliz_cloud/config.py,sha256=-Qb50m-Hcz86OcMURU21n61Rz-RpFqKfUsmjna85OR8,909
 vectordb_bench/backend/clients/zilliz_cloud/zilliz_cloud.py,sha256=B9EUDmK11oQ2GIslVkbRVAitHT-NbRGxQD_Weia-vhY,681
 vectordb_bench/backend/runner/__init__.py,sha256=mF8YnErTa7MVG37zZb0KFXBSrmMw_afttuiqWcwrVls,228
-vectordb_bench/backend/runner/mp_runner.py,sha256=AJHrQmUADDWDQZ0eZ4aaAH9HOQtZHiafXJYGU5PNq3Y,9645
+vectordb_bench/backend/runner/mp_runner.py,sha256=n8IiRs7JUJGQVXwGlVMdvcpotikF9VsjXGFHMMylsS0,10119
 vectordb_bench/backend/runner/rate_runner.py,sha256=2coO7qalEh6ZbVKUkyFvip4JWjs1yJM-iiExSrjEp9c,4306
 vectordb_bench/backend/runner/read_write_runner.py,sha256=CXYBXEEkS1S7-NurdzN5Wh6N0Vx-rprM9Qehk1WKwl8,7822
 vectordb_bench/backend/runner/serial_runner.py,sha256=Y4Y2mSK8nU3hml7gliiF6BXUaW49sD-Ueci0xn62IL0,10290
 vectordb_bench/backend/runner/util.py,sha256=tjTFUxth6hNnVrlU82TqkHhfeZo4ymj7WlyK4zFyPTg,522
 vectordb_bench/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vectordb_bench/cli/cli.py,sha256=cr4BycwIs51YJgNorHplzKP46M474jDTatevPdD-oKE,15434
-vectordb_bench/cli/vectordbbench.py,sha256=pU2sDzsWXRozRBmg3N70x5AnWGHNz7c7wnPu_CV_1Eo,1441
+vectordb_bench/cli/cli.py,sha256=1bZzK7uCwAi9ILtvlZiFAAMwJfwQec1HF3RRSpbqxKY,16000
+vectordb_bench/cli/vectordbbench.py,sha256=EA0x0vKDGIszAKstbnDtJz26U6_Wnl11W07PDukLNzo,1604
 vectordb_bench/config-files/sample_config.yml,sha256=yw9ZgHczNi9PedNuTVxZKiOTI6AVoQS1h8INNgoDjPk,340
 vectordb_bench/custom/custom_case.json,sha256=uKo7NJgXDPPLtf_V6y1uc5w1aIcjLp-GCJEYOCty1As,475
 vectordb_bench/frontend/utils.py,sha256=8eb4I9F0cQdnPQiFX0gMEk1e2fdgultgTKzzY5zS0Q0,489
@@ -109,16 +113,16 @@ vectordb_bench/frontend/components/custom/initStyle.py,sha256=ortsoUNqH-vVq9ECiw
 vectordb_bench/frontend/components/get_results/saveAsImage.py,sha256=POaFiwKoCGqrY-zhanWC7-tubE64bV_JjqI4lgIuMts,1459
 vectordb_bench/frontend/components/run_test/autoRefresh.py,sha256=mjIa43VQQmNjYPkEbOtKNlJ1UfGPcqRKvc2Jh4kx8U0,289
 vectordb_bench/frontend/components/run_test/caseSelector.py,sha256=ea3u-NDtCX32Au9YkfqGA8mhF6K_Av9HZvp0Mem3C0o,5328
-vectordb_bench/frontend/components/run_test/dbConfigSetting.py,sha256=C3icY6THcWjl7SgdrKa-Gz-LU4I_YEf-1kAeVMkqu3s,2642
+vectordb_bench/frontend/components/run_test/dbConfigSetting.py,sha256=k0tGoJokTVvI3zofArNxH9NYUu9Hzo1uyobbZ_h9HfM,2895
 vectordb_bench/frontend/components/run_test/dbSelector.py,sha256=hzMEIL1DzvpP8xkL6JhELTdcml0ysC70Gw-WLr8vW9A,1123
 vectordb_bench/frontend/components/run_test/generateTasks.py,sha256=3y8NHtWJMNqoP2SvoWuR7kj84g0OEg68IULebimzz7E,741
 vectordb_bench/frontend/components/run_test/hideSidebar.py,sha256=vb5kzIMmbMqWX67qFEHek21X4sGO_tPyn_uPqUEtp3Q,234
 vectordb_bench/frontend/components/run_test/initStyle.py,sha256=osPUgfFfH7rRlVNHSMumvmZxvKWlLxmZiNqgnMiUJEU,723
 vectordb_bench/frontend/components/run_test/submitTask.py,sha256=VZjkopkCBNhqLwGqsoM0hbPEeF6Q5UOQcdFUaegerxc,4094
 vectordb_bench/frontend/components/tables/data.py,sha256=5DdnC64BB7Aj2z9acht2atsPB4NabzQCZKALfIUnqtQ,1233
-vectordb_bench/frontend/config/dbCaseConfigs.py,sha256=1HjKl9s-ilJgPedaJEK8-hu3bCgOGZa7_53EuvfHHhQ,46715
+vectordb_bench/frontend/config/dbCaseConfigs.py,sha256=DQrSuBVuTCjwS_I1hVNTnYygDu6Zkka7PLfLi7TNN3E,51023
 vectordb_bench/frontend/config/dbPrices.py,sha256=10aBKjVcEg8y7TPSda28opmBM1KmXNrvbU9WM_BsZcE,176
-vectordb_bench/frontend/config/styles.py,sha256=Iic14kvGrm0oW-uXNZegceLvEJErWuYpG7WZF_G1zvE,2544
+vectordb_bench/frontend/config/styles.py,sha256=y-vYXCF4_o0-88BNzbKNKvfhvVxmz8BSr4v_E_Qv37E,2643
 vectordb_bench/frontend/pages/concurrent.py,sha256=bvoSafRSIsRzBQkI3uBwwrdg8jnhRUQG-epZbrJhGiE,2082
 vectordb_bench/frontend/pages/custom.py,sha256=j7oJ2FHBv5O50D7YbzXTLRuIDgwkGt0iEd0FRHHkYLw,2436
 vectordb_bench/frontend/pages/quries_per_dollar.py,sha256=BDukiFwxyqQK_btCSsRR5D_a17PMu0yI8Muw3eRLz6Y,2461
@@ -142,9 +146,9 @@ vectordb_bench/results/WeaviateCloud/result_20230808_standard_weaviatecloud.json
 vectordb_bench/results/ZillizCloud/result_20230727_standard_zillizcloud.json,sha256=-Mdm4By65XDRCrmVOCF8yQXjcZtH4Xo4shcjoDoBUKU,18293
 vectordb_bench/results/ZillizCloud/result_20230808_standard_zillizcloud.json,sha256=77XlHT5zM_K7mG5HfDQKwXZnSCuR37VUbt6-P3J_amI,15737
 vectordb_bench/results/ZillizCloud/result_20240105_standard_202401_zillizcloud.json,sha256=TualfJ0664Hs-vdIW68bdkqAEYyzotXmu2P0yIN-GHk,42526
-vectordb_bench-0.0.27.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
-vectordb_bench-0.0.27.dist-info/METADATA,sha256=UC8hc6cQKAYshgbSFEBzDPODzeltBiimXbVkrakDLDQ,38061
-vectordb_bench-0.0.27.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
-vectordb_bench-0.0.27.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
-vectordb_bench-0.0.27.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
-vectordb_bench-0.0.27.dist-info/RECORD,,
+vectordb_bench-0.0.29.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-0.0.29.dist-info/METADATA,sha256=8ekrKUsItuE-dEvCBGOk1ktXNF19qSw8Qat9FRGG-o8,38448
+vectordb_bench-0.0.29.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+vectordb_bench-0.0.29.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
+vectordb_bench-0.0.29.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-0.0.29.dist-info/RECORD,,

{vectordb_bench-0.0.27.dist-info → vectordb_bench-0.0.29.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.0.1)
+Generator: setuptools (80.7.1)
 Root-Is-Purelib: true
 Tag: py3-none-any