enhance: fix coding styles

Signed-off-by: yangxuan <xuan.yang@zilliz.com>

Author: XuanYang-cn

vectordb_bench/backend/clients/alisql/alisql.py

@@ -75,14 +75,12 @@ def _create_db_table(self, dim: int):
             log.info(f"{self.name} client create table : {self.table_name}")
             self.cursor.execute(f'USE {self.db_config["database"]}')
 
-            self.cursor.execute(
-                f"""
+            self.cursor.execute(f"""
               CREATE TABLE {self.table_name} (
                 id INT PRIMARY KEY,
                 v VECTOR({self.dim}) NOT NULL
               )
-            """
-            )
+            """)
             self.cursor.execute("COMMIT")
 
         except Exception as e:
@@ -143,12 +141,10 @@ def optimize(self, data_size: int) -> None:
             if index_param["index_type"] == "HNSW" and index_param["M"] is not None:
                 index_options += f" M={index_param['M']}"
 
-            self.cursor.execute(
-                f"""
+            self.cursor.execute(f"""
               ALTER TABLE {self.db_config["database"]}.{self.table_name}
               ADD VECTOR KEY v(v) {index_options}
-            """
-            )
+            """)
             self.cursor.execute("COMMIT")
 
         except Exception as e:

vectordb_bench/backend/clients/cockroachdb/cockroachdb.py

@@ -315,14 +315,12 @@ def _create_table(self, cursor: Cursor, conn: Connection, dim: int):
             )
         else:
             cursor.execute(
-                sql.SQL(
-                    """
+                sql.SQL("""
                     CREATE TABLE IF NOT EXISTS {table_name}
                     ({primary_field} UUID PRIMARY KEY DEFAULT gen_random_uuid(),
                      {metadata_field} BIGINT NOT NULL,
                      {vector_field} VECTOR({dim}));
-                    """
-                ).format(
+                    """).format(
                     table_name=sql.Identifier(self.table_name),
                     primary_field=sql.Identifier(self._primary_field),
                     metadata_field=sql.Identifier(self._metadata_field),

vectordb_bench/backend/clients/hologres/hologres.py

@@ -170,11 +170,9 @@ def _vacuum(self):
             self.conn.autocommit = True
             with self.conn.cursor() as cursor:
                 cursor.execute(
-                    sql.SQL(
-                        """
+                    sql.SQL("""
                         VACUUM {table_name};
-                        """
-                    ).format(
+                        """).format(
                         table_name=sql.Identifier(self.table_name),
                     )
                 )
@@ -193,14 +191,12 @@ def _analyze(self):
     def _full_compact(self):
         log.info(f"{self.name} client full compact table : {self.table_name}")
         self.cursor.execute(
-            sql.SQL(
-                """
+            sql.SQL("""
                 SELECT hologres.hg_full_compact_table(
                     '{table_name}',
                     'max_file_size_mb={full_compact_max_file_size_mb}'
                 );
-                """
-            ).format(
+                """).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)),
             )
@@ -211,17 +207,15 @@ 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(
-            """
+        sql_index = sql.SQL("""
             CALL set_table_property ('{table_name}', 'vectors', '{{
                 "embedding": {{
                     "algorithm": "{algorithm}",
                     "distance_method": "{distance_method}",
                     "builder_params": {builder_params}
                 }}
             }}');
