[fix] Format clickhouse_handler with ruff 0.11.11

Author: HamoonDBA

mindsdb/integrations/handlers/clickhouse_handler/clickhouse_handler.py

@@ -13,7 +13,7 @@
 from mindsdb.integrations.libs.response import (
     HandlerStatusResponse as StatusResponse,
     HandlerResponse as Response,
-    RESPONSE_TYPE
+    RESPONSE_TYPE,
 )
 
 logger = log.getLogger(__name__)
@@ -24,15 +24,15 @@ class ClickHouseHandler(MetaDatabaseHandler):
     This handler handles connection and execution of the ClickHouse statements.
     """
 
-    name = 'clickhouse'
+    name = "clickhouse"
 
     def __init__(self, name, connection_data, **kwargs):
         super().__init__(name)
-        self.dialect = 'clickhouse'
+        self.dialect = "clickhouse"
         self.connection_data = connection_data
         self.renderer = SqlalchemyRender(ClickHouseDialect)
         self.is_connected = False
-        self.protocol = connection_data.get('protocol', 'native')
+        self.protocol = connection_data.get("protocol", "native")
         self._has_is_nullable_column = None  # Cache for version check
 
     def __del__(self):
@@ -52,23 +52,23 @@ def connect(self):
         if self.is_connected:
             return self.connection
 
-        protocol = "clickhouse+native" if self.protocol == 'native' else "clickhouse+http"
-        host = quote(self.connection_data['host'])
-        port = self.connection_data['port']
-        user = quote(self.connection_data['user'])
-        password = quote(self.connection_data['password'])
-        database = quote(self.connection_data['database'])
-        url = f'{protocol}://{user}:{password}@{host}:{port}/{database}'
+        protocol = "clickhouse+native" if self.protocol == "native" else "clickhouse+http"
+        host = quote(self.connection_data["host"])
+        port = self.connection_data["port"]
+        user = quote(self.connection_data["user"])
+        password = quote(self.connection_data["password"])
+        database = quote(self.connection_data["database"])
+        url = f"{protocol}://{user}:{password}@{host}:{port}/{database}"
         # This is not redundunt. Check https://clickhouse-sqlalchemy.readthedocs.io/en/latest/connection.html#http
-        if self.protocol == 'https':
+        if self.protocol == "https":
             url = url + "?protocol=https"
         try:
             engine = create_engine(url)
             connection = engine.raw_connection()
             self.is_connected = True
             self.connection = connection
         except SQLAlchemyError as e:
-            logger.error(f'Error connecting to ClickHouse {self.connection_data["database"]}, {e}!')
+            logger.error(f"Error connecting to ClickHouse {self.connection_data['database']}, {e}!")
             self.is_connected = False
             raise
 
@@ -88,12 +88,12 @@ def check_connection(self) -> StatusResponse:
             connection = self.connect()
             cur = connection.cursor()
             try:
-                cur.execute('select 1;')
+                cur.execute("select 1;")
             finally:
                 cur.close()
             response.success = True
         except SQLAlchemyError as e:
-            logger.error(f'Error connecting to ClickHouse {self.connection_data["database"]}, {e}!')
+            logger.error(f"Error connecting to ClickHouse {self.connection_data['database']}, {e}!")
             response.error_message = str(e)
             self.is_connected = False
 
@@ -119,22 +119,13 @@ def native_query(self, query: str) -> Response:
             cur.execute(query)
             result = cur.fetchall()
             if result:
-                response = Response(
-                    RESPONSE_TYPE.TABLE,
-                    pd.DataFrame(
-                        result,
-                        columns=[x[0] for x in cur.description]
-                    )
-                )
+                response = Response(RESPONSE_TYPE.TABLE, pd.DataFrame(result, columns=[x[0] for x in cur.description]))
             else:
                 response = Response(RESPONSE_TYPE.OK)
             connection.commit()
         except SQLAlchemyError as e:
-            logger.error(f'Error running query: {query} on {self.connection_data["database"]}!')
-            response = Response(
-                RESPONSE_TYPE.ERROR,
-                error_message=str(e)
-            )
+            logger.error(f"Error running query: {query} on {self.connection_data['database']}!")
+            response = Response(RESPONSE_TYPE.ERROR, error_message=str(e))
             connection.rollback()
         finally:
             cur.close()
@@ -157,7 +148,7 @@ def get_tables(self) -> Response:
         df = result.data_frame
 
         if df is not None:
-            result.data_frame = df.rename(columns={df.columns[0]: 'table_name'})
+            result.data_frame = df.rename(columns={df.columns[0]: "table_name"})
 
         return result
 
@@ -173,13 +164,13 @@ def _check_has_is_nullable_column(self) -> bool:
         """
         Checks if the is_nullable column exists in system.columns table.
         This column was added in ClickHouse 23.x.
