vectordb-bench 0.0.20__py3-none-any.whl → 0.0.21__py3-none-any.whl

vectordb_bench/backend/assembler.py

@@ -53,8 +53,8 @@ class Assembler:
             _ = k.init_cls
 
         # sort by dataset size
-        for k, _ in db2runner:
-            db2runner[k].sort(key=lambda x: x.ca.dataset.data.size)
+        for _, runner in db2runner.items():
+            runner.sort(key=lambda x: x.ca.dataset.data.size)
 
         all_runners = []
         all_runners.extend(load_runners)

vectordb_bench/backend/clients/__init__.py

@@ -42,7 +42,7 @@ class DB(Enum):
     AliyunOpenSearch = "AliyunOpenSearch"
 
     @property
-    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912
+    def init_cls(self) -> type[VectorDB]:  # noqa: PLR0911, PLR0912, C901
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.milvus import Milvus
@@ -129,11 +129,16 @@ class DB(Enum):
 
             return AliyunOpenSearch
 
+        if self == DB.Test:
+            from .test.test import Test
+
+            return Test
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 
     @property
-    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912
+    def config_cls(self) -> type[DBConfig]:  # noqa: PLR0911, PLR0912, C901
         """Import while in use"""
         if self == DB.Milvus:
             from .milvus.config import MilvusConfig
@@ -220,6 +225,11 @@ class DB(Enum):
 
             return AliyunOpenSearchConfig
 
+        if self == DB.Test:
+            from .test.config import TestConfig
+
+            return TestConfig
+
         msg = f"Unknown DB: {self.name}"
         raise ValueError(msg)
 

vectordb_bench/backend/clients/aliyun_opensearch/aliyun_opensearch.py

@@ -325,10 +325,7 @@ class AliyunOpenSearch(VectorDB):
 
         return False
 
-    def optimize(self):
-        pass
-
-    def optimize_with_size(self, data_size: int):
+    def optimize(self, data_size: int):
         log.info(f"optimize count: {data_size}")
         retry_times = 0
         while True:
@@ -340,6 +337,3 @@ class AliyunOpenSearch(VectorDB):
             if total_count == data_size:
                 log.info("optimize table finish.")
                 return
-
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases."""

vectordb_bench/backend/clients/alloydb/alloydb.py

@@ -149,10 +149,7 @@ class AlloyDB(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):

vectordb_bench/backend/clients/api.py

@@ -137,6 +137,13 @@ class VectorDB(ABC):
     @contextmanager
     def init(self) -> None:
         """create and destory connections to database.
+        Why contextmanager:
+
+            In multiprocessing search tasks, vectordbbench might init
+            totally hundreds of thousands of connections with DB server.
+
+            Too many connections may drain local FDs or server connection resources.
+            If the DB client doesn't have `close()` method, just set the object to None.
 
         Examples:
             >>> with self.init():
@@ -187,9 +194,8 @@ class VectorDB(ABC):
         """
         raise NotImplementedError
 
-    # TODO: remove
     @abstractmethod
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         """optimize will be called between insertion and search in performance cases.
 
         Should be blocked until the vectorDB is ready to be tested on
@@ -199,16 +205,3 @@ class VectorDB(ABC):
         Optimize's execution time is limited, the limited time is based on cases.
         """
         raise NotImplementedError
-
-    def optimize_with_size(self, data_size: int):
-        self.optimize()
-
-    # TODO: remove
-    @abstractmethod
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases.
-
-        Should be blocked until the vectorDB is ready to be tested on
-        heavy load cases.
-        """
-        raise NotImplementedError

vectordb_bench/backend/clients/aws_opensearch/aws_opensearch.py

@@ -145,15 +145,15 @@ class AWSOpenSearch(VectorDB):
                 docvalue_fields=[self.id_col_name],
                 stored_fields="_none_",
             )
-            log.info(f'Search took: {resp["took"]}')
-            log.info(f'Search shards: {resp["_shards"]}')
-            log.info(f'Search hits total: {resp["hits"]["total"]}')
+            log.info(f"Search took: {resp['took']}")
+            log.info(f"Search shards: {resp['_shards']}")
+            log.info(f"Search hits total: {resp['hits']['total']}")
             return [int(h["fields"][self.id_col_name][0]) for h in resp["hits"]["hits"]]
         except Exception as e:
             log.warning(f"Failed to search: {self.index_name} error: {e!s}")
             raise e from None
 
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         """optimize will be called between insertion and search in performance cases."""
         # Call refresh first to ensure that all segments are created
         self._refresh_index()
@@ -194,6 +194,3 @@ class AWSOpenSearch(VectorDB):
             log.info("Calling warmup API to load graphs into memory")
             warmup_endpoint = f"/_plugins/_knn/warmup/{self.index_name}"
             self.client.transport.perform_request("GET", warmup_endpoint)
