vectordb-bench 0.0.12__py3-none-any.whl → 0.0.14__py3-none-any.whl

vectordb_bench/backend/clients/pgvectorscale/cli.py

@@ -0,0 +1,108 @@
+import click
+import os
+from pydantic import SecretStr
+
+from ....cli.cli import (
+    CommonTypedDict,
+    cli,
+    click_parameter_decorators_from_typed_dict,
+    run,
+)
+from typing import Annotated, Unpack
+from vectordb_bench.backend.clients import DB
+
+
+class PgVectorScaleTypedDict(CommonTypedDict):
+    user_name: Annotated[
+        str, click.option("--user-name", type=str, help="Db username", required=True)
+    ]
+    password: Annotated[
+        str,
+        click.option("--password",
+                     type=str,
+                     help="Postgres database password",
+                     default=lambda: os.environ.get("POSTGRES_PASSWORD", ""),
+                     show_default="$POSTGRES_PASSWORD",
+                     ),
+    ]
+
+    host: Annotated[
+        str, click.option("--host", type=str, help="Db host", required=True)
+    ]
+    db_name: Annotated[
+        str, click.option("--db-name", type=str, help="Db name", required=True)
+    ]
+
+
+class PgVectorScaleDiskAnnTypedDict(PgVectorScaleTypedDict):
+    storage_layout: Annotated[
+        str,
+        click.option(
+            "--storage-layout", type=str, help="Streaming DiskANN storage layout",
+        ),
+    ]
+    num_neighbors: Annotated[
+        int,
+        click.option(
+            "--num-neighbors", type=int, help="Streaming DiskANN num neighbors",
+        ),
+    ]
+    search_list_size: Annotated[
+        int,
+        click.option(
+            "--search-list-size", type=int, help="Streaming DiskANN search list size",
+        ),
+    ]
+    max_alpha: Annotated[
+        float,
+        click.option(
+            "--max-alpha", type=float, help="Streaming DiskANN max alpha",
+        ),
+    ]
+    num_dimensions: Annotated[
+        int,
+        click.option(
+            "--num-dimensions", type=int, help="Streaming DiskANN num dimensions",
+        ),
+    ]
+    query_search_list_size: Annotated[
+        int,
+        click.option(
+            "--query-search-list-size", type=int, help="Streaming DiskANN query search list size",
+        ),
+    ]
+    query_rescore: Annotated[
+        int,
+        click.option(
+            "--query-rescore", type=int, help="Streaming DiskANN query rescore",
+        ),
+    ]
+
+
+@cli.command()
+@click_parameter_decorators_from_typed_dict(PgVectorScaleDiskAnnTypedDict)
+def PgVectorScaleDiskAnn(
+    **parameters: Unpack[PgVectorScaleDiskAnnTypedDict],
+):
+    from .config import PgVectorScaleConfig, PgVectorScaleStreamingDiskANNConfig
+
+    run(
+        db=DB.PgVectorScale,
+        db_config=PgVectorScaleConfig(
+            db_label=parameters["db_label"],
+            user_name=SecretStr(parameters["user_name"]),
+            password=SecretStr(parameters["password"]),
+            host=parameters["host"],
+            db_name=parameters["db_name"],
+        ),
+        db_case_config=PgVectorScaleStreamingDiskANNConfig(
+            storage_layout=parameters["storage_layout"],
+            num_neighbors=parameters["num_neighbors"],
+            search_list_size=parameters["search_list_size"],
+            max_alpha=parameters["max_alpha"],
+            num_dimensions=parameters["num_dimensions"],
+            query_search_list_size=parameters["query_search_list_size"],
+            query_rescore=parameters["query_rescore"],
+        ),
+        **parameters,
+    )

vectordb_bench/backend/clients/pgvectorscale/config.py