-        
+
         Returns:
             bool: True if is_nullable column exists, False otherwise.
         """
         if self._has_is_nullable_column is not None:
             return self._has_is_nullable_column
-        
+
         try:
             check_query = """
                 SELECT name 
@@ -189,14 +180,11 @@ def _check_has_is_nullable_column(self) -> bool:
                     AND name = 'is_nullable'
             """
             result = self.native_query(check_query)
-            self._has_is_nullable_column = (
-                result.resp_type == RESPONSE_TYPE.TABLE 
-                and not result.data_frame.empty
-            )
+            self._has_is_nullable_column = result.resp_type == RESPONSE_TYPE.TABLE and not result.data_frame.empty
         except Exception as e:
             logger.warning(f"Could not check for is_nullable column: {e}")
             self._has_is_nullable_column = False
-        
+
         return self._has_is_nullable_column
 
     def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
@@ -210,8 +198,8 @@ def meta_get_tables(self, table_names: Optional[List[str]] = None) -> Response:
         Returns:
             Response: A response object containing the metadata information.
         """
-        database = self.connection_data['database']
-        
+        database = self.connection_data["database"]
+
         query = f"""
             SELECT 
                 name as table_name,
@@ -244,23 +232,23 @@ def meta_get_columns(self, table_names: Optional[List[str]] = None) -> Response:
         Returns:
             Response: A response object containing the column metadata.
         """
-        database = self.connection_data['database']
-        
+        database = self.connection_data["database"]
+
         # Check if is_nullable column is available (ClickHouse 23.x+)
         has_is_nullable = self._check_has_is_nullable_column()
-        
+
         # Build the SELECT clause based on available columns
         select_clause = """
                 table as table_name,
                 name as column_name,
                 type as data_type,
                 comment as column_description,
                 default_expression as column_default"""
-        
+
         if has_is_nullable:
             select_clause += """,
                 is_nullable as is_nullable"""
-        
+
         query = f"""
             SELECT {select_clause}
             FROM system.columns
@@ -295,15 +283,15 @@ def meta_get_column_statistics_for_table(
     ) -> Response:
         """
         Retrieves column statistics for a specific table.
-        
+
         Args:
             table_name (str): The name of the table.
-            column_names (Optional[List[str]]): List of column names to retrieve statistics for. 
+            column_names (Optional[List[str]]): List of column names to retrieve statistics for.
                                                   If None, statistics for all columns will be returned.
         Returns:
             Response: A response object containing the column statistics for the table.
         """
-        database = self.connection_data['database']
+        database = self.connection_data["database"]
 
         # Get the list of columns for this table
         columns_query = f"""
