Trigger splitter: track CASE..END and skip preamble comments

Two follow-ups to the recent CREATE TRIGGER body splitter.

CASE..END expressions inside trigger bodies use the same ``END``
keyword as the BEGIN..END block; the depth tracker decremented on
every ``END`` and prematurely flipped ``in_trigger_body`` to False
on the inner CASE close. The trailing ``;`` then split the DDL
mid-statement and the bare outer ``END`` matched the COMMIT/END
branch in the transaction tracker — exactly the desync the trigger
splitter was meant to prevent.

Add a ``case_depth`` counter scoped to the trigger body. ``CASE``
increments; ``END`` decrements ``case_depth`` first if non-zero,
otherwise decrements ``trigger_depth``. Nested CASE expressions
unwind correctly.

Migration tools (Alembic, Flyway, Liquibase change-log markers)
routinely interleave ``--`` line and ``/* */`` block comments
between top-level keywords. The trigger preamble scanner only
consumed whitespace, so ``CREATE/* migration v3 */TRIGGER ...``
silently bypassed the trigger-body-mode entry. Factor out a
``_skip_ws_and_comments`` helper and use it in the preamble (where
the post-TRIGGER body scan already had full comment handling).

Author: antoineleclair

src/dqliteclient/connection.py

@@ -144,8 +144,15 @@ def _split_top_level_statements(sql: str) -> list[str]:
     # ``in_trigger_body``: inside a ``CREATE TRIGGER ... BEGIN`` body.
     # ``trigger_depth``: inner BEGIN..END nesting count (for compound
     # SQLite trigger bodies, e.g. ``BEGIN ... BEGIN ... END; END;``).
+    # ``case_depth``: open ``CASE`` expressions inside the body. ``END``
+    # closes the innermost CASE first; only when no CASE is open does
+    # ``END`` decrement ``trigger_depth``. Without this counter, an
+    # inner ``CASE WHEN ... END`` would prematurely flip
+    # ``in_trigger_body`` to False and the trailing ``;`` would split
+    # the DDL mid-statement.
     in_trigger_body = False
     trigger_depth = 0
+    case_depth = 0
     # Position in the current statement piece where we last checked
     # for a CREATE TRIGGER preamble — only check ahead of, not behind,
     # to keep this O(n) per piece.
@@ -223,15 +230,24 @@ def _split_top_level_statements(sql: str) -> list[str]:
             else:
                 # Inside trigger body — track nested BEGIN..END so a
                 # compound trigger (BEGIN ... BEGIN ... END; END;)
-                # closes correctly.
+                # closes correctly. Also track CASE expressions so
+                # the inner ``END`` of ``CASE WHEN ... END`` does not
+                # decrement ``trigger_depth``.
                 if kw == "BEGIN":
                     trigger_depth += 1
                     i = kw_end
                     continue
+                if kw == "CASE":
+                    case_depth += 1
+                    i = kw_end
+                    continue
                 if kw == "END":
-                    trigger_depth -= 1
-                    if trigger_depth == 0:
-                        in_trigger_body = False
+                    if case_depth > 0:
+                        case_depth -= 1
+                    else:
+                        trigger_depth -= 1
+                        if trigger_depth == 0:
+                            in_trigger_body = False
                     i = kw_end
                     continue
             i = kw_end
@@ -256,6 +272,32 @@ def _is_word_char(c: str) -> bool:
     return c.isalnum() or c == "_"
 
 
+def _skip_ws_and_comments(sql: str, i: int, n: int) -> int:
+    """Advance past whitespace and SQL comments (``--`` line and
+    ``/* */`` block).
+
+    Used by the trigger-preamble scan so migration-tool output that
+    interleaves comments between top-level keywords (e.g.
+    ``CREATE/* migration v3 */TRIGGER``) parses correctly. Stops at
+    end-of-input or at any non-whitespace, non-comment character.
+    """
+    while i < n:
+        c = sql[i]
+        if c.isspace():
+            i += 1
+            continue
+        if c == "-" and i + 1 < n and sql[i + 1] == "-":
+            nl = sql.find("\n", i + 2)
+            i = n if nl == -1 else nl + 1
+            continue
+        if c == "/" and i + 1 < n and sql[i + 1] == "*":
+            end = sql.find("*/", i + 2)
+            i = n if end == -1 else end + 2
+            continue
+        break
+    return i
+
+
 def _scan_for_trigger_begin(sql: str, after_create: int, n: int) -> int:
     """Look ahead from just after ``CREATE`` for the trigger preamble
     ``[TEMP|TEMPORARY] TRIGGER ... BEGIN`` and return the index just
@@ -269,20 +311,20 @@ def _scan_for_trigger_begin(sql: str, after_create: int, n: int) -> int:
     constructs by the time the alpha-token branch fires).
     """
     i = after_create