@@ -0,0 +1,111 @@
+from abc import abstractmethod
+from typing import TypedDict
+from pydantic import BaseModel, SecretStr
+from typing_extensions import LiteralString
+from ..api import DBCaseConfig, DBConfig, IndexType, MetricType
+
+POSTGRE_URL_PLACEHOLDER = "postgresql://%s:%s@%s/%s"
+
+
+class PgVectorScaleConfigDict(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 PgVectorScaleConfig(DBConfig):
+    user_name: SecretStr = SecretStr("postgres")
+    password: SecretStr
+    host: str = "localhost"
+    port: int = 5432
+    db_name: str
+
+    def to_dict(self) -> PgVectorScaleConfigDict:
+        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,
+        }
+
+
+class PgVectorScaleIndexConfig(BaseModel, DBCaseConfig):
+    metric_type: MetricType | None = None
+    create_index_before_load: bool = False
+    create_index_after_load: bool = True
+
+    def parse_metric(self) -> str:
+        if self.metric_type == MetricType.COSINE:
+            return "vector_cosine_ops"
+        return ""
+        
+    def parse_metric_fun_op(self) -> LiteralString:
+        if self.metric_type == MetricType.COSINE:
+            return "<=>"
+        return ""
+
+    def parse_metric_fun_str(self) -> str:
+        if self.metric_type == MetricType.COSINE:
+            return "cosine_distance"
+        return ""
+    
+    @abstractmethod
+    def index_param(self) -> dict:
+        ...
+
+    @abstractmethod
+    def search_param(self) -> dict:
+        ...
+
+    @abstractmethod
+    def session_param(self) -> dict:
+        ...
+    
+
+class PgVectorScaleStreamingDiskANNConfig(PgVectorScaleIndexConfig):
+    index: IndexType = IndexType.STREAMING_DISKANN
+    storage_layout: str | None
+    num_neighbors: int | None
+    search_list_size: int | None
+    max_alpha: float | None
+    num_dimensions: int | None
+    num_bits_per_dimension: int | None
+    query_search_list_size: int | None
+    query_rescore: int | None
+
+    def index_param(self) -> dict:
+        return {
+            "metric": self.parse_metric(),
+            "index_type": self.index.value,
+            "options": {
+                "storage_layout": self.storage_layout,
+                "num_neighbors": self.num_neighbors,
+                "search_list_size": self.search_list_size,
+                "max_alpha": self.max_alpha,
+                "num_dimensions": self.num_dimensions,
+            },
+        }
+    
+    def search_param(self) -> dict:
+        return {
+            "metric": self.parse_metric(),
+            "metric_fun_op": self.parse_metric_fun_op(),
+        }
+    
+    def session_param(self) -> dict:
+        return {
+            "diskann.query_search_list_size": self.query_search_list_size,
+            "diskann.query_rescore": self.query_rescore,
+        }
+    
+_pgvectorscale_case_config = {
+    IndexType.STREAMING_DISKANN: PgVectorScaleStreamingDiskANNConfig,
+}

vectordb_bench/backend/clients/pgvectorscale/pgvectorscale.py

@@ -0,0 +1,290 @@
+"""Wrapper around the Pgvectorscale vector database over VectorDB"""
+
+import logging
+import pprint
+from contextlib import contextmanager
+from typing import Any, Generator, Optional, Tuple
+
+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 PgVectorScaleConfigDict, PgVectorScaleIndexConfig
+
+log = logging.getLogger(__name__)
+
+
+class PgVectorScale(VectorDB):
+    """Use psycopg instructions"""
+
+    conn: psycopg.Connection[Any] | None = None
+    coursor: psycopg.Cursor[Any] | None = None
+
+    _unfiltered_search: sql.Composed
+    _filtered_search: sql.Composed
+
+    def __init__(
+        self,
+        dim: int,
+        db_config: PgVectorScaleConfigDict,
+        db_case_config: PgVectorScaleIndexConfig,
+        collection_name: str = "pg_vectorscale_collection",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.name = "PgVectorScale"
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.table_name = collection_name
+        self.dim = dim
+
+        self._index_name = "pgvectorscale_index"
+        self._primary_field = "id"
+        self._vector_field = "embedding"
+
+        self.conn, self.cursor = self._create_connection(**self.db_config)        
+
+        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 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._drop_index()
+            self._drop_table()
+            self._create_table(dim)
+            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)
+        conn.cursor().execute("CREATE EXTENSION IF NOT EXISTS vectorscale CASCADE")
+        conn.commit()
+        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) -> Generator[None, None, None]:
+        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: dict[str, Any] = self.case_config.session_param()
+
+        if len(session_options) > 0:
+            for setting_name, setting_val in session_options.items():
+                command = sql.SQL("SET {setting_name} " + "= {setting_val};").format(
+                    setting_name=sql.Identifier(setting_name),
+                    setting_val=sql.Identifier(str(setting_val)),
+                )
+                log.debug(command.as_string(self.cursor))
+                self.cursor.execute(command)
+            self.conn.commit()
+        
+        self._filtered_search = sql.Composed(
+            [
+                sql.SQL("SELECT id FROM public.{} WHERE id >= %s 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")
+            ]
+        )
+        
+        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:
+            self.cursor.close()
+            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"
+        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):
+        self._post_insert()
+
+    def _post_insert(self):
+        log.info(f"{self.name} post insert before optimize")
+        if self.case_config.create_index_after_load:
+            self._drop_index()
+            self._create_index()
+
+    def _drop_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 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 _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: dict[str, Any] = self.case_config.index_param()
+
+        options = []
+        for option_name, option_val in index_param["options"].items():
+            if option_val is not None:
+                options.append(
+                    sql.SQL("{option_name} = {val}").format(
+                        option_name=sql.Identifier(option_name),
+                        val=sql.Identifier(str(option_val)),
+                    )
+                )
+        
+        num_bits_per_dimension = "2" if self.dim < 900 else "1"
+        options.append(
+            sql.SQL("{option_name} = {val}").format(
+                option_name=sql.Identifier("num_bits_per_dimension"),
+                val=sql.Identifier(num_bits_per_dimension),
+            )
+        )
+
+        if any(options):
+            with_clause = sql.SQL("WITH ({});").format(sql.SQL(", ").join(options))
+        else:
+            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"].lower()),
+            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):
+        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}")
+
+            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.conn.commit()
+        except Exception as e:
+            log.warning(
+                f"Failed to create pgvectorscale table: {self.table_name} error: {e}"
+            )
+            raise e from None
+
+    def insert_embeddings(
+        self,
+        embeddings: list[list[float]],
+        metadata: list[int],
+        **kwargs: Any,
+    ) -> 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:
+            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}"
+            )
+            return 0, e
+
+    def search_embedding(
+        self,
+        query: list[float],
+        k: int = 100,
+        filters: dict | None = None,
+        timeout: int | None = None,
+    ) -> list[int]:
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        q = np.asarray(query)
+        if filters:
+            gt = filters.get("id")
+            result = self.cursor.execute(
+                self._filtered_search, (gt, q, k), prepare=True, binary=True
+            )
+        else:
+            result = self.cursor.execute(
+                self._unfiltered_search, (q, k), prepare=True, binary=True
+            )
+
+        return [int(i[0]) for i in result.fetchall()]

vectordb_bench/backend/clients/pinecone/config.py

@@ -4,12 +4,10 @@ from ..api import DBConfig
 
 class PineconeConfig(DBConfig):
     api_key: SecretStr
-    environment: SecretStr
     index_name: str
 
     def to_dict(self) -> dict:
         return {
             "api_key": self.api_key.get_secret_value(),
-            "environment": self.environment.get_secret_value(),
             "index_name": self.index_name,
         }

vectordb_bench/backend/clients/pinecone/pinecone.py

@@ -3,7 +3,7 @@
 import logging
 from contextlib import contextmanager
 from typing import Type
-
+import pinecone
 from ..api import VectorDB, DBConfig, DBCaseConfig, EmptyDBCaseConfig, IndexType
 from .config import PineconeConfig
 
@@ -11,7 +11,8 @@ from .config import PineconeConfig
 log = logging.getLogger(__name__)
 
 PINECONE_MAX_NUM_PER_BATCH = 1000
-PINECONE_MAX_SIZE_PER_BATCH = 2 * 1024 * 1024 # 2MB
+PINECONE_MAX_SIZE_PER_BATCH = 2 * 1024 * 1024  # 2MB
+
 
 class Pinecone(VectorDB):
     def __init__(
@@ -23,30 +24,25 @@ class Pinecone(VectorDB):
         **kwargs,
     ):
         """Initialize wrapper around the milvus vector database."""
-        self.index_name = db_config["index_name"]
-        self.api_key = db_config["api_key"]
-        self.environment = db_config["environment"]
-        self.batch_size = int(min(PINECONE_MAX_SIZE_PER_BATCH / (dim * 5), PINECONE_MAX_NUM_PER_BATCH))
-        # Pincone will make connections with server while import
-        # so place the import here.
-        import pinecone
-        pinecone.init(
-            api_key=self.api_key, environment=self.environment)
+        self.index_name = db_config.get("index_name", "")
+        self.api_key = db_config.get("api_key", "")
+        self.batch_size = int(
+            min(PINECONE_MAX_SIZE_PER_BATCH / (dim * 5), PINECONE_MAX_NUM_PER_BATCH)
+        )
+
+        pc = pinecone.Pinecone(api_key=self.api_key)
+        index = pc.Index(self.index_name)
+
         if drop_old:
-            list_indexes = pinecone.list_indexes()
-            if self.index_name in list_indexes:
-                index = pinecone.Index(self.index_name)
-                index_dim = index.describe_index_stats()["dimension"]
-                if (index_dim != dim):
-                    raise ValueError(
-                        f"Pinecone index {self.index_name} dimension mismatch, expected {index_dim} got {dim}")
-                log.info(
-                    f"Pinecone client delete old index: {self.index_name}")
-                index.delete(delete_all=True)
-                index.close()
-            else:
+            index_stats = index.describe_index_stats()
+            index_dim = index_stats["dimension"]
+            if index_dim != dim:
                 raise ValueError(
-                    f"Pinecone index {self.index_name} does not exist")
+                    f"Pinecone index {self.index_name} dimension mismatch, expected {index_dim} got {dim}"
+                )
+            for namespace in index_stats["namespaces"]:
+                log.info(f"Pinecone index delete namespace: {namespace}")
+                index.delete(delete_all=True, namespace=namespace)
 
         self._metadata_key = "meta"
 
@@ -59,13 +55,10 @@ class Pinecone(VectorDB):
         return EmptyDBCaseConfig
 
     @contextmanager
-    def init(self) -> None:
-        import pinecone
-        pinecone.init(
-            api_key=self.api_key, environment=self.environment)
-        self.index = pinecone.Index(self.index_name)
+    def init(self):
+        pc = pinecone.Pinecone(api_key=self.api_key)
+        self.index = pc.Index(self.index_name)
         yield
-        self.index.close()
 
     def ready_to_load(self):
         pass
@@ -83,11 +76,16 @@ class Pinecone(VectorDB):
         insert_count = 0
         try:
             for batch_start_offset in range(0, len(embeddings), self.batch_size):
-                batch_end_offset = min(batch_start_offset + self.batch_size, len(embeddings))
+                batch_end_offset = min(
+                    batch_start_offset + self.batch_size, len(embeddings)
+                )
                 insert_datas = []
                 for i in range(batch_start_offset, batch_end_offset):
-                    insert_data = (str(metadata[i]), embeddings[i], {
-                                self._metadata_key: metadata[i]})
+                    insert_data = (
+                        str(metadata[i]),
+                        embeddings[i],
+                        {self._metadata_key: metadata[i]},
+                    )
                     insert_datas.append(insert_data)
                 self.index.upsert(insert_datas)
                 insert_count += batch_end_offset - batch_start_offset
@@ -101,7 +99,7 @@ class Pinecone(VectorDB):
         k: int = 100,
         filters: dict | None = None,
         timeout: int | None = None,
-    ) -> list[tuple[int, float]]:
+    ) -> list[int]:
         if filters is None:
             pinecone_filters = {}
         else:
@@ -111,9 +109,9 @@ class Pinecone(VectorDB):
                 top_k=k,
                 vector=query,
                 filter=pinecone_filters,
-            )['matches']
+            )["matches"]
         except Exception as e:
             print(f"Error querying index: {e}")
             raise e
-        id_res = [int(one_res['id']) for one_res in res]
+        id_res = [int(one_res["id"]) for one_res in res]
         return id_res

vectordb_bench/backend/clients/redis/cli.py

@@ -3,6 +3,9 @@ from typing import Annotated, TypedDict, Unpack
 import click
 from pydantic import SecretStr
 
+from .config import RedisHNSWConfig
+
+
 from ....cli.cli import (
     CommonTypedDict,
     HNSWFlavor2,
@@ -69,6 +72,11 @@ def Redis(**parameters: Unpack[RedisHNSWTypedDict]):
             ssl=parameters["ssl"],
             ssl_ca_certs=parameters["ssl_ca_certs"],
             cmd=parameters["cmd"],
+        ),        
+        db_case_config=RedisHNSWConfig(
+            M=parameters["m"],
+            efConstruction=parameters["ef_construction"],
+            ef=parameters["ef_runtime"],
         ),
         **parameters,
     )