execsql2 2.22.2__tar.gz → 2.22.4__tar.gz

{execsql2-2.22.2 → execsql2-2.22.4}/.github/workflows/ci-cd.yml

@@ -323,7 +323,7 @@ jobs:
                   name: ${{ github.event.repository.name }}
                   path: dist/
             - name: Publish to PyPI
-              uses: pypa/gh-action-pypi-publish@cef221092ed1bacb1cc03d23a2d87d1d172e277b  # release/v1
+              uses: pypa/gh-action-pypi-publish@dc37677b2e1c63e2034f94d8a5b11f265b73ba33  # v1.14.2
               with:
                   packages-dir: dist
                   skip-existing: true

{execsql2-2.22.2 → execsql2-2.22.4}/.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.2 → execsql2-2.22.4}/CHANGELOG.md

@@ -13,6 +13,24 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.22.4] - 2026-08-27
+
+### Fixed
+
+- `HALT` with a message no longer opens a dialog and blocks forever in unattended runs. Without a GUI console and below `gui_level` 2 (no `-v2`/`-v3`), the message is written to the console and the script exits with the requested `EXIT_STATUS` — as the documentation has always described. Scripts that worked around this by pairing `WRITE` with a bare `HALT` can go back to `HALT MESSAGE`.
+- `HALT … DISPLAY` now shows its table on the console in non-interactive runs instead of discarding it; an empty table appears as its column headings and a count of zero rows.
+- Textual (`--gui-framework textual`) `HALT` dialogs now show the single OK button the metacommand asks for, rather than a Cancel/Continue pair whose Cancel exited with status 2 instead of the requested `EXIT_STATUS`. `HALT … DISPLAY` also renders its table in the dialog, and <kbd>Esc</kbd> no longer cancels it.
+
+______________________________________________________________________
+
+## [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

{execsql2-2.22.2 → execsql2-2.22.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: execsql2
-Version: 2.22.2
+Version: 2.22.4
 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.2
+    rev: v2.22.4
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.2 → execsql2-2.22.4}/README.md

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

{execsql2-2.22.2 → execsql2-2.22.4}/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
 
@@ -314,6 +315,8 @@ These are behavioral changes driven by security or correctness issues in the ups
 | DB-export type inference overrides source types     | `DataTable`/`Column` inferred column types from the *string shape* of values — correct for CSV import (everything is `str`) but wrong for DB-query exports where the driver returns typed Python objects. A text column with values like `"2026-06-30 10:07:20 PM"` was inferred as `TIMESTAMP`, causing DuckDB bind errors. SQLite, DuckDB, HDF5, and JSON-schema exports now pass `infer_strings=False` to `DataTable`: string values are classified as text types only, while native Python objects (`Decimal`, `datetime`, etc.) still run through the full accumulator set for accurate schema inference. |
 | `EXPORT FORMAT SQLITE` rejects `decimal.Decimal`    | SQLite's Python adapter does not accept `Decimal` in `executemany`, raising `ProgrammingError`. SQLite exports now convert `Decimal` values to their exact string representation before binding; SQLite's NUMERIC affinity stores them without loss of precision.                                                                                                                                                                                                                                                                                                                                              |
 | Unsupported Python objects crash native exports     | `EXPORT FORMAT SQLITE` and `EXPORT FORMAT DUCKDB` raised bind errors when the DB driver returned user-defined Python objects (e.g. PostGIS geometry). Both exporters now stringify any object whose type is not in the adapter's safe-binding set, preserving values as their `str()` form instead of crashing.                                                                                                                                                                                                                                                                                                |
