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

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/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,91 @@
+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).where(f"id >= {filters['id']}", prefilter=True).limit(k).to_list()
+        else:
+            results = self.table.search(query).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/cli/cli.py

@@ -405,6 +405,7 @@ class CommonTypedDict(TypedDict):
             show_default=True,
         ),
     ]
+    task_label: Annotated[str, click.option("--task-label", help="Task label")]
 
 
 class HNSWBaseTypedDict(TypedDict):
@@ -499,10 +500,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
@@ -33,6 +34,7 @@ cli.add_command(MariaDBHNSW)
 cli.add_command(TiDB)
 cli.add_command(Clickhouse)
 cli.add_command(Vespa)
+cli.add_command(LanceDB)
 
 
 if __name__ == "__main__":

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
@@ -96,6 +97,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"
@@ -247,13 +251,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.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectordb-bench
-Version: 0.0.27
+Version: 0.0.28
 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,6 +88,8 @@ 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
@@ -358,13 +361,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 +384,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.28.dist-info}/RECORD

@@ -4,7 +4,7 @@ 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=aQPO6sLFtNL0CU0JySZqrZIQ5SdckCj5SOI7EfyaLNM,11995
 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
@@ -13,8 +13,8 @@ vectordb_bench/backend/dataset.py,sha256=lH2Q01AEJxA-sYfZHzH2BM019mwuy9mB_i0VLhI
 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/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
@@ -33,6 +33,9 @@ vectordb_bench/backend/clients/clickhouse/clickhouse.py,sha256=nRTFE5KQn-_juKrtI
 vectordb_bench/backend/clients/clickhouse/config.py,sha256=Bd2fqpaJU5YcPKTNOL0mzEFWpaoVyxVt_21-Jb_tHKk,2659
 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=nylYVn7I2kLmKZACQoPf9CvGU-3g9vFNOkiLXZMBdjg,3018
 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
@@ -86,8 +89,8 @@ vectordb_bench/backend/runner/read_write_runner.py,sha256=CXYBXEEkS1S7-NurdzN5Wh
 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=Ik6n-4cIq_huHLucP6ug48Lc2uHlzaRmWQrsD9CRbPE,15568
+vectordb_bench/cli/vectordbbench.py,sha256=5Ic2cVxn4aKx53N0pN7W9eguaJlC05jHd_SVRndfzHI,1516
 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
@@ -116,9 +119,9 @@ vectordb_bench/frontend/components/run_test/hideSidebar.py,sha256=vb5kzIMmbMqWX6
 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 +145,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.28.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-0.0.28.dist-info/METADATA,sha256=wz_jhR3BceHrcdbARNJeXnWXN8YNevrINi5GsZ2G_f8,38159
+vectordb_bench-0.0.28.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+vectordb_bench-0.0.28.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
+vectordb_bench-0.0.28.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-0.0.28.dist-info/RECORD,,

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

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