vectordb-bench 0.0.8__py3-none-any.whl → 0.0.9__py3-none-any.whl

vectordb_bench/backend/clients/api.py

@@ -20,6 +20,7 @@ class IndexType(str, Enum):
     Flat = "FLAT"
     AUTOINDEX = "AUTOINDEX"
     ES_HNSW = "hnsw"
+    ES_IVFFlat = "ivfflat"
     GPU_IVF_FLAT = "GPU_IVF_FLAT"
     GPU_IVF_PQ = "GPU_IVF_PQ"
     GPU_CAGRA = "GPU_CAGRA"

vectordb_bench/backend/clients/milvus/milvus.py

@@ -89,6 +89,7 @@ class Milvus(VectorDB):
         connections.disconnect("default")
 
     def _optimize(self):
+        self._post_insert()
         log.info(f"{self.name} optimizing before search")
         try:
             self.col.load()
@@ -116,7 +117,7 @@ class Milvus(VectorDB):
                     time.sleep(5)
 
             wait_index()
-            
+
             # Skip compaction if use GPU indexType
             if self.case_config.index in [IndexType.GPU_CAGRA, IndexType.GPU_IVF_FLAT, IndexType.GPU_IVF_PQ]:
                 log.debug("skip compaction for gpu index type.")
@@ -179,8 +180,6 @@ class Milvus(VectorDB):
                 ]
                 res = self.col.insert(insert_data)
                 insert_count += len(res.primary_keys)
-            if kwargs.get("last_batch"):
-                self._post_insert()
         except MilvusException as e:
             log.info(f"Failed to insert data: {e}")
             return (insert_count, e)

vectordb_bench/backend/clients/pgvector/config.py

@@ -1,29 +1,62 @@
+from abc import abstractmethod
+from typing import Any, Mapping, Optional, Sequence, TypedDict
 from pydantic import BaseModel, SecretStr
-from ..api import DBConfig, DBCaseConfig, IndexType, MetricType
+from typing_extensions import LiteralString
+from ..api import DBCaseConfig, DBConfig, IndexType, MetricType
 
 POSTGRE_URL_PLACEHOLDER = "postgresql://%s:%s@%s/%s"
 
+
+class PgVectorConfigDict(TypedDict):
+    """These keys will be directly used as kwargs in psycopg connection string,
+        so the names must match exactly psycopg API"""
+
+    user: str
+    password: str
+    host: str
+    port: int
+    dbname: str
+
+
 class PgVectorConfig(DBConfig):
-    user_name: SecretStr = "postgres"
+    user_name: SecretStr = SecretStr("postgres")
     password: SecretStr
     host: str = "localhost"
     port: int = 5432
     db_name: str
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> PgVectorConfigDict:
         user_str = self.user_name.get_secret_value()
         pwd_str = self.password.get_secret_value()
         return {
-            "host" : self.host,
-            "port" : self.port,
-            "dbname" : self.db_name,
-            "user" : user_str,
-            "password" : pwd_str
+            "host": self.host,
+            "port": self.port,
+            "dbname": self.db_name,
+            "user": user_str,
+            "password": pwd_str,
         }
 
+
+class PgVectorIndexParam(TypedDict):
+    metric: str
+    index_type: str
+    index_creation_with_options: Sequence[dict[str, Any]]
+    maintenance_work_mem: Optional[str]
+    max_parallel_workers: Optional[int]
+
+
+class PgVectorSearchParam(TypedDict):
+    metric_fun_op: LiteralString
+
+
+class PgVectorSessionCommands(TypedDict):
+    session_options: Sequence[dict[str, Any]]
+
+
 class PgVectorIndexConfig(BaseModel, DBCaseConfig):
     metric_type: MetricType | None = None
-    index: IndexType
+    create_index_before_load: bool = False
+    create_index_after_load: bool = True
 
     def parse_metric(self) -> str:
         if self.metric_type == MetricType.L2:
@@ -32,7 +65,7 @@ class PgVectorIndexConfig(BaseModel, DBCaseConfig):
             return "vector_ip_ops"
         return "vector_cosine_ops"
 
-    def parse_metric_fun_op(self) -> str:
+    def parse_metric_fun_op(self) -> LiteralString:
         if self.metric_type == MetricType.L2:
             return "<->"
         elif self.metric_type == MetricType.IP:
@@ -46,55 +79,137 @@ class PgVectorIndexConfig(BaseModel, DBCaseConfig):
             return "max_inner_product"
         return "cosine_distance"
 
-
-
-class HNSWConfig(PgVectorIndexConfig):
-    M: int
-    efConstruction: int
-    ef: int | None = None
-    index: IndexType = IndexType.HNSW
-
-    def index_param(self) -> dict:
+    @abstractmethod
+    def index_param(self) -> PgVectorIndexParam:
+        ...
+
+    @abstractmethod
+    def search_param(self) -> PgVectorSearchParam:
+        ...
+
+    @abstractmethod
+    def session_param(self) -> PgVectorSessionCommands:
+        ...
+
+    @staticmethod
+    def _optionally_build_with_options(with_options: Mapping[str, Any]) -> Sequence[dict[str, Any]]:
+        """Walk through mappings, creating a List of {key1 = value} pairs. That will be used to build a where clause"""
+        options = []
+        for option_name, value in with_options.items():
+            if value is not None:
+                options.append(
+                    {
+                        "option_name": option_name,
+                        "val": str(value),
+                    }
+                )
+        return options
+
+    @staticmethod
+    def _optionally_build_set_options(
+        set_mapping: Mapping[str, Any]
+    ) -> Sequence[dict[str, Any]]:
+        """Walk through options, creating 'SET 'key1 = "value1";' commands"""
+        session_options = []
+        for setting_name, value in set_mapping.items():
+            if value:
+                session_options.append(
+                    {"parameter": {
+                            "setting_name": setting_name,
+                            "val": str(value),
+                        },
+                    }
+                )
+        return session_options
+
+
+class PgVectorIVFFlatConfig(PgVectorIndexConfig):
+    """
+    An IVFFlat index divides vectors into lists, and then searches a subset of those lists that are
+    closest to the query vector. It has faster build times and uses less memory than HNSW,
+    but has lower query performance (in terms of speed-recall tradeoff).
+
+    Three keys to achieving good recall are:
+
+    Create the index after the table has some data
+    Choose an appropriate number of lists - a good place to start is rows / 1000 for up to 1M rows and sqrt(rows) for
+    over 1M rows.
+    When querying, specify an appropriate number of probes (higher is better for recall, lower is better for speed) -
+    a good place to start is sqrt(lists)
+    """
+
+    lists: int | None
+    probes: int | None
+    index: IndexType = IndexType.ES_IVFFlat
+    maintenance_work_mem: Optional[str] = None
+    max_parallel_workers: Optional[int] = None
+
+    def index_param(self) -> PgVectorIndexParam:
+        index_parameters = {"lists": self.lists}
         return {
-            "metric_type": self.parse_metric(),
+            "metric": self.parse_metric(),
             "index_type": self.index.value,
-            "params": {"M": self.M, "efConstruction": self.efConstruction},
+            "index_creation_with_options": self._optionally_build_with_options(
+                index_parameters
+            ),
+            "maintenance_work_mem": self.maintenance_work_mem,
+            "max_parallel_workers": self.max_parallel_workers,
         }
 
-    def index_param(self) -> dict:
+    def search_param(self) -> PgVectorSearchParam:
         return {
-            "m" : self.M,
-            "efConstruction" : self.efConstruction,
-            "metric" : self.parse_metric()
+            "metric_fun_op": self.parse_metric_fun_op(),
         }
 
-    def search_param(self) -> dict:
+    def session_param(self) -> PgVectorSessionCommands:
+        session_parameters = {"ivfflat.probes": self.probes}
         return {
-            "ef" : self.ef,
-            "metric_fun" : self.parse_metric_fun_str(),
-            "metric_fun_op" : self.parse_metric_fun_op(),
+            "session_options": self._optionally_build_set_options(session_parameters)
         }
 
 
-class IVFFlatConfig(PgVectorIndexConfig):
-    lists: int | None = 1000
-    probes: int | None = 10
-    index: IndexType = IndexType.IVFFlat
+class PgVectorHNSWConfig(PgVectorIndexConfig):
+    """
+    An HNSW index creates a multilayer graph. It has better query performance than IVFFlat (in terms of
+    speed-recall tradeoff), but has slower build times and uses more memory. Also, an index can be
+    created without any data in the table since there isn't a training step like IVFFlat.
+    """
+
+    m: int | None  # DETAIL:  Valid values are between "2" and "100".
+    ef_construction: (
+        int | None
+    )  # ef_construction must be greater than or equal to 2 * m
+    ef_search: int | None
+    index: IndexType = IndexType.ES_HNSW
+    maintenance_work_mem: Optional[str] = None
+    max_parallel_workers: Optional[int] = None
+
+    def index_param(self) -> PgVectorIndexParam:
+        index_parameters = {"m": self.m, "ef_construction": self.ef_construction}
+        return {
+            "metric": self.parse_metric(),
+            "index_type": self.index.value,
+            "index_creation_with_options": self._optionally_build_with_options(
+                index_parameters
+            ),
+            "maintenance_work_mem": self.maintenance_work_mem,
+            "max_parallel_workers": self.max_parallel_workers,
+        }
 
-    def index_param(self) -> dict:
+    def search_param(self) -> PgVectorSearchParam:
         return {
-            "lists" : self.lists,
-            "metric" : self.parse_metric()
+            "metric_fun_op": self.parse_metric_fun_op(),
         }
 
-    def search_param(self) -> dict:
+    def session_param(self) -> PgVectorSessionCommands:
+        session_parameters = {"hnsw.ef_search": self.ef_search}
         return {
-            "probes" : self.probes,
-            "metric_fun" : self.parse_metric_fun_str(),
-            "metric_fun_op" : self.parse_metric_fun_op(),
+            "session_options": self._optionally_build_set_options(session_parameters)
         }
 
+
 _pgvector_case_config = {
-    IndexType.HNSW: HNSWConfig,
-    IndexType.IVFFlat: IVFFlatConfig,
+        IndexType.HNSW: PgVectorHNSWConfig,
+        IndexType.ES_HNSW: PgVectorHNSWConfig,
+        IndexType.IVFFlat: PgVectorIVFFlatConfig,
 }

vectordb_bench/backend/clients/pgvector/pgvector.py

@@ -1,25 +1,36 @@
 """Wrapper around the Pgvector vector database over VectorDB"""
 
-import io
 import logging
+import pprint
 from contextlib import contextmanager
-from typing import Any
-import pandas as pd
-import psycopg2
-import psycopg2.extras
+from typing import Any, Generator, Optional, Tuple, Sequence
 
-from ..api import IndexType, VectorDB, DBCaseConfig
+import numpy as np
+import psycopg
+from pgvector.psycopg import register_vector
+from psycopg import Connection, Cursor, sql
+
+from ..api import VectorDB
+from .config import PgVectorConfigDict, PgVectorIndexConfig
+
+log = logging.getLogger(__name__)
 
-log = logging.getLogger(__name__) 
 
 class PgVector(VectorDB):
-    """ Use SQLAlchemy instructions"""
+    """Use psycopg instructions"""
+
+    conn: psycopg.Connection[Any] | None = None
+    cursor: psycopg.Cursor[Any] | None = None
+
+    # TODO add filters support
+    _unfiltered_search: sql.Composed
+
     def __init__(
         self,
         dim: int,
-        db_config: dict,
-        db_case_config: DBCaseConfig,
-        collection_name: str = "PgVectorCollection",
+        db_config: PgVectorConfigDict,
+        db_case_config: PgVectorIndexConfig,
+        collection_name: str = "pg_vector_collection",
         drop_old: bool = False,
         **kwargs,
     ):
@@ -29,44 +40,89 @@ class PgVector(VectorDB):
         self.table_name = collection_name
         self.dim = dim
 
-        self._index_name = "pqvector_index"
+        self._index_name = "pgvector_index"
         self._primary_field = "id"
         self._vector_field = "embedding"
 
         # construct basic units
-        self.conn = psycopg2.connect(**self.db_config)
-        self.conn.autocommit = False
-        self.cursor = self.conn.cursor() 
-        
+        self.conn, self.cursor = self._create_connection(**self.db_config)
+
         # create vector extension
-        self.cursor.execute('CREATE EXTENSION IF NOT EXISTS vector')
+        self.cursor.execute("CREATE EXTENSION IF NOT EXISTS vector")
         self.conn.commit()
-        
-        if drop_old :
-            log.info(f"Pgvector client drop table : {self.table_name}")
+
+        log.info(f"{self.name} config values: {self.db_config}\n{self.case_config}")
+        if not any(
+            (
+                self.case_config.create_index_before_load,
+                self.case_config.create_index_after_load,
+            )
+        ):
+            err = f"{self.name} config must create an index using create_index_before_load and/or create_index_after_load"
+            log.error(err)
+            raise RuntimeError(
+                f"{err}\n{pprint.pformat(self.db_config)}\n{pprint.pformat(self.case_config)}"
+            )
+
+        if drop_old:
             # self.pg_table.drop(pg_engine, checkfirst=True)
             self._drop_index()
             self._drop_table()
             self._create_table(dim)
-            self._create_index()
-        
+            if self.case_config.create_index_before_load:
+                self._create_index()
+
         self.cursor.close()
         self.conn.close()
         self.cursor = None
         self.conn = None
 
+    @staticmethod
+    def _create_connection(**kwargs) -> Tuple[Connection, Cursor]:
+        conn = psycopg.connect(**kwargs)
+        register_vector(conn)
+        conn.autocommit = False
+        cursor = conn.cursor()
+
+        assert conn is not None, "Connection is not initialized"
+        assert cursor is not None, "Cursor is not initialized"
+
+        return conn, cursor
+
     @contextmanager
-    def init(self) -> None:
+    def init(self) -> Generator[None, None, None]:
         """
         Examples:
             >>> with self.init():
             >>>     self.insert_embeddings()
             >>>     self.search_embedding()
         """