-
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases."""

vectordb_bench/backend/clients/chroma/chroma.py

@@ -57,10 +57,7 @@ class ChromaClient(VectorDB):
     def ready_to_search(self) -> bool:
         pass
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py

@@ -143,7 +143,7 @@ class ElasticCloud(VectorDB):
             log.warning(f"Failed to search: {self.indice} error: {e!s}")
             raise e from None
 
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         """optimize will be called between insertion and search in performance cases."""
         assert self.client is not None, "should self.init() first"
         self.client.indices.refresh(index=self.indice)
@@ -158,6 +158,3 @@ class ElasticCloud(VectorDB):
             task_status = self.client.tasks.get(task_id=force_merge_task_id)
             if task_status["completed"]:
                 return
-
-    def ready_to_load(self):
-        """ready_to_load will be called before load in load cases."""

vectordb_bench/backend/clients/memorydb/cli.py

@@ -43,8 +43,8 @@ class MemoryDBTypedDict(TypedDict):
             show_default=True,
             default=False,
             help=(
-                "Cluster Mode Disabled (CMD), use this flag when testing locally on a single node instance.",
-                " In production, MemoryDB only supports cluster mode (CME)",
+                "Cluster Mode Disabled (CMD), use this flag when testing locally on a single node instance."
+                " In production, MemoryDB only supports cluster mode (CME)"
             ),
         ),
     ]

vectordb_bench/backend/clients/memorydb/memorydb.py

@@ -157,17 +157,14 @@ class MemoryDB(VectorDB):
         self.conn = self.get_client()
         search_param = self.case_config.search_param()
         if search_param["ef_runtime"]:
-            self.ef_runtime_str = f'EF_RUNTIME {search_param["ef_runtime"]}'
+            self.ef_runtime_str = f"EF_RUNTIME {search_param['ef_runtime']}"
         else:
             self.ef_runtime_str = ""
         yield
         self.conn.close()
         self.conn = None
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def insert_embeddings(

vectordb_bench/backend/clients/milvus/milvus.py

@@ -138,26 +138,7 @@ class Milvus(VectorDB):
             log.warning(f"{self.name} optimize error: {e}")
             raise e from None
 
-    def ready_to_load(self):
-        assert self.col, "Please call self.init() before"
-        self._pre_load(self.col)
-
-    def _pre_load(self, coll: Collection):
-        try:
-            if not coll.has_index(index_name=self._index_name):
-                log.info(f"{self.name} create index")
-                coll.create_index(
-                    self._vector_field,
-                    self.case_config.index_param(),
-                    index_name=self._index_name,
-                )
-            coll.load()
-            log.info(f"{self.name} load")
-        except Exception as e:
-            log.warning(f"{self.name} pre load error: {e}")
-            raise e from None
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.col, "Please call self.init() before"
         self._optimize()
 

vectordb_bench/backend/clients/pgdiskann/pgdiskann.py

@@ -143,10 +143,7 @@ class PgDiskANN(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):

vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py

@@ -153,10 +153,7 @@ class PgVectoRS(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -200,10 +197,7 @@ class PgVectoRS(VectorDB):
             self.cursor.execute(index_create_sql)
             self.conn.commit()
         except Exception as e:
-            log.warning(
-                f"Failed to create pgvecto.rs index {self._index_name} \
-                    at table {self.table_name} error: {e}",
-            )
+            log.warning(f"Failed to create pgvecto.rs index {self._index_name} at table {self.table_name} error: {e}")
             raise e from None
 
     def _create_table(self, dim: int):
@@ -258,9 +252,7 @@ class PgVectoRS(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvecto.rs table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvecto.rs table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

vectordb_bench/backend/clients/pgvector/pgvector.py

@@ -228,10 +228,7 @@ class PgVector(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -415,9 +412,7 @@ class PgVector(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py

@@ -143,10 +143,7 @@ class PgVectorScale(VectorDB):
         )
         self.conn.commit()
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         self._post_insert()
 
     def _post_insert(self):
@@ -255,9 +252,7 @@ class PgVectorScale(VectorDB):
 
             return len(metadata), None
         except Exception as e:
-            log.warning(
-                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}",
-            )
+            log.warning(f"Failed to insert data into pgvector table ({self.table_name}), error: {e}")
             return 0, e
 
     def search_embedding(

vectordb_bench/backend/clients/pinecone/pinecone.py

@@ -59,10 +59,7 @@ class Pinecone(VectorDB):
         self.index = pc.Index(self.index_name)
         yield
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/qdrant_cloud/qdrant_cloud.py

@@ -62,10 +62,7 @@ class QdrantCloud(VectorDB):
         self.qdrant_client = None
         del self.qdrant_client
 
-    def ready_to_load(self):
-        pass
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.qdrant_client, "Please call self.init() before"
         # wait for vectors to be fully indexed
         try:
@@ -76,8 +73,8 @@ class QdrantCloud(VectorDB):
                     continue
                 if info.status == CollectionStatus.GREEN:
                     msg = (
-                        f"Stored vectors: {info.vectors_count}, Indexed vectors: {info.indexed_vectors_count}, ",
-                        f"Collection status: {info.indexed_vectors_count}",
+                        f"Stored vectors: {info.vectors_count}, Indexed vectors: {info.indexed_vectors_count}, "
+                        f"Collection status: {info.indexed_vectors_count}"
                     )
                     log.info(msg)
                     return

vectordb_bench/backend/clients/redis/redis.py

@@ -95,10 +95,7 @@ class Redis(VectorDB):
     def ready_to_search(self) -> bool:
         """Check if the database is ready to search."""
 
-    def ready_to_load(self) -> bool:
-        pass
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/test/cli.py

@@ -17,7 +17,7 @@ class TestTypedDict(CommonTypedDict): ...
 @click_parameter_decorators_from_typed_dict(TestTypedDict)
 def Test(**parameters: Unpack[TestTypedDict]):
     run(
-        db=DB.NewClient,
+        db=DB.Test,
         db_config=TestConfig(db_label=parameters["db_label"]),
         db_case_config=TestIndexConfig(),
         **parameters,

vectordb_bench/backend/clients/test/test.py

@@ -33,10 +33,7 @@ class Test(VectorDB):
 
         yield
 
-    def ready_to_load(self) -> bool:
-        return True
-
-    def optimize(self) -> None:
+    def optimize(self, data_size: int | None = None):
         pass
 
     def insert_embeddings(

vectordb_bench/backend/clients/weaviate_cloud/weaviate_cloud.py

@@ -67,10 +67,7 @@ class WeaviateCloud(VectorDB):
         self.client = None
         del self.client
 
-    def ready_to_load(self):
-        """Should call insert first, do nothing"""
-
-    def optimize(self):
+    def optimize(self, data_size: int | None = None):
         assert self.client.schema.exists(self.collection_name)
         self.client.schema.update_config(
             self.collection_name,

vectordb_bench/backend/data_source.py

@@ -63,9 +63,7 @@ class AliyunOSSReader(DatasetReader):
         # check size equal
         remote_size, local_size = info.content_length, local.stat().st_size
         if remote_size != local_size:
-            log.info(
-                f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]",
-            )
+            log.info(f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]")
             return False
 
         return True
@@ -89,9 +87,7 @@ class AliyunOSSReader(DatasetReader):
                 local_file = local_ds_root.joinpath(file)
 
                 if (not local_file.exists()) or (not self.validate_file(remote_file, local_file)):
-                    log.info(
-                        f"local file: {local_file} not match with remote: {remote_file}; add to downloading list",
-                    )
+                    log.info(f"local file: {local_file} not match with remote: {remote_file}; add to downloading list")
                     downloads.append((remote_file, local_file))
 
         if len(downloads) == 0:
@@ -135,9 +131,7 @@ class AwsS3Reader(DatasetReader):
                 local_file = local_ds_root.joinpath(file)
 
                 if (not local_file.exists()) or (not self.validate_file(remote_file, local_file)):
-                    log.info(
-                        f"local file: {local_file} not match with remote: {remote_file}; add to downloading list",
-                    )
+                    log.info(f"local file: {local_file} not match with remote: {remote_file}; add to downloading list")
                     downloads.append(remote_file)
 
         if len(downloads) == 0:
@@ -157,9 +151,7 @@ class AwsS3Reader(DatasetReader):
         # check size equal
         remote_size, local_size = info.get("size"), local.stat().st_size
         if remote_size != local_size:
-            log.info(
-                f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]",
-            )
+            log.info(f"local file: {local} size[{local_size}] not match with remote size[{remote_size}]")
             return False
 
         return True

vectordb_bench/backend/runner/mp_runner.py

@@ -79,14 +79,14 @@ class MultiProcessingSearchRunner:
 
                 if count % 500 == 0:
                     log.debug(
-                        f"({mp.current_process().name:16}) ",
-                        f"search_count: {count}, latest_latency={time.perf_counter()-s}",
+                        f"({mp.current_process().name:16}) "
+                        f"search_count: {count}, latest_latency={time.perf_counter()-s}"
                     )
 
         total_dur = round(time.perf_counter() - start_time, 4)
         log.info(
             f"{mp.current_process().name:16} search {self.duration}s: "
-            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}",
+            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}"
         )
 
         return (count, total_dur, latencies)
@@ -94,9 +94,7 @@ class MultiProcessingSearchRunner:
     @staticmethod
     def get_mp_context():
         mp_start_method = "spawn"
-        log.debug(
-            f"MultiProcessingSearchRunner get multiprocessing start method: {mp_start_method}",
-        )
+        log.debug(f"MultiProcessingSearchRunner get multiprocessing start method: {mp_start_method}")
         return mp.get_context(mp_start_method)
 
     def _run_all_concurrencies_mem_efficient(self):
@@ -113,9 +111,7 @@ class MultiProcessingSearchRunner:
                         mp_context=self.get_mp_context(),
                         max_workers=conc,
                     ) as executor:
-                        log.info(
-                            f"Start search {self.duration}s in concurrency {conc}, filters: {self.filters}",
-                        )
+                        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:
@@ -124,9 +120,7 @@ class MultiProcessingSearchRunner:
 
                         with cond:
                             cond.notify_all()
-                            log.info(
-                                f"Syncing all process and start concurrency search, concurrency={conc}",
-                            )
+                            log.info(f"Syncing all process and start concurrency search, concurrency={conc}")
 
                         start = time.perf_counter()
                         all_count = sum([r.result()[0] for r in future_iter])
@@ -140,18 +134,14 @@ class MultiProcessingSearchRunner:
                         conc_qps_list.append(qps)
                         conc_latency_p99_list.append(latency_p99)
                         conc_latency_avg_list.append(latency_avg)
-                        log.info(
-                            f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}",
-                        )
+                        log.info(f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}")
 
                 if qps > max_qps:
                     max_qps = qps
-                    log.info(
-                        f"Update largest qps with concurrency {conc}: current max_qps={max_qps}",
-                    )
+                    log.info(f"Update largest qps with concurrency {conc}: current max_qps={max_qps}")
         except Exception as e:
             log.warning(
-                f"Fail to search all concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}",
+                f"Fail to search, concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}"
             )
             traceback.print_exc()
 
@@ -193,9 +183,7 @@ class MultiProcessingSearchRunner:
                         mp_context=self.get_mp_context(),
                         max_workers=conc,
                     ) as executor:
-                        log.info(
-                            f"Start search_by_dur {duration}s in concurrency {conc}, filters: {self.filters}",
-                        )
+                        log.info(f"Start search_by_dur {duration}s in concurrency {conc}, filters: {self.filters}")
                         future_iter = [
                             executor.submit(self.search_by_dur, duration, self.test_data, q, cond) for i in range(conc)
                         ]
@@ -206,24 +194,18 @@ class MultiProcessingSearchRunner:
 
                         with cond:
                             cond.notify_all()
-                            log.info(
-                                f"Syncing all process and start concurrency search, concurrency={conc}",
-                            )
+                            log.info(f"Syncing all process and start concurrency search, concurrency={conc}")
 
                         start = time.perf_counter()
                         all_count = sum([r.result() for r in future_iter])
                         cost = time.perf_counter() - start
 
                         qps = round(all_count / cost, 4)
-                        log.info(
-                            f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}",
-                        )
+                        log.info(f"End search in concurrency {conc}: dur={cost}s, total_count={all_count}, qps={qps}")
 
                 if qps > max_qps:
                     max_qps = qps
-                    log.info(
-                        f"Update largest qps with concurrency {conc}: current max_qps={max_qps}",
-                    )
+                    log.info(f"Update largest qps with concurrency {conc}: current max_qps={max_qps}")
         except Exception as e:
             log.warning(
                 f"Fail to search all concurrencies: {self.concurrencies}, max_qps before failure={max_qps}, reason={e}",
@@ -275,14 +257,14 @@ class MultiProcessingSearchRunner:
 
                 if count % 500 == 0:
                     log.debug(
-                        f"({mp.current_process().name:16}) search_count: {count}, ",
-                        f"latest_latency={time.perf_counter()-s}",
+                        f"({mp.current_process().name:16}) search_count: {count}, "
+                        f"latest_latency={time.perf_counter()-s}"
                     )
 
         total_dur = round(time.perf_counter() - start_time, 4)
         log.debug(
             f"{mp.current_process().name:16} search {self.duration}s: "
-            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}",
+            f"actual_dur={total_dur}s, count={count}, qps in this process: {round(count / total_dur, 4):3}"
         )
 
         return count

vectordb_bench/backend/runner/rate_runner.py

@@ -73,14 +73,14 @@ class RatedMultiThreadingInsertRunner:
 
                         if len(not_done) > 0:
                             log.warning(
-                                f"Failed to finish all tasks in 1s, [{len(not_done)}/{len(executing_futures)}] ",
-                                f"tasks are not done, waited={wait_interval:.2f}, trying to wait in the next round",
+                                f"Failed to finish all tasks in 1s, [{len(not_done)}/{len(executing_futures)}] "
+                                f"tasks are not done, waited={wait_interval:.2f}, trying to wait in the next round"
                             )
                             executing_futures = list(not_done)
                         else:
                             log.debug(
-                                f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} ",
-                                f"task in 1s, wait_interval={wait_interval:.2f}",
+                                f"Finished {len(executing_futures)} insert-{config.NUM_PER_BATCH} "
+                                f"task in 1s, wait_interval={wait_interval:.2f}"
                             )
                             executing_futures = []
                     except Exception as e:

vectordb_bench/backend/runner/read_write_runner.py

@@ -45,8 +45,8 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
         self.read_dur_after_write = read_dur_after_write
 
         log.info(
-            f"Init runner, concurencys={concurrencies}, search_stage={search_stage}, ",
-            f"stage_search_dur={read_dur_after_write}",
+            f"Init runner, concurencys={concurrencies}, search_stage={search_stage}, "
+            f"stage_search_dur={read_dur_after_write}"
         )
 
         test_emb = np.stack(dataset.test_data["emb"])
@@ -80,7 +80,7 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
         """Optimize needs to run in differenct process for pymilvus schema recursion problem"""
         with self.db.init():
             log.info("Search after write - Optimize start")
-            self.db.optimize()
+            self.db.optimize(data_size=self.data_volume)
             log.info("Search after write - Optimize finished")
 
     def run_search(self):
@@ -88,12 +88,10 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
         res, ssearch_dur = self.serial_search_runner.run()
         recall, ndcg, p99_latency = res
         log.info(
-            f"Search after write - Serial search - recall={recall}, ndcg={ndcg}, p99={p99_latency}, ",
+            f"Search after write - Serial search - recall={recall}, ndcg={ndcg}, p99={p99_latency}, "
             f"dur={ssearch_dur:.4f}",
         )
-        log.info(
-            f"Search after wirte - Conc search start, dur for each conc={self.read_dur_after_write}",
-        )
+        log.info(f"Search after wirte - Conc search start, dur for each conc={self.read_dur_after_write}")
         max_qps = self.run_by_dur(self.read_dur_after_write)
         log.info(f"Search after wirte - Conc search finished, max_qps={max_qps}")
 
@@ -157,9 +155,7 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
 
             got = wait_next_target(start_batch, target_batch)
             if got is False:
-                log.warning(
-                    f"Abnormal exit, target_batch={target_batch}, start_batch={start_batch}",
-                )
+                log.warning(f"Abnormal exit, target_batch={target_batch}, start_batch={start_batch}")
                 return None
 
             log.info(f"Insert {perc}% done, total batch={total_batch}")
@@ -167,8 +163,8 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
             res, ssearch_dur = self.serial_search_runner.run()
             recall, ndcg, p99_latency = res
             log.info(
-                f"[{target_batch}/{total_batch}] Serial search - {perc}% done, recall={recall}, ",
-                f"ndcg={ndcg}, p99={p99_latency}, dur={ssearch_dur:.4f}",
+                f"[{target_batch}/{total_batch}] Serial search - {perc}% done, recall={recall}, "
+                f"ndcg={ndcg}, p99={p99_latency}, dur={ssearch_dur:.4f}"
             )
 
             # Search duration for non-last search stage is carefully calculated.
@@ -183,8 +179,8 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
                 each_conc_search_dur = csearch_dur / len(self.concurrencies)
                 if each_conc_search_dur < 30:
                     warning_msg = (
-                        f"Results might be inaccurate, duration[{csearch_dur:.4f}] left for conc-search is too short, ",
-                        f"total available dur={total_dur_between_stages}, serial_search_cost={ssearch_dur}.",
+                        f"Results might be inaccurate, duration[{csearch_dur:.4f}] left for conc-search is too short, "
+                        f"total available dur={total_dur_between_stages}, serial_search_cost={ssearch_dur}."
                     )
                     log.warning(warning_msg)
 
@@ -193,7 +189,7 @@ class ReadWriteRunner(MultiProcessingSearchRunner, RatedMultiThreadingInsertRunn
                 each_conc_search_dur = 60
 
             log.info(
-                f"[{target_batch}/{total_batch}] Concurrent search - {perc}% start, dur={each_conc_search_dur:.4f}",
+                f"[{target_batch}/{total_batch}] Concurrent search - {perc}% start, dur={each_conc_search_dur:.4f}"
             )
             max_qps = self.run_by_dur(each_conc_search_dur)
             result.append((perc, max_qps, recall, ndcg, p99_latency))

vectordb_bench/backend/runner/serial_runner.py

@@ -40,9 +40,7 @@ class SerialInsertRunner:
     def task(self) -> int:
         count = 0
         with self.db.init():
-            log.info(
-                f"({mp.current_process().name:16}) Start inserting embeddings in batch {config.NUM_PER_BATCH}",
-            )
+            log.info(f"({mp.current_process().name:16}) Start inserting embeddings in batch {config.NUM_PER_BATCH}")
             start = time.perf_counter()
             for data_df in self.dataset:
                 all_metadata = data_df["id"].tolist()
@@ -66,13 +64,11 @@ class SerialInsertRunner:
                 assert insert_count == len(all_metadata)
                 count += insert_count
                 if count % 100_000 == 0:
-                    log.info(
-                        f"({mp.current_process().name:16}) Loaded {count} embeddings into VectorDB",
-                    )
+                    log.info(f"({mp.current_process().name:16}) Loaded {count} embeddings into VectorDB")
 
             log.info(
-                f"({mp.current_process().name:16}) Finish loading all dataset into VectorDB, ",
-                f"dur={time.perf_counter()-start}",
+                f"({mp.current_process().name:16}) Finish loading all dataset into VectorDB, "
+                f"dur={time.perf_counter() - start}"
             )
             return count
 
@@ -83,8 +79,8 @@ class SerialInsertRunner:
 
             num_batches = math.ceil(len(all_embeddings) / NUM_PER_BATCH)
             log.info(
-                f"({mp.current_process().name:16}) Start inserting {len(all_embeddings)} ",
-                f"embeddings in batch {NUM_PER_BATCH}",
+                f"({mp.current_process().name:16}) Start inserting {len(all_embeddings)} "
+                f"embeddings in batch {NUM_PER_BATCH}"
             )
             count = 0
             for batch_id in range(num_batches):
@@ -94,8 +90,8 @@ class SerialInsertRunner:
                 embeddings = all_embeddings[batch_id * NUM_PER_BATCH : (batch_id + 1) * NUM_PER_BATCH]
 
                 log.debug(
-                    f"({mp.current_process().name:16}) batch [{batch_id:3}/{num_batches}], ",
-                    f"Start inserting {len(metadata)} embeddings",
+                    f"({mp.current_process().name:16}) batch [{batch_id:3}/{num_batches}], "
+                    f"Start inserting {len(metadata)} embeddings"
                 )
                 while retry_count < LOAD_MAX_TRY_COUNT:
                     insert_count, error = self.db.insert_embeddings(
@@ -113,15 +109,15 @@ class SerialInsertRunner:
                     else:
                         break
                 log.debug(
-                    f"({mp.current_process().name:16}) batch [{batch_id:3}/{num_batches}], ",
-                    f"Finish inserting {len(metadata)} embeddings",
+                    f"({mp.current_process().name:16}) batch [{batch_id:3}/{num_batches}], "
+                    f"Finish inserting {len(metadata)} embeddings"
                 )
 
                 assert already_insert_count == len(metadata)
                 count += already_insert_count
             log.info(
-                f"({mp.current_process().name:16}) Finish inserting {len(all_embeddings)} embeddings in ",
-                f"batch {NUM_PER_BATCH}",
+                f"({mp.current_process().name:16}) Finish inserting {len(all_embeddings)} embeddings in "
+                f"batch {NUM_PER_BATCH}"
             )
         return count
 
@@ -160,8 +156,6 @@ class SerialInsertRunner:
         start_time = time.perf_counter()
         max_load_count, times = 0, 0
         try:
-            with self.db.init():
-                self.db.ready_to_load()
             while time.perf_counter() - start_time < self.timeout:
                 count = self.endless_insert_data(
                     all_embeddings,
@@ -171,13 +165,13 @@ class SerialInsertRunner:
                 max_load_count += count
                 times += 1
                 log.info(
-                    f"Loaded {times} entire dataset, current max load counts={utils.numerize(max_load_count)}, ",
-                    f"{max_load_count}",
+                    f"Loaded {times} entire dataset, current max load counts={utils.numerize(max_load_count)}, "
+                    f"{max_load_count}"
                 )
         except Exception as e:
             log.info(
-                f"Capacity case load reach limit, insertion counts={utils.numerize(max_load_count)}, ",
-                f"{max_load_count}, err={e}",
+                f"Capacity case load reach limit, insertion counts={utils.numerize(max_load_count)}, "
+                f"{max_load_count}, err={e}"
             )
             traceback.print_exc()
             return max_load_count
@@ -209,9 +203,7 @@ class SerialSearchRunner:
         self.ground_truth = ground_truth
 
     def search(self, args: tuple[list, pd.DataFrame]) -> tuple[float, float, float]:
-        log.info(
-            f"{mp.current_process().name:14} start search the entire test_data to get recall and latency",
-        )
+        log.info(f"{mp.current_process().name:14} start search the entire test_data to get recall and latency")
         with self.db.init():
             test_data, ground_truth = args
             ideal_dcg = get_ideal_dcg(self.k)
@@ -242,8 +234,8 @@ class SerialSearchRunner:
 
                 if len(latencies) % 100 == 0:
                     log.debug(
-                        f"({mp.current_process().name:14}) search_count={len(latencies):3}, ",
-                        f"latest_latency={latencies[-1]}, latest recall={recalls[-1]}",
+                        f"({mp.current_process().name:14}) search_count={len(latencies):3}, "
+                        f"latest_latency={latencies[-1]}, latest recall={recalls[-1]}"
                     )
 
         avg_latency = round(np.mean(latencies), 4)
@@ -258,7 +250,7 @@ class SerialSearchRunner:
             f"avg_recall={avg_recall}, "
             f"avg_ndcg={avg_ndcg},"
             f"avg_latency={avg_latency}, "
-            f"p99={p99}",
+            f"p99={p99}"
         )
         return (avg_recall, avg_ndcg, p99)
 

vectordb_bench/backend/task_runner.py

@@ -98,9 +98,7 @@ class CaseRunner(BaseModel):
             self.init_db(drop_old)
             self.ca.dataset.prepare(self.dataset_source, filters=self.ca.filter_rate)
         except ModuleNotFoundError as e:
-            log.warning(
-                f"pre run case error: please install client for db: {self.config.db}, error={e}",
-            )
+            log.warning(f"pre run case error: please install client for db: {self.config.db}, error={e}")
             raise e from None
 
     def run(self, drop_old: bool = True) -> Metric:
@@ -136,9 +134,7 @@ class CaseRunner(BaseModel):
             log.warning(f"Failed to run capacity case, reason = {e}")
             raise e from None
         else:
-            log.info(
-                f"Capacity case loading dataset reaches VectorDB's limit: max capacity = {count}",
-            )
+            log.info(f"Capacity case loading dataset reaches VectorDB's limit: max capacity = {count}")
             return Metric(max_load_count=count)
 
     def _run_perf_case(self, drop_old: bool = True) -> Metric:
@@ -147,22 +143,6 @@ class CaseRunner(BaseModel):
         Returns:
             Metric: load_duration, recall, serial_latency_p99, and, qps
         """
-        """
-                    if drop_old:
-                _, load_dur = self._load_train_data()
-                build_dur = self._optimize()
-                m.load_duration = round(load_dur+build_dur, 4)
-                log.info(
-                    f"Finish loading the entire dataset into VectorDB,"
-                    f" insert_duration={load_dur}, optimize_duration={build_dur}"
-                    f" load_duration(insert + optimize) = {m.load_duration}"
-                )
-
-            self._init_search_runner()
-
-            m.qps, m.conc_num_list, m.conc_qps_list, m.conc_latency_p99_list = self._conc_search()
-            m.recall, m.serial_latency_p99 = self._serial_search()
-        """
 
         log.info("Start performance case")
         try:
@@ -175,7 +155,7 @@ class CaseRunner(BaseModel):
                     log.info(
                         f"Finish loading the entire dataset into VectorDB,"
                         f" insert_duration={load_dur}, optimize_duration={build_dur}"
-                        f" load_duration(insert + optimize) = {m.load_duration}",
+                        f" load_duration(insert + optimize) = {m.load_duration}"
                     )
                 else:
                     log.info("Data loading skipped")
@@ -254,13 +234,13 @@ class CaseRunner(BaseModel):
             self.stop()
 
     @utils.time_it
-    def _task(self) -> None:
+    def _optimize_task(self) -> None:
         with self.db.init():
-            self.db.optimize_with_size(data_size=self.ca.dataset.data.size)
+            self.db.optimize(data_size=self.ca.dataset.data.size)
 
     def _optimize(self) -> float:
         with concurrent.futures.ProcessPoolExecutor(max_workers=1) as executor:
-            future = executor.submit(self._task)
+            future = executor.submit(self._optimize_task)
             try:
                 return future.result(timeout=self.ca.optimize_timeout)[1]
             except TimeoutError as e:

vectordb_bench/interface.py

@@ -65,9 +65,7 @@ class BenchMarkRunner:
             log.warning("Empty tasks submitted")
             return False
 
-        log.debug(
-            f"tasks: {tasks}, task_label: {task_label}, dataset source: {self.dataset_source}",
-        )
+        log.debug(f"tasks: {tasks}, task_label: {task_label}, dataset source: {self.dataset_source}")
 
         # Generate run_id
         run_id = uuid.uuid4().hex
@@ -169,14 +167,13 @@ class BenchMarkRunner:
                 drop_old = TaskStage.DROP_OLD in runner.config.stages
                 if (latest_runner and runner == latest_runner) or not self.drop_old:
                     drop_old = False
+                num_cases = running_task.num_cases()
                 try:
-                    log.info(
-                        f"[{idx+1}/{running_task.num_cases()}] start case: {runner.display()}, drop_old={drop_old}",
-                    )
+                    log.info(f"[{idx+1}/{num_cases}] start case: {runner.display()}, drop_old={drop_old}")
                     case_res.metrics = runner.run(drop_old)
                     log.info(
-                        f"[{idx+1}/{running_task.num_cases()}] finish case: {runner.display()}, "
-                        f"result={case_res.metrics}, label={case_res.label}",
+                        f"[{idx+1}/{num_cases}] finish case: {runner.display()}, "
+                        f"result={case_res.metrics}, label={case_res.label}"
                     )
 
                     # cache the latest succeeded runner
@@ -189,16 +186,12 @@ class BenchMarkRunner:
                     if not drop_old:
                         case_res.metrics.load_duration = cached_load_duration if cached_load_duration else 0.0
                 except (LoadTimeoutError, PerformanceTimeoutError) as e:
-                    log.warning(
-                        f"[{idx+1}/{running_task.num_cases()}] case {runner.display()} failed to run, reason={e}",
-                    )
+                    log.warning(f"[{idx+1}/{num_cases}] case {runner.display()} failed to run, reason={e}")
                     case_res.label = ResultLabel.OUTOFRANGE
                     continue
 
                 except Exception as e:
-                    log.warning(
-                        f"[{idx+1}/{running_task.num_cases()}] case {runner.display()} failed to run, reason={e}",
-                    )
+                    log.warning(f"[{idx+1}/{num_cases}] case {runner.display()} failed to run, reason={e}")
                     traceback.print_exc()
                     case_res.label = ResultLabel.FAILED
                     continue
@@ -217,9 +210,7 @@ class BenchMarkRunner:
 
             send_conn.send((SIGNAL.SUCCESS, None))
             send_conn.close()
-            log.info(
-                f"Success to finish task: label={running_task.task_label}, run_id={running_task.run_id}",
-            )
+            log.info(f"Success to finish task: label={running_task.task_label}, run_id={running_task.run_id}")
 
         except Exception as e:
             err_msg = (
@@ -249,8 +240,8 @@ class BenchMarkRunner:
 
     def _run_async(self, conn: Connection) -> bool:
         log.info(
-            f"task submitted: id={self.running_task.run_id}, {self.running_task.task_label}, ",
-            f"case number: {len(self.running_task.case_runners)}",
+            f"task submitted: id={self.running_task.run_id}, {self.running_task.task_label}, "
+            f"case number: {len(self.running_task.case_runners)}"
         )
         global global_result_future
         executor = concurrent.futures.ProcessPoolExecutor(

{vectordb_bench-0.0.20.dist-info → vectordb_bench-0.0.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: vectordb-bench
-Version: 0.0.20
+Version: 0.0.21
 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

{vectordb_bench-0.0.20.dist-info → vectordb_bench-0.0.21.dist-info}/RECORD

@@ -1,74 +1,74 @@
 vectordb_bench/__init__.py,sha256=d5psAfISw9F6PFL2xPlSYUKKFDw7ifQm7g3LWC8_yUA,2375
 vectordb_bench/__main__.py,sha256=cyYbVSU-zA1AgzneGKcRRuzR4ftRDr9sIi9Ei9NZnhI,858
 vectordb_bench/base.py,sha256=AgavIF0P9ku_RmCRk1KKziba-wI4ZpA2aJvjJzNhRSs,129
-vectordb_bench/interface.py,sha256=8iTNV2oq0LAU-8y3DbeEfzVex03d8M5kves4OXs_ubY,10016
+vectordb_bench/interface.py,sha256=XaCjTgUeI17uVjsgOauPeVlkvnkuCyQOWyOaWhrgCt8,9811
 vectordb_bench/log_util.py,sha256=hOdK0TnrcpYZOrRZoBslievXSW8qtTvLvube43rxbVc,2776
 vectordb_bench/metric.py,sha256=pj-AxQHyIRHTaJY-wTIkTbC6TqEqMzt3kcEmMWEv71w,2063
 vectordb_bench/models.py,sha256=5N4-0lJLWpoR6NnzX4ONuH7vyi4nRFFuNS0q9jQ4cgM,11023
 vectordb_bench/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vectordb_bench/backend/assembler.py,sha256=CkXn40A18x2nOWbL1F8DrrSz--TcYAlwxhqD0VQMCbA,2040
+vectordb_bench/backend/assembler.py,sha256=6GInRT7yBgfTaIPmo-XMkYX4pA8PJQmjMQInynwaunE,2047
 vectordb_bench/backend/cases.py,sha256=obDdY6g3p9Z2fog7qDwLLDuRMwo3LGQKMHsP66QZd2M,16296
-vectordb_bench/backend/data_source.py,sha256=VGrQ6P1a4Yt5RT5VkQe3YhW8vb8Lre0a7uARwYnwuAA,5680
+vectordb_bench/backend/data_source.py,sha256=bfa_Zg4O9fRP2ENmVZ_2-NISKozoFN-TocyxOlw1JtE,5524
 vectordb_bench/backend/dataset.py,sha256=V4OKPt23v0kmdvgJwDr_R2fLJv3lXLZEii992cEM2Q0,8993
 vectordb_bench/backend/result_collector.py,sha256=mpROVdZ-HChKBVyMV5TZ5v7YGRb69bvfT7Gezn5F5sY,819
-vectordb_bench/backend/task_runner.py,sha256=VIyyMG2NCyzK_aJvZX5UxtW_YcEulC9EbHp5pmsCRuk,12244
+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=GWBOsRsYULH4V9aA078iB0cHAMkODoWPiYlrZYG2s5o,7998
-vectordb_bench/backend/clients/api.py,sha256=74yDDCFNJegNZSmWTNtLc9moPpGLa0vVVJfFuVgDWUY,6229
+vectordb_bench/backend/clients/__init__.py,sha256=YvXoI8CS69WOTLl5n858xkRReeqiiRFBETZAAnD14qg,8212
+vectordb_bench/backend/clients/api.py,sha256=uQaX_FiMFlD3z_91awUzB-qtBkvyDsMKE8ks5bBgJSY,6233
 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=GI8v59ntuy6f8C2wxz_EoCTcWvgxmgcCN7WBu7caL64,13385
+vectordb_bench/backend/clients/aliyun_opensearch/aliyun_opensearch.py,sha256=rwa4rtbbP2Kaczh7Bf0bc_lE_sGG5w9PhtfdFu7rQNs,13237
 vectordb_bench/backend/clients/aliyun_opensearch/config.py,sha256=KSiuRu-p7oL2PEukfD6SvYCKg1jTVvro9lMcUnQSN6I,1214
-vectordb_bench/backend/clients/alloydb/alloydb.py,sha256=ehMwguVtzxaRAgyoY-bS7TNPD87M4rqExZgbaRPkB_g,13022
+vectordb_bench/backend/clients/alloydb/alloydb.py,sha256=E24hxCUgpBCRiScdcS_iBk8n0wngUgVg8qujOWiUhw0,13009
 vectordb_bench/backend/clients/alloydb/cli.py,sha256=G6Q0WApoDXDG_pqmK2lEKFIvKB8qAsZFPM8TfsURydE,5086
 vectordb_bench/backend/clients/alloydb/config.py,sha256=PJs2wIJqwcG6UJ3T8R7Pi3xTMBfxTZiNkcWyhtHv5dc,5313
-vectordb_bench/backend/clients/aws_opensearch/aws_opensearch.py,sha256=dLRuK-LN247CTW3pQ7qKrUzH3VFlZjoAZCGGhs3hC4k,7611
+vectordb_bench/backend/clients/aws_opensearch/aws_opensearch.py,sha256=PAFP5W6k0GxbpvvIFs8u3pMi7x-sLw9cm4mUsM2agws,7541
 vectordb_bench/backend/clients/aws_opensearch/cli.py,sha256=845dUYcD5m9j9FNOCXAspgCkvOKWWJXt2k87I55Odbs,1301
 vectordb_bench/backend/clients/aws_opensearch/config.py,sha256=XsQBKGBPR0lqH3XrQpijwgt9Tfb6KBVg35x2L9LQQMw,1881
 vectordb_bench/backend/clients/aws_opensearch/run.py,sha256=Ry5aAlielWjq0hx7LnbdShfOwzZhz3Gq9WYu5U43x9s,5001
-vectordb_bench/backend/clients/chroma/chroma.py,sha256=_JpLaCu5SXJMSJzuR2UZheP1AGfzBkMYKAH_WxaU8Rs,3638
+vectordb_bench/backend/clients/chroma/chroma.py,sha256=TGsmAnG5I3bbIjJ5L7ktke6fD8lOrx56Wt2tMCb3dY8,3609
 vectordb_bench/backend/clients/chroma/config.py,sha256=8nXpPdecQ5HrNqcsQwAVgacSz6uLgI-BI7v4tB8CeDk,347
 vectordb_bench/backend/clients/elastic_cloud/config.py,sha256=_5Cz3__CbMU7zCizkhK1pGhH3TLJacn8efVueUZ0lnQ,1573
-vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py,sha256=51yiwuW9eRH4t44we0qGF3YvhfEmKB8-T78ueUPsh7E,5513
-vectordb_bench/backend/clients/memorydb/cli.py,sha256=AIjkKTu7L4UFGbrtUeqx7mFC5_-6F1jjzuhQy0oYHa0,2661
+vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py,sha256=juWDlWt-eDd9WZEw35Q4WKvfW1pmNaFXdWjK4UveyyA,5443
+vectordb_bench/backend/clients/memorydb/cli.py,sha256=mUpBN0VoE6M55AAEwyd20uEtPkOpckJzmcP2XXpue30,2659
 vectordb_bench/backend/clients/memorydb/config.py,sha256=D2Q-HkDwnmz98ek1e_iNu4o9CIRB14pOQWSZgRvd6oY,1500
-vectordb_bench/backend/clients/memorydb/memorydb.py,sha256=dX_5Rm3t_B5M439QA8aOgUW0dNn4OoaigHpTT_Ex9fY,10248
+vectordb_bench/backend/clients/memorydb/memorydb.py,sha256=WrZhDYJqpwN173sk2lmPnOibHcQCPrq_PEAMFcL62U4,10219
 vectordb_bench/backend/clients/milvus/cli.py,sha256=xGvYYKOAs32vz78oB5Ks_xnWIMzcl_f7TPEPRk94FeQ,8895
 vectordb_bench/backend/clients/milvus/config.py,sha256=oFZ5VG5UHws161M1cYmMr2b9NSEoqwwst998T59QGQo,7520
-vectordb_bench/backend/clients/milvus/milvus.py,sha256=yhIvmUPVf16BZSQ-y7xTxplbXjJrxO7T5HR4bMP0Jdo,7509
+vectordb_bench/backend/clients/milvus/milvus.py,sha256=xdVVjMnBzD5KGJ7iUB-B3SuTL4JDW1UD15QBevExMLw,6862
 vectordb_bench/backend/clients/pgdiskann/cli.py,sha256=o5ddAp1Be2TOnm8Wh9IyIWUxdnw5N6v92Ms1s6CEwBo,3135
 vectordb_bench/backend/clients/pgdiskann/config.py,sha256=DBsVgLn4edl-irSlP_GV7KW-8jFemns_ujR_CuVnQtE,4412
-vectordb_bench/backend/clients/pgdiskann/pgdiskann.py,sha256=VNI2rdtkz0YS94YyakBix9wterHDCDI8rU0AVLW0SuI,12312
+vectordb_bench/backend/clients/pgdiskann/pgdiskann.py,sha256=Z8K74Y6uMi6q8gnnD68doBxc5pWBSpRnNLDhlifseH4,12299
 vectordb_bench/backend/clients/pgvecto_rs/cli.py,sha256=n0cMbUrGS2jzCpusVExxRDJb3iUzWblkeNmuRzLPmoE,4686
 vectordb_bench/backend/clients/pgvecto_rs/config.py,sha256=jWs3078s5chH37O94zSHoQ98ptLTYiJeHiLy6BQgTE4,4725
-vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py,sha256=eABNe74U0p5Sauk1p2Ej6xbeEftP42j56TjybBKt80I,9925
+vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py,sha256=ZSOPpQjLtWxpQz7-R24X-e2oVLHJsZeEmaOzfd5pELA,9828
 vectordb_bench/backend/clients/pgvector/cli.py,sha256=aeuYMRIVWgR_rRkuEa_hU6_e0J5y43pxiprInQ_OrGg,6229
 vectordb_bench/backend/clients/pgvector/config.py,sha256=llLdn5y9NtK24tzT9bqbJmIaDYxkg_BqPbedoW5nfH0,8924
-vectordb_bench/backend/clients/pgvector/pgvector.py,sha256=pZAlzdfhJzP9KYqeGlWoPW_8idR-kaiwRI5P9OLRJcA,18631
+vectordb_bench/backend/clients/pgvector/pgvector.py,sha256=-KNqr57bmeUeeNO72IN6nzop79Pp1Emn-MmqvdE1rNk,18587
 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=Ajo339JWpWH6enCMcb0rl76msPXWXf-uoDXRHxdtbfs,10180
+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=Ko9eFODiBIyOrVYCq-3xBCUtx1uuWsOUvOTypYuCs0g,3599
+vectordb_bench/backend/clients/pinecone/pinecone.py,sha256=9uxAp3KgofaFMoosnbqwP4CUkbn4kNplhtho-IDEqB4,3586
 vectordb_bench/backend/clients/qdrant_cloud/config.py,sha256=81eRgFNJJy7oe-FreNv7RzhAfyd-_19REbVcW-hJTt4,1348
-vectordb_bench/backend/clients/qdrant_cloud/qdrant_cloud.py,sha256=n50L2-yyf6iQLnG27wSD7Ww3R2MZ2qFZv8OL9b4WeYU,5441
+vectordb_bench/backend/clients/qdrant_cloud/qdrant_cloud.py,sha256=fh-FP6661Siz6oynL1K5Tf-Y_tTw4bVs02RHCBMyhmY,5426
 vectordb_bench/backend/clients/redis/cli.py,sha256=tFLXzNyvh_GYUZihqMvj65C5vBKPVVAYIXtbzGaVCcU,2167
 vectordb_bench/backend/clients/redis/config.py,sha256=xVSVC6xjjAKsiwJuJoLguCGhiiUT9w13Db_Up5ZqljY,1241
-vectordb_bench/backend/clients/redis/redis.py,sha256=QYbULIehrZ-6SIs20vTCS1wMcd3REKcgXkwlXo88rcY,6798
-vectordb_bench/backend/clients/test/cli.py,sha256=ro7RRQ63horo68Xgn0g7IPxH40I7o7D8je0Mf42KV20,548
+vectordb_bench/backend/clients/redis/redis.py,sha256=39-JfyMQp584jLN5ltCKqyB-sNwC18VICd6Z1XpJNMg,6769
+vectordb_bench/backend/clients/test/cli.py,sha256=NqvX7Rl6iEzAcvdy4VXOier-bOp0N3yVQ84rQOKjZEo,543
 vectordb_bench/backend/clients/test/config.py,sha256=_Eufl8g9EYBUlUw-6vNf4b4FK2KM2u9a41cz7n08QI8,390
-vectordb_bench/backend/clients/test/test.py,sha256=JESJ7GFBzlxTtQI-2RJobJTJ5Jmxm7CzxstfhnxGWSo,1399
+vectordb_bench/backend/clients/test/test.py,sha256=p8ZJ9PPQOPMc3fgtZpMMw3LROOk3VGWY-1j81NkCi8Q,1363
 vectordb_bench/backend/clients/weaviate_cloud/cli.py,sha256=Cy9epFJgeImVa3STogZhEyFAePjCZ7LY_iDu8nRpiME,1047
 vectordb_bench/backend/clients/weaviate_cloud/config.py,sha256=kLSxWFtEr12WCF610SBGWyVRzXbgnO0PsftNPSIiBMM,1245
-vectordb_bench/backend/clients/weaviate_cloud/weaviate_cloud.py,sha256=1OLS5A_ZszFeBxPOSkLHM7xwD6yxy9nd6waEqVQ46yg,5241
+vectordb_bench/backend/clients/weaviate_cloud/weaviate_cloud.py,sha256=OZifz7ZzUzMFqdx2QUgI9QG9bMrYjNo6cFFyzGe4-LU,5190
 vectordb_bench/backend/clients/zilliz_cloud/cli.py,sha256=3_eD3ZG-FeTw1cenhbBFniPnVLgT_UQwdIuGmGDroJw,1551
 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=22jySJFd7u1Ee1QfpA8N_pltZvx9MChwEuKphbisS-c,10118
-vectordb_bench/backend/runner/rate_runner.py,sha256=GluVVBl8a-LrSlaVvs4UjiHgaxL3UQ-IvjAxOtANnO4,4310
-vectordb_bench/backend/runner/read_write_runner.py,sha256=ItnajqPbpv82IfF8pZVk4NJi5l28rN8tbem6R2v1R2I,7866
-vectordb_bench/backend/runner/serial_runner.py,sha256=hey6X7HweiUIgdu5er_8Oqxvhq7frezc50ikIAzwoxc,10281
+vectordb_bench/backend/runner/mp_runner.py,sha256=AJHrQmUADDWDQZ0eZ4aaAH9HOQtZHiafXJYGU5PNq3Y,9645
+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=URymqOy-9NdVE3kXWBW3e9R0Oh2sG9zF1vJkV7sk48E,10092
 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=-BXRfiWzW6KjBF7d-6Lw7RexPktERm1pcwJqgetSX0c,15275
@@ -127,9 +127,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.20.dist-info/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
-vectordb_bench-0.0.20.dist-info/METADATA,sha256=XlLpjF9OvIO2y9xO_kpH1_kMbAUSdGvUNTYtPTjHW_8,34577
-vectordb_bench-0.0.20.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-vectordb_bench-0.0.20.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
-vectordb_bench-0.0.20.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
-vectordb_bench-0.0.20.dist-info/RECORD,,
+vectordb_bench-0.0.21.dist-info/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-0.0.21.dist-info/METADATA,sha256=SDCFG-7cwQRoLe3mrvjCQNslK1Ju8aw0VQ_Kc8408hw,34577
+vectordb_bench-0.0.21.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+vectordb_bench-0.0.21.dist-info/entry_points.txt,sha256=Qzw6gVx96ui8esG21H6yHsI6nboEohRmV424TYhQNrA,113
+vectordb_bench-0.0.21.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-0.0.21.dist-info/RECORD,,