@@ -326,14 +314,16 @@ def meta_get_column_statistics_for_table(
             # Build statistics query - collect all stats in one query
             select_parts = []
             for _, row in columns_result.data_frame.iterrows():
-                col = row['name']
+                col = row["name"]
                 # Use backticks to handle special characters in column names
-                select_parts.extend([
-                    f"countIf(`{col}` IS NULL) AS nulls_{col}",
-                    f"uniq(`{col}`) AS distincts_{col}",
-                    f"toString(min(`{col}`)) AS min_{col}",
-                    f"toString(max(`{col}`)) AS max_{col}",
-                ])
+                select_parts.extend(
+                    [
+                        f"countIf(`{col}` IS NULL) AS nulls_{col}",
+                        f"uniq(`{col}`) AS distincts_{col}",
+                        f"toString(min(`{col}`)) AS min_{col}",
+                        f"toString(max(`{col}`)) AS max_{col}",
+                    ]
+                )
 
             if not select_parts:
                 return Response(RESPONSE_TYPE.TABLE, pd.DataFrame())
@@ -342,7 +332,7 @@ def meta_get_column_statistics_for_table(
             stats_query = f"""
                 SELECT 
                     count(*) AS total_rows,
-                    {', '.join(select_parts)}
+                    {", ".join(select_parts)}
                 FROM `{database}`.`{table_name}`
             """
 
@@ -353,55 +343,58 @@ def meta_get_column_statistics_for_table(
                 # Return placeholder stats
                 placeholder_data = []
                 for _, row in columns_result.data_frame.iterrows():
-                    placeholder_data.append({
-                        'table_name': table_name,
-                        'column_name': row['name'],
-                        'null_percentage': None,
-                        'distinct_values_count': None,
-                        'most_common_values': None,
-                        'most_common_frequencies': None,
-                        'minimum_value': None,
-                        'maximum_value': None,
-                    })
+                    placeholder_data.append(
+                        {
+                            "table_name": table_name,
+                            "column_name": row["name"],
+                            "null_percentage": None,
+                            "distinct_values_count": None,
+                            "most_common_values": None,
+                            "most_common_frequencies": None,
+                            "minimum_value": None,
+                            "maximum_value": None,
+                        }
+                    )
                 return Response(RESPONSE_TYPE.TABLE, pd.DataFrame(placeholder_data))
 
             # Parse the stats result
             stats_data = stats_result.data_frame.iloc[0]
-            total_rows = stats_data.get('total_rows', 0)
+            total_rows = stats_data.get("total_rows", 0)
 
             # Build the final statistics DataFrame
             all_stats = []
             for _, row in columns_result.data_frame.iterrows():
-                col = row['name']
-                nulls = stats_data.get(f'nulls_{col}', 0)
-                distincts = stats_data.get(f'distincts_{col}', None)
-                min_val = stats_data.get(f'min_{col}', None)
-                max_val = stats_data.get(f'max_{col}', None)
+                col = row["name"]
+                nulls = stats_data.get(f"nulls_{col}", 0)
+                distincts = stats_data.get(f"distincts_{col}", None)
+                min_val = stats_data.get(f"min_{col}", None)
+                max_val = stats_data.get(f"max_{col}", None)
 
                 # Calculate null percentage
                 null_pct = None
                 if total_rows is not None and total_rows > 0:
                     null_pct = round((nulls / total_rows) * 100, 2)
 
-                all_stats.append({
-                    'table_name': table_name,
-                    'column_name': col,
-                    'null_percentage': null_pct,
-                    'distinct_values_count': distincts,
-                    'most_common_values': None,
-                    'most_common_frequencies': None,
-                    'minimum_value': min_val,
-                    'maximum_value': max_val,
-                })
+                all_stats.append(
+                    {
+                        "table_name": table_name,
+                        "column_name": col,
+                        "null_percentage": null_pct,
+                        "distinct_values_count": distincts,
+                        "most_common_values": None,
+                        "most_common_frequencies": None,
+                        "minimum_value": min_val,
+                        "maximum_value": max_val,
+                    }
+                )
 
             return Response(RESPONSE_TYPE.TABLE, pd.DataFrame(all_stats))
 
         except Exception as e:
             logger.error(f"Exception while fetching statistics for table {table_name}: {e}")
             # Return empty stats on error
             return Response(
-                RESPONSE_TYPE.ERROR, 
-                error_message=f"Could not retrieve statistics for table {table_name}: {str(e)}"
+                RESPONSE_TYPE.ERROR, error_message=f"Could not retrieve statistics for table {table_name}: {str(e)}"
             )
 
     def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Response:
@@ -414,8 +407,8 @@ def meta_get_primary_keys(self, table_names: Optional[List[str]] = None) -> Resp
         Returns:
             Response: A response object containing the primary key information.
         """
-        database = self.connection_data['database']
-        
+        database = self.connection_data["database"]
+
         query = f"""
             SELECT 
                 table as table_name,
@@ -449,13 +442,15 @@ def meta_get_foreign_keys(self, table_names: Optional[List[str]] = None) -> Resp
         """
         # ClickHouse does not support foreign key constraints
         # Return an empty DataFrame with the expected columns
-        df = pd.DataFrame(columns=[
-            'parent_table_name',
-            'parent_column_name', 
-            'child_table_name',
-            'child_column_name',
-            'constraint_name'
-        ])
+        df = pd.DataFrame(
+            columns=[
+                "parent_table_name",
+                "parent_column_name",
+                "child_table_name",
+                "child_column_name",
+                "constraint_name",
+            ]
+        )
         return Response(RESPONSE_TYPE.TABLE, df)
 
     def meta_get_handler_info(self, **kwargs) -> str: