execsql2 2.22.1__tar.gz → 2.22.3__tar.gz

{execsql2-2.22.1 → execsql2-2.22.3}/.gitignore

@@ -46,10 +46,12 @@ scripts/*
 # Superseded monolith
 _execsql/
 
-# Claude
+# AI
 .claude/
 CLAUDE.md
 AUDIT.md
 DOC_AUDIT.md
 PROMPTS.md
 audit/
+AGENTS.md
+.codex/

{execsql2-2.22.1 → execsql2-2.22.3}/CHANGELOG.md

@@ -13,6 +13,22 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.22.3] - 2026-07-23
+
+### Fixed
+
+- `execsql-format` no longer sends a completed dollar-quoted PL/pgSQL body to sqlglot. A `CREATE FUNCTION … $$ … $$;` or `DO $$ … $$;` whose quote closed before the block was flushed was reformatted (signature exploded, `LANGUAGE … AS` reordered, body types uppercased) and drifted — gaining one space of indentation on every run, so `--check` never converged. Such statements are now kept verbatim.
+
+______________________________________________________________________
+
+## [2.22.2] - 2026-07-13
+
+### Fixed
+
+- `ASK … SUB` now stores the actual answer ("Yes" or "No"); it previously stored "No" for every response, so `IF(IS_TRUE(…))` and `IF(…)` branches keyed on the answer never took the yes path. Pressing `Esc` at the prompt again quits the script.
+
+______________________________________________________________________
+
 ## [2.22.1] - 2026-07-04
 
 ### Fixed

{execsql2-2.22.1 → execsql2-2.22.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.22.1
+Version: 2.22.3
 Summary: Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables.
 Project-URL: Homepage, https://execsql2.readthedocs.io
 Project-URL: Repository, https://github.com/geocoug/execsql
@@ -384,7 +384,7 @@ execsql-format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.22.1
+    rev: v2.22.3
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.1 → execsql2-2.22.3}/README.md

@@ -253,7 +253,7 @@ execsql-format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.22.1
+    rev: v2.22.3
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.1 → execsql2-2.22.3}/docs/about/divergence.md

@@ -111,6 +111,7 @@ Formatter correctness notes added in the 2.19.x line:
 - **2.19.1** — All four substitution-variable forms (`!!var!!`, `!'!var!'!`, `!"!var!"!`, and the deferred form `!{var}!`) are hidden from the sqlglot pass. Previously, `!'!var!'!` and `!"!var!"!` were parsed as `NOT` operators and rewritten — e.g. `!'!myvar!'!` → `NOT NOT '!myvar!'`. Scripts using quoted substitution variables are now safe to run through `execsql-format`.
 - **2.19.2** — The published pre-commit hook declares `sqlglot` as an isolated-env dependency. The 2.19.0 move of `sqlglot` to the `[formatter]` extra meant the hook env (which installs the bare package) crashed with `ModuleNotFoundError: No module named 'sqlglot'` on first run. After upgrading, downstream users should run `pre-commit clean && pre-commit install --install-hooks` once to rebuild the env.
 - **Tagged dollar quotes** — Tagged PL/pgSQL function bodies (`$body$ … $body$`, `$func$ … $func$`, any `$tag$`) are now recognized and skipped over by the formatter. Previously the tracker only saw untagged `$$`, so tagged function bodies were sent to sqlglot which mangled `IF / END IF / LOOP / RETURN`.
+- **Closed dollar quotes** — Any statement that *contains* a dollar-quoted region is now opaque to sqlglot, tracked with a sticky flag rather than the parser's live `in_dollar_quote` state. A complete `CREATE FUNCTION … $$ … $$;` or `DO $$ … $$;` had its quote already closed by the time the block was flushed, so the guard passed and the whole body was reformatted — and, because dropped comments were re-indented onto the nearest output line each pass, the body drifted (gaining a space of indentation) on every run, so `--check` never converged. A side effect is that a single-line `SELECT $$literal$$;` also skips the sqlglot pass (no keyword uppercasing), which is the safe, conservative behavior.
 
 ### GUI
 

{execsql2-2.22.1 → execsql2-2.22.3}/docs/guides/formatter.md

@@ -160,7 +160,7 @@ select id,name,created_at from users where active = true order by name;
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.22.1
+    rev: v2.22.3
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.1 → execsql2-2.22.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.22.1"
+version = "2.22.3"
 description = "Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE.txt" }
@@ -178,7 +178,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.22.1"
+current_version = "2.22.3"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.22.1 → execsql2-2.22.3}/src/execsql/format.py

@@ -642,6 +642,12 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
     # "body" for `$body$`, etc.). Nested markers with a different tag
     # are ignored — only a matching close marker re-opens us.
     current_dq_tag: str | None = None
+    # Sticky flag: True once the current accumulator has seen ANY dollar-quote
+    # marker. `in_dollar_quote` alone is False by the time a complete
+    # `CREATE FUNCTION ... $$ ... $$;` is flushed (the closing `$$` reset it),
+    # which would wrongly hand the PL/pgSQL body to sqlglot. This flag keeps the
+    # whole containing statement opaque to sqlglot. Reset in flush_sql().
+    sql_acc_contains_dollar_quote = False
     in_block_comment = False
     # Track whether we are inside an open SQL statement (last SQL line
     # did not end with ';').  Blank lines mid-statement should NOT flush
@@ -655,15 +661,19 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
 
     def flush_sql() -> None:
         nonlocal in_dollar_quote, current_dq_tag, in_sql_statement
+        nonlocal sql_acc_contains_dollar_quote
         if sql_acc:
             # If any line in the accumulated block is inside a $$-delimited
             # region, skip sqlglot formatting entirely.  PL/pgSQL function
             # bodies contain IF/END IF, LOOP, RETURN, etc. that sqlglot does
             # not understand and will corrupt (e.g., rewriting to COMMIT).
-            safe_for_sqlglot = use_sql and not in_dollar_quote
+            # `sql_acc_contains_dollar_quote` catches the case where the region
+            # already closed (`... $$;`) so `in_dollar_quote` is False at flush.
+            safe_for_sqlglot = use_sql and not in_dollar_quote and not sql_acc_contains_dollar_quote
             output.extend(format_sql_block(sql_acc, depth, indent, safe_for_sqlglot, leading_comma=leading_comma))
             sql_acc.clear()
         in_sql_statement = False
+        sql_acc_contains_dollar_quote = False
 
     for raw_line in source.expandtabs(4).splitlines():
         stripped_line = raw_line.strip()
@@ -727,6 +737,7 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
             # PL/pgSQL. Walk every dollar-quote marker on the line; toggle
             # state only when we hit the matching open or close.
             for m in _DOLLAR_QUOTE_RE.finditer(raw_line):
+                sql_acc_contains_dollar_quote = True
                 tag = m.group(1) or ""
                 if not in_dollar_quote:
                     in_dollar_quote = True

{execsql2-2.22.1 → execsql2-2.22.3}/src/execsql/utils/gui.py

@@ -540,18 +540,27 @@ def gui_credentials(
 # ---------------------------------------------------------------------------
 
 
-def get_yn(prompt: str) -> bool:
-    """Prompt for a yes/no answer on the terminal."""
+def get_yn(prompt: str) -> str:
+    """Prompt for a yes/no answer on the terminal.
+
+    Returns:
+        ``"y"`` or ``"n"``, or ``chr(27)`` (ESC) if the user aborts via EOF
+        (Ctrl-D / piped stdin closed). Matches the upstream v1.130.1
+        ``get_yn`` character contract expected by callers such as ``x_ask``.
+    """
     while True:
-        answer = input(f"{prompt} [y/n]: ").strip().lower()
+        try:
+            answer = input(f"{prompt} [y/n]: ").strip().lower()
+        except EOFError:
+            return chr(27)
         if answer in ("y", "yes"):
-            return True
+            return "y"
         if answer in ("n", "no"):
-            return False
+            return "n"
         print("Please enter y or n.", file=sys.stderr)
 
 
-def get_yn_win(prompt: str) -> bool:
+def get_yn_win(prompt: str) -> str:
     """GUI yes/no dialog — falls back to terminal in headless mode."""
     return get_yn(prompt)
 

{execsql2-2.22.1 → execsql2-2.22.3}/tests/gui/test_backends.py

@@ -786,27 +786,37 @@ class TestGuiPublicAPI:
         from execsql.utils.gui import get_yn
 
         monkeypatch.setattr("builtins.input", lambda *a: "y")
-        assert get_yn("Continue?") is True
+        assert get_yn("Continue?") == "y"
 
     def test_get_yn_no(self, monkeypatch):
         from execsql.utils.gui import get_yn
 
         monkeypatch.setattr("builtins.input", lambda *a: "n")
-        assert get_yn("Continue?") is False
+        assert get_yn("Continue?") == "n"
 
     def test_get_yn_full_words(self, monkeypatch):
         from execsql.utils.gui import get_yn
 
         inputs = iter(["yes"])
         monkeypatch.setattr("builtins.input", lambda *a: next(inputs))
-        assert get_yn("?") is True
+        assert get_yn("?") == "y"
 
     def test_get_yn_retry_on_bad_input(self, monkeypatch):
         from execsql.utils.gui import get_yn
 
         inputs = iter(["maybe", "no"])
         monkeypatch.setattr("builtins.input", lambda *a: next(inputs))
-        assert get_yn("?") is False
+        assert get_yn("?") == "n"
+
+    def test_get_yn_eof_returns_esc(self, monkeypatch):
+        """Ctrl-D / piped EOF is treated as the quit sentinel, matching upstream."""
+        from execsql.utils.gui import get_yn
+
+        def _raise_eof(*a):
+            raise EOFError
+
+        monkeypatch.setattr("builtins.input", _raise_eof)
+        assert get_yn("?") == chr(27)
 
     def test_gui_credentials_console_fallback(self, monkeypatch):
         """gui_credentials must not call auth.get_password (which needs
@@ -912,7 +922,7 @@ class TestGuiPublicAPI:
         from execsql.utils.gui import get_yn_win
 
         monkeypatch.setattr("builtins.input", lambda *a: "y")
-        assert get_yn_win("?") is True
+        assert get_yn_win("?") == "y"
 
     def test_gui_console_on_off_updates_isrunning(self):
         """gui_console_on/off should be reflected by gui_console_isrunning()."""

{execsql2-2.22.1 → execsql2-2.22.3}/tests/metacommands/test_prompt.py

@@ -499,6 +499,33 @@ class TestXAsk:
             os_mock.name = "posix"
             _prompt.x_ask(**self._kwargs())
 
+    def test_real_get_yn_yes_stores_yes(self, fake_state, monkeypatch) -> None:
+        """Regression: ASK ... SUB var must store "Yes" when the user answers y.
+
+        Exercises the real (unmocked) execsql.utils.gui.get_yn through x_ask,
+        driven by a patched builtins.input, instead of mocking get_yn itself.
+        This is what caught the bool-vs-char-contract regression where
+        get_yn() started returning True/False instead of "y"/"n"/chr(27),
+        making x_ask's `resp == "y"` comparison always false.
+        """
+        s = fake_state()
+        _state.gui_console = None
+        monkeypatch.setattr("builtins.input", lambda *a: "y")
+        with patch("execsql.metacommands.prompt.os") as os_mock:
+            os_mock.name = "posix"
+            _prompt.x_ask(**self._kwargs())
+        s.subvars.add_substitution.assert_called_with("ans", "Yes")
+
+    def test_real_get_yn_no_stores_no(self, fake_state, monkeypatch) -> None:
+        """Regression: ASK ... SUB var must store "No" when the user answers n."""
+        s = fake_state()
+        _state.gui_console = None
+        monkeypatch.setattr("builtins.input", lambda *a: "n")
+        with patch("execsql.metacommands.prompt.os") as os_mock:
+            os_mock.name = "posix"
+            _prompt.x_ask(**self._kwargs())
+        s.subvars.add_substitution.assert_called_with("ans", "No")
+
 
 # ---------------------------------------------------------------------------
 # x_pause

{execsql2-2.22.1 → execsql2-2.22.3}/tests/test_format.py

@@ -6,6 +6,7 @@ import subprocess
 import sys
 from unittest.mock import patch
 
+import pytest
 
 from execsql.format import (
     _is_comment_line,
@@ -1825,6 +1826,101 @@ class TestDollarQuotedStrings:
         assert "EXIT WHEN n >= 3" in result
         assert "END LOOP" in result
 
+    def test_closed_dollar_quote_body_not_sent_to_sqlglot(self):
+        """A *complete* `CREATE FUNCTION ... $$ ... $$;` must stay opaque.
+
+        The closing `$$` resets `in_dollar_quote` to False before the block is
+        flushed, so a guard that only checked `in_dollar_quote` handed the whole
+        procedural body to sqlglot — exploding the arg list, reordering
+        `LANGUAGE ... AS`, and uppercasing the body's types. The sticky
+        `sql_acc_contains_dollar_quote` flag keeps the statement verbatim.
+        """
+        source = (
+            "CREATE FUNCTION check_case(val text) RETURNS boolean AS $$\n"
+            "BEGIN\n"
+            "    -- compare lowercased value\n"
+            "    IF lower(val) = val THEN\n"
+            "        RETURN true;\n"
+            "    END IF;\n"
+            "    RETURN false;\n"
+            "END;\n"
+            "$$ LANGUAGE plpgsql;\n"
+        )
+        result = format_file(source, use_sql=True)
+        # Body preserved byte-for-byte: signature not exploded, types not
+        # uppercased, LANGUAGE clause not reordered, indentation intact.
+        assert "CREATE FUNCTION check_case(val text) RETURNS boolean AS $$" in result
+        assert "    -- compare lowercased value" in result
+        assert "        RETURN true;" in result
+        assert "$$ LANGUAGE plpgsql;" in result
+
+    @pytest.mark.parametrize(
+        "source",
+        [
+            # Untagged $$ with a comment inside the body.
+            (
+                "CREATE FUNCTION check_case(val text) RETURNS boolean AS $$\n"
+                "BEGIN\n"
+                "    -- compare lowercased value\n"
+                "    IF lower(val) = val THEN\n"
+                "        RETURN true;\n"
+                "    END IF;\n"
+                "    RETURN false;\n"
+                "END;\n"
+                "$$ LANGUAGE plpgsql;\n"
+            ),
+            # Tagged body ($body$ ... $body$).
+            (
+                "CREATE FUNCTION add_one(x int) RETURNS int AS $body$\n"
+                "BEGIN\n"
+                "    -- add one\n"
+                "    IF x IS NULL THEN\n"
+                "        RETURN 0;\n"
+                "    END IF;\n"
+                "    RETURN x + 1;\n"
+                "END\n"
+                "$body$ LANGUAGE plpgsql;\n"
+            ),
+            # DO $$ ... $$;
+            (
+                "DO $$\n"
+                "DECLARE\n"
+                "    n int := 0;\n"
+                "BEGIN\n"
+                "    -- loop three times\n"
+                "    LOOP\n"
+                "        EXIT WHEN n >= 3;\n"
+                "        n := n + 1;\n"
+                "    END LOOP;\n"
+                "END\n"
+                "$$;\n"
+            ),
+            # Dollar-quoted body wrapped in an explicit BEGIN SQL / END SQL block.
+            (
+                "-- !x! BEGIN SQL\n"
+                "CREATE FUNCTION add_one(x int) RETURNS int AS $$\n"
+                "BEGIN\n"
+                "    -- add one\n"
+                "    RETURN x + 1;\n"
+                "END;\n"
+                "$$ LANGUAGE plpgsql;\n"
+                "-- !x! END SQL\n"
+            ),
+        ],
+        ids=["untagged", "tagged-body", "do-block", "in-begin-sql"],
+    )
+    def test_dollar_quoted_body_idempotent(self, source):
+        """Formatting a dollar-quoted body must be idempotent (no drift).
+
+        Prior to the fix, each SQL-enabled pass re-indented the body's comment
+        and control-flow lines by one more space, so `execsql-format --check`
+        never converged. Assert `first == second == third`.
+        """
+        first = format_file(source, use_sql=True)
+        second = format_file(first, use_sql=True)
+        third = format_file(second, use_sql=True)
+        assert first == second == third
+
     def test_if_inline_regex_agrees_with_parser(self):
         """`_IF_INLINE_RE` (formatter) and `_IF_INLINE_RX` (AST parser) must
         recognise the same inline-IF payloads. They are intentionally kept

{execsql2-2.22.1 → execsql2-2.22.3}/uv.lock

@@ -722,7 +722,7 @@ wheels = [
 
 [[package]]
 name = "execsql2"
-version = "2.22.1"
+version = "2.22.3"
 source = { editable = "." }
 dependencies = [
     { name = "python-dateutil" },