-    # Optional whitespace, then optional TEMP/TEMPORARY, then required
-    # TRIGGER keyword.
-    while i < n and sql[i].isspace():
-        i += 1
+    # Optional whitespace + comments, then optional TEMP/TEMPORARY,
+    # then required TRIGGER keyword. Comment-handling matches the
+    # post-TRIGGER body scan so migration-tool output that places
+    # ``/* ... */`` markers between top-level keywords parses
+    # correctly.
+    i = _skip_ws_and_comments(sql, i, n)
     if i >= n:
         return 0
     j = i
     while j < n and _is_word_char(sql[j]):
         j += 1
     word = sql[i:j].upper()
     if word in ("TEMP", "TEMPORARY"):
-        i = j
-        while i < n and sql[i].isspace():
-            i += 1
+        i = _skip_ws_and_comments(sql, j, n)
         j = i
         while j < n and _is_word_char(sql[j]):
             j += 1

tests/test_split_trigger_case_and_comments.py

@@ -0,0 +1,85 @@
+"""Pin: trigger splitter handles CASE...END expressions and comments
+between CREATE and TRIGGER.
+
+Two cycle-19 follow-ups:
+
+1. ``CASE WHEN ... END`` inside a trigger body must NOT decrement
+   ``trigger_depth`` (the END terminates the CASE expression, not
+   the BEGIN..END block).
+2. Comments (``--`` line, ``/* */`` block) between ``CREATE`` and
+   ``TRIGGER`` (or between ``TEMP`` / ``TEMPORARY`` and ``TRIGGER``)
+   must be skipped — migration-tool output routinely interleaves
+   metadata comments at this position.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from dqliteclient.connection import _split_top_level_statements
+
+
+class TestTriggerBodyCaseExpression:
+    def test_simple_case_in_update_kept_together(self) -> None:
+        sql = (
+            "CREATE TRIGGER aud AFTER UPDATE ON t BEGIN\n"
+            "  UPDATE t SET x = CASE WHEN y > 0 THEN 1 ELSE 2 END;\n"
+            "END;"
+        )
+        pieces = _split_top_level_statements(sql)
+        assert len(pieces) == 1
+
+    def test_nested_case(self) -> None:
+        sql = (
+            "CREATE TRIGGER aud AFTER UPDATE ON t BEGIN\n"
+            "  UPDATE t SET x = CASE WHEN y > 0 THEN "
+            "(CASE WHEN z THEN 'a' ELSE 'b' END) ELSE 'c' END;\n"
+            "END;"
+        )
+        pieces = _split_top_level_statements(sql)
+        assert len(pieces) == 1
+
+    def test_multiple_cases_in_body(self) -> None:
+        sql = (
+            "CREATE TRIGGER aud AFTER UPDATE ON t BEGIN\n"
+            "  UPDATE t SET x = CASE WHEN a THEN 1 END;\n"
+            "  UPDATE t SET y = CASE WHEN b THEN 2 ELSE 3 END;\n"
+            "END;"
+        )
+        pieces = _split_top_level_statements(sql)
+        assert len(pieces) == 1
+
+
+class TestTriggerPreambleComments:
+    @pytest.mark.parametrize(
+        "sql",
+        [
+            "CREATE/* migration v3 */TRIGGER aud AFTER INSERT ON x BEGIN UPDATE y SET v=1; END;",
+            "CREATE -- migration v3\nTRIGGER aud AFTER INSERT ON x BEGIN UPDATE y SET v=1; END;",
+            "CREATE TEMP /* tmp */TRIGGER aud AFTER INSERT ON x BEGIN UPDATE y SET v=1; END;",
+            "CREATE/*A*/TEMPORARY/*B*/TRIGGER aud AFTER INSERT ON x BEGIN UPDATE y SET v=1; END;",
+            "CREATE  -- explanation\n   TRIGGER aud AFTER INSERT ON x BEGIN UPDATE y SET v=1; END;",
+        ],
+    )
+    def test_trigger_preamble_with_comments_kept_together(self, sql: str) -> None:
+        pieces = _split_top_level_statements(sql)
+        assert len(pieces) == 1, f"got {len(pieces)} pieces: {pieces!r}"
+
+
+class TestRegressionsFromCycle19StillPass:
+    def test_basic_trigger_body_kept_together(self) -> None:
+        """Sanity: cycle 19's basic regression test still passes."""
+        sql = (
+            "CREATE TRIGGER aud AFTER INSERT ON x BEGIN\n"
+            "  UPDATE y SET v=1 WHERE id=NEW.id;\n"
+            "  DELETE FROM z WHERE id=NEW.id;\n"
+            "END;"
+        )
+        pieces = _split_top_level_statements(sql)
+        assert len(pieces) == 1
+
+    def test_bare_begin_commit_still_split(self) -> None:
+        """Sanity: ordinary multi-statement batches still split."""
+        sql = "BEGIN; INSERT INTO t VALUES (1); COMMIT;"
+        pieces = _split_top_level_statements(sql)
+        assert len(pieces) == 3