fix type issues

Signed-off-by: varun-edachali-dbx <varun.edachali@databricks.com>

Author: varun-edachali-dbx

src/databricks/sql/backend/filters.py

@@ -23,9 +23,6 @@
 if TYPE_CHECKING:
     from databricks.sql.result_set import ResultSet
 
-# Type variable for the result set type
-T = TypeVar("T")
-
 logger = logging.getLogger(__name__)
 
 
@@ -82,7 +79,7 @@ def filter_by_column_values(
         column_index: int,
         allowed_values: List[str],
         case_sensitive: bool = False,
-    ) -> Any:
+    ) -> "ResultSet":
         """
         Filter a result set by values in a specific column.
 
@@ -124,7 +121,7 @@ def filter_by_column_values(
     @staticmethod
     def filter_tables_by_type(
         result_set: "ResultSet", table_types: Optional[List[str]] = None
-    ) -> Any:
+    ) -> "ResultSet":
         """
         Filter a result set of tables by the specified table types.
 

src/databricks/sql/backend/sea_backend.py

@@ -328,7 +328,7 @@ def execute_command(
 
         if state != CommandState.SUCCEEDED:
             raise ServerOperationError(
-                f"Statement execution did not succeed: {status.error.message}",
+                f"Statement execution did not succeed: {status.error.message if status.error else 'Unknown error'}",
                 {
                     "operation-id": command_id.to_sea_statement_id(),
                     "diagnostic-info": None,

src/databricks/sql/backend/utils/http_client.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import requests
-from typing import Dict, Any, Optional, Union, List
+from typing import Callable, Dict, Any, Optional, Union, List, Tuple
 from urllib.parse import urljoin
 
 from databricks.sql.auth.authenticators import AuthProvider
@@ -23,7 +23,7 @@ def __init__(
         server_hostname: str,
         port: int,
         http_path: str,
-        http_headers: List[tuple],
+        http_headers: List[Tuple[str, str]],
         auth_provider: AuthProvider,
         ssl_options: SSLOptions,
         **kwargs,
@@ -40,6 +40,7 @@ def __init__(
             ssl_options: SSL configuration options
             **kwargs: Additional keyword arguments
         """
+
         self.server_hostname = server_hostname
         self.port = port
         self.http_path = http_path
@@ -48,7 +49,7 @@ def __init__(
 
         self.base_url = f"https://{server_hostname}:{port}"
 
-        self.headers = dict(http_headers)
+        self.headers: Dict[str, str] = dict(http_headers)
         self.headers.update({"Content-Type": "application/json"})
 
         self.max_retries = kwargs.get("_retry_stop_after_attempts_count", 30)
@@ -86,6 +87,17 @@ def _get_auth_headers(self) -> Dict[str, str]:
         self.auth_provider.add_headers(headers)
         return headers
 
+    def _get_call(self, method: str) -> Callable:
+        """Get the appropriate HTTP method function."""
+        method = method.upper()
+        if method == "GET":
+            return self.session.get
+        if method == "POST":
+            return self.session.post
+        if method == "DELETE":
+            return self.session.delete
+        raise ValueError(f"Unsupported HTTP method: {method}")
+
     def _make_request(
         self,
         method: str,
@@ -100,33 +112,28 @@ def _make_request(
             method: HTTP method (GET, POST, DELETE)
             path: API endpoint path
             data: Request payload data
+            params: Query parameters
 
         Returns:
             Dict[str, Any]: Response data parsed from JSON
 
         Raises:
             RequestError: If the request fails
         """
+
         url = urljoin(self.base_url, path)
-        headers = {**self.headers, **self._get_auth_headers()}
+        headers: Dict[str, str] = {**self.headers, **self._get_auth_headers()}
 
         logger.debug(f"making {method} request to {url}")
 
         try:
-            args = {
-                "url": url,
-                "headers": headers,
-                "json": data,
-                "params": params,
-            }
-            if method.upper() == "GET":
-                response = self.session.get(**args)
-            elif method.upper() == "POST":
-                response = self.session.post(**args)
-            elif method.upper() == "DELETE":
-                response = self.session.delete(**args)
-            else:
-                raise ValueError(f"Unsupported HTTP method: {method}")
+            call = self._get_call(method)
+            response = call(
+                url=url,
+                headers=headers,
+                json=data,
+                params=params,
+            )
 
             # Check for HTTP errors
             response.raise_for_status()
@@ -137,45 +144,41 @@ def _make_request(
             # Parse JSON response
             if response.content:
                 result = response.json()
-
                 # Log response content (but limit it for large responses)
-                content_str = json.dumps(result, indent=4, sort_keys=True)
-                content_str = (
-                    content_str[:1000] + "..."
-                    if len(content_str) > 1000
-                    else content_str
-                )
-                logger.debug(f"Response content: {content_str}")
-
+                content_str = json.dumps(result)
+                if len(content_str) > 1000:
+                    logger.debug(
+                        f"Response content (truncated): {content_str[:1000]}..."
+                    )
+                else:
+                    logger.debug(f"Response content: {content_str}")
                 return result
             return {}
 
         except requests.exceptions.RequestException as e:
-            # Handle request errors
+            # Handle request errors and extract details from response if available
             error_message = f"SEA HTTP request failed: {str(e)}"
-            logger.error(error_message)
 
-            # Extract error details from response if available
             if hasattr(e, "response") and e.response is not None:
+                status_code = e.response.status_code
                 try:
                     error_details = e.response.json()
                     error_message = (
                         f"{error_message}: {error_details.get('message', '')}"
                     )
                     logger.error(
-                        f"Response status: {e.response.status_code}, Error details: {error_details}"
+                        f"Request failed (status {status_code}): {error_details}"
                     )
                 except (ValueError, KeyError):
-                    # If we can't parse the JSON, just log the raw content
-                    content_str = (
+                    # If we can't parse JSON, log raw content
+                    content = (
                         e.response.content.decode("utf-8", errors="replace")
                         if isinstance(e.response.content, bytes)
                         else str(e.response.content)
                     )
-                    logger.error(
-                        f"Response status: {e.response.status_code}, Raw content: {content_str}"
-                    )
-                    pass
+                    logger.error(f"Request failed (status {status_code}): {content}")
+            else:
+                logger.error(error_message)
 
             # Re-raise as a RequestError
             from databricks.sql.exc import RequestError