+| `HALT` with a message hangs unattended runs         | The message-bearing `HALT` patterns are registered after the general one and so take priority, meaning `x_halt`'s `gui_level > 1` guard was never reached and every `HALT MESSAGE` opened a modal dialog — blocking cron and CI runs indefinitely at `gui_level` 0, contrary to the documented behavior. The guard now lives in `x_halt_msg`: without a GUI console and below `gui_level` 2, the message and any `DISPLAY` rowset are written to the error output and the script exits with the requested status. An empty `DISPLAY` table renders as headings plus a zero row count rather than nothing.      |
+| Textual `HALT` dialog ignored `button_list`         | The Textual `MsgScreen` hardcoded a Cancel/Continue pair and dropped the caller's `column_headers`/`rowset`, so a `HALT` asking for a single OK button offered a Cancel that exited with status 2 instead of the requested `EXIT_STATUS`, and `HALT ... DISPLAY` showed no table. `MsgScreen` now honors `button_list` and `no_cancel` (which also suppresses <kbd>Esc</kbd>) and renders the rowset, matching the Tkinter backend.                                                                                                                                                                            |
 
 ______________________________________________________________________
 

{execsql2-2.22.2 → execsql2-2.22.4}/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.2
+    rev: v2.22.4
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.2 → execsql2-2.22.4}/docs/reference/configuration.md

@@ -247,7 +247,7 @@ The section and property names that may be used in a configuration file are list
 
     - 0: Do not use any optional GUI dialogs.
     - 1: Use GUI dialogs for password prompts and for the [PAUSE](metacommands.md#pause) metacommand.
-    - 2: Also use a GUI dialog if a message is included with the [HALT](metacommands.md#halt) metacommand, and prompt for the initial database to use if no database connection parameters are specified in a configuration file or on the command line.
+    - 2: Also use a GUI dialog if a message is included with the [HALT](metacommands.md#halt) metacommand, and prompt for the initial database to use if no database connection parameters are specified in a configuration file or on the command line. At levels 0 and 1, a HALT message is written to the console instead, and the script exits without waiting for input.
     - 3: Additionally, open a GUI console when *execsql* starts.
 
 `gui_framework` { #gui_framework }

{execsql2-2.22.2 → execsql2-2.22.4}/docs/reference/metacommands.md

@@ -1361,11 +1361,23 @@ HALT [[MESSAGE] "<error_message>" [TEE TO <outfile>]]
     [DISPLAY <table_or_view>] [EXIT_STATUS <n>]
 ```
 
-Script processing is halted, and the *execsql* program terminates. If an error message is provided, it is written to the console, unless the "-v2" or "-v3" option is used, in which case the message is displayed in a dialog. If the TEE clause is used, the error message will be appended to the specified file. If the DISPLAY clause is used, the specified table or view will be displayed in a GUI dialog. If an EXIT_STATUS value is specified, the [system exit status](https://en.wikipedia.org/wiki/Exit_status) is set to that value, otherwise, the system exit status is set to 3.
+Script processing is halted, and the *execsql* program terminates. If the TEE clause is used, the error message will be appended to the specified file. If an EXIT_STATUS value is specified, the [system exit status](https://en.wikipedia.org/wiki/Exit_status) is set to that value, otherwise, the system exit status is set to 3.
+
+The error message and the DISPLAY table are reported in a dialog only when the run is interactive — that is, when the "-v2" or "-v3" option is used (or [`gui_level`](configuration.md#gui_level) is set to 2 or 3), or a GUI console is already open. Otherwise the message is written to the console, followed by the DISPLAY table as a plain-text table with a row count, and the script exits immediately. An unattended run therefore fails with the requested exit status rather than waiting on a dialog that nobody is present to dismiss.
+
+A DISPLAY table with no rows is shown on the console as its column headings and a count of zero rows; in a dialog, an empty table is omitted.
+
+```sql
+-- Fail the run and print the offending rows, in a cron job or in a GUI session.
+-- !x! if(hasrows(bad_rows)) { halt message "Validation failed." display bad_rows exit_status 7 }
+```
 
 !!! warning
     A backward-incompatible change to HALT MESSAGE was made in version 1.26.1.0 (2018-06-13): the default exit status was changed from 2 to 3.
 
+!!! note
+    Through execsql 2.22.3, a HALT that carried a message always opened a dialog, even at `gui_level` 0, which caused unattended runs to block indefinitely. Scripts that worked around this by writing the message with [WRITE](#write) before a bare `HALT` do not need to change, but they can now use `HALT MESSAGE` directly.
+
 The text to be written may be enclosed in double quotes (as shown above), or in single quotes, matching square brackets, backticks, tildes, or hash marks (#).
 
 

{execsql2-2.22.2 → execsql2-2.22.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.22.2"
+version = "2.22.4"
 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.2"
+current_version = "2.22.4"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.22.2 → execsql2-2.22.4}/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.2 → execsql2-2.22.4}/src/execsql/gui/base.py

@@ -9,11 +9,66 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     pass
 
-__all__ = ["DiffResult", "GuiBackend", "compare_stats", "compute_row_diffs"]
+__all__ = ["DiffResult", "GuiBackend", "compare_stats", "compute_row_diffs", "format_table", "row_count_text"]
 
 DIFF_MARKER = "● "
 
 
+# ---------------------------------------------------------------------------
+# Plain-text table rendering (shared by the console backend and by
+# non-interactive metacommand fallbacks such as HALT ... DISPLAY)
+# ---------------------------------------------------------------------------
+
+
+def row_count_text(n: int) -> str:
+    """Return a human-readable row count string, e.g. ``'3 rows'`` or ``'1 row'``."""
+    return f"{n:,} row{'s' if n != 1 else ''}"
+
+
+def format_table(
+    headers: list,
+    rows: list,
+    row_states: list[str] | None = None,
+    changed_cols: list[set[str]] | None = None,
+) -> str:
+    """Render *headers* and *rows* as a plain-text table.
+
+    Columns are left-aligned and padded to the widest value.  When *row_states*
+    and *changed_cols* are provided, cells that differ in ``"changed"`` rows are
+    prefixed with the diff marker (``"● "``) and the marker width is included in
+    the column sizing.
+
+    Returns an empty string when *headers* is empty.  The result has no trailing
+    newline.
+    """
+    if not headers:
+        return ""
+    headers_str = [str(h) for h in headers]
+
+    # Pre-compute display values so column widths account for markers.
+    display_rows: list[list[str]] = []
+    for ridx, row in enumerate(rows):
+        cells: list[str] = []
+        state = row_states[ridx] if row_states and ridx < len(row_states) else ""
+        diff_set = changed_cols[ridx] if changed_cols and ridx < len(changed_cols) else set()
+        for ci, cell in enumerate(row):
+            val = str(cell) if cell is not None else ""
+            if state == "changed" and ci < len(headers_str) and headers_str[ci] in diff_set:
+                val = f"{DIFF_MARKER}{val}"
+            cells.append(val)
+        display_rows.append(cells)
+
+    col_widths = [len(h) for h in headers_str]
+    for cells in display_rows:
+        for i, cell in enumerate(cells):
+            col_widths[i] = max(col_widths[i], len(cell))
+    fmt = "  " + "  ".join(f"{{:<{w}}}" for w in col_widths)
+    sep = "  " + "  ".join("-" * w for w in col_widths)
+    lines = [fmt.format(*headers_str), sep]
+    lines.extend(fmt.format(*cells) for cells in display_rows)
+    return "\n".join(lines)
+
+
 # ---------------------------------------------------------------------------
 # Value comparison helpers
 # ---------------------------------------------------------------------------

{execsql2-2.22.2 → execsql2-2.22.4}/src/execsql/gui/console.py

@@ -11,7 +11,13 @@ import sys
 import time
 from typing import Any, cast
 
-from execsql.gui.base import DIFF_MARKER, GuiBackend, compare_stats as _compare_stats, compute_row_diffs
+from execsql.gui.base import (
+    GuiBackend,
+    compare_stats as _compare_stats,
+    compute_row_diffs,
+    format_table,
+    row_count_text as _row_count_text,
+)
 
 __all__ = ["ConsoleBackend"]
 
@@ -23,11 +29,6 @@ def _print_help_url(args: dict) -> None:
         print(f"  Help: {url}", file=sys.stderr)
 
 
-def _row_count_text(n: int) -> str:
-    """Return a human-readable row count string, e.g. '3 rows' or '1 row'."""
-    return f"{n:,} row{'s' if n != 1 else ''}"
-
-
 def _print_table(
     headers: list,
     rows: list,
@@ -42,33 +43,9 @@ def _print_table(
     """
     if file is None:
         file = sys.stderr
-    if not headers:
-        return
-    headers_str = [str(h) for h in headers]
-
-    # Pre-compute display values so column widths account for markers.
-    display_rows: list[list[str]] = []
-    for ridx, row in enumerate(rows):
-        cells: list[str] = []
-        state = row_states[ridx] if row_states and ridx < len(row_states) else ""
-        diff_set = changed_cols[ridx] if changed_cols and ridx < len(changed_cols) else set()
-        for ci, cell in enumerate(row):
-            val = str(cell) if cell is not None else ""
-            if state == "changed" and ci < len(headers_str) and headers_str[ci] in diff_set:
-                val = f"{DIFF_MARKER}{val}"
-            cells.append(val)
-        display_rows.append(cells)
-
-    col_widths = [len(h) for h in headers_str]
-    for cells in display_rows:
-        for i, cell in enumerate(cells):
-            col_widths[i] = max(col_widths[i], len(cell))
-    fmt = "  " + "  ".join(f"{{:<{w}}}" for w in col_widths)
-    sep = "  " + "  ".join("-" * w for w in col_widths)
-    print(fmt.format(*headers_str), file=file)
-    print(sep, file=file)
-    for cells in display_rows:
-        print(fmt.format(*cells), file=file)
+    rendered = format_table(headers, rows, row_states=row_states, changed_cols=changed_cols)
+    if rendered:
+        print(rendered, file=file)
 
 
 def _prompt_buttons(button_list: list) -> int | None:

{execsql2-2.22.2 → execsql2-2.22.4}/src/execsql/gui/tui.py

@@ -89,14 +89,18 @@ def _help_button(url: str | None) -> Button | None:
     return None
 
 
-def _button_row(button_list: list) -> list[Button]:
+def _button_row(button_list: list, no_cancel: bool = False) -> list[Button]:
     """Create Button widgets from a button_list of (label, value, key?) tuples.
 
-    A Cancel button (id ``btn_cancel_exit``) is always prepended so it appears
-    on the left while the primary action button sits on the far right.
-    Entries in *button_list* with a falsy value (0 or None) are treated as the
-    cancel label source and are otherwise excluded from the numbered buttons so
-    that ``btn_N`` indices stay aligned with ``button_list`` positions.
+    A Cancel button (id ``btn_cancel_exit``) is prepended so it appears on the
+    left while the primary action button sits on the far right.  Entries in
+    *button_list* with a falsy value (0 or None) are treated as the cancel
+    label source and are otherwise excluded from the numbered buttons so that
+    ``btn_N`` indices stay aligned with ``button_list`` positions.
+
+    When *no_cancel* is set, the Cancel button is omitted — dialogs such as
+    HALT have no meaningful cancel action, and cancelling one would exit with
+    the generic status 2 rather than the status the caller asked for.
     """
     cancel_label = "Cancel"
     primary_buttons = []
@@ -107,6 +111,8 @@ def _button_row(button_list: list) -> list[Button]:
         else:
             variant: Literal["primary", "default"] = "primary" if i == 0 else "default"
             primary_buttons.append(Button(label, id=f"btn_{i}", variant=variant))
+    if no_cancel:
+        return primary_buttons
     return [Button(cancel_label, id="btn_cancel_exit", variant="warning")] + primary_buttons
 
 
@@ -182,7 +188,14 @@ class _BaseDialog(ModalScreen):
         return self._result
 
     def action_cancel(self) -> None:
-        """Dismiss the dialog as cancelled (triggered by Escape key)."""
+        """Dismiss the dialog as cancelled (triggered by Escape key).
+
+        Ignored for dialogs that pass ``no_cancel`` (e.g. HALT), which have no
+        meaningful cancel action.  This matches the Tkinter backend, which does
+        not bind ``<Escape>`` to cancellation in that case.
+        """
+        if self.args.get("no_cancel", False):
+            return
         self._result = {"button": None, "cancelled": True}
         self.dismiss(self._result)
 
@@ -210,31 +223,48 @@ class _BaseDialog(ModalScreen):
 
 
 class MsgScreen(_BaseDialog):
-    """Simple message dialog with Continue and Cancel buttons."""
+    """Message dialog with an optional data table.
+
+    Honours the caller's ``button_list`` and ``no_cancel`` arguments, and
+    renders ``column_headers``/``rowset`` when supplied (as the HALT
+    metacommand's DISPLAY clause does), matching the Tkinter MsgDialog.
+    """
 
     BINDINGS = [
         *_BaseDialog.BINDINGS,
         Binding("enter", "submit", "Continue", show=True),
     ]
 
+    def _button_list(self) -> list:
+        return cast(list, self.args.get("button_list") or [("Continue", 1, "<Return>")])
+
     def compose(self) -> ComposeResult:
         title = self.args.get("title", "Message")
         message = self.args.get("message", "")
+        headers = self.args.get("column_headers")
+        rows = self.args.get("rowset")
         with Container(id="dialog"):
             yield Label(title, id="title")
             yield Static(message, id="message")
+            if headers and rows:
+                with ScrollableContainer(id="table_container"):
+                    yield _make_table_widget("msg_table", headers, rows)
+                yield Static(_row_count_text(len(rows)), classes="row-count")
             with Horizontal(id="buttons"):
-                yield Button("Cancel", id="btn_cancel_exit", variant="warning")
-                yield Button("Continue", id="btn_close", variant="primary")
+                yield from _button_row(self._button_list(), no_cancel=self.args.get("no_cancel", False))
 
     def action_submit(self) -> None:
-        """Continue the dialog (triggered by Enter key)."""
-        self._result = {"button": 1}
-        self.dismiss(self._result)
+        """Dismiss with the first non-cancel button value (triggered by Enter)."""
+        for btn in self._button_list():
+            if btn[1]:
+                self._result = {"button": btn[1]}
+                self.dismiss(self._result)
+                return
 
     def on_button_pressed(self, event: Button.Pressed) -> None:
-        if event.button.id == "btn_close":
-            self._result = {"button": 1}
+        btn_id = event.button.id
+        if btn_id and btn_id.startswith("btn_") and btn_id[4:].isdigit():
+            self._result = {"button": self._button_list()[int(btn_id[4:])][1]}
             self.dismiss(self._result)
 
 

{execsql2-2.22.2 → execsql2-2.22.4}/src/execsql/metacommands/control.py

@@ -33,6 +33,7 @@ from execsql.exceptions import ErrInfo
 from typing import Any
 
 import execsql.state as _state
+from execsql.gui.base import format_table, row_count_text
 from execsql.script import current_script_line
 from execsql.utils.errors import exit_now
 from execsql.utils.fileio import EncodedFile, check_dir
@@ -214,6 +215,14 @@ def x_wait_until(**kwargs: Any) -> None:
 
 # x_halt_msg is also needed by x_halt - define it here
 def x_halt_msg(**kwargs: Any) -> None:
+    """Halt the script, reporting *errmsg* in a dialog or on the console.
+
+    The dialog is used only when the run is interactive — either a GUI console
+    is already running, or ``gui_level`` is greater than 1.  Otherwise the
+    message (and any ``DISPLAY`` rowset) is written to the error output and the
+    script exits, so that unattended runs fail instead of blocking forever on a
+    modal nobody can dismiss.
+    """
     import queue as _queue
 
     errmsg = kwargs["errmsg"]
@@ -242,6 +251,23 @@ def x_halt_msg(**kwargs: Any) -> None:
         headers, rows = db.select_data(sql)
     else:
         headers, rows = None, None
+
+    # Non-interactive runs (no GUI console, gui_level 0 or 1) must not block on
+    # a modal dialog: report on the console and exit instead.  This mirrors the
+    # guard in x_halt, which the message-bearing HALT forms never reach because
+    # their metacommand patterns are registered later and so take priority.
+    if not (gui_console_isrunning() or conf.gui_level > 1):
+        if errmsg:
+            _state.output.write_err(errmsg)
+        if headers:
+            # Unlike the dialog, render an empty rowset too — a HALT diagnostic
+            # showing zero rows is more useful than showing nothing at all.
+            _state.output.write_err(format_table(headers, rows or []))
+            _state.output.write_err(row_count_text(len(rows or [])))
+        _state.exec_log.log_exit_halt(*current_script_line(), msg=errmsg)
+        exit_now(errlevel, None)
+        return
+
     enable_gui()
     return_queue: _queue.Queue[Any] = _queue.Queue()
     gui_args = {

execsql2-2.22.4/tests/gui/test_format_table.py

@@ -0,0 +1,85 @@
+"""Tests for the shared plain-text table renderer in execsql.gui.base.
+
+``format_table`` backs both the console GUI backend's ``_print_table`` and the
+non-interactive HALT fallback in ``x_halt_msg``, so its output is user-visible
+in unattended runs.
+"""
+
+from __future__ import annotations
+
+from execsql.gui.base import DIFF_MARKER, format_table, row_count_text
+
+
+class TestRowCountText:
+    def test_plural(self):
+        assert row_count_text(2) == "2 rows"
+
+    def test_singular(self):
+        assert row_count_text(1) == "1 row"
+
+    def test_zero_is_plural(self):
+        assert row_count_text(0) == "0 rows"
+
+    def test_thousands_separator(self):
+        assert row_count_text(12345) == "12,345 rows"
+
+
+class TestFormatTable:
+    def test_empty_headers_yield_empty_string(self):
+        assert format_table([], [("a",)]) == ""
+
+    def test_headers_only(self):
+        """A zero-row rowset still renders headers and a separator."""
+        out = format_table(["id", "reason"], [])
+        lines = out.splitlines()
+        assert len(lines) == 2
+        assert "id" in lines[0] and "reason" in lines[0]
+        assert set(lines[1].strip()) == {"-", " "}
+
+    def test_columns_pad_to_widest_value(self):
+        out = format_table(["id"], [("1",), ("longer",)])
+        lines = out.splitlines()
+        # Header, separator, and both data rows share one column width.
+        assert len({len(line) for line in lines}) == 1
+
+    def test_none_renders_as_empty(self):
+        out = format_table(["a", "b"], [(None, "x")])
+        assert "None" not in out
+        assert "x" in out
+
+    def test_non_string_values_are_stringified(self):
+        out = format_table(["n"], [(42,)])
+        assert "42" in out
+
+    def test_no_trailing_newline(self):
+        out = format_table(["a"], [("b",)])
+        assert not out.endswith("\n")
+
+    def test_diff_marker_applied_to_changed_cells(self):
+        out = format_table(
+            ["k", "v"],
+            [("1", "old")],
+            row_states=["changed"],
+            changed_cols=[{"v"}],
+        )
+        assert f"{DIFF_MARKER}old" in out
+        assert f"{DIFF_MARKER}1" not in out
+
+    def test_diff_marker_width_included_in_column_sizing(self):
+        """Marker width must not push the marked row wider than the others."""
+        out = format_table(
+            ["v"],
+            [("aaa",), ("aaa",)],
+            row_states=["changed", "unchanged"],
+            changed_cols=[{"v"}, set()],
+        )
+        assert len({len(line) for line in out.splitlines()}) == 1
+
+    def test_unchanged_rows_are_unmarked(self):
+        out = format_table(
+            ["v"],
+            [("x",)],
+            row_states=["unchanged"],
+            changed_cols=[{"v"}],
+        )
+        assert DIFF_MARKER not in out