fix(explore): show SQL and error for parsing failures in View Query modal

When SQL generation succeeds but optimization/parsing fails, View Query
modal now displays both the error message and the SQL that failed to parse.

This is Phase 2 of the fix for #35492. Phase 1 fixed validation errors
(before SQL generation). Phase 2 fixes parsing errors (after SQL generation,
during optimization).

Backend changes:
- Added SupersetParseError handling in _get_query()
- Extracts SQL from error.extra['sql'] when parsing fails
- Returns both query and error to frontend

Frontend changes:
- Updated ViewQueryModal to render both Alert and ViewQuery simultaneously
- Changed from ternary (either/or) to conditional rendering (both)
- Added Fragment wrapper to support multiple children

Tests:
- Added backend unit test for SupersetParseError handling
- Added frontend test for rendering both error and SQL
- All 8 backend tests passing
- All 2 frontend tests passing

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sadpandajoe

superset-frontend/src/explore/components/controls/ViewQueryModal.test.tsx

@@ -35,7 +35,7 @@ afterEach(() => {
 
 test('renders Alert component when query result contains validation error', async () => {
   /**
-   * Regression test for issue #35492
+   * Regression test for issue #35492 - Phase 1
    * Verifies that validation errors from the backend are displayed in an Alert
    * component instead of showing a blank panel
    */
@@ -49,7 +49,9 @@ test('renders Alert component when query result contains validation error', asyn
     ],
   });
 
-  render(<ViewQueryModal latestQueryFormData={mockFormData} />);
+  render(<ViewQueryModal latestQueryFormData={mockFormData} />, {
+    useRedux: true,
+  });
 
   // Wait for API call to complete
   await waitFor(() =>
@@ -60,3 +62,47 @@ test('renders Alert component when query result contains validation error', asyn
   expect(screen.getByRole('alert')).toBeInTheDocument();
   expect(screen.getByText('Missing temporal column')).toBeInTheDocument();
 });
+
+test('renders both Alert and SQL query when parsing error occurs', async () => {
+  /**
+   * Regression test for issue #35492 - Phase 2
+   * Verifies that parsing errors (which occur after SQL generation) display
+   * both the error message AND the SQL query that failed to parse.
+   *
+   * This differs from validation errors (Phase 1) where no SQL was generated.
+   * For parsing errors, the SQL was successfully compiled but optimization failed.
+   */
+  // Mock API response with parsing error (has both query and error)
+  fetchMock.post(chartDataEndpoint, {
+    result: [
+      {
+        query: 'SELECT SUM ( Open',
+        error: "Error parsing near 'Open' at line 1:17",
+        language: 'sql',
+      },
+    ],
+  });
+
+  render(<ViewQueryModal latestQueryFormData={mockFormData} />, {
+    useRedux: true,
+  });
+
+  // Wait for the error message to appear
+  await waitFor(() =>
+    expect(
+      screen.getByText("Error parsing near 'Open' at line 1:17"),
+    ).toBeInTheDocument(),
+  );
+
+  // Assert Alert component is rendered with error message
+  expect(screen.getByRole('alert')).toBeInTheDocument();
+
+  // Assert SQL query is also displayed
+  // Note: The SQL is rendered inside a syntax-highlighted code block where
+  // each keyword is in a separate span element
+  await waitFor(() => {
+    expect(screen.getByText('SELECT')).toBeInTheDocument();
+    expect(screen.getByText('SUM')).toBeInTheDocument();
+    expect(screen.getByText('Open')).toBeInTheDocument();
+  });
+});

superset-frontend/src/explore/components/controls/ViewQueryModal.tsx

@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-import { FC, useEffect, useState } from 'react';
+import { FC, Fragment, useEffect, useState } from 'react';
 
 import {
   styled,
@@ -89,23 +89,26 @@ const ViewQueryModal: FC<Props> = ({ latestQueryFormData }) => {
 
   return (
     <ViewQueryModalContainer>
-      {result.map((item, index) =>
-        item.error ? (
-          <Alert
-            key={`error-${index}`}
-            type="error"
-            message={item.error}
-            closable={false}
-          />
-        ) : item.query ? (
-          <ViewQuery
-            key={`query-${index}`}
-            datasource={latestQueryFormData.datasource}
-            sql={item.query}
-            language={item.language}
-          />
-        ) : null,
-      )}
+      {result.map((item, index) => (
+        <Fragment key={index}>
+          {item.error && (
+            <Alert
+              key={`error-${index}`}
+              type="error"
+              message={item.error}
+              closable={false}
+            />
+          )}
+          {item.query && (
+            <ViewQuery
+              key={`query-${index}`}
+              datasource={latestQueryFormData.datasource}
+              sql={item.query}
+              language={item.language}
+            />
+          )}
+        </Fragment>
+      ))}
     </ViewQueryModalContainer>
   );
 };

superset/common/query_actions.py

@@ -24,7 +24,7 @@
 from superset.common.chart_data import ChartDataResultType
 from superset.common.db_query_status import QueryStatus
 from superset.connectors.sqla.models import BaseDatasource
-from superset.exceptions import QueryObjectValidationError
+from superset.exceptions import QueryObjectValidationError, SupersetParseError
 from superset.utils.core import (
     extract_column_dtype,
     extract_dataframe_dtypes,
@@ -86,7 +86,15 @@ def _get_query(
     try:
         result["query"] = datasource.get_query_str(query_obj.to_dict())
     except QueryObjectValidationError as err:
+        # Validation errors (missing required fields, invalid config)
+        # No SQL was generated
         result["error"] = err.message
+    except SupersetParseError as err:
+        # Parsing errors (SQL optimization/parsing failed)
+        # SQL was generated but couldn't be optimized - show both
+        if err.error.extra:
+            result["query"] = err.error.extra.get("sql")
+        result["error"] = err.error.message
     return result
 
 

tests/unit_tests/charts/commands/data/test_get_data_command.py

@@ -15,7 +15,7 @@
 # specific language governing permissions and limitations
 # under the License.
 
-from unittest.mock import Mock
+from unittest.mock import Mock, patch
 
 import pytest
 
@@ -207,3 +207,49 @@ def test_full_result_type_fails_fast_on_first_error_in_multiple_queries() -> Non
         command.run()
 
     assert "First query failed" in str(exc_info.value)
+
+
+def test_get_query_catches_parsing_error() -> None:
+    """
+    Test that _get_query() catches SupersetParseError and returns both SQL and error.
+
+    When SQL generation succeeds but optimization/parsing fails:
+    - SQL has already been compiled (stored in error.extra['sql'])
+    - Error message describes the parsing failure
+    - Both should be returned to the frontend for display
+
+    This is Phase 2 of the fix for GitHub Issue #35492.
+    Phase 1 fixed validation errors (before SQL generation).
+    Phase 2 fixes parsing errors (after SQL generation, during optimization).
+    """
+    from superset.common.query_actions import _get_query
+    from superset.common.query_object import QueryObject
+    from superset.exceptions import SupersetParseError
+
+    # Create mock query_context and query_obj
+    mock_query_context = Mock()
+    mock_query_obj = Mock(spec=QueryObject)
+
+    # Create SupersetParseError with SQL in error.extra
+    parse_error = SupersetParseError(
+        sql="SELECT SUM ( Open",  # SQL was generated before parsing failed
+        engine="postgresql",
+        message="Error parsing near 'Open' at line 1:17",
+        line=1,
+        column=17,
+    )
+
+    # Mock _get_datasource and datasource.get_query_str to raise the error
+    with patch("superset.common.query_actions._get_datasource") as mock_get_ds:
+        mock_datasource = Mock()
+        mock_datasource.query_language = "sql"
+        mock_datasource.get_query_str.side_effect = parse_error
+        mock_get_ds.return_value = mock_datasource
+
+        # GREEN: Exception is caught, values returned (new behavior after fix)
+        result = _get_query(mock_query_context, mock_query_obj, False)
+
+        # Should return both query (from error.extra['sql']) and error message
+        assert result["query"] == "SELECT SUM ( Open"
+        assert result["error"] == "Error parsing near 'Open' at line 1:17"
+        assert result["language"] == "sql"