vectordb-bench 1.0.7__py3-none-any.whl → 1.0.9__py3-none-any.whl

vectordb_bench/backend/clients/hologres/config.py

@@ -104,8 +104,6 @@ class HologresIndexConfig(BaseModel, DBCaseConfig):
             self.base_quantization_type = "fp32"
 
         return {
-            "min_flush_proxima_row_count": self.min_flush_proxima_row_count,
-            "min_compaction_proxima_row_count": self.min_compaction_proxima_row_count,
             "max_total_size_to_merge_mb": self.max_total_size_to_merge_mb,
             "build_thread_count": self.build_thread_count,
             "base_quantization_type": self.base_quantization_type,
@@ -113,6 +111,7 @@ class HologresIndexConfig(BaseModel, DBCaseConfig):
             "ef_construction": self.ef_construction,
             "precise_quantization_type": self.precise_quantization_type,
             "use_reorder": self.use_reorder,
+            "precise_io_type": "reader_io",
         }
 
     def searcher_params(self) -> dict:

vectordb_bench/backend/clients/hologres/hologres.py

@@ -128,6 +128,18 @@ class Hologres(VectorDB):
         )
         self.conn.commit()
 
+        try:
+            log.info(f"{self.name} client purge table recycle bin: {self.table_name}")
+            self.cursor.execute(
+                sql.SQL("purge TABLE {table_name};").format(
+                    table_name=sql.Identifier(self.table_name),
+                ),
+            )
+        except Exception as e:
+            log.info(f"{self.name} client purge table {self.table_name} recycle bin failed, error: {e}, ignore.")
+        finally:
+            self.conn.commit()
+
         try:
             log.info(f"{self.name} client drop table group : {self._tg_name}")
             self.cursor.execute(sql.SQL(f"CALL HG_DROP_TABLE_GROUP('{self._tg_name}');"))
@@ -136,6 +148,14 @@ class Hologres(VectorDB):
         finally:
             self.conn.commit()
 
+        try:
+            log.info(f"{self.name} client free cache")
+            self.cursor.execute("select hg_admin_command('freecache');")
+        except Exception as e:
+            log.info(f"{self.name} client free cache failed, error: {e}, ignore.")
+        finally:
+            self.conn.commit()
+
     def optimize(self, data_size: int | None = None):
         if self.case_config.create_index_after_load:
             self._create_index()

vectordb_bench/backend/clients/milvus/config.py

@@ -320,7 +320,6 @@ class GPUIVFFlatConfig(MilvusIndexConfig, DBCaseConfig):
 
 class GPUBruteForceConfig(MilvusIndexConfig, DBCaseConfig):
     limit: int = 10  # Default top-k for search
-    metric_type: str  # Metric type (e.g., 'L2', 'IP', etc.)
     index: IndexType = IndexType.GPU_BRUTE_FORCE  # Index type set to GPU_BRUTE_FORCE
 
     def index_param(self) -> dict:

vectordb_bench/backend/clients/pgvector/config.py

@@ -21,21 +21,25 @@ class PgVectorConfigDict(TypedDict):
 
 
 class PgVectorConfig(DBConfig):
-    user_name: SecretStr = SecretStr("postgres")
+    user_name: SecretStr = "postgres"
     password: SecretStr
     host: str = "localhost"
     port: int = 5432
-    db_name: str
+    db_name: str = "vectordb"
+    table_name: str = "vdbbench_table_test"
 
     def to_dict(self) -> PgVectorConfigDict:
-        user_str = self.user_name.get_secret_value()
+        user_str = self.user_name.get_secret_value() if isinstance(self.user_name, SecretStr) else self.user_name
         pwd_str = self.password.get_secret_value()
         return {
-            "host": self.host,
-            "port": self.port,
-            "dbname": self.db_name,
-            "user": user_str,
-            "password": pwd_str,
+            "connect_config": {
+                "host": self.host,
+                "port": self.port,
+                "dbname": self.db_name,
+                "user": user_str,
+                "password": pwd_str,
+            },
+            "table_name": self.table_name,
         }
 
 
@@ -59,6 +63,10 @@ class PgVectorIndexConfig(BaseModel, DBCaseConfig):
     metric_type: MetricType | None = None
     create_index_before_load: bool = False
     create_index_after_load: bool = True
+    # Scan more of the index to get enough results for filter-cases.
+    # Options: "strict_order" (order by distance), "relaxed_order" (slightly out of order but better recall)
+    # See: https://github.com/pgvector/pgvector?tab=readme-ov-file#iterative-index-scans
+    iterative_scan: str = "relaxed_order"
 
     def parse_metric(self) -> str:
         d = {
@@ -205,7 +213,7 @@ class PgVectorIVFFlatConfig(PgVectorIndexConfig):
         }
 
     def session_param(self) -> PgVectorSessionCommands:
-        session_parameters = {"ivfflat.probes": self.probes}
+        session_parameters = {"ivfflat.probes": self.probes, "ivfflat.iterative_scan": self.iterative_scan}
         return {"session_options": self._optionally_build_set_options(session_parameters)}
 
 
@@ -255,7 +263,7 @@ class PgVectorHNSWConfig(PgVectorIndexConfig):
         }
 
     def session_param(self) -> PgVectorSessionCommands:
-        session_parameters = {"hnsw.ef_search": self.ef_search}
+        session_parameters = {"hnsw.ef_search": self.ef_search, "hnsw.iterative_scan": self.iterative_scan}
         return {"session_options": self._optionally_build_set_options(session_parameters)}
 
 

vectordb_bench/backend/clients/pgvector/pgvector.py

@@ -10,6 +10,8 @@ import psycopg
 from pgvector.psycopg import register_vector
 from psycopg import Connection, Cursor, sql
 
+from vectordb_bench.backend.filter import Filter, FilterOp
+
 from ..api import VectorDB
 from .config import PgVectorConfigDict, PgVectorIndexConfig
 
@@ -19,39 +21,46 @@ log = logging.getLogger(__name__)
 class PgVector(VectorDB):
     """Use psycopg instructions"""
 
+    supported_filter_types: list[FilterOp] = [
+        FilterOp.NonFilter,
+        FilterOp.NumGE,
+        FilterOp.StrEqual,
+    ]
+
     conn: psycopg.Connection[Any] | None = None
     cursor: psycopg.Cursor[Any] | None = None
 
-    _filtered_search: sql.Composed
-    _unfiltered_search: sql.Composed
+    _search: sql.Composed
 
     def __init__(
         self,
         dim: int,
         db_config: PgVectorConfigDict,
         db_case_config: PgVectorIndexConfig,
-        collection_name: str = "pg_vector_collection",
         drop_old: bool = False,
+        with_scalar_labels: bool = False,
         **kwargs,
     ):
         self.name = "PgVector"
-        self.db_config = db_config
         self.case_config = db_case_config
-        self.table_name = collection_name
+        self.table_name = db_config["table_name"]
+        self.connect_config = db_config["connect_config"]
         self.dim = dim
+        self.with_scalar_labels = with_scalar_labels
 
         self._index_name = "pgvector_index"
         self._primary_field = "id"
         self._vector_field = "embedding"
+        self._scalar_label_field = "label"
 
         # construct basic units
-        self.conn, self.cursor = self._create_connection(**self.db_config)
+        self.conn, self.cursor = self._create_connection(**self.connect_config)
 
         # create vector extension
         self.cursor.execute("CREATE EXTENSION IF NOT EXISTS vector")
         self.conn.commit()
 
-        log.info(f"{self.name} config values: {self.db_config}\n{self.case_config}")
+        log.info(f"{self.name} config values: {self.connect_config}\n{self.case_config}")
         if not any(
             (
                 self.case_config.create_index_before_load,
@@ -60,7 +69,7 @@ class PgVector(VectorDB):
         ):
             msg = (
                 f"{self.name} config must create an index using create_index_before_load or create_index_after_load"
-                f"{self.name} config values: {self.db_config}\n{self.case_config}"
+                f"{self.name} config values: {self.connect_config}\n{self.case_config}"
             )
             log.error(msg)
             raise RuntimeError(msg)
@@ -89,13 +98,13 @@ class PgVector(VectorDB):
 
         return conn, cursor
 
-    def _generate_search_query(self, filtered: bool = False) -> sql.Composed:
+    def _generate_search_query(self) -> sql.Composed:
         index_param = self.case_config.index_param()
         reranking = self.case_config.search_param()["reranking"]
         column_name = (
-            sql.SQL("binary_quantize({0})").format(sql.Identifier("embedding"))
+            sql.SQL("binary_quantize({0})").format(sql.Identifier(self._vector_field))
             if index_param["quantization_type"] == "bit" and index_param["table_quantization_type"] != "bit"
-            else sql.SQL("embedding")
+            else sql.SQL(self._vector_field)
         )
         search_vector = (
             sql.SQL("binary_quantize({0})").format(sql.Placeholder())
@@ -114,12 +123,14 @@ class PgVector(VectorDB):
                             """
                             SELECT i.id
                             FROM (
-                                SELECT id, embedding {reranking_metric_fun_op} %s::{table_quantization_type} AS distance
+                                SELECT {primary_field}, {vector_field} {reranking_metric_fun_op} %s::{table_quantization_type} AS distance
                                 FROM public.{table_name} {where_clause}
                                 ORDER BY {column_name}::{quantization_type}({dim})
-                            """,
+                            """,  # noqa: E501
                         ).format(
                             table_name=sql.Identifier(self.table_name),
+                            primary_field=sql.Identifier(self._primary_field),
+                            vector_field=sql.Identifier(self._vector_field),
                             column_name=column_name,
                             reranking_metric_fun_op=sql.SQL(
                                 self.case_config.search_param()["reranking_metric_fun_op"],
@@ -128,7 +139,7 @@ class PgVector(VectorDB):
                             table_quantization_type=sql.SQL(index_param["table_quantization_type"]),
                             quantization_type=sql.SQL(index_param["quantization_type"]),
                             dim=sql.Literal(self.dim),
-                            where_clause=sql.SQL("WHERE id >= %s") if filtered else sql.SQL(""),
+                            where_clause=sql.SQL(self.where_clause),
                         ),
                         sql.SQL(self.case_config.search_param()["metric_fun_op"]),
                         sql.SQL(
@@ -154,15 +165,16 @@ class PgVector(VectorDB):
                     [
                         sql.SQL(
                             """
-                            SELECT id FROM public.{table_name}
+                            SELECT {primary_field} FROM public.{table_name}
                             {where_clause} ORDER BY {column_name}::{quantization_type}({dim})
                             """,
                         ).format(
                             table_name=sql.Identifier(self.table_name),
+                            primary_field=sql.Identifier(self._primary_field),
                             column_name=column_name,
                             quantization_type=sql.SQL(index_param["quantization_type"]),
                             dim=sql.Literal(self.dim),
-                            where_clause=sql.SQL("WHERE id >= %s") if filtered else sql.SQL(""),
+                            where_clause=sql.SQL(self.where_clause),
                         ),
                         sql.SQL(self.case_config.search_param()["metric_fun_op"]),
                         sql.SQL(" {search_vector}::{quantization_type}({dim}) LIMIT %s::int").format(
@@ -176,10 +188,12 @@ class PgVector(VectorDB):
             search_query = sql.Composed(
                 [
                     sql.SQL(
-                        "SELECT id FROM public.{table_name} {where_clause} ORDER BY embedding ",
+                        "SELECT {primary_field} FROM public.{table_name} {where_clause} ORDER BY {vector_field}",
                     ).format(
                         table_name=sql.Identifier(self.table_name),
-                        where_clause=sql.SQL("WHERE id >= %s") if filtered else sql.SQL(""),
+                        primary_field=sql.Identifier(self._primary_field),
+                        vector_field=sql.Identifier(self._vector_field),
+                        where_clause=sql.SQL(self.where_clause),
                     ),
                     sql.SQL(self.case_config.search_param()["metric_fun_op"]),
                     sql.SQL(" {search_vector}::{quantization_type}({dim}) LIMIT %s::int").format(
@@ -201,7 +215,7 @@ class PgVector(VectorDB):
             >>>     self.search_embedding()
         """
 
-        self.conn, self.cursor = self._create_connection(**self.db_config)
+        self.conn, self.cursor = self._create_connection(**self.connect_config)
 
         # index configuration may have commands defined that we should set during each client session
         session_options: Sequence[dict[str, Any]] = self.case_config.session_param()["session_options"]
@@ -216,9 +230,6 @@ class PgVector(VectorDB):
                 self.cursor.execute(command)
             self.conn.commit()
 
-        self._filtered_search = self._generate_search_query(filtered=True)
-        self._unfiltered_search = self._generate_search_query()
-
         try:
             yield
         finally:
@@ -274,7 +285,7 @@ class PgVector(VectorDB):
             )
             self.cursor.execute(
                 sql.SQL("ALTER USER {} SET maintenance_work_mem TO {};").format(
-                    sql.Identifier(self.db_config["user"]),
+                    sql.Identifier(self.connect_config["user"]),
                     index_param["maintenance_work_mem"],
                 ),
             )
@@ -288,7 +299,7 @@ class PgVector(VectorDB):
             )
             self.cursor.execute(
                 sql.SQL("ALTER USER {} SET max_parallel_maintenance_workers TO '{}';").format(
-                    sql.Identifier(self.db_config["user"]),
+                    sql.Identifier(self.connect_config["user"]),
                     index_param["max_parallel_workers"],
                 ),
             )