-        self.conn = psycopg2.connect(**self.db_config)
-        self.conn.autocommit = False
-        self.cursor = self.conn.cursor()
-        
+
+        self.conn, self.cursor = self._create_connection(**self.db_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"]
+
+        if len(session_options) > 0:
+            for setting in session_options:
+                command = sql.SQL("SET {setting_name} " + "= {val};").format(
+                    setting_name=sql.Identifier(setting['parameter']['setting_name']),
+                    val=sql.Identifier(str(setting['parameter']['val'])),
+                )
+                log.debug(command.as_string(self.cursor))
+                self.cursor.execute(command)
+            self.conn.commit()
+
+        self._unfiltered_search = sql.Composed(
+            [
+                sql.SQL("SELECT id FROM public.{} ORDER BY embedding ").format(
+                    sql.Identifier(self.table_name)
+                ),
+                sql.SQL(self.case_config.search_param()["metric_fun_op"]),
+                sql.SQL(" %s::vector LIMIT %s::int"),
+            ]
+        )
+
         try:
             yield
         finally:
@@ -74,61 +130,170 @@ class PgVector(VectorDB):
             self.conn.close()
             self.cursor = None
             self.conn = None
-    
+
     def _drop_table(self):
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
-        
-        self.cursor.execute(f'DROP TABLE IF EXISTS public."{self.table_name}"')
+        log.info(f"{self.name} client drop table : {self.table_name}")
+
+        self.cursor.execute(
+            sql.SQL("DROP TABLE IF EXISTS public.{table_name}").format(
+                table_name=sql.Identifier(self.table_name)
+            )
+        )
         self.conn.commit()
-    
+
     def ready_to_load(self):
         pass
 
     def optimize(self):
-        pass
-    
+        self._post_insert()
+
     def _post_insert(self):
         log.info(f"{self.name} post insert before optimize")
-        self._drop_index()
-        self._create_index()
+        if self.case_config.create_index_after_load:
+            self._drop_index()
+            self._create_index()
 
-    def ready_to_search(self):
-        pass
-        
     def _drop_index(self):
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
-        
-        self.cursor.execute(f'DROP INDEX IF EXISTS "{self._index_name}"')
+        log.info(f"{self.name} client drop index : {self._index_name}")
+
+        drop_index_sql = sql.SQL("DROP INDEX IF EXISTS {index_name}").format(
+            index_name=sql.Identifier(self._index_name)
+        )
+        log.debug(drop_index_sql.as_string(self.cursor))
+        self.cursor.execute(drop_index_sql)
         self.conn.commit()
-    
+
+    def _set_parallel_index_build_param(self):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        index_param = self.case_config.index_param()
+
+        if index_param["maintenance_work_mem"] is not None:
+            self.cursor.execute(
+                sql.SQL("SET maintenance_work_mem TO {};").format(
+                    index_param["maintenance_work_mem"]
+                )
+            )
+            self.cursor.execute(
+                sql.SQL("ALTER USER {} SET maintenance_work_mem TO {};").format(
+                    sql.Identifier(self.db_config["user"]),
+                    index_param["maintenance_work_mem"],
+                )
+            )
+            self.conn.commit()
+
+        if index_param["max_parallel_workers"] is not None:
+            self.cursor.execute(
+                sql.SQL("SET max_parallel_maintenance_workers TO '{}';").format(
+                    index_param["max_parallel_workers"]
+                )
+            )
+            self.cursor.execute(
+                sql.SQL(
+                    "ALTER USER {} SET max_parallel_maintenance_workers TO '{}';"
+                ).format(
+                    sql.Identifier(self.db_config["user"]),
+                    index_param["max_parallel_workers"],
+                )
+            )
+            self.cursor.execute(
+                sql.SQL("SET max_parallel_workers TO '{}';").format(
+                    index_param["max_parallel_workers"]
+                )
+            )
+            self.cursor.execute(
+                sql.SQL(
+                    "ALTER USER {} SET max_parallel_workers TO '{}';"
+                ).format(
+                    sql.Identifier(self.db_config["user"]),
+                    index_param["max_parallel_workers"],
+                )
+            )
+            self.cursor.execute(
+                sql.SQL(
+                    "ALTER TABLE {} SET (parallel_workers = {});"
+                ).format(
+                    sql.Identifier(self.table_name),
+                    index_param["max_parallel_workers"],
+                )
+            )
+            self.conn.commit()
+
+        results = self.cursor.execute(
+            sql.SQL("SHOW max_parallel_maintenance_workers;")
+        ).fetchall()
+        results.extend(
+            self.cursor.execute(sql.SQL("SHOW max_parallel_workers;")).fetchall()
+        )
+        results.extend(
+            self.cursor.execute(sql.SQL("SHOW maintenance_work_mem;")).fetchall()
+        )
+        log.info(f"{self.name} parallel index creation parameters: {results}")
+
     def _create_index(self):
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
-        
+        log.info(f"{self.name} client create index : {self._index_name}")
+
         index_param = self.case_config.index_param()
-        if self.case_config.index == IndexType.HNSW:
-            log.debug(f'Creating HNSW index. m={index_param["m"]}, ef_construction={index_param["ef_construction"]}')
-            self.cursor.execute(f'CREATE INDEX IF NOT EXISTS {self._index_name} ON public."{self.table_name}" USING hnsw (embedding {index_param["metric"]}) WITH (m={index_param["m"]}, ef_construction={index_param["ef_construction"]});')
-        elif self.case_config.index == IndexType.IVFFlat:
-            log.debug(f'Creating IVFFLAT index. list={index_param["lists"]}')
-            self.cursor.execute(f'CREATE INDEX IF NOT EXISTS {self._index_name} ON public."{self.table_name}" USING ivfflat (embedding {index_param["metric"]}) WITH (lists={index_param["lists"]});')
+        self._set_parallel_index_build_param()
+        options = []
+        for option in index_param["index_creation_with_options"]:
+            if option['val'] is not None:
+                options.append(
+                    sql.SQL("{option_name} = {val}").format(
+                        option_name=sql.Identifier(option['option_name']),
+                        val=sql.Identifier(str(option['val'])),
+                    )
+                )
+        if any(options):
+            with_clause = sql.SQL("WITH ({});").format(sql.SQL(", ").join(options))
         else:
-            assert "Invalid index type {self.case_config.index}"
+            with_clause = sql.Composed(())
+
+        index_create_sql = sql.SQL(
+            "CREATE INDEX IF NOT EXISTS {index_name} ON public.{table_name} USING {index_type} (embedding {embedding_metric})"
+        ).format(
+            index_name=sql.Identifier(self._index_name),
+            table_name=sql.Identifier(self.table_name),
+            index_type=sql.Identifier(index_param["index_type"]),
+            embedding_metric=sql.Identifier(index_param["metric"]),
+        )
+        index_create_sql_with_with_clause = (
+            index_create_sql + with_clause
+        ).join(" ")
+        log.debug(index_create_sql_with_with_clause.as_string(self.cursor))
+        self.cursor.execute(index_create_sql_with_with_clause)
         self.conn.commit()
-        
-    def _create_table(self, dim : int):
+
+    def _create_table(self, dim: int):
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
-        
+
         try:
+            log.info(f"{self.name} client create table : {self.table_name}")
+
             # create table
-            self.cursor.execute(f'CREATE TABLE IF NOT EXISTS public."{self.table_name}" (id BIGINT PRIMARY KEY, embedding vector({dim}));')
-            self.cursor.execute(f'ALTER TABLE public."{self.table_name}" ALTER COLUMN embedding SET STORAGE PLAIN;')
+            self.cursor.execute(
+                sql.SQL(
+                    "CREATE TABLE IF NOT EXISTS public.{table_name} (id BIGINT PRIMARY KEY, embedding vector({dim}));"
+                ).format(table_name=sql.Identifier(self.table_name), dim=dim)
+            )
+            self.cursor.execute(
+                sql.SQL(
+                    "ALTER TABLE public.{table_name} ALTER COLUMN embedding SET STORAGE PLAIN;"
+                ).format(table_name=sql.Identifier(self.table_name))
+            )
             self.conn.commit()
         except Exception as e:
-            log.warning(f"Failed to create pgvector table: {self.table_name} error: {e}")
+            log.warning(
+                f"Failed to create pgvector table: {self.table_name} error: {e}"
+            )
             raise e from None
 
     def insert_embeddings(
@@ -136,31 +301,35 @@ class PgVector(VectorDB):
         embeddings: list[list[float]],
         metadata: list[int],
         **kwargs: Any,
-    ) -> (int, Exception):
+    ) -> Tuple[int, Optional[Exception]]:
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
 
         try:
-            items = {
-                "id": metadata,
-                "embedding": embeddings
-            }
-            df = pd.DataFrame(items)
-            csv_buffer = io.StringIO()
-            df.to_csv(csv_buffer, index=False, header=False)
-            csv_buffer.seek(0)
-            self.cursor.copy_expert(f"COPY public.\"{self.table_name}\" FROM STDIN WITH (FORMAT CSV)", csv_buffer)
+            metadata_arr = np.array(metadata)
+            embeddings_arr = np.array(embeddings)
+
+            with self.cursor.copy(
+                sql.SQL("COPY public.{table_name} FROM STDIN (FORMAT BINARY)").format(
+                    table_name=sql.Identifier(self.table_name)
+                )
+            ) as copy:
+                copy.set_types(["bigint", "vector"])
+                for i, row in enumerate(metadata_arr):
+                    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}")   
+            log.warning(
+                f"Failed to insert data into pgvector table ({self.table_name}), error: {e}"
+            )
             return 0, e
 
-    def search_embedding(        
+    def search_embedding(
         self,
         query: list[float],
         k: int = 100,
@@ -170,18 +339,9 @@ class PgVector(VectorDB):
         assert self.conn is not None, "Connection is not initialized"
         assert self.cursor is not None, "Cursor is not initialized"
 
-        search_param =self.case_config.search_param()
-
-        if self.case_config.index == IndexType.HNSW:
-            self.cursor.execute(f'SET hnsw.ef_search = {search_param["ef"]}')
-            self.cursor.execute(f"SELECT id FROM public.\"{self.table_name}\" ORDER BY embedding {search_param['metric_fun_op']} '{query}' LIMIT {k};")
-        elif self.case_config.index == IndexType.IVFFlat:
-            self.cursor.execute(f'SET ivfflat.probes = {search_param["probes"]}')
-            self.cursor.execute(f"SELECT id FROM public.\"{self.table_name}\" ORDER BY embedding {search_param['metric_fun_op']} '{query}' LIMIT {k};")
-        else:
-            assert "Invalid index type {self.case_config.index}"
-        self.conn.commit()
-        result = self.cursor.fetchall()
+        # TODO add filters support
+        result = self.cursor.execute(
+            self._unfiltered_search, (query, k), prepare=True, binary=True
+        )
 
-        return [int(i[0]) for i in result]
-        
+        return [int(i[0]) for i in result.fetchall()]

vectordb_bench/backend/runner/serial_runner.py

@@ -46,11 +46,9 @@ class SerialInsertRunner:
                 del(emb_np)
                 log.debug(f"batch dataset size: {len(all_embeddings)}, {len(all_metadata)}")
 
-                last_batch = self.dataset.data.size - count == len(all_metadata)
                 insert_count, error = self.db.insert_embeddings(
                     embeddings=all_embeddings,
                     metadata=all_metadata,
-                    last_batch=last_batch,
                 )
                 if error is not None:
                     raise error

vectordb_bench/backend/task_runner.py

@@ -140,8 +140,8 @@ class CaseRunner(BaseModel):
                 )
 
             self._init_search_runner()
-            m.recall, m.serial_latency_p99 = self._serial_search()
             m.qps = self._conc_search()
+            m.recall, m.serial_latency_p99 = self._serial_search()
         except Exception as e:
             log.warning(f"Failed to run performance case, reason = {e}")
             traceback.print_exc()

vectordb_bench/frontend/components/run_test/caseSelector.py

@@ -65,25 +65,28 @@ def caseConfigSetting(st, allCaseConfigs, case, activedDbList):
                 key = "%s-%s-%s" % (db, case, config.label.value)
                 if config.inputType == InputType.Text:
                     caseConfig[config.label] = column.text_input(
-                        config.label.value,
+                        config.displayLabel if config.displayLabel else config.label.value,
                         key=key,
+                        help=config.inputHelp,
                         value=config.inputConfig["value"],
                     )
                 elif config.inputType == InputType.Option:
                     caseConfig[config.label] = column.selectbox(
-                        config.label.value,
+                        config.displayLabel if config.displayLabel else config.label.value,
                         config.inputConfig["options"],
                         key=key,
+                        help=config.inputHelp,
                     )
                 elif config.inputType == InputType.Number:
                     caseConfig[config.label] = column.number_input(
-                        config.label.value,
+                        config.displayLabel if config.displayLabel else config.label.value,
                         # format="%d",
                         step=config.inputConfig.get("step", 1),
                         min_value=config.inputConfig["min"],
                         max_value=config.inputConfig["max"],
                         key=key,
                         value=config.inputConfig["value"],
+                        help=config.inputHelp,
                     )
                 k += 1
         if k == 0:

vectordb_bench/frontend/const/dbCaseConfigs.py

@@ -49,6 +49,8 @@ class CaseConfigInput(BaseModel):
     label: CaseConfigParamType
     inputType: InputType = InputType.Text
     inputConfig: dict = {}
+    inputHelp: str = ""
+    displayLabel: str = ""
     # todo type should be a function
     isDisplayed: typing.Any = lambda x: True
 
@@ -71,6 +73,18 @@ CaseConfigParamInput_IndexType = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_IndexType_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.IndexType,
+    inputHelp="Select Index Type",
+    inputType=InputType.Option,
+    inputConfig={
+        "options": [
+            IndexType.HNSW.value,
+            IndexType.IVFFlat.value,
+        ],
+    },
+)
+
 CaseConfigParamInput_M = CaseConfigInput(
     label=CaseConfigParamType.M,
     inputType=InputType.Number,
@@ -83,6 +97,19 @@ CaseConfigParamInput_M = CaseConfigInput(
     == IndexType.HNSW.value,
 )
 
+CaseConfigParamInput_m = CaseConfigInput(
+    label=CaseConfigParamType.m,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 4,
+        "max": 64,
+        "value": 16,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.HNSW.value,
+)
+
+
 CaseConfigParamInput_EFConstruction_Milvus = CaseConfigInput(
     label=CaseConfigParamType.EFConstruction,
     inputType=InputType.Number,
@@ -115,6 +142,30 @@ CaseConfigParamInput_EFConstruction_ES = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_maintenance_work_mem_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.maintenance_work_mem,
+    inputHelp="Recommended value: 1.33x the index size, not to exceed the available free memory."
+              "Specify in gigabytes. e.g. 8GB",
+    inputType=InputType.Text,
+    inputConfig={
+        "value": "8GB",
+    },
+)
+
+CaseConfigParamInput_max_parallel_workers_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.max_parallel_workers,
+    displayLabel="Max parallel workers",
+    inputHelp="Recommended value: (cpu cores - 1). This will set the parameters: max_parallel_maintenance_workers,"
+              " max_parallel_workers & table(parallel_workers)",
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 0,
+        "max": 1024,
+        "value": 16,
+    },
+)
+
+
 CaseConfigParamInput_EFConstruction_PgVectoRS = CaseConfigInput(
     label=CaseConfigParamType.EFConstruction,
     inputType=InputType.Number,
@@ -127,6 +178,19 @@ CaseConfigParamInput_EFConstruction_PgVectoRS = CaseConfigInput(
     == IndexType.HNSW.value,
 )
 
+CaseConfigParamInput_EFConstruction_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.ef_construction,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 8,
+        "max": 1024,
+        "value": 256,
+    },
+    isDisplayed=lambda config: config[CaseConfigParamType.IndexType]
+    == IndexType.HNSW.value,
+)
+
+
 CaseConfigParamInput_M_ES = CaseConfigInput(
     label=CaseConfigParamType.M,
     inputType=InputType.Number,
@@ -379,6 +443,8 @@ CaseConfigParamInput_Lists = CaseConfigInput(
         "max": 65536,
         "value": 10,
     },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    in [IndexType.IVFFlat.value],
 )
 
 CaseConfigParamInput_Probes = CaseConfigInput(
@@ -391,6 +457,42 @@ CaseConfigParamInput_Probes = CaseConfigInput(
     },
 )
 
+CaseConfigParamInput_Lists_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.lists,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 1,
+        "max": 65536,
+        "value": 10,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.IVFFlat.value,
+)
+
+CaseConfigParamInput_Probes_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.probes,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 1,
+        "max": 65536,
+        "value": 1,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.IVFFlat.value,
+)
+
+CaseConfigParamInput_EFSearch_PgVector = CaseConfigInput(
+    label=CaseConfigParamType.ef_search,
+    inputType=InputType.Number,
+    inputConfig={
+        "min": 1,
+        "max": 2048,
+        "value": 256,
+    },
+    isDisplayed=lambda config: config.get(CaseConfigParamType.IndexType, None)
+    == IndexType.HNSW.value,
+)
+
 CaseConfigParamInput_QuantizationType_PgVectoRS = CaseConfigInput(
     label=CaseConfigParamType.quantizationType,
     inputType=InputType.Option,
@@ -479,8 +581,22 @@ ESPerformanceConfig = [
     CaseConfigParamInput_NumCandidates_ES,
 ]
 
-PgVectorLoadingConfig = [CaseConfigParamInput_Lists]
-PgVectorPerformanceConfig = [CaseConfigParamInput_Lists, CaseConfigParamInput_Probes]
+PgVectorLoadingConfig = [CaseConfigParamInput_IndexType_PgVector,
+                         CaseConfigParamInput_Lists_PgVector,
+                         CaseConfigParamInput_m,
+                         CaseConfigParamInput_EFConstruction_PgVector,
+                         CaseConfigParamInput_maintenance_work_mem_PgVector,
+                         CaseConfigParamInput_max_parallel_workers_PgVector,
+                         ]
+PgVectorPerformanceConfig = [CaseConfigParamInput_IndexType_PgVector,
+                             CaseConfigParamInput_m,
+                             CaseConfigParamInput_EFConstruction_PgVector,
+                             CaseConfigParamInput_EFSearch_PgVector,
+                             CaseConfigParamInput_Lists_PgVector,
+                             CaseConfigParamInput_Probes_PgVector,
+                             CaseConfigParamInput_maintenance_work_mem_PgVector,
+                             CaseConfigParamInput_max_parallel_workers_PgVector,
+                             ]
 
 PgVectoRSLoadingConfig = [
     CaseConfigParamInput_IndexType,

vectordb_bench/models.py

@@ -1,8 +1,8 @@
 import logging
 import pathlib
 from datetime import date
-from typing import Self
-from enum import Enum
+from enum import Enum, StrEnum, auto
+from typing import List, Self, Sequence, Set
 
 import ujson
 
@@ -37,8 +37,10 @@ class CaseConfigParamType(Enum):
     IndexType = "IndexType"
     M = "M"
     EFConstruction = "efConstruction"
+    ef_construction = "ef_construction"
     EF = "ef"
     SearchList = "search_list"
+    ef_search = "ef_search"
     Nlist = "nlist"
     Nprobe = "nprobe"
     MaxConnections = "maxConnections"
@@ -60,7 +62,8 @@ class CaseConfigParamType(Enum):
     cache_dataset_on_device = "cache_dataset_on_device"
     refine_ratio = "refine_ratio"
     level = "level"
-
+    maintenance_work_mem = "maintenance_work_mem"
+    max_parallel_workers = "max_parallel_workers"
 
 class CustomizedCase(BaseModel):
     pass

{vectordb_bench-0.0.8.dist-info → vectordb_bench-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vectordb-bench
-Version: 0.0.8
+Version: 0.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
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pytz
 Requires-Dist: streamlit-autorefresh
-Requires-Dist: streamlit >=1.23.0
+Requires-Dist: streamlit !=1.34.0
 Requires-Dist: streamlit-extras
 Requires-Dist: tqdm
 Requires-Dist: s3fs
@@ -36,6 +36,7 @@ Requires-Dist: sqlalchemy ; extra == 'all'
 Requires-Dist: redis ; extra == 'all'
 Requires-Dist: chromadb ; extra == 'all'
 Requires-Dist: psycopg2 ; extra == 'all'
+Requires-Dist: psycopg ; extra == 'all'
 Provides-Extra: chromadb
 Requires-Dist: chromadb ; extra == 'chromadb'
 Provides-Extra: elastic
@@ -44,7 +45,7 @@ Provides-Extra: pgvecto_rs
 Requires-Dist: psycopg2 ; extra == 'pgvecto_rs'
 Provides-Extra: pgvector
 Requires-Dist: pgvector ; extra == 'pgvector'
-Requires-Dist: psycopg2 ; extra == 'pgvector'
+Requires-Dist: psycopg ; extra == 'pgvector'
 Provides-Extra: pinecone
 Requires-Dist: pinecone-client ; extra == 'pinecone'
 Provides-Extra: qdrant

{vectordb_bench-0.0.8.dist-info → vectordb_bench-0.0.9.dist-info}/RECORD

@@ -4,27 +4,27 @@ vectordb_bench/base.py,sha256=d34WCGXZI1u5RGQtqrPHd3HbOF5AmioFrM2j30Aj1sY,130
 vectordb_bench/interface.py,sha256=7-nIr9oSDRfkbFDLJW0iZHCa7ItFG9O2TQAS7wHvWfk,9645
 vectordb_bench/log_util.py,sha256=nMnW-sN24WyURcI07t-WA3q2N5R-YIvFgboRsSrNJDg,2906
 vectordb_bench/metric.py,sha256=-SAcUm2m0OkHcph2QZusx-wZh8wCTrrHMy1Kv0WWL2w,1332
-vectordb_bench/models.py,sha256=gmOqKXnHZ6kC_C3fXbuaipfbGzhhFArSNaNtK-9SoAI,8552
+vectordb_bench/models.py,sha256=MOxNLVaU-5GZ-2_X2fCNEyLEKVCLuqNQJNLgjzDOvYI,8755
 vectordb_bench/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 vectordb_bench/backend/assembler.py,sha256=W03o8xaOoa5CTBr5586nIzm4sEJ4a-85sfcEG-d60VY,2000
 vectordb_bench/backend/cases.py,sha256=3Ektg8VzU9FESgkwoh0tz6JYDIjhGarnKhIcaMczu5k,13570
 vectordb_bench/backend/data_source.py,sha256=j4-eD0nIe7Y6fSM5WKEij3GfhyU_YOQ3L5Tyl-1GxX0,5446
 vectordb_bench/backend/dataset.py,sha256=E-ZdYNXwCN3Fa4b_9rvhbiJgPLiKXQmi_fqZk0r7AHk,8295
 vectordb_bench/backend/result_collector.py,sha256=jdQf5-q1z5y07SKy9Sig1wFROmm-p9x_Y81fId0sjaU,807
-vectordb_bench/backend/task_runner.py,sha256=kPedp8K_UeOfnmpV_ZtKYx0mhn-RjQzuHC9cTFgxSRU,9526
+vectordb_bench/backend/task_runner.py,sha256=LLfnsIDDXGTbHKtQlsjWWJop6ouFEFMQuZsqurLDkMI,9526
 vectordb_bench/backend/utils.py,sha256=2UixYyfKvl8zRiashywB1l6hTI3jMtiZhiVm_bXHV1Y,1811
 vectordb_bench/backend/clients/__init__.py,sha256=vYN2PZo1-zeO2kN-WRndxo2-BzmpOTLSGw8nUXTXvxI,4582
-vectordb_bench/backend/clients/api.py,sha256=ocqiS_CbYl7toINutFx9pBXOkFqOFknLBqilz8rGiVk,5613
+vectordb_bench/backend/clients/api.py,sha256=U4jdrwkZpiOvvOc5BSylbnvc1n-O1bn5ucYIrGIKBuM,5640
 vectordb_bench/backend/clients/chroma/chroma.py,sha256=Rg-GVWSDLdw32XfltJQlS3JHtNX1BJYDHxTSy086tKA,3739
 vectordb_bench/backend/clients/chroma/config.py,sha256=7Tp_di0cdBsh4kX-IijTLsmFK2JJpcrXP2K6e24OUGc,345
 vectordb_bench/backend/clients/elastic_cloud/config.py,sha256=xkaBNtsayByelVLda8LiSEwxjQjESpijJ8IFOh03f_0,1598
 vectordb_bench/backend/clients/elastic_cloud/elastic_cloud.py,sha256=rWHthqGEpYwwka-0bsjyWfCwTAsYKNPvB17qe0Z1VDQ,5709
 vectordb_bench/backend/clients/milvus/config.py,sha256=Usx-fpNsjHYZ1s-cL8qh9RXtCrh43wOs0jmdkswr8Ac,6677
-vectordb_bench/backend/clients/milvus/milvus.py,sha256=H1KXJqpiTUciJ2aZsnidtQ2sKufmGr5rZM0q94c2Uo8,7199
+vectordb_bench/backend/clients/milvus/milvus.py,sha256=XFihIefPF7SRG7rENXg72_FZNB4zV0Hde_aNc_zOS9U,7138
 vectordb_bench/backend/clients/pgvecto_rs/config.py,sha256=scdEXN6RT4yGA5j8fXSAooAvB550WQQ1JnN7SBQCUZM,3648
 vectordb_bench/backend/clients/pgvecto_rs/pgvecto_rs.py,sha256=Od9g1wIhgslXBavEwCV8-LYsclqOJB3OwpeU6ZA265k,6195
-vectordb_bench/backend/clients/pgvector/config.py,sha256=mh8ij7oYO62xTUGCBWR0GssJ3t8buUsCQMeZ2DFX1rc,2808
-vectordb_bench/backend/clients/pgvector/pgvector.py,sha256=sZLqboBTjDv45hHzDw4xUS3c-BUqXW3mLBcKvnNIKfQ,6933
+vectordb_bench/backend/clients/pgvector/config.py,sha256=p4Dlp9PXXSCY3gtSTzZzQO8-PAl7kixp_wID9Nu4CNs,7206
+vectordb_bench/backend/clients/pgvector/pgvector.py,sha256=MAGmnMmP_LYRYs3zVjHezeOBEod1XiOuS45nqWtOgvo,12496
 vectordb_bench/backend/clients/pinecone/config.py,sha256=4WvMu-9zxgoGfP5GPb7hpW-PRYEORADhlQvMa8JJh8k,384
 vectordb_bench/backend/clients/pinecone/pinecone.py,sha256=U31QbXLuTcNPp7PK24glE6LM23-YpbxK_Kj-NmEwoZY,4078
 vectordb_bench/backend/clients/qdrant_cloud/config.py,sha256=jk6gLcjZnjV0kQlc4RrrcXyekF6qkwzgWOYD3Mm8AOU,1385
@@ -37,7 +37,7 @@ vectordb_bench/backend/clients/zilliz_cloud/config.py,sha256=3Tk7X4r0n2SLzan110x
 vectordb_bench/backend/clients/zilliz_cloud/zilliz_cloud.py,sha256=4JcwiVEJcdEykW6n471nfHeIlmhIDa-gOZ7G5H_4krY,681
 vectordb_bench/backend/runner/__init__.py,sha256=5dZfPky8pY9Bi9HD5GZ3Fge8V2FJWrkGkQUkNL2v1t0,230
 vectordb_bench/backend/runner/mp_runner.py,sha256=NEyDeim_lRbSNBbseUHZQzt12DwLMibCD1N4od6zQe0,4809
-vectordb_bench/backend/runner/serial_runner.py,sha256=2FdO2r3L51w8dL3Qg74BosTTVwqPbeoHdHsFXLx5eZU,9292
+vectordb_bench/backend/runner/serial_runner.py,sha256=LVmhv2qIuCU_v85CrWWiKKVfZUx5wmB0__HbO8HeQgo,9168
 vectordb_bench/frontend/utils.py,sha256=BzKR1kMX1ErlXAzkFUb06O2mIcxBbquRzJtxoHgRnKs,162
 vectordb_bench/frontend/vdb_benchmark.py,sha256=z9VCsMp2Ra43J-oFXRsX98Ww3Xq_koUpZ9PEZoU5qws,1649
 vectordb_bench/frontend/components/check_results/charts.py,sha256=zbtEyUSk2FJbSlaGw1LH4boSljFXfhVZlC8rrIgVw_4,5113
@@ -51,13 +51,13 @@ vectordb_bench/frontend/components/check_results/priceTable.py,sha256=E7sxhSCjkB
 vectordb_bench/frontend/components/check_results/stPageConfig.py,sha256=rAL2prWx0hT7Q3QWz6ALyKUMNladX6U48GlKvVq3DFA,429
 vectordb_bench/frontend/components/get_results/saveAsImage.py,sha256=MdQCqjrX5rQyK34XfTkVykVLOcOouIz4enMR1P5GBiY,1457
 vectordb_bench/frontend/components/run_test/autoRefresh.py,sha256=ofsl2sdmBd2y9O_xaJDr58NPycJsDwCdf2rEyE_f6e8,288
-vectordb_bench/frontend/components/run_test/caseSelector.py,sha256=V9EvhCc3X6LJV7Nt1sn4rawLtBnLCEfEd5UMCY2Z8Vk,3660
+vectordb_bench/frontend/components/run_test/caseSelector.py,sha256=B1rtbSDlzPHbdPK52mxFf3FbF4qYs1J9YNYdSnTxCRg,3945
 vectordb_bench/frontend/components/run_test/dbConfigSetting.py,sha256=hoelDzXP-J2EmzvgGh6Euk7uBfu9iw0YGM7lxjo0cb8,2074
 vectordb_bench/frontend/components/run_test/dbSelector.py,sha256=r8ABYpu6aWA94FiQxB0g75n7jU_mOFY5nYcHkKQ8e8g,1242
 vectordb_bench/frontend/components/run_test/generateTasks.py,sha256=9r1vb03FMSJ_vG4px_wHMKMB_RWaKv6ttv0FptsytgA,812
 vectordb_bench/frontend/components/run_test/hideSidebar.py,sha256=vb5kzIMmbMqWX67qFEHek21X4sGO_tPyn_uPqUEtp3Q,234
 vectordb_bench/frontend/components/run_test/submitTask.py,sha256=4W-wvrnwPZjEAyHjeLtahLE8-Ekjw2wYNX5aAXZbark,3050
-vectordb_bench/frontend/const/dbCaseConfigs.py,sha256=86WK4_7TrtF-jRfT0YtDlPgA3GjU6mfKd5y0SSY7mtA,14575
+vectordb_bench/frontend/const/dbCaseConfigs.py,sha256=dxKTrLeKXoizTu7dKxOZjH4ZdhHr-YuDYp6Xvbe652A,18345
 vectordb_bench/frontend/const/dbPrices.py,sha256=10aBKjVcEg8y7TPSda28opmBM1KmXNrvbU9WM_BsZcE,176
 vectordb_bench/frontend/const/styles.py,sha256=B2ycRJ6CHBzew8B2P7z9nnzY-20W5SlggXLI2olfxac,2174
 vectordb_bench/frontend/pages/quries_per_dollar.py,sha256=SpXwKwdarwPz7RtF_qxyODfwARBb3VI9iKElYtnwEVs,2422
@@ -80,9 +80,9 @@ vectordb_bench/results/WeaviateCloud/result_20230808_standard_weaviatecloud.json
 vectordb_bench/results/ZillizCloud/result_20230727_standard_zillizcloud.json,sha256=wzrlCEsqaoy4EujDNeLebCKZIC__aXNe2NhFDEdewKo,17398
 vectordb_bench/results/ZillizCloud/result_20230808_standard_zillizcloud.json,sha256=G44g4aTJfeC0FyqosPEtaC-iy8JUX-bVpnA6dn0iiYU,14969
 vectordb_bench/results/ZillizCloud/result_20240105_standard_202401_zillizcloud.json,sha256=5R5PGJheoCOksx9uOXeSu8Z24Zc6Xp9LUkgJ-OzGAtM,41007
-vectordb_bench-0.0.8.dist-info/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
-vectordb_bench-0.0.8.dist-info/METADATA,sha256=aq_qqOsWNn1gUM2uX3WHWA3Py9PpVLS92zLzGbCu5MU,22642
-vectordb_bench-0.0.8.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-vectordb_bench-0.0.8.dist-info/entry_points.txt,sha256=RVG6ppvzIsstAM199pDqeKu8lnxntjwYapn0smVQY7A,60
-vectordb_bench-0.0.8.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
-vectordb_bench-0.0.8.dist-info/RECORD,,
+vectordb_bench-0.0.9.dist-info/LICENSE,sha256=HXbxhrb5u5SegVzeLNF_voVgRsJMavcLaOmD1N0lZkM,1067
+vectordb_bench-0.0.9.dist-info/METADATA,sha256=VYoxjLKMXlz7VDWTz8y5l4wwVk8EDWK15FG-zlhEwiM,22681
+vectordb_bench-0.0.9.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+vectordb_bench-0.0.9.dist-info/entry_points.txt,sha256=RVG6ppvzIsstAM199pDqeKu8lnxntjwYapn0smVQY7A,60
+vectordb_bench-0.0.9.dist-info/top_level.txt,sha256=jnhZFZAuKX1J60yt-XOeBZ__ctiZMvoC_s0RFq29lpM,15
+vectordb_bench-0.0.9.dist-info/RECORD,,