Simplify implementation per review feedback

- Move length check into parse_sql instead of adding utility function
- Rename setting to PRETTIFY_SQL_MAX_LENGTH to match PRETTIFY_SQL
- Change default to 10000 to match sqlparse's MAX_GROUPING_TOKENS
- Remove _format_skipped_sql function (just return escaped SQL)
- Move test imports to file top

Author: kkm-horikawa

debug_toolbar/panels/sql/utils.py

@@ -91,54 +91,21 @@ def is_select_query(sql):
     return sql.lower().lstrip(" (").startswith("select")
 
 
-def _format_skipped_sql(sql, reason):
-    """
-    Format SQL that was skipped from prettification.
-
-    Shows a notice and the first portion of raw SQL for debugging.
-    """
-    preview_length = 500
-    preview = escape(sql[:preview_length])
-    total_length = len(sql)
-
-    if total_length > preview_length:
-        suffix = f"\n\n... ({total_length - preview_length:,} more characters)"
-    else:
-        suffix = ""
-
-    return (
-        f'<span class="djdt-sql-skipped">'
-        f"<em>SQL formatting skipped ({reason})</em>"
-        f"</span>"
-        f"<pre>{preview}{suffix}</pre>"
-    )
-
-
 def reformat_sql(sql, *, with_toggle=False):
-    # Check length threshold to prevent slow formatting of large queries
-    max_length = dt_settings.get_config()["SQL_PRETTIFY_MAX_LENGTH"]
-    if max_length and len(sql) > max_length:
-        skipped = _format_skipped_sql(
-            sql,
-            f"query length {len(sql):,} exceeds threshold {max_length:,}",
-        )
-        if with_toggle:
-            # Return as non-collapsible since both versions would be the same
-            return f'<span class="djDebugUncollapsed">{skipped}</span>'
-        return skipped
-
     formatted = parse_sql(sql)
     if not with_toggle:
         return formatted
     simplified = parse_sql(sql, simplify=True)
-
     uncollapsed = f'<span class="djDebugUncollapsed">{simplified}</span>'
     collapsed = f'<span class="djDebugCollapsed djdt-hidden">{formatted}</span>'
     return collapsed + uncollapsed
 
 
 @lru_cache(maxsize=128)
 def parse_sql(sql, *, simplify=False):
+    max_length = dt_settings.get_config()["PRETTIFY_SQL_MAX_LENGTH"]
+    if max_length and len(sql) > max_length:
+        return escape(sql, quote=False)
     stack = get_filter_stack(simplify=simplify)
     return "".join(stack.run(sql))
 

debug_toolbar/settings.py

@@ -50,7 +50,7 @@ def _is_running_tests():
         "django.utils.functional",
     ),
     "PRETTIFY_SQL": True,
-    "SQL_PRETTIFY_MAX_LENGTH": 50000,  # Skip formatting for SQL longer than this
+    "PRETTIFY_SQL_MAX_LENGTH": 10000,  # Skip formatting for SQL longer than this
     "PROFILER_CAPTURE_PROJECT_CODE": True,
     "PROFILER_MAX_DEPTH": 10,
     "PROFILER_THRESHOLD_RATIO": 8,

docs/changes.rst

@@ -4,10 +4,10 @@ Change log
 Pending
 -------
 
-* Added ``SQL_PRETTIFY_MAX_LENGTH`` setting to skip SQL formatting for
-  queries exceeding the threshold. This prevents the SQL panel from freezing
-  or crashing when queries contain large IN clauses with thousands of
-  parameters.
+* Added ``PRETTIFY_SQL_MAX_LENGTH`` setting to skip SQL formatting for
+  queries exceeding the threshold (default: 10000, matching sqlparse's
+  ``MAX_GROUPING_TOKENS``). This prevents the SQL panel from freezing
+  when queries contain large IN clauses with thousands of parameters.
 * Deprecated ``RedirectsPanel`` in favor of ``HistoryPanel`` for viewing
   toolbar data from redirected requests.
 * Fixed support for generating code coverage comments in PRs.

tests/panels/test_sql.py

@@ -19,6 +19,7 @@
 from debug_toolbar import settings as dt_settings
 from debug_toolbar.models import HistoryEntry
 from debug_toolbar.panels.sql import SQLPanel, tracking
+from debug_toolbar.panels.sql.utils import reformat_sql
 
 try:
     import psycopg
@@ -870,48 +871,42 @@ def test_explain_with_union(self):
         self.assertTrue(query["is_select"])
 
     @override_settings(
-        DEBUG_TOOLBAR_CONFIG={"SQL_PRETTIFY_MAX_LENGTH": 100, "PRETTIFY_SQL": True}
+        DEBUG_TOOLBAR_CONFIG={"PRETTIFY_SQL_MAX_LENGTH": 100, "PRETTIFY_SQL": True}
     )
-    def test_sql_prettify_max_length(self):
+    def test_prettify_sql_max_length(self):
         """
         Test that SQL formatting is skipped for queries exceeding the max length threshold.
         """
-        from debug_toolbar.panels.sql.utils import reformat_sql
-
-        # Short SQL should be formatted normally
+        # Short SQL should be formatted normally (includes <strong> tags for keywords)
         short_sql = "SELECT * FROM auth_user WHERE id = 1"
         result = reformat_sql(short_sql, with_toggle=True)
-        self.assertNotIn("SQL formatting skipped", result)
-        self.assertIn("SELECT", result)
+        self.assertIn("<strong>", result)
 
-        # Long SQL should skip formatting and show a message
+        # Long SQL should skip formatting (no <strong> tags, just escaped SQL)
         long_sql = (
             "SELECT * FROM auth_user WHERE id IN ("
             + ", ".join([f"'{i}'" for i in range(100)])
             + ")"
         )
         result = reformat_sql(long_sql, with_toggle=True)
-        self.assertIn("SQL formatting skipped", result)
-        self.assertIn("exceeds threshold", result)
+        self.assertNotIn("<strong>", result)
+        self.assertIn("SELECT", result)
 
-    def test_sql_prettify_max_length_disabled(self):
+    @override_settings(
+        DEBUG_TOOLBAR_CONFIG={"PRETTIFY_SQL_MAX_LENGTH": 0, "PRETTIFY_SQL": True}
+    )
+    def test_prettify_sql_max_length_disabled(self):
         """
-        Test that SQL_PRETTIFY_MAX_LENGTH=0 or None disables the length check.
+        Test that PRETTIFY_SQL_MAX_LENGTH=0 disables the length check.
         """
-        from debug_toolbar.panels.sql.utils import reformat_sql
-
         long_sql = (
             "SELECT * FROM auth_user WHERE id IN ("
             + ", ".join([f"'{i}'" for i in range(100)])
             + ")"
         )
-
-        with override_settings(
-            DEBUG_TOOLBAR_CONFIG={"SQL_PRETTIFY_MAX_LENGTH": 0, "PRETTIFY_SQL": True}
-        ):
-            result = reformat_sql(long_sql, with_toggle=True)
-            # When max_length is 0 (falsy), formatting should not be skipped
-            self.assertNotIn("SQL formatting skipped", result)
+        result = reformat_sql(long_sql, with_toggle=True)
+        # When max_length is 0 (falsy), formatting should not be skipped
+        self.assertIn("<strong>", result)
 
 
 class SQLPanelMultiDBTestCase(BaseMultiDBTestCase):