vectordb-bench 1.0.5__py3-none-any.whl → 1.0.8__py3-none-any.whl

vectordb_bench/backend/clients/hologres/hologres.py

@@ -0,0 +1,385 @@
+"""Wrapper around the Hologres vector database over VectorDB"""
+
+import json
+import logging
+from collections.abc import Generator
+from contextlib import contextmanager
+from io import StringIO
+from typing import Any
+
+import psycopg
+from psycopg import Connection, Cursor, sql
+
+from ..api import VectorDB
+from .config import HologresConfig, HologresIndexConfig
+
+log = logging.getLogger(__name__)
+
+
+class Hologres(VectorDB):
+    """Use psycopg instructions"""
+
+    conn: psycopg.Connection[Any] | None = None
+    cursor: psycopg.Cursor[Any] | None = None
+
+    _tg_name: str = "vdb_bench_tg_1"
+
+    def __init__(
+        self,
+        dim: int,
+        db_config: HologresConfig,
+        db_case_config: HologresIndexConfig,
+        collection_name: str = "vector_collection",
+        drop_old: bool = False,
+        **kwargs,
+    ):
+        self.name = "Alibaba Cloud Hologres"
+        self.db_config = db_config
+        self.case_config = db_case_config
+        self.table_name = collection_name
+        self.dim = dim
+
+        self._primary_field = "id"
+        self._vector_field = "embedding"
+
+        # construct basic units
+        self.conn, self.cursor = self._create_connection(**self.db_config)
+
+        # create vector extension
+        if self.case_config.is_proxima():
+            self.cursor.execute("CREATE EXTENSION proxima;")
+            self.conn.commit()
+
+        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,
+            ),
+        ):
+            msg = (
+                f"{self.name} config must create an index using create_index_before_load or create_index_after_load"
+                f"{self.name} config values: {self.db_config}\n{self.case_config}"
+            )
+            log.error(msg)
+            raise RuntimeError(msg)
+
+        if drop_old:
+            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.autocommit = True
+        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]:
+        """
+        Examples:
+            >>> with self.init():
+            >>>     self.insert_embeddings()
+            >>>     self.search_embedding()
+        """
+
+        self.conn, self.cursor = self._create_connection(**self.db_config)
+
+        self._set_search_guc()
+
+        try:
+            yield
+        finally:
+            self.cursor.close()
+            self.conn.close()
+            self.cursor = None
+            self.conn = None
+
+    def _set_search_guc(self):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        sql_guc = sql.SQL(f"SET hg_vector_ef_search = {self.case_config.ef_search};")
+        log.info(f"{self.name} client set search guc: {sql_guc.as_string()}")
+        self.cursor.execute(sql_guc)
+        self.conn.commit()
+
+    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 {table_name};").format(
+                table_name=sql.Identifier(self.table_name),
+            ),
+        )
+        self.conn.commit()
+
+        try:
+            log.info(f"{self.name} client purge table recycle bin: {self.table_name}")
+            self.cursor.execute(
+                sql.SQL("purge TABLE {table_name};").format(
+                    table_name=sql.Identifier(self.table_name),
+                ),
+            )
+        except Exception as e:
+            log.info(f"{self.name} client purge table {self.table_name} recycle bin failed, error: {e}, ignore.")
+        finally:
+            self.conn.commit()
+
+        try:
+            log.info(f"{self.name} client drop table group : {self._tg_name}")
+            self.cursor.execute(sql.SQL(f"CALL HG_DROP_TABLE_GROUP('{self._tg_name}');"))
+        except Exception as e:
+            log.info(f"{self.name} client drop table group : {self._tg_name} failed, error: {e}, ignore.")
+        finally:
+            self.conn.commit()
+
+        try:
+            log.info(f"{self.name} client free cache")
+            self.cursor.execute("select hg_admin_command('freecache');")
+        except Exception as e:
+            log.info(f"{self.name} client free cache failed, error: {e}, ignore.")
+        finally:
+            self.conn.commit()
+
+    def optimize(self, data_size: int | None = None):
+        if self.case_config.create_index_after_load:
+            self._create_index()
+        self._full_compact()
+        self._analyze()
+
+    def _vacuum(self):
+        log.info(f"{self.name} client vacuum table : {self.table_name}")
+        try:
+            # VACUUM cannot run inside a transaction block
+            # it's better to new a connection
+            self.conn.autocommit = True
+            with self.conn.cursor() as cursor:
+                cursor.execute(
+                    sql.SQL(
+                        """
+                        VACUUM {table_name};
+                        """
+                    ).format(
+                        table_name=sql.Identifier(self.table_name),
+                    )
+                )
+            log.info(f"{self.name} client vacuum table : {self.table_name} done")
+        except Exception as e:
+            log.warning(f"Failed to vacuum table: {self.table_name} error: {e}")
+            raise e from None
+        finally:
+            self.conn.autocommit = True
+
+    def _analyze(self):
+        log.info(f"{self.name} client analyze table : {self.table_name}")
+        self.cursor.execute(sql.SQL(f"ANALYZE {self.table_name};"))
+        log.info(f"{self.name} client analyze table : {self.table_name} done")
+
+    def _full_compact(self):
+        log.info(f"{self.name} client full compact table : {self.table_name}")
+        self.cursor.execute(
+            sql.SQL(
+                """
+                SELECT hologres.hg_full_compact_table(
+                    '{table_name}',
+                    'max_file_size_mb={full_compact_max_file_size_mb}'
+                );
+                """
+            ).format(
+                table_name=sql.SQL(self.table_name),
+                full_compact_max_file_size_mb=sql.SQL(str(self.case_config.full_compact_max_file_size_mb)),
+            )
+        )
+        log.info(f"{self.name} client full compact table : {self.table_name} done")
+
+    def _create_index(self):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        sql_index = sql.SQL(
+            """
+            CALL set_table_property ('{table_name}', 'vectors', '{{
+                "embedding": {{
+                    "algorithm": "{algorithm}",
+                    "distance_method": "{distance_method}",
+                    "builder_params": {builder_params}
+                }}
+            }}');
+            """
+        ).format(
+            table_name=sql.Identifier(self.table_name),
+            algorithm=sql.SQL(self.case_config.algorithm()),
+            distance_method=sql.SQL(self.case_config.distance_method()),
+            builder_params=sql.SQL(json.dumps(self.case_config.builder_params())),
+        )
+
+        log.info(f"{self.name} client create index on table : {self.table_name}, with sql: {sql_index.as_string()}")
+        try:
+            self.cursor.execute(sql_index)
+            self.conn.commit()
+        except Exception as e:
+            log.warning(f"Failed to create index on table: {self.table_name} error: {e}")
+            raise e from None
+
+    def _set_replica_count(self, replica_count: int = 2):
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        try:
+            # non-warehouse mode by default
+            sql_tg_replica = sql.SQL(
+                f"CALL hg_set_table_group_property('{self._tg_name}', 'replica_count', '{replica_count}');"
+            )
+
+            # check warehouse mode
+            sql_check = sql.SQL("select count(*) from hologres.hg_warehouses;")
+            log.info(f"check warehouse mode with sql: {sql_check}")
+            self.cursor.execute(sql_check)
+            result_check = self.cursor.fetchone()[0]
+            if result_check > 0:
+                # get warehouse name
+                sql_get_warehouse_name = sql.SQL("select current_warehouse();")
+                log.info(f"get warehouse name with sql: {sql_get_warehouse_name}")
+                self.cursor.execute(sql_get_warehouse_name)
+                sql_tg_replica = sql.SQL(
+                    """
+                    CALL hg_table_group_set_warehouse_replica_count (
+                        '{dbname}.{tg_name}',
+                        {replica_count},
+                        '{warehouse_name}'
+                    );
+                    """
+                ).format(
+                    tg_name=sql.SQL(self._tg_name),
+                    warehouse_name=sql.SQL(self.cursor.fetchone()[0]),
+                    dbname=sql.SQL(self.db_config["dbname"]),
+                    replica_count=replica_count,
+                )
+            log.info(f"{self.name} client set table group replica: {self._tg_name}, with sql: {sql_tg_replica}")
+            self.cursor.execute(sql_tg_replica)
+        except Exception as e:
+            log.warning(f"Failed to set replica count, error: {e}, ignore")
+        finally:
+            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"
+
+        sql_tg = sql.SQL(f"CALL HG_CREATE_TABLE_GROUP ('{self._tg_name}', 1);")
+        log.info(f"{self.name} client create table group : {self._tg_name}, with sql: {sql_tg}")
+        try:
+            self.cursor.execute(sql_tg)
+        except Exception as e:
+            log.warning(f"Failed to create table group : {self._tg_name} error: {e}, ignore")
+        finally:
+            self.conn.commit()
+
+        self._set_replica_count(replica_count=2)
+
+        sql_table = sql.SQL(
+            """
+            CREATE TABLE IF NOT EXISTS {table_name} (
+                id BIGINT PRIMARY KEY,
+                embedding FLOAT4[] CHECK (array_ndims(embedding) = 1 AND array_length(embedding, 1) = {dim})
+            )
+            WITH (table_group = {tg_name});
+            """
+        ).format(
+            table_name=sql.Identifier(self.table_name),
+            dim=dim,
+            tg_name=sql.SQL(self._tg_name),
+        )
+        log.info(f"{self.name} client create table : {self.table_name}, with sql: {sql_table.as_string()}")
+        try:
+            self.cursor.execute(sql_table)
+            self.conn.commit()
+        except Exception as e:
+            log.warning(f"Failed to create 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, Exception | None]:
+        assert self.conn is not None, "Connection is not initialized"
+        assert self.cursor is not None, "Cursor is not initialized"
+
+        try:
+            buffer = StringIO()
+            for i in range(len(metadata)):
+                buffer.write("%d\t%s\n" % (metadata[i], "{" + ",".join("%f" % x for x in embeddings[i]) + "}"))
+            buffer.seek(0)
+
+            with self.cursor.copy(
+                sql.SQL("COPY {table_name} FROM STDIN").format(table_name=sql.Identifier(self.table_name))
+            ) as copy:
+                copy.write(buffer.getvalue())
+            self.conn.commit()
+
+            return len(metadata), None
+        except Exception as e:
+            log.warning(f"Failed to insert data into table ({self.table_name}), error: {e}")
+            return 0, e
+
+    def _compose_query_and_params(self, vec: list[float], topk: int, ge_id: int | None = None):
+        params = []
+
+        where_clause = sql.SQL("")
+        if ge_id is not None:
+            where_clause = sql.SQL(" WHERE id >= %s ")
+            params.append(ge_id)
+
+        vec_float4 = [psycopg._wrappers.Float4(i) for i in vec]
+        params.append(vec_float4)
+        params.append(topk)
+
+        query = sql.SQL(
+            """
+            SELECT id
+            FROM {table_name}
+            {where_clause}
+            ORDER BY {distance_function}(embedding, %b)
+            {order_direction}
+            LIMIT %s;
+            """
+        ).format(
+            table_name=sql.Identifier(self.table_name),
+            distance_function=sql.SQL(self.case_config.distance_function()),
+            where_clause=where_clause,
+            order_direction=sql.SQL(self.case_config.order_direction()),
+        )
+
+        return query, params
+
+    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"
+
+        ge = filters.get("id") if filters else None
+        q, params = self._compose_query_and_params(query, k, ge)
+        result = self.cursor.execute(q, params, prepare=True, binary=True)
+        return [int(i[0]) for i in result.fetchall()]

vectordb_bench/backend/clients/lancedb/lancedb.py

@@ -65,6 +65,7 @@ class LanceDB(VectorDB):
         self,
         embeddings: list[list[float]],
         metadata: list[int],
+        **kwargs,
     ) -> tuple[int, Exception | None]:
         try:
             data = [{"id": meta, "vector": emb} for meta, emb in zip(metadata, embeddings, strict=False)]

vectordb_bench/backend/clients/milvus/cli.py

@@ -40,6 +40,17 @@ class MilvusTypedDict(TypedDict):
             show_default=True,
         ),
     ]
+    replica_number: Annotated[
+        int,
+        click.option(
+            "--replica-number",
+            type=int,
+            help="Number of replicas",
+            required=False,
+            default=1,
+            show_default=True,
+        ),
+    ]
 
 
 class MilvusAutoIndexTypedDict(CommonTypedDict, MilvusTypedDict): ...
@@ -58,6 +69,7 @@ def MilvusAutoIndex(**parameters: Unpack[MilvusAutoIndexTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=AutoIndexConfig(),
         **parameters,
@@ -77,6 +89,7 @@ def MilvusFlat(**parameters: Unpack[MilvusAutoIndexTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=FLATConfig(),
         **parameters,
@@ -99,6 +112,7 @@ def MilvusHNSW(**parameters: Unpack[MilvusHNSWTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=HNSWConfig(
             M=parameters["m"],
@@ -163,6 +177,7 @@ def MilvusHNSWPQ(**parameters: Unpack[MilvusHNSWPQTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=HNSWPQConfig(
             M=parameters["m"],
@@ -206,6 +221,7 @@ def MilvusHNSWPRQ(**parameters: Unpack[MilvusHNSWPRQTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=HNSWPRQConfig(
             M=parameters["m"],
@@ -246,6 +262,7 @@ def MilvusHNSWSQ(**parameters: Unpack[MilvusHNSWSQTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=HNSWSQConfig(
             M=parameters["m"],
@@ -276,6 +293,7 @@ def MilvusIVFFlat(**parameters: Unpack[MilvusIVFFlatTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=IVFFlatConfig(
             nlist=parameters["nlist"],
@@ -298,6 +316,7 @@ def MilvusIVFSQ8(**parameters: Unpack[MilvusIVFFlatTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=IVFSQ8Config(
             nlist=parameters["nlist"],
@@ -359,6 +378,7 @@ def MilvusIVFRabitQ(**parameters: Unpack[MilvusIVFRABITQTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=IVFRABITQConfig(
             nlist=parameters["nlist"],
@@ -389,6 +409,7 @@ def MilvusDISKANN(**parameters: Unpack[MilvusDISKANNTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=DISKANNConfig(
             search_list=parameters["search_list"],
@@ -418,6 +439,7 @@ def MilvusGPUIVFFlat(**parameters: Unpack[MilvusGPUIVFTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=GPUIVFFlatConfig(
             nlist=parameters["nlist"],
@@ -453,6 +475,7 @@ def MilvusGPUBruteForce(**parameters: Unpack[MilvusGPUBruteForceTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=GPUBruteForceConfig(
             metric_type=parameters["metric_type"],
@@ -485,6 +508,7 @@ def MilvusGPUIVFPQ(**parameters: Unpack[MilvusGPUIVFPQTypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=GPUIVFPQConfig(
             nlist=parameters["nlist"],
@@ -525,6 +549,7 @@ def MilvusGPUCAGRA(**parameters: Unpack[MilvusGPUCAGRATypedDict]):
             user=parameters["user_name"],
             password=SecretStr(parameters["password"]) if parameters["password"] else None,
             num_shards=int(parameters["num_shards"]),
+            replica_number=int(parameters["replica_number"]),
         ),
         db_case_config=GPUCAGRAConfig(
             intermediate_graph_degree=parameters["intermediate_graph_degree"],

vectordb_bench/backend/clients/milvus/config.py

@@ -8,6 +8,7 @@ class MilvusConfig(DBConfig):
     user: str | None = None
     password: SecretStr | None = None
     num_shards: int = 1
+    replica_number: int = 1
 
     def to_dict(self) -> dict:
         return {
@@ -15,6 +16,7 @@ class MilvusConfig(DBConfig):
             "user": self.user if self.user else None,
             "password": self.password.get_secret_value() if self.password else None,
             "num_shards": self.num_shards,
+            "replica_number": self.replica_number,
         }
 
     @validator("*")
@@ -318,7 +320,6 @@ class GPUIVFFlatConfig(MilvusIndexConfig, DBCaseConfig):
 
 class GPUBruteForceConfig(MilvusIndexConfig, DBCaseConfig):
     limit: int = 10  # Default top-k for search
-    metric_type: str  # Metric type (e.g., 'L2', 'IP', etc.)
     index: IndexType = IndexType.GPU_BRUTE_FORCE  # Index type set to GPU_BRUTE_FORCE
 
     def index_param(self) -> dict:

vectordb_bench/backend/clients/milvus/milvus.py

@@ -92,7 +92,7 @@ class Milvus(VectorDB):
             )
 
             self.create_index()
-            col.load()
+            col.load(replica_number=self.db_config.get("replica_number", 1))
 
         connections.disconnect("default")
 

vectordb_bench/backend/clients/oceanbase/cli.py

@@ -93,6 +93,7 @@ def OceanBaseIVF(**parameters: Unpack[OceanBaseIVFTypedDict]):
             m=input_m,
             nlist=parameters["nlist"],
             sample_per_nlist=parameters["sample_per_nlist"],
+            nbits=parameters["nbits"],
             index=input_index_type,
             ivf_nprobes=parameters["ivf_nprobes"],
         ),

vectordb_bench/backend/clients/oceanbase/config.py

@@ -85,6 +85,7 @@ class OceanBaseHNSWConfig(OceanBaseIndexConfig, DBCaseConfig):
 class OceanBaseIVFConfig(OceanBaseIndexConfig, DBCaseConfig):
     m: int
     sample_per_nlist: int
+    nbits: int | None = None
     nlist: int
     index: IndexType
     ivf_nprobes: int | None = None
@@ -96,8 +97,9 @@ class OceanBaseIVFConfig(OceanBaseIndexConfig, DBCaseConfig):
                 "metric_type": self.parse_metric(),
                 "index_type": self.index.value,
                 "params": {
-                    "m": self.M,
+                    "m": self.m,
                     "sample_per_nlist": self.sample_per_nlist,
+                    "nbits": self.nbits,
                     "nlist": self.nlist,
                 },
             }

vectordb_bench/backend/clients/oceanbase/oceanbase.py

@@ -7,6 +7,8 @@ from typing import Any
 
 import mysql.connector as mysql
 
+from vectordb_bench.backend.filter import Filter, FilterOp
+
 from ..api import IndexType, VectorDB
 from .config import OceanBaseConfigDict, OceanBaseHNSWConfig
 
@@ -16,6 +18,12 @@ OCEANBASE_DEFAULT_LOAD_BATCH_SIZE = 256
 
 
 class OceanBase(VectorDB):
+    supported_filter_types: list[FilterOp] = [
+        FilterOp.NonFilter,
+        FilterOp.NumGE,
+        FilterOp.StrEqual,
+    ]
+
     def __init__(
         self,
         dim: int,
@@ -187,22 +195,30 @@ class OceanBase(VectorDB):
 
         return insert_count, None
 
+    def prepare_filter(self, filters: Filter):
+        if filters.type == FilterOp.NonFilter:
+            self.expr = ""
+        elif filters.type == FilterOp.NumGE:
+            self.expr = f"WHERE id >= {filters.int_value}"
+        elif filters.type == FilterOp.StrEqual:
+            self.expr = f"WHERE id == '{filters.label_value}'"
+        else:
+            msg = f"Not support Filter for Oceanbase - {filters}"
+            raise ValueError(msg)
+
     def search_embedding(
         self,
         query: list[float],
         k: int = 100,
-        filters: dict[str, Any] | None = None,
-        timeout: int | None = None,
     ) -> list[int]:
         if not self._cursor:
             raise ValueError("Cursor is not initialized")
 
         packed = struct.pack(f"<{len(query)}f", *query)
         hex_vec = packed.hex()
-        filter_clause = f"WHERE id >= {filters['id']}" if filters else ""
         query_str = (
             f"SELECT id FROM {self.table_name} "  # noqa: S608
-            f"{filter_clause} ORDER BY "
+            f"{self.expr} ORDER BY "
             f"{self.db_case_config.parse_metric_func_str()}(embedding, X'{hex_vec}') "
             f"APPROXIMATE LIMIT {k}"
         )