feat: Wrap and pass SQL Errors (#6498)

## 📝 Summary

Starting point to format SQL errors in a bit more friendly manner.
@Light2Dark let me know if you want to take over this branch, or create
a PR against it.

<img width="838" height="298" alt="image"
src="https://github.com/user-attachments/assets/7c51e7d6-8339-4a6a-b26b-dc8068a938da"
/>


Not sure what's up with my codegen? I can cherry pick the commit if it's
a little too noisy.

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: dmadisetti

frontend/src/components/editor/output/MarimoErrorOutput.tsx

@@ -1,6 +1,10 @@
 /* Copyright 2024 Marimo. All rights reserved. */
 
-import { NotebookPenIcon, SquareArrowOutUpRightIcon } from "lucide-react";
+import {
+  InfoIcon,
+  NotebookPenIcon,
+  SquareArrowOutUpRightIcon,
+} from "lucide-react";
 import { Fragment, type JSX } from "react";
 import {
   Accordion,
@@ -72,6 +76,8 @@ export const MarimoErrorOutput = ({
     titleContents = "Ancestor stopped";
     alertVariant = "default";
     titleColor = "text-secondary-foreground";
+  } else if (errors.some((e) => e.type === "sql-error")) {
+    titleContents = "SQL Error in statement";
   } else {
     // Check for exception type
     const exceptionError = errors.find((e) => e.type === "exception");
@@ -126,6 +132,10 @@ export const MarimoErrorOutput = ({
   const unknownErrors = errors.filter(
     (e): e is Extract<MarimoError, { type: "unknown" }> => e.type === "unknown",
   );
+  const sqlErrors = errors.filter(
+    (e): e is Extract<MarimoError, { type: "sql-error" }> =>
+      e.type === "sql-error",
+  );
 
   const openScratchpad = () => {
     chromeActions.openApplication("scratchpad");
@@ -485,6 +495,55 @@ export const MarimoErrorOutput = ({
       );
     }
 
+    if (sqlErrors.length > 0) {
+      messages.push(
+        <div key="sql-errors">
+          {sqlErrors.map((error, idx) => {
+            const line =
+              error.sql_line != null ? (error?.sql_line | 0) + 1 : null;
+            const col = error.sql_col != null ? (error?.sql_col | 0) + 1 : null;
+            return (
+              <div key={`sql-error-${idx}`} className="space-y-2">
+                <p className="text-muted-foreground">{error.msg}</p>
+                {error.hint && (
+                  <div className="flex items-start gap-2">
+                    <InfoIcon className="h-4 w-4 text-muted-foreground mt-0.5 flex-shrink-0" />
+                    <pre className="whitespace-pre-wrap text-sm text-muted-foreground">
+                      {error.hint}
+                    </pre>
+                  </div>
+                )}
+                {error.sql_statement && (
+                  <div className="bg-muted/50 p-2 rounded text-xs font-mono">
+                    <pre className="whitespace-pre-wrap">
+                      {error.sql_statement}
+                    </pre>
+                  </div>
+                )}
+                {line !== null && col !== null && (
+                  <p className="text-xs text-muted-foreground">
+                    Error at line {line}, column {col}
+                  </p>
+                )}
+              </div>
+            );
+          })}
+          {cellId && <AutoFixButton errors={sqlErrors} cellId={cellId} />}
+          <Tip title="How to fix SQL errors">
+            <p className="pb-2">
+              SQL parsing errors often occur due to invalid syntax, missing
+              keywords, or unsupported SQL features.
+            </p>
+            <p className="py-2">
+              Check your SQL syntax and ensure you're using supported SQL
+              dialect features. The error location can help you identify the
+              problematic part of your query.
+            </p>
+          </Tip>
+        </div>,
+      );
+    }
+
     return messages;
   };
 

marimo/_ast/sql_utils.py

@@ -1,11 +1,10 @@
 # Copyright 2025 Marimo. All rights reserved.
 
-import ast
-import re
-from typing import Callable, Literal, Optional, TypedDict, Union
+from typing import Literal, Optional, Union
 
 from marimo import _loggers
 from marimo._dependencies.dependencies import DependencyManager
+from marimo._sql.error_utils import log_sql_error
 
 LOGGER = _loggers.marimo_logger()
 
@@ -19,20 +18,6 @@
 ]
 
 
-class SQLErrorMetadata(TypedDict):
-    """Structured metadata for SQL parsing errors."""
-
-    lint_rule: str
-    error_type: str
-    clean_message: str  # Just the meaningful error without SQL trace
-    node_lineno: int
-    node_col_offset: int
-    sql_statement: str  # Truncated if needed
-    sql_line: Optional[int]  # 0-based line within SQL
-    sql_col: Optional[int]  # 0-based column within SQL
-    context: str
-
-
 def classify_sql_statement(
     sql_statement: str, dialect: Optional[SQLGLOT_DIALECTS] = None
 ) -> Union[SQL_TYPE, Literal["unknown"]]:
@@ -75,45 +60,3 @@ def classify_sql_statement(
             return "DQL"
 
     return "unknown"
-
-
-def log_sql_error(
-    logger: Callable[..., None],
-    *,
-    message: str,
-    exception: BaseException,
-    rule_code: str,
-    node: Optional[ast.expr] = None,
-    sql_content: str = "",
-    context: str = "",
-) -> None:
-    """Utility to log SQL-related errors with consistent metadata."""
-    # Parse SQL position from exception message if available
-    sql_line = None
-    sql_col = None
-
-    exception_msg = str(exception)
-    line_col_match = re.search(r"Line (\d+), Col: (\d+)", exception_msg)
-    if line_col_match:
-        sql_line = int(line_col_match.group(1)) - 1  # Convert to 0-based
-        sql_col = int(line_col_match.group(2)) - 1  # Convert to 0-based
-
-    # Truncate long SQL content
-    truncated_sql = sql_content
-    if sql_content and len(sql_content) > 200:
-        truncated_sql = sql_content[:200] + "..."
-
-    # Create metadata using TypedDict
-    metadata: SQLErrorMetadata = {
-        "lint_rule": rule_code,
-        "error_type": type(exception).__name__,
-        "clean_message": exception_msg.split("\n", 1)[0],
-        "node_lineno": node.lineno if node else 0,
-        "node_col_offset": node.col_offset if node else 0,
-        "sql_statement": truncated_sql,
-        "sql_line": sql_line,
-        "sql_col": sql_col,
-        "context": context,
-    }
-
-    logger(message, exception, extra=metadata)

marimo/_ast/visitor.py

@@ -12,7 +12,6 @@
 
 from marimo import _loggers
 from marimo._ast.errors import ImportStarError
-from marimo._ast.sql_utils import log_sql_error
 from marimo._ast.sql_visitor import (
     SQLDefs,
     SQLKind,
@@ -23,6 +22,7 @@
 )
 from marimo._ast.variables import is_local
 from marimo._dependencies.dependencies import DependencyManager
+from marimo._sql.error_utils import log_sql_error
 from marimo._utils.strings import standardize_annotation_quotes
 
 LOGGER = _loggers.marimo_logger()

marimo/_messaging/errors.py

@@ -113,6 +113,25 @@ def describe(self) -> str:
         return self.msg
 
 
+class MarimoSQLError(msgspec.Struct, tag="sql-error"):
+    """
+    SQL-specific error with enhanced metadata for debugging.
+    """
+
+    msg: str
+    sql_statement: str
+    hint: Optional[str] = (
+        None  # Helpful hints like "Did you mean?" or "Candidate bindings"
+    )
+    sql_line: Optional[int] = None  # 0-based line within SQL
+    sql_col: Optional[int] = None  # 0-based column within SQL
+    node_lineno: int = 0
+    node_col_offset: int = 0
+
+    def describe(self) -> str:
+        return self.msg
+
+
 def is_unexpected_error(error: Error) -> bool:
     """
     These errors are unexpected, in that they are not intentional.
@@ -154,5 +173,6 @@ def is_sensitive_error(error: Error) -> bool:
     MarimoInterruptionError,
     MarimoSyntaxError,
     MarimoInternalError,
+    MarimoSQLError,
     UnknownError,
 ]

marimo/_runtime/runner/cell_runner.py

@@ -38,6 +38,10 @@
     get_executor,
 )
 from marimo._runtime.marimo_pdb import MarimoPdb
+from marimo._sql.error_utils import (
+    create_sql_error_from_exception,
+    is_sql_parse_error,
+)
 from marimo._types.ids import CellId_t
 
 LOGGER = marimo_logger()
@@ -403,6 +407,13 @@ def _run_result_from_exception(
                         exception = output
                 except Exception:
                     pass
+        # Handle SQL parsing errors
+        elif unwrapped_exception is not None and is_sql_parse_error(
+            unwrapped_exception
+        ):
+            cell = self.graph.cells[cell_id]
+            output = create_sql_error_from_exception(unwrapped_exception, cell)
+            exception = output
         elif isinstance(unwrapped_exception, MarimoStopError):
             output = unwrapped_exception.output
             exception = unwrapped_exception

marimo/_runtime/runner/hooks_post_execution.py

@@ -16,6 +16,7 @@
 from marimo._messaging.errors import (
     MarimoExceptionRaisedError,
     MarimoInterruptionError,
+    MarimoSQLError,
     MarimoStrictExecutionError,
 )
 from marimo._messaging.ops import (
@@ -333,6 +334,13 @@ def _broadcast_outputs(
             clear_console=False,
             cell_id=cell.cell_id,
         )
+    elif isinstance(run_result.exception, MarimoSQLError):
+        LOGGER.debug("Cell %s raised a SQL error", cell.cell_id)
+        CellOp.broadcast_error(
+            data=[run_result.exception],
+            clear_console=True,
+            cell_id=cell.cell_id,
+        )
     elif run_result.exception is not None:
         LOGGER.debug(
             "Cell %s raised %s",