-            """
-        ).format(
+            """).format(
             table_name=sql.Identifier(self.table_name),
             algorithm=sql.SQL(self.case_config.algorithm()),
             distance_method=sql.SQL(self.case_config.distance_method()),
@@ -256,15 +250,13 @@ def _set_replica_count(self, replica_count: int = 2):
                 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(
-                    """
+                sql_tg_replica = sql.SQL("""
                     CALL hg_table_group_set_warehouse_replica_count (
                         '{dbname}.{tg_name}',
                         {replica_count},
                         '{warehouse_name}'
                     );
-                    """
-                ).format(
+                    """).format(
                     tg_name=sql.SQL(self._tg_name),
                     warehouse_name=sql.SQL(self.cursor.fetchone()[0]),
                     dbname=sql.SQL(self.db_config["dbname"]),
@@ -292,15 +284,13 @@ def _create_table(self, dim: int):
 
         self._set_replica_count(replica_count=2)
 
-        sql_table = sql.SQL(
-            """
+        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(
+            """).format(
             table_name=sql.Identifier(self.table_name),
             dim=dim,
             tg_name=sql.SQL(self._tg_name),
@@ -351,16 +341,14 @@ def _compose_query_and_params(self, vec: list[float], topk: int, ge_id: int | No
         params.append(vec_float4)
         params.append(topk)
 
-        query = sql.SQL(
-            """
+        query = sql.SQL("""
             SELECT id
             FROM {table_name}
             {where_clause}
             ORDER BY {distance_function}(embedding, %b)
             {order_direction}
             LIMIT %s;
-            """
-        ).format(
+            """).format(
             table_name=sql.Identifier(self.table_name),
             distance_function=sql.SQL(self.case_config.distance_function()),
             where_clause=where_clause,

vectordb_bench/backend/clients/mariadb/mariadb.py

@@ -73,14 +73,12 @@ def _create_db_table(self, dim: int):
             log.info(f"{self.name} client create table : {self.table_name}")
             self.cursor.execute(f"USE {self.db_name}")
 
-            self.cursor.execute(
-                f"""
+            self.cursor.execute(f"""
               CREATE TABLE {self.table_name} (
                 id INT PRIMARY KEY,
                 v VECTOR({self.dim}) NOT NULL
               ) ENGINE={index_param["storage_engine"]}
-            """
-            )
+            """)
             self.cursor.execute("COMMIT")
 
         except Exception as e:
@@ -142,12 +140,10 @@ def optimize(self) -> None:
             if index_param["index_type"] == "HNSW" and index_param["M"] is not None:
                 index_options += f" M={index_param['M']}"
 
-            self.cursor.execute(
-                f"""
+            self.cursor.execute(f"""
               ALTER TABLE {self.db_name}.{self.table_name}
               ADD VECTOR KEY v(v) {index_options}
-            """
-            )
+            """)
             self.cursor.execute("COMMIT")
 
         except Exception as e:

vectordb_bench/backend/clients/pgdiskann/pgdiskann.py

@@ -105,8 +105,7 @@ def init(self) -> Generator[None, None, None]:
 
         if search_params.get("reranking"):
             # Reranking-enabled queries
-            self._filtered_search = sql.SQL(
-                """
+            self._filtered_search = sql.SQL("""
                 SELECT i.id
                 FROM (
                     SELECT id, embedding
@@ -117,16 +116,14 @@ def init(self) -> Generator[None, None, None]:
                 ) i
                 ORDER BY i.embedding {reranking_metric_fun_op} %s::vector
                 LIMIT %s::int
-            """
-            ).format(
+            """).format(
                 table_name=sql.Identifier(self.table_name),
                 metric_fun_op=sql.SQL(search_params["metric_fun_op"]),
                 reranking_metric_fun_op=sql.SQL(search_params["reranking_metric_fun_op"]),
                 quantized_fetch_limit=sql.Literal(search_params["quantized_fetch_limit"]),
             )
 
-            self._unfiltered_search = sql.SQL(
-                """
+            self._unfiltered_search = sql.SQL("""
                 SELECT i.id
                 FROM (
                     SELECT id, embedding
@@ -136,8 +133,7 @@ def init(self) -> Generator[None, None, None]:
                 ) i
                 ORDER BY i.embedding {reranking_metric_fun_op} %s::vector
                 LIMIT %s::int
-            """
-            ).format(
+            """).format(
                 table_name=sql.Identifier(self.table_name),
                 metric_fun_op=sql.SQL(search_params["metric_fun_op"]),
                 reranking_metric_fun_op=sql.SQL(search_params["reranking_metric_fun_op"]),

vectordb_bench/backend/clients/pgvector/pgvector.py

@@ -410,12 +410,10 @@ def _create_table(self, dim: int):
                 )
             else:
                 self.cursor.execute(
-                    sql.SQL(
-                        """
+                    sql.SQL("""
                         CREATE TABLE IF NOT EXISTS public.{table_name}
                         ({primary_field} BIGINT PRIMARY KEY, embedding {table_quantization_type}({dim}));
-                        """
-                    ).format(
+                        """).format(
                         table_name=sql.Identifier(self.table_name),
                         table_quantization_type=sql.SQL(index_param["table_quantization_type"]),
                         dim=dim,

vectordb_bench/backend/clients/tidb/tidb.py

@@ -68,15 +68,13 @@ def _create_table(self):
         try:
             index_param = self.case_config.index_param()
             with self._get_connection() as (conn, cursor):
-                cursor.execute(
-                    f"""
+                cursor.execute(f"""
                     CREATE TABLE {self.table_name} (
                         id BIGINT PRIMARY KEY,
                         embedding VECTOR({self.dim}) NOT NULL,
                         VECTOR INDEX (({index_param["metric_fn"]}(embedding)))
                     );
-                    """
-                )
+                    """)
                 conn.commit()
         except Exception as e:
             log.warning("Failed to create table: %s error: %s", self.table_name, e)
@@ -118,12 +116,10 @@ def _optimize_check_tiflash_replica_progress(self):
         try:
             database = self.db_config["database"]
             with self._get_connection() as (_, cursor):
-                cursor.execute(
-                    f"""
+                cursor.execute(f"""
                     SELECT PROGRESS FROM information_schema.tiflash_replica
                     WHERE TABLE_SCHEMA = "{database}" AND TABLE_NAME = "{self.table_name}"
-                    """  # noqa: S608
-                )
+                    """)  # noqa: S608
                 result = cursor.fetchone()
                 return result[0]
         except Exception as e:
@@ -155,13 +151,11 @@ def _optimize_get_tiflash_index_pending_rows(self):
         try:
             database = self.db_config["database"]
             with self._get_connection() as (_, cursor):
-                cursor.execute(
-                    f"""
+                cursor.execute(f"""
                     SELECT SUM(ROWS_STABLE_NOT_INDEXED)
                     FROM information_schema.tiflash_indexes
                     WHERE TIDB_DATABASE = "{database}" AND TIDB_TABLE = "{self.table_name}"
-                    """  # noqa: S608
-                )
+                    """)  # noqa: S608
                 result = cursor.fetchone()
                 return result[0]
         except Exception as e:
@@ -223,11 +217,9 @@ def search_embedding(
         timeout: int | None = None,
         **kwargs: Any,
     ) -> list[int]:
-        self.cursor.execute(
-            f"""
+        self.cursor.execute(f"""
             SELECT id FROM {self.table_name}
             ORDER BY {self.search_fn}(embedding, "{query!s}") LIMIT {k};
-            """  # noqa: S608
-        )
+            """)  # noqa: S608
         result = self.cursor.fetchall()
         return [int(i[0]) for i in result]

vectordb_bench/frontend/components/custom/displaypPrams.py

@@ -1,6 +1,5 @@
 def displayParams(st):
-    st.markdown(
-        """
+    st.markdown("""
 - `Folder Path` - The path to the folder containing all the files. Please ensure that all files in the folder are in the `Parquet` format.
   - Vectors data files: The file should have two kinds of columns: `id` as an incrementing `int` and `emb` as an array of `float32`. The name of two columns could be defined on your own.
   - Query test vectors: The file could be named on your own and should have two kinds of columns: `id` as an incrementing `int` and `emb` as an array of `float32`. The `id` column must be named as `id`, and `emb` column could be defined on your own.  
@@ -14,8 +13,7 @@ def displayParams(st):
 
 - `Label percentages` - If you have filter file, please input label percentage you want to real run and `split with ','` when it's `more than one`. If you `don't have` filter file, than `keep the text vacant.`
 
-"""
-    )
+""")
     st.caption(
         """We recommend limiting the number of test query vectors, like 1,000.""",
         help="""

vectordb_bench/frontend/components/welcome/explainPrams.py

@@ -1,24 +1,20 @@
 def explainPrams(st):
     st.markdown("## descriptions")
     st.markdown("### 1. Overview")
-    st.markdown(
-        """
+    st.markdown("""
 - **VectorDBBench(VDBBench)** is an open-source benchmarking tool designed specifically for vector databases. Its main features include:
     - (1) An easy-to-use **web UI** for configuration of tests and visual analysis of results.
     - (2) A comprehensive set of **standards for testing and metric collection**.
     - (3) Support for **various scenarios**, including additional support for **Filter** and **Streaming** based on standard tests.
 - VDBBench embraces open-source and welcome contributions of code and test result submissions. The testing process and extended scenarios of VDBBench, as well as the intention behind our design will be introduced as follows.
-"""
-    )
+""")
     st.markdown("### 2. Dataset")
-    st.markdown(
-        """
+    st.markdown("""
 - We provide two embedding datasets:
     - (1)*[Cohere 768dim](https://huggingface.co/datasets/Cohere/wikipedia-22-12)*, generated using the **Cohere** model based on the Wikipedia corpus. 
     - (2)*[Cohere 1024dim](https://huggingface.co/datasets/Cohere/beir-embed-english-v3)*, generated using the **Cohere** embed-english-v3.0 model based on the bioasq corpus.
     - (3)*OpenAI 1536dim*, generated using the **OpenAI** model based on the [C4 corpus](https://huggingface.co/datasets/legacy-datasets/c4).
-"""
-    )
+""")
     st.markdown("### 3. Standard Test")
     st.markdown(
         """
@@ -43,15 +39,12 @@ def explainPrams(st):
         unsafe_allow_html=True,
     )
     st.markdown("### 4. Filter Search Test")
-    st.markdown(
-        """
+    st.markdown("""
 - Compared to the Standard Test, the **Filter Search** introduces additional scalar constraints (e.g. **color == red**) during the Search Test. Different **filter_ratios** present varying levels of challenge to the VectorDB's search performance.
 - We provide an additional **string column** containing 10 labels with different distribution ratios (50%,20%,10%,5%,2%,1%,0.5%,0.2%,0.1%). For each label, we conduct both a **Serial Test** and a **Concurrency Test** to observe the VectorDB's performance in terms of **QPS, latency, and recall** under different filtering conditions.
-"""
-    )
+""")
     st.markdown("### 5. Streaming Search Test")
-    st.markdown(
-        """
+    st.markdown("""
 Different from Standard's load and search separation, Streaming Search Test primarily focuses on **search performance during the insertion process**. 
 Different **base dataset sizes** and varying **insertion rates** set distinct challenges to the VectorDB's search capabilities.
 VDBBench will send insert requests at a **fixed rate**, maintaining consistent insertion pressure. The search test consists of three steps as follows:
@@ -62,5 +55,4 @@ def explainPrams(st):
         - Note: at this time, the insertion pressure drops to zero since data insertion is complete.
 - 3.**Optimized Search (Optional)**
     - Users can optionally perform an additional optimization step followed by a Serial Test and a Concurrent Test, recording qps, latency, and recall performance. This step **compares performance in Streaming section with the theoretically optimal performance**.
-"""
-    )
+""")

vectordb_bench/frontend/utils.py

@@ -1,7 +1,6 @@
 import random
 import string
 
-
 passwordKeys = ["password", "api_key"]