@@ -299,7 +310,7 @@ class PgVector(VectorDB):
             )
             self.cursor.execute(
                 sql.SQL("ALTER USER {} SET max_parallel_workers TO '{}';").format(
-                    sql.Identifier(self.db_config["user"]),
+                    sql.Identifier(self.connect_config["user"]),
                     index_param["max_parallel_workers"],
                 ),
             )
@@ -382,18 +393,36 @@ class PgVector(VectorDB):
             log.info(f"{self.name} client create table : {self.table_name}")
 
             # create table
-            self.cursor.execute(
-                sql.SQL(
-                    """
-                    CREATE TABLE IF NOT EXISTS public.{table_name}
-                    (id BIGINT PRIMARY KEY, embedding {table_quantization_type}({dim}));
-                    """
-                ).format(
-                    table_name=sql.Identifier(self.table_name),
-                    table_quantization_type=sql.SQL(index_param["table_quantization_type"]),
-                    dim=dim,
+            if self.with_scalar_labels:
+                self.cursor.execute(
+                    sql.SQL(
+                        """
+                        CREATE TABLE IF NOT EXISTS public.{table_name}
+                        ({primary_field} BIGINT PRIMARY KEY, embedding {table_quantization_type}({dim}), {label_field} VARCHAR(64));
+                        """,  # noqa: E501
+                    ).format(
+                        table_name=sql.Identifier(self.table_name),
+                        table_quantization_type=sql.SQL(index_param["table_quantization_type"]),
+                        dim=dim,
+                        primary_field=sql.Identifier(self._primary_field),
+                        label_field=sql.Identifier(self._scalar_label_field),
+                    )
                 )
-            )
+            else:
+                self.cursor.execute(
+                    sql.SQL(
+                        """
+                        CREATE TABLE IF NOT EXISTS public.{table_name}
+                        ({primary_field} BIGINT PRIMARY KEY, embedding {table_quantization_type}({dim}));
+                        """
+                    ).format(
+                        table_name=sql.Identifier(self.table_name),
+                        table_quantization_type=sql.SQL(index_param["table_quantization_type"]),
+                        dim=dim,
+                        primary_field=sql.Identifier(self._primary_field),
+                    )
+                )
+
             self.cursor.execute(
                 sql.SQL(
                     "ALTER TABLE public.{table_name} ALTER COLUMN embedding SET STORAGE PLAIN;",
@@ -404,14 +433,17 @@ class PgVector(VectorDB):
             log.warning(f"Failed to create pgvector table: {self.table_name} error: {e}")
             raise e from None
 
-    def insert_embeddings(
+    def insert_embeddings(  # noqa: PLR0912
         self,
         embeddings: list[list[float]],
         metadata: list[int],
+        labels_data: list[str] | None = None,
         **kwargs: Any,
     ) -> tuple[int, Exception | None]:
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
+        if self.with_scalar_labels:
+            assert labels_data is not None, "labels_data should be provided if with_scalar_labels is set to True"
 
         index_param = self.case_config.index_param()
 
@@ -433,7 +465,10 @@ class PgVector(VectorDB):
                                 embeddings_bit += "1"
                             else:
                                 embeddings_bit += "0"
-                        copy.write_row((str(row), embeddings_bit))
+                        if self.with_scalar_labels:
+                            copy.write_row((str(row), embeddings_bit, labels_data[i]))
+                        else:
+                            copy.write_row((str(row), embeddings_bit))
             else:
                 with self.cursor.copy(
                     sql.SQL("COPY public.{table_name} FROM STDIN (FORMAT BINARY)").format(
@@ -441,29 +476,47 @@ class PgVector(VectorDB):
                     )
                 ) as copy:
                     if index_param["table_quantization_type"] == "halfvec":
-                        copy.set_types(["bigint", "halfvec"])
                         for i, row in enumerate(metadata_arr):
-                            copy.write_row((row, np.float16(embeddings_arr[i])))
+                            if self.with_scalar_labels:
+                                copy.set_types(["bigint", "halfvec", "varchar"])
+                                copy.write_row((row, np.float16(embeddings_arr[i]), labels_data[i]))
+                            else:
+                                copy.set_types(["bigint", "halfvec"])
+                                copy.write_row((row, np.float16(embeddings_arr[i])))
                     else:
-                        copy.set_types(["bigint", "vector"])
                         for i, row in enumerate(metadata_arr):
-                            copy.write_row((row, embeddings_arr[i]))
+                            if self.with_scalar_labels:
+                                copy.set_types(["bigint", "vector", "varchar"])
+                                copy.write_row((row, embeddings_arr[i], labels_data[i]))
+                            else:
+                                copy.set_types(["bigint", "vector"])
+                                copy.write_row((row, embeddings_arr[i]))
             self.conn.commit()
 
-            if kwargs.get("last_batch"):
-                self._post_insert()
-
             return len(metadata), None
         except Exception as e:
             log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
+    def prepare_filter(self, filters: Filter):
+        if filters.type == FilterOp.NonFilter:
+            self.where_clause = ""
+        elif filters.type == FilterOp.NumGE:
+            self.where_clause = f"WHERE {self._primary_field} >= {filters.int_value}"
+        elif filters.type == FilterOp.StrEqual:
+            self.where_clause = f"WHERE {self._scalar_label_field} = '{filters.label_value}'"
+        else:
+            msg = f"Not support Filter for PgVector - {filters}"
+            raise ValueError(msg)
+
+        self._search = self._generate_search_query()
+
     def search_embedding(
         self,
         query: list[float],
         k: int = 100,
-        filters: dict | None = None,
         timeout: int | None = None,
+        **kwargs: Any,
     ) -> list[int]:
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
@@ -471,36 +524,10 @@ class PgVector(VectorDB):
         index_param = self.case_config.index_param()
         search_param = self.case_config.search_param()
         q = np.asarray(query)
-        if filters:
-            gt = filters.get("id")
-            if index_param["quantization_type"] == "bit" and search_param["reranking"]:
-                result = self.cursor.execute(
-                    self._filtered_search,
-                    (q, gt, q, k),
-                    prepare=True,
-                    binary=True,
-                )
-            else:
-                result = self.cursor.execute(
-                    self._filtered_search,
-                    (gt, q, k),
-                    prepare=True,
-                    binary=True,
-                )
-
-        elif index_param["quantization_type"] == "bit" and search_param["reranking"]:
-            result = self.cursor.execute(
-                self._unfiltered_search,
-                (q, q, k),
-                prepare=True,
-                binary=True,
-            )
-        else:
-            result = self.cursor.execute(
-                self._unfiltered_search,
-                (q, k),
-                prepare=True,
-                binary=True,
-            )
-
+        result = self.cursor.execute(
+            self._search,
+            (q, q, k) if index_param["quantization_type"] == "bit" and search_param["reranking"] else (q, k),
+            prepare=True,
+            binary=True,
+        )
         return [int(i[0]) for i in result.fetchall()]

vectordb_bench/backend/runner/serial_runner.py

@@ -205,7 +205,7 @@ class SerialInsertRunner:
             raise LoadTimeoutError(self.timeout)
 
     def run(self) -> int:
-        count, dur = self._insert_all_batches()
+        count, _ = self._insert_all_batches()
         return count
 
 

vectordb_bench/cli/cli.py

@@ -183,6 +183,11 @@ def get_custom_case_config(parameters: dict) -> dict:
                 "with_gt": parameters["custom_dataset_with_gt"],
             },
         }
+    elif parameters["case_type"] == "NewIntFilterPerformanceCase":
+        custom_case_config = {
+            "dataset_with_size_type": parameters["dataset_with_size_type"],
+            "filter_rate": parameters["filter_rate"],
+        }
     return custom_case_config
 
 
@@ -416,6 +421,26 @@ class CommonTypedDict(TypedDict):
         ),
     ]
     task_label: Annotated[str, click.option("--task-label", help="Task label")]
+    dataset_with_size_type: Annotated[
+        str,
+        click.option(
+            "--dataset-with-size-type",
+            help="Dataset with size type for NewIntFilterPerformanceCase, you can use Medium Cohere (768dim, 1M)|"
+            "Large Cohere (768dim, 10M)|Medium Bioasq (1024dim, 1M)|Large Bioasq (1024dim, 10M)|"
+            "Large OpenAI (1536dim, 5M)|Medium OpenAI (1536dim, 500K)",
+            default="Medium Cohere (768dim, 1M)",
+            show_default=True,
+        ),
+    ]
+    filter_rate: Annotated[
+        float,
+        click.option(
+            "--filter-rate",
+            help="Filter rate for NewIntFilterPerformanceCase",
+            default=0.01,
+            show_default=True,
+        ),
+    ]
 
 
 class HNSWBaseTypedDict(TypedDict):

vectordb_bench/interface.py

@@ -279,7 +279,7 @@ class BenchMarkRunner:
                 p.send_signal(sig)
             except psutil.NoSuchProcess:
                 pass
-        gone, alive = psutil.wait_procs(children, timeout=timeout, callback=on_terminate)
+        _, alive = psutil.wait_procs(children, timeout=timeout, callback=on_terminate)
 
         for p in alive:
             log.warning(f"force killing child process: {p}")

vectordb_bench/models.py

@@ -127,6 +127,7 @@ class CaseConfigParamType(Enum):
     use_routing = "use_routing"
 
     dataset_with_size_type = "dataset_with_size_type"
+    filter_rate = "filter_rate"
     insert_rate = "insert_rate"
     search_stages = "search_stages"
     concurrencies = "concurrencies"

{vectordb_bench-1.0.7.dist-info → vectordb_bench-1.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectordb-bench
-Version: 1.0.7
+Version: 1.0.9
 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
@@ -375,12 +375,18 @@ Options:
 
 ### Run Hologres from command line
 
+It is recommended to use the following code for installation.
+```shell
+pip install vectordb-bench[hologres] "psycopg[binary]" pgvector
+```
+
 Execute tests for the index types: HGraph.
 
 ```shell
-vectordbbench hologreshgraph --host xxx --port xxx --user ACCESS_ID --password ACCESS_KEY --database test \
---m 64 --ef-construction 400 --case-type Performance768D1M \
---index-type HGraph --ef-search 51 --k 10
+NUM_PER_BATCH=10000 vectordbbench hologreshgraph --host Hologres_Endpoint --port 80 \
+--user ACCESS_ID --password ACCESS_KEY --database DATABASE_NAME \
+--m 64 --ef-construction 400 --case-type Performance768D10M \
+--index-type HGraph --ef-search 400 --k 10 --num-concurrency 1,60,70,75,80,90,95,100,110,120
 ```
 
 To list the options for Hologres, execute `vectordbbench hologreshgraph --help`, The following are some Hologres-specific command-line options.

{vectordb_bench-1.0.7.dist-info → vectordb_bench-1.0.9.dist-info}/RECORD

@@ -1,10 +1,10 @@
 vectordb_bench/__init__.py,sha256=JkFWNtQCp6wKVFtBvf5oMwMTli6erkpzcbcYbnYPML4,2581
 vectordb_bench/__main__.py,sha256=2zZQJ9tg7gVCWWq9HaoJ8_hTR-3AXZgFHfJK4l88DFA,853
 vectordb_bench/base.py,sha256=AgavIF0P9ku_RmCRk1KKziba-wI4ZpA2aJvjJzNhRSs,129
-vectordb_bench/interface.py,sha256=SQBJl_VTglok5TV7MaKBu-v4D07_NSvaRiYqY8AY02w,10186
+vectordb_bench/interface.py,sha256=DSSyEu4GWubCZcf6rO7ybqorutAT8zVhGidIBEvZMIA,10183
 vectordb_bench/log_util.py,sha256=wDNaU_JBBOfKi_Z4vq7LDa0kOlLjoNNzDX3VZQn_Dxo,3239
 vectordb_bench/metric.py,sha256=c73EOPHGXwTInl85MNLPJb9oWrFRYAtp-e5qfFoxw34,3020
-vectordb_bench/models.py,sha256=ZlrV0FtRaOS0W6xYdG0tKHtNvazepHDte4GkVqpee-I,15166
+vectordb_bench/models.py,sha256=aEZsn_Hs8oL04g7rzZcZ7NRu-HpXOr6qtOyEc_XM3ro,15198
 vectordb_bench/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/backend/assembler.py,sha256=MdAOXVhCrRGT76Q21xBusCmDc4mXS7yMrhSYAlKPQVA,2785
 vectordb_bench/backend/cases.py,sha256=cU5mX7f5iar_dSUJGk9-rfwtaMq1vX4JMsEkAFLLup8,25181
@@ -35,8 +35,8 @@ vectordb_bench/backend/clients/clickhouse/config.py,sha256=-waHUHrT9WwuSNjHYE7T5
 vectordb_bench/backend/clients/elastic_cloud/config.py,sha256=Xq1zcWamswuFkrcjmIKCkSADlmk01MVsCfWFK4cWh1E,2466
 vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py,sha256=ZdQaR3rbfiGk_ul93H31kvITtcXAuzU6jX5kQ5s8fSg,8888
 vectordb_bench/backend/clients/hologres/cli.py,sha256=uR6e5qDLbrJEIQFlyVpvF3-Sz5qN2RSbTg0T6DeEovs,1803
-vectordb_bench/backend/clients/hologres/config.py,sha256=Qw9ut4mePZZ1AAuIaYHofTl5pEYoe1l4OLjL0qMhK9c,4142
-vectordb_bench/backend/clients/hologres/hologres.py,sha256=kxQxVgmqLqUsaCO1Lll45hpv98K6ue3ZQG72SayUtFg,13299
+vectordb_bench/backend/clients/hologres/config.py,sha256=3UwVB-AOzEOtuIsvG7pDZ8DVPH0GHGluGjC_brUvLpo,4022
+vectordb_bench/backend/clients/hologres/hologres.py,sha256=nnGIXeWUCsMYgYnHE3SpMxGjNPpNLrdhw_BBE1opLno,14088
 vectordb_bench/backend/clients/lancedb/cli.py,sha256=BxTkyNtOPXEogSoqBKrK9m_RF_WTXDvHg8HBFLNa1uw,4429
 vectordb_bench/backend/clients/lancedb/config.py,sha256=NshH3VrJjy78aYBI-di33x4ko5xkTr16mkZ1liNu550,3233
 vectordb_bench/backend/clients/lancedb/lancedb.py,sha256=k71_6cv9TjucW6_W7so5XmVKgg3oYwdmwMu_ZS6Wosc,4127
@@ -47,7 +47,7 @@ vectordb_bench/backend/clients/memorydb/cli.py,sha256=mUpBN0VoE6M55AAEwyd20uEtPk
 vectordb_bench/backend/clients/memorydb/config.py,sha256=D2Q-HkDwnmz98ek1e_iNu4o9CIRB14pOQWSZgRvd6oY,1500
 vectordb_bench/backend/clients/memorydb/memorydb.py,sha256=5PPOSdFLQes6Gq5H3Yfi_q2m32eErMfNVO86qIjlnoc,10219
 vectordb_bench/backend/clients/milvus/cli.py,sha256=sovr2pCRrTzoZddNvQeWWOruyWqAzwpt1rlShIwxdws,18847
-vectordb_bench/backend/clients/milvus/config.py,sha256=GVOi-4FS0fmWMxf9IwJDEx1P5jJREGWXAWQLm7Z57vg,12931
+vectordb_bench/backend/clients/milvus/config.py,sha256=yrtPLWBnDvah2YZFnn3V_oOL-52GfM-uIgkQjd1REME,12870
 vectordb_bench/backend/clients/milvus/milvus.py,sha256=w_ANUibqxjffqFR-irRAvo4dBDSeXKU4dLZGLvZIYCo,9332
 vectordb_bench/backend/clients/mongodb/config.py,sha256=7DZCh0bjPiqJW2luPypfpNeGfvKxVC4mdHLqgcjF1hA,1745
 vectordb_bench/backend/clients/mongodb/mongodb.py,sha256=ts2gpAzUTarpkfMFnM5ANi6T-xvcjS8kc4-apPt9jug,7225
@@ -65,8 +65,8 @@ vectordb_bench/backend/clients/pgvecto_rs/cli.py,sha256=n0cMbUrGS2jzCpusVExxRDJb
 vectordb_bench/backend/clients/pgvecto_rs/config.py,sha256=jWs3078s5chH37O94zSHoQ98ptLTYiJeHiLy6BQgTE4,4725
 vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py,sha256=ZSOPpQjLtWxpQz7-R24X-e2oVLHJsZeEmaOzfd5pELA,9828
 vectordb_bench/backend/clients/pgvector/cli.py,sha256=0MRBSZe6xwmE0dcb10rzOneo3YlOUmegjcpMn3wZ3yE,6770
-vectordb_bench/backend/clients/pgvector/config.py,sha256=GgCCnVhRBTM2l3jghggSch9KiiKQ6Q99AzLB6lx6Wd0,9957
-vectordb_bench/backend/clients/pgvector/pgvector.py,sha256=tLmxZ4aI61gqBVGrR_k03Y3awv3-v1oSh5ZqOYN8vQc,21044
+vectordb_bench/backend/clients/pgvector/config.py,sha256=h2tNd6gQlv70erSa0Ni7jqUcA8uz3LYeLiopQbDatVI,10574
+vectordb_bench/backend/clients/pgvector/pgvector.py,sha256=q3s-fTy6teqAw06tQOy0peu_ymfzbZ1FuYnMRRxIsGU,23121
 vectordb_bench/backend/clients/pgvectorscale/cli.py,sha256=3XL2NdBXh9ug8SyUwPD6fGXkjYflahew5GO2xIza43g,3403
 vectordb_bench/backend/clients/pgvectorscale/config.py,sha256=ZMcRQPyCMzMJLXw56zODUGJmqOP-sOMA1entNsfE-Ck,3122
 vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py,sha256=NONFdcE-b-mt6GsRTru6UbMMu8iqX8PfRF43fY_AODw,10136
@@ -103,11 +103,11 @@ vectordb_bench/backend/runner/__init__.py,sha256=lkk-naYS2ai3kQLwNaqSsnudL9SVl0O
 vectordb_bench/backend/runner/mp_runner.py,sha256=qPjMkusf2Uicm8ROzhjsJ7dYI6SCbINDRBkM5_x5zi8,11191
 vectordb_bench/backend/runner/rate_runner.py,sha256=onC1FOT0LosunRq1CW8VRX7XoWF2xgslZVRGHYryTrk,5763
 vectordb_bench/backend/runner/read_write_runner.py,sha256=dqlaEkTb4mAZ45DRAlt-bIQMQ3aTZ6JDG778jb2eb8c,11410
-vectordb_bench/backend/runner/serial_runner.py,sha256=TEps9zgToGqhG5gadLlo87nFvtiOUBbdqX8Hm-XLsbM,12792
+vectordb_bench/backend/runner/serial_runner.py,sha256=pivPYAv_GhCcbeJ5nCoe0MrGzl2XajLrUwssSXpoYRc,12790
 vectordb_bench/backend/runner/util.py,sha256=tjTFUxth6hNnVrlU82TqkHhfeZo4ymj7WlyK4zFyPTg,522
 vectordb_bench/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/cli/batch_cli.py,sha256=lnVrIP1rweoqfFkrdTLzxnLzy713xP2AnW6xmhd4bu0,3658
-vectordb_bench/cli/cli.py,sha256=xcXJj_1ZL-0X81aCwNpzurYp6ocJeNw938e0MkN38Mg,18768
+vectordb_bench/cli/cli.py,sha256=JnEiT2yQmz3Z2IjEYfgRDbXbwl_yGLJ7X3nuUQk3MZc,19735
 vectordb_bench/cli/vectordbbench.py,sha256=g61M3naKy87AeblCfh2P9U2jKWKmcNjburLNFsfK6QE,2067
 vectordb_bench/config-files/batch_sample_config.yml,sha256=3n0SfLgVWeboAZZcO8j_UP4A9CExHGPE8tOmtVPPFiA,370
 vectordb_bench/config-files/sample_config.yml,sha256=yw9ZgHczNi9PedNuTVxZKiOTI6AVoQS1h8INNgoDjPk,340
@@ -196,9 +196,9 @@ vectordb_bench/results/S3Vectors/result_20250722_standard_s3vectors.json,sha256=
 vectordb_bench/results/WeaviateCloud/result_20230727_standard_weaviatecloud.json,sha256=WBlfjmbO3R4G6F4lDuneEigffUyTU7ti1SyWoff3oNI,15497
 vectordb_bench/results/WeaviateCloud/result_20230808_standard_weaviatecloud.json,sha256=lXjudo-l-6H0EOIemoB5n4GddOOHJnwndrGwCJIH-EY,7865
 vectordb_bench/results/ZillizCloud/result_20250613_standard_zillizcloud.json,sha256=gZCnDanS5Yb6Uzvb0Q6wDxMl81UAoGzsZRHU8JwqNds,215610
-vectordb_bench-1.0.7.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
-vectordb_bench-1.0.7.dist-info/METADATA,sha256=nUvyenEbO5y3ceu95dHc7lMfJYhli9_akFXx37tac_w,42015
-vectordb_bench-1.0.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-vectordb_bench-1.0.7.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
-vectordb_bench-1.0.7.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
-vectordb_bench-1.0.7.dist-info/RECORD,,
+vectordb_bench-1.0.9.dist-info/licenses/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-1.0.9.dist-info/METADATA,sha256=Dq846vYzNlG3npkwafTjx4QqKLDvirnjwIBbf7H_xbo,42251
+vectordb_bench-1.0.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectordb_bench-1.0.9.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
+vectordb_bench-1.0.9.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-1.0.9.dist-info/RECORD,,