execsql2 2.22.4__tar.gz → 2.22.5__tar.gz

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

@@ -283,7 +283,8 @@ jobs:
         name: Build distribution 📦
         runs-on: ubuntu-latest
         needs: [ lint, typecheck, pre-commit, docs, tests, integration-tests ]
-        if: startsWith(github.ref, 'refs/tags/v')
+        # Deliberately NOT gated on tags: packaging breaks must surface on a PR,
+        # not at release time. Only publish/generate-release below are tag-gated.
         permissions:
             contents: read
         steps:
@@ -296,7 +297,12 @@ jobs:
             - name: Build sdist + wheel
               run: |
                   python -m pip install --upgrade pip
-                  python -m pip install build twine
+                  # twine is pinned to the version vendored by the publish job's
+                  # pypa/gh-action-pypi-publish pin (its requirements/runtime.txt).
+                  # That action runs its own `twine check` before uploading, so
+                  # validating here with a *newer* twine can pass while the publish
+                  # fails. Bump this pin and the action pin together.
+                  python -m pip install build 'twine==7.0.0'
                   python -m build --sdist --wheel --outdir dist/
                   python -m twine check dist/*
             - name: Upload dist artifact

{execsql2-2.22.4 → execsql2-2.22.5}/.pre-commit-hooks.yaml

@@ -6,4 +6,4 @@
   types: [file]
   files: \.sql$
   args: [--in-place]
-  additional_dependencies: [sqlglot]
+  additional_dependencies: ["sqlglot>=25.0,<31"]

{execsql2-2.22.4 → execsql2-2.22.5}/CHANGELOG.md

@@ -13,13 +13,26 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.22.5] - 2026-08-27
+
+### Fixed
+
+- `execsql-format` no longer alters PostgreSQL escape strings; `E'\\s+'` was rewritten as `e'\s+'`, turning a whitespace regex into a letter-`s` regex, and lost a further backslash on every run.
+- `execsql-format` now leaves a statement unformatted when its string literals would change; the previous check compared only alphanumeric counts and missed punctuation-only rewrites.
+
+### Changed
+
+- The `execsql-format` pre-commit hook pins `sqlglot>=25.0,<31` so a given commit formats identically on every machine.
+
+______________________________________________________________________
+
 ## [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.
+- `HALT` with a message no longer blocks on a dialog in unattended runs; below `gui_level` 2 the message is written to the console and the script exits with the requested `EXIT_STATUS`.
+- `HALT … DISPLAY` now writes its table to the console in non-interactive runs instead of discarding it.
+- Textual `HALT` dialogs now show the single OK button the metacommand asks for, render the `DISPLAY` table, and ignore <kbd>Esc</kbd>; cancelling previously exited with status 2 instead of the requested `EXIT_STATUS`.
 
 ______________________________________________________________________
 

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

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

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

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

{execsql2-2.22.4 → execsql2-2.22.5}/docs/about/divergence.md

@@ -272,51 +272,53 @@ These are behavioral changes driven by security or correctness issues in the ups
 
 ### Bug Fixes
 
-| Area                                                | Fix                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Oracle default port                                 | Corrected from `5432` (PostgreSQL) to `1521`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| MySQL `LOAD DATA INFILE` encoding                   | Python encoding names are now mapped to MySQL charset names.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `dt_cast` type converters                           | Base `Database` class auto-populates 8 type converters that were previously left empty after the refactor.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `FileWriter` CPU busy-loop                          | Uses blocking `queue.get(timeout=0.1)` instead of `get_nowait()` in a tight loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| Substitution variable cycles                        | 100-iteration limit prevents infinite loops on cyclic variable references.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| Script location in error messages                   | `ErrInfo.script_file` and `script_line_no` are now populated via `stamp_errinfo()` so error output includes "Line N of script foo.sql" context — restoring behavior present in the monolith.                                                                                                                                                                                                                                                                                                                                                                                                                   |
-| `$ERROR_MESSAGE` not updated                        | `$ERROR_MESSAGE` is now set on every error path: `exit_now()`, non-halting SQL errors, and non-halting metacommand errors. Previously it was initialized to `""` and never changed.                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| Metacommand error message lost                      | When `halt_on_metacommand_err` is `ON`, the original handler `ErrInfo` is now re-raised; the generic "Unknown metacommand" message no longer replaces the specific error from the handler.                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| Empty script name in error msg                      | `_execute_script_direct()` and `_execute_script_textual_console()` no longer append "in script , line 0" to uncaught-exception messages when `current_script_line()` returns an empty string.                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `PROMPT COMPARE` diff comparison                    | Diff engine uses native Python equality instead of string comparison — numeric types, Decimals, and booleans compare correctly. `None` is distinguished from empty string. Columns are matched by name (not position), key columns are excluded from comparison, and duplicate PKs keep the first row.                                                                                                                                                                                                                                                                                                         |
-| `win_config_file` broken                            | Checked `os.name == "windows"` which Python never returns (correct value is `"nt"`). Fixed to `os.name == "nt"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| ELSEIF + ANDIF/ORIF                                 | ANDIF/ORIF after an ELSEIF were silently attached to the parent IF condition instead of the ELSEIF clause. The compound condition was never evaluated for the ELSEIF branch. Fixed in the AST parser and executor.                                                                                                                                                                                                                                                                                                                                                                                             |
-| Cursor leak in `select_rowsource()`                 | Cursor was not closed on query execution failure. Row generators in EXPORT and COPY paths were not explicitly closed on error, relying on garbage collection for cleanup.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
-| `NumericParser` right-associative                   | Arithmetic operators were parsed right-to-left. `10 - 3 - 2` evaluated as `9` instead of `5`. Fixed to left-associative parsing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
-| Empty-column check precedence                       | `DataTable` and `Database.populate_table()` had an operator precedence bug in the extra-column emptiness check — a redundant `and conf.del_empty_cols` caused incorrect short-circuit evaluation.                                                                                                                                                                                                                                                                                                                                                                                                              |
-| SQLite import string processing                     | `SQLiteDatabase.populate_table()` applied `trim_strings`, `replace_newlines`, and `empty_strings` after copying row data, so processing never reached the INSERT. Fixed to process before extraction.                                                                                                                                                                                                                                                                                                                                                                                                          |
-| `$CURRENT_DATABASE`/`$CURRENT_DBMS` stale after USE | These variables were only set at startup and on CONNECT, not refreshed when `USE` switched the active database. Now set in `set_static_system_vars()` so they update on any connection change.                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `DT_Text.data_type_name` wrong                      | Was `"character"` (same as `DT_Character`), making error messages indistinguishable. Corrected to `"text"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
-| `DT_Varchar` non-string data unchecked              | `_from_data()` only enforced the 255-char limit for `str` inputs; non-string values passed through without conversion or length check.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| `WriteHooks.write_err()` crash on empty string      | `strval[-1]` raised `IndexError` on empty input. Fixed to use `str.endswith()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `NumericParser` division by zero                    | `NumericAstNode.eval()` raised unhandled `ZeroDivisionError`. Now raises `NumericParserError` with a clear message.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `CondAstNode.eval()` could return `None`            | Missing fallthrough for unknown node types silently returned `None`. Now raises `CondParserError`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `DT_Timestamp` claims time-only values              | `dateutil.parser.parse()` silently fills in today's date for bare time strings like `"13:15:45"`, so `DT_Timestamp` matched before `DT_Time` in the inference order. `parse_datetime()` now rejects time-only strings.                                                                                                                                                                                                                                                                                                                                                                                         |
-| `CounterVars.substitute` skipped pos 0–1            | `re.I` was passed as the positional `pos` argument, skipping the first 2 characters of every string during counter variable expansion. Counter variables at the very start of a line were never matched.                                                                                                                                                                                                                                                                                                                                                                                                       |
-| `exec_cmd` (SQLite/DuckDB) always raised TypeError  | Passed bytes to `curs.execute()` via `.encode()`, which Python 3 `sqlite3`/`duckdb` reject. `EXECUTE PROCEDURE` metacommand was non-functional on these backends.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| MySQL `LOAD DATA INFILE` injection                  | File path, delimiter, and quotechar were interpolated without escaping. Now single-quotes are escaped consistent with the PostgreSQL COPY path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| Missing server/database name at connect             | Connecting to a server-based database without a server or database name now stops with a clear fatal error ("Configured database requires a server name, but none is provided.") instead of crashing inside the driver with a `TypeError`.                                                                                                                                                                                                                                                                                                                                                                     |
-| Config file chain infinite loop                     | The `config_file` directive could chain config files without limit. A circular reference (via symlinks or different relative paths) caused an infinite loop at startup. Now capped at 20 files.                                                                                                                                                                                                                                                                                                                                                                                                                |
-| Cursor leaks in database adapters                   | ~15 methods across all adapters used `curs = self.cursor()` / `curs.close()` without `try/finally`. If the query raised, the cursor leaked. Converted to `with self._cursor() as curs:`.                                                                                                                                                                                                                                                                                                                                                                                                                       |
-| JSON export malformed on special column names       | Column names containing `"` or `\` produced invalid JSON. Now uses `json.dumps()` for all field names.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| Temp file creation TOCTOU race                      | `TempFileMgr.new_temp_fn()` discarded the `NamedTemporaryFile` handle, creating a race window. Now uses `tempfile.mkstemp()` for secure creation.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `shlex.split` on Windows incorrect mode             | Called without `posix=False` on Windows, mishandling backslash-heavy paths in SHELL commands.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| AST executor `~`/`+` variable scoping broken        | The AST executor passed `localvars` through function parameters but never pushed `CommandList` frames onto `commandliststack`. Legacy metacommand handlers (`x_sub`, `x_rm_sub`, `xf_sub_defined`, `SUB_LOCAL`, prompt handlers, REPL) access `commandliststack[-1]` for `~` local and `+` outer-scope variables. This caused `~` vars to be invisible to SQL, `SUB_DEFINED(~var)` to always return false, and the REPL `.vars`/`.stack` to show empty state. Fixed by pushing/popping `CommandList` frames in `execute()` and `_execute_script_native()`.                                                     |
-| Firebird adapter import                             | Adapter imported `fdb` (the unmaintained legacy driver) while the `[firebird]` extra declared `firebird-driver`. `pip install execsql2[firebird]` followed by a Firebird connect raised `ModuleNotFoundError: No module named 'fdb'`. Adapter now imports `firebird.driver`, matching the declared dependency.                                                                                                                                                                                                                                                                                                 |
-| Connect timeouts on network adapters                | MySQL, SQL Server / Access / DSN (pyodbc), Firebird, and SMTP all now apply a 30 s connect timeout matching the existing PostgreSQL default. A silently-dropped network peer (firewall rule, dead VM) used to hang scripts indefinitely; now the connect fails fast.                                                                                                                                                                                                                                                                                                                                           |
-| AST parser INCLUDE quoted paths broken              | The AST parser captured the full INCLUDE target including surrounding quotes (`"path"`), but the legacy dispatch regex stripped them. Quoted INCLUDE paths failed with "File does not exist" even when the file was present. Fixed by stripping matched quote pairs in the parser.                                                                                                                                                                                                                                                                                                                             |
-| AST parser `BEGIN SCRIPT name(params)` rejected     | The regex required whitespace between the script name and parameter list. `BEGIN SCRIPT foo(a,b)` (no space before `(`) silently failed to match, causing the matching `END SCRIPT` to raise "Unmatched END SCRIPT metacommand." Fixed by allowing optional whitespace before the parameter expression.                                                                                                                                                                                                                                                                                                        |
-| AST executor forward SCRIPT references broken       | The legacy engine registered all `BEGIN SCRIPT` blocks at parse time (two-pass), so `EXECUTE SCRIPT foo` could appear before the `BEGIN SCRIPT foo` definition. The AST executor walked the tree in a single pass, so forward references failed with "There is no SCRIPT named foo." Fixed by adding a pre-registration scan of all SCRIPT blocks before execution begins.                                                                                                                                                                                                                                     |
-| 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.                                                                                                                                                                            |
+| Area                                                  | Fix                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ----------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Oracle default port                                   | Corrected from `5432` (PostgreSQL) to `1521`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| MySQL `LOAD DATA INFILE` encoding                     | Python encoding names are now mapped to MySQL charset names.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `dt_cast` type converters                             | Base `Database` class auto-populates 8 type converters that were previously left empty after the refactor.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `FileWriter` CPU busy-loop                            | Uses blocking `queue.get(timeout=0.1)` instead of `get_nowait()` in a tight loop.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| Substitution variable cycles                          | 100-iteration limit prevents infinite loops on cyclic variable references.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| Script location in error messages                     | `ErrInfo.script_file` and `script_line_no` are now populated via `stamp_errinfo()` so error output includes "Line N of script foo.sql" context — restoring behavior present in the monolith.                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `$ERROR_MESSAGE` not updated                          | `$ERROR_MESSAGE` is now set on every error path: `exit_now()`, non-halting SQL errors, and non-halting metacommand errors. Previously it was initialized to `""` and never changed.                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| Metacommand error message lost                        | When `halt_on_metacommand_err` is `ON`, the original handler `ErrInfo` is now re-raised; the generic "Unknown metacommand" message no longer replaces the specific error from the handler.                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| Empty script name in error msg                        | `_execute_script_direct()` and `_execute_script_textual_console()` no longer append "in script , line 0" to uncaught-exception messages when `current_script_line()` returns an empty string.                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `PROMPT COMPARE` diff comparison                      | Diff engine uses native Python equality instead of string comparison — numeric types, Decimals, and booleans compare correctly. `None` is distinguished from empty string. Columns are matched by name (not position), key columns are excluded from comparison, and duplicate PKs keep the first row.                                                                                                                                                                                                                                                                                                         |
+| `win_config_file` broken                              | Checked `os.name == "windows"` which Python never returns (correct value is `"nt"`). Fixed to `os.name == "nt"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| ELSEIF + ANDIF/ORIF                                   | ANDIF/ORIF after an ELSEIF were silently attached to the parent IF condition instead of the ELSEIF clause. The compound condition was never evaluated for the ELSEIF branch. Fixed in the AST parser and executor.                                                                                                                                                                                                                                                                                                                                                                                             |
+| Cursor leak in `select_rowsource()`                   | Cursor was not closed on query execution failure. Row generators in EXPORT and COPY paths were not explicitly closed on error, relying on garbage collection for cleanup.                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `NumericParser` right-associative                     | Arithmetic operators were parsed right-to-left. `10 - 3 - 2` evaluated as `9` instead of `5`. Fixed to left-associative parsing.                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| Empty-column check precedence                         | `DataTable` and `Database.populate_table()` had an operator precedence bug in the extra-column emptiness check — a redundant `and conf.del_empty_cols` caused incorrect short-circuit evaluation.                                                                                                                                                                                                                                                                                                                                                                                                              |
+| SQLite import string processing                       | `SQLiteDatabase.populate_table()` applied `trim_strings`, `replace_newlines`, and `empty_strings` after copying row data, so processing never reached the INSERT. Fixed to process before extraction.                                                                                                                                                                                                                                                                                                                                                                                                          |
+| `$CURRENT_DATABASE`/`$CURRENT_DBMS` stale after USE   | These variables were only set at startup and on CONNECT, not refreshed when `USE` switched the active database. Now set in `set_static_system_vars()` so they update on any connection change.                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `DT_Text.data_type_name` wrong                        | Was `"character"` (same as `DT_Character`), making error messages indistinguishable. Corrected to `"text"`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `DT_Varchar` non-string data unchecked                | `_from_data()` only enforced the 255-char limit for `str` inputs; non-string values passed through without conversion or length check.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `WriteHooks.write_err()` crash on empty string        | `strval[-1]` raised `IndexError` on empty input. Fixed to use `str.endswith()`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `NumericParser` division by zero                      | `NumericAstNode.eval()` raised unhandled `ZeroDivisionError`. Now raises `NumericParserError` with a clear message.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `CondAstNode.eval()` could return `None`              | Missing fallthrough for unknown node types silently returned `None`. Now raises `CondParserError`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `DT_Timestamp` claims time-only values                | `dateutil.parser.parse()` silently fills in today's date for bare time strings like `"13:15:45"`, so `DT_Timestamp` matched before `DT_Time` in the inference order. `parse_datetime()` now rejects time-only strings.                                                                                                                                                                                                                                                                                                                                                                                         |
+| `CounterVars.substitute` skipped pos 0–1              | `re.I` was passed as the positional `pos` argument, skipping the first 2 characters of every string during counter variable expansion. Counter variables at the very start of a line were never matched.                                                                                                                                                                                                                                                                                                                                                                                                       |
+| `exec_cmd` (SQLite/DuckDB) always raised TypeError    | Passed bytes to `curs.execute()` via `.encode()`, which Python 3 `sqlite3`/`duckdb` reject. `EXECUTE PROCEDURE` metacommand was non-functional on these backends.                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| MySQL `LOAD DATA INFILE` injection                    | File path, delimiter, and quotechar were interpolated without escaping. Now single-quotes are escaped consistent with the PostgreSQL COPY path.                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| Missing server/database name at connect               | Connecting to a server-based database without a server or database name now stops with a clear fatal error ("Configured database requires a server name, but none is provided.") instead of crashing inside the driver with a `TypeError`.                                                                                                                                                                                                                                                                                                                                                                     |
+| Config file chain infinite loop                       | The `config_file` directive could chain config files without limit. A circular reference (via symlinks or different relative paths) caused an infinite loop at startup. Now capped at 20 files.                                                                                                                                                                                                                                                                                                                                                                                                                |
+| Cursor leaks in database adapters                     | ~15 methods across all adapters used `curs = self.cursor()` / `curs.close()` without `try/finally`. If the query raised, the cursor leaked. Converted to `with self._cursor() as curs:`.                                                                                                                                                                                                                                                                                                                                                                                                                       |
+| JSON export malformed on special column names         | Column names containing `"` or `\` produced invalid JSON. Now uses `json.dumps()` for all field names.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| Temp file creation TOCTOU race                        | `TempFileMgr.new_temp_fn()` discarded the `NamedTemporaryFile` handle, creating a race window. Now uses `tempfile.mkstemp()` for secure creation.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| `shlex.split` on Windows incorrect mode               | Called without `posix=False` on Windows, mishandling backslash-heavy paths in SHELL commands.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| AST executor `~`/`+` variable scoping broken          | The AST executor passed `localvars` through function parameters but never pushed `CommandList` frames onto `commandliststack`. Legacy metacommand handlers (`x_sub`, `x_rm_sub`, `xf_sub_defined`, `SUB_LOCAL`, prompt handlers, REPL) access `commandliststack[-1]` for `~` local and `+` outer-scope variables. This caused `~` vars to be invisible to SQL, `SUB_DEFINED(~var)` to always return false, and the REPL `.vars`/`.stack` to show empty state. Fixed by pushing/popping `CommandList` frames in `execute()` and `_execute_script_native()`.                                                     |
+| Firebird adapter import                               | Adapter imported `fdb` (the unmaintained legacy driver) while the `[firebird]` extra declared `firebird-driver`. `pip install execsql2[firebird]` followed by a Firebird connect raised `ModuleNotFoundError: No module named 'fdb'`. Adapter now imports `firebird.driver`, matching the declared dependency.                                                                                                                                                                                                                                                                                                 |
+| Connect timeouts on network adapters                  | MySQL, SQL Server / Access / DSN (pyodbc), Firebird, and SMTP all now apply a 30 s connect timeout matching the existing PostgreSQL default. A silently-dropped network peer (firewall rule, dead VM) used to hang scripts indefinitely; now the connect fails fast.                                                                                                                                                                                                                                                                                                                                           |
+| AST parser INCLUDE quoted paths broken                | The AST parser captured the full INCLUDE target including surrounding quotes (`"path"`), but the legacy dispatch regex stripped them. Quoted INCLUDE paths failed with "File does not exist" even when the file was present. Fixed by stripping matched quote pairs in the parser.                                                                                                                                                                                                                                                                                                                             |
+| AST parser `BEGIN SCRIPT name(params)` rejected       | The regex required whitespace between the script name and parameter list. `BEGIN SCRIPT foo(a,b)` (no space before `(`) silently failed to match, causing the matching `END SCRIPT` to raise "Unmatched END SCRIPT metacommand." Fixed by allowing optional whitespace before the parameter expression.                                                                                                                                                                                                                                                                                                        |
+| AST executor forward SCRIPT references broken         | The legacy engine registered all `BEGIN SCRIPT` blocks at parse time (two-pass), so `EXECUTE SCRIPT foo` could appear before the `BEGIN SCRIPT foo` definition. The AST executor walked the tree in a single pass, so forward references failed with "There is no SCRIPT named foo." Fixed by adding a pre-registration scan of all SCRIPT blocks before execution begins.                                                                                                                                                                                                                                     |
+| 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.                                                                                                                                                                            |
+| `execsql-format` corrupts `E'...'` literals           | sqlglot's Postgres tokenizer consumes backslash escapes inside an escape string but its generator never re-emits them (tobymao/sqlglot#8191), so `E'\\s+'` became `e'\s+'` — a regex matching the letter `s` rather than whitespace — losing one backslash per pass until `E'\\\\'` degraded to the unparsable `e'\''`. Escape strings are now masked out of the sqlglot round trip and restored byte-for-byte, independently of the installed sqlglot version.                                                                                                                                                |
+| Formatter could not detect literal-level content loss | The content-loss guard deleted every non-alphanumeric character before comparing *lengths*, so any rewrite confined to punctuation was invisible to it at any threshold. A literal round-trip check now requires every string literal in the input to survive verbatim in the output, falling back to the unformatted text otherwise.                                                                                                                                                                                                                                                                          |
 
 ______________________________________________________________________
 

{execsql2-2.22.4 → execsql2-2.22.5}/docs/guides/formatter.md

@@ -91,9 +91,18 @@ Block comments (`/* */`) that contain `-- !x!` metacommand markers (e.g. comment
 
 execsql substitution variables (`!!varname!!`, `!{varname}!`) are replaced with valid SQL identifiers before formatting, then restored afterward, so the formatter does not corrupt them — including in schema-qualified names (`!!staging!!.!!table!!`), CASE expressions, JOIN conditions, and string concatenation.
 
+#### String literal preservation { #string_literals }
+
+Formatting never changes what a string literal contains. Two mechanisms enforce this:
+
+- PostgreSQL escape strings (`E'...'`) are held out of the sqlglot round trip entirely and restored byte-for-byte, keeping both their backslash escapes and their `E` prefix. This matters because sqlglot consumes backslash escapes inside an escape string without re-emitting them, which would turn `E'\\s+'` (a regex matching whitespace) into `e'\s+'` (a regex matching the letter `s`).
+- Every other literal — ordinary `'...'` strings and dollar-quoted bodies (`$$...$$`, `$tag$...$tag$`) — is compared before and after formatting. If any literal fails to come back unchanged, the statement is left unformatted rather than rewritten.
+
+The second check is deliberately conservative: a statement may occasionally be left alone when the rewrite would in fact have been harmless (for example, sqlglot normalizes `interval '1 day'` to `INTERVAL '1 DAY'`, which changes the literal's text but not its meaning). Losing formatting on a statement is recoverable; silently changing what a query does is not.
+
 #### Fallback behavior
 
-If sqlglot cannot parse a SQL statement, or if safety checks detect that formatting would corrupt the SQL (e.g. statement count changes, significant content loss), the original text is preserved unchanged.
+If sqlglot cannot parse a SQL statement, or if safety checks detect that formatting would corrupt the SQL — statement count changes, significant content loss, or an altered [string literal](#string_literals) — the original text is preserved unchanged.
 
 Use `--no-sql` to skip SQL reformatting entirely and only normalize metacommands.
 
@@ -160,7 +169,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.4
+    rev: v2.22.5
     hooks:
       - id: execsql-format
 ```

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

@@ -1807,7 +1807,7 @@ SUB_DEFINED(<match_string>)
 Evaluates whether a replacement string has been defined for the specified substitution variable (matching string).
 
 
-### *SUB_EMPTY*
+### *SUB_EMPTY* { #sub_empty_cond }
 
 ```
 SUB_EMPTY(<match_string>)
@@ -2946,6 +2946,20 @@ Defines a [substitution variable](substitution_vars.md#substitution_vars) (the \
 
 If the variable name (\<match_string\>) starts with a tilde, a [local variable](substitution_vars.md#local_vars) will be created. If the variable name starts with a plus, the substitution is assigned to the first (proceeding outward) local variable by the same name found in an enclosing script. The plus prefix may only be used to refer to an existing instance of an outer-scope local variables; it cannot be used to create a new instance. If no corresponding local variable exists in any outer scope, an error will be raised.
 
+The replacement string cannot be empty. A SUB metacommand with no replacement string matches no metacommand at all, and fails with an "Unknown metacommand" error naming the SUB line. Use [SUB_EMPTY](#sub_empty) to assign a zero-length string.
+
+This also applies when the replacement string comes from a variable — a value taken from [SELECT_SUB](#select_sub) or [SUBDATA](#subdata), for example. If the query returns an empty value, the substituted line reduces to `SUB <match_string>` and fails the same way:
+
+```sql
+-- The script works until the query happens to return an empty string.
+-- !x! SELECT_SUB v
+-- !x! SUB myvar !!@c!!
+```
+
+The variable is still *defined* in that case, so [SUB_DEFINED](#sub_defined) will not detect it. Test with the [SUB_EMPTY](#sub_empty_cond) conditional before the SUB, or coalesce the value to a non-empty sentinel in the query.
+
+Leading and trailing whitespace is removed from the replacement string, so SUB cannot store a value whose surrounding whitespace is significant. Trailing whitespace is stripped from every metacommand line before it is dispatched, so this applies to substituted values as well as to literal text. Indentation that must be preserved should be supplied where the variable is used rather than stored in the variable. [SUB_APPEND](#sub_append) differs here: it preserves leading whitespace in the appended text, while still losing trailing whitespace to the same line-level strip.
+
 
 ## SUB_ADD
 

{execsql2-2.22.4 → execsql2-2.22.5}/docs/reference/substitution_vars.md

@@ -298,7 +298,7 @@ Substitution variables can also be defined in the "variables" section of a [conf
 
 ## Quoting Convention { #quoting_convention }
 
-[SUB](metacommands.md#subcmd) stores its replacement string verbatim, and substitution inserts the stored text without modification. [EXECUTE SCRIPT](metacommands.md#executescript) argument values, however, are stripped of one pair of surrounding quotes when bound to parameters. As a result, `SUB myfile "filename.txt"` followed by `EXECUTE SCRIPT proc(arg='!!myfile!!')` leaves the called script's `!!#arg!!` expanding to `"filename.txt"` — still wrapped in the double quotes from the SUB, with no in-script primitive to strip them.
+[SUB](metacommands.md#subcmd) stores surrounding quotes verbatim, and substitution inserts the stored text without modification. (Surrounding *whitespace* is the exception — SUB trims it; see the [SUB](metacommands.md#subcmd) entry.) [EXECUTE SCRIPT](metacommands.md#executescript) argument values, however, are stripped of one pair of surrounding quotes when bound to parameters. As a result, `SUB myfile "filename.txt"` followed by `EXECUTE SCRIPT proc(arg='!!myfile!!')` leaves the called script's `!!#arg!!` expanding to `"filename.txt"` — still wrapped in the double quotes from the SUB, with no in-script primitive to strip them.
 
 To avoid this, store bare values and apply quoting only at the point of use:
 

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

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

{execsql2-2.22.4 → execsql2-2.22.5}/src/execsql/format.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 import contextlib
 import io
 import re
+from collections.abc import Iterator
 from pathlib import Path
 
 __all__ = ["collect_paths", "format_file", "main", "parse_keyword"]
@@ -169,6 +170,170 @@ def parse_keyword(payload: str) -> str:
 _EXECSQL_VAR_RE = re.compile(r"""!(['"]?)!([^!\s][^!]*)!\1!|!\{[^}]+\}!""")
 
 
+# Characters that may appear in an identifier, used to tell an ``E'...'``
+# escape-string prefix from a trailing ``e`` on an identifier (``abce'x'`` is
+# the identifier ``abce`` followed by a separate literal).
+_IDENT_CHAR_RE = re.compile(r"[A-Za-z0-9_$]")
+
+
+def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
+    """Yield ``(start, end, kind)`` spans for every string literal in *sql*.
+
+    This is a lexical walk rather than a regex sweep, because an apostrophe
+    only starts a literal in some contexts.  Line comments, block comments
+    (which nest in PostgreSQL), and quoted identifiers are skipped entirely,
+    so quotes inside them never open a literal.
+
+    *kind* is one of:
+
+    ``"estring"``
+        A PostgreSQL escape string, ``E'...'``.  Backslash escapes are
+        significant inside it, which is what makes it unsafe to hand to
+        sqlglot — see :func:`_protect_estrings`.
+    ``"plain"``
+        An ordinary ``'...'`` literal, where only a doubled ``''`` escapes.
+    ``"dollar"``
+        A dollar-quoted body, ``$$...$$`` or ``$tag$...$tag$``, in which no
+        character is special.
+    """
+    i, n = 0, len(sql)
+    while i < n:
+        c = sql[i]
+
+        if c == "-" and sql.startswith("--", i):
+            nl = sql.find("\n", i)
+            i = n if nl < 0 else nl + 1
+            continue
+
+        if c == "/" and sql.startswith("/*", i):
+            depth, i = 1, i + 2
+            while i < n and depth:
+                if sql.startswith("/*", i):
+                    depth, i = depth + 1, i + 2
+                elif sql.startswith("*/", i):
+                    depth, i = depth - 1, i + 2
+                else:
+                    i += 1
+            continue
+
+        if c == '"':
+            i += 1
+            while i < n:
+                if sql[i] == '"':
+                    if sql.startswith('""', i):
+                        i += 2
+                        continue
+                    i += 1
+                    break
+                i += 1
+            continue
+
+        if c == "$":
+            m = _DOLLAR_QUOTE_RE.match(sql, i)
+            if m:
+                tag = m.group(0)
+                close = sql.find(tag, m.end())
+                stop = n if close < 0 else close + len(tag)
+                yield i, stop, "dollar"
+                i = stop
+                continue
+
+        # E'...' — only when the `e` is not the tail of an identifier.
+        if c in "eE" and sql.startswith("'", i + 1) and not (i and _IDENT_CHAR_RE.match(sql[i - 1])):
+            j = i + 2
+            while j < n:
+                if sql[j] == "\\" and j + 1 < n:
+                    j += 2
+                    continue
+                if sql[j] == "'":
+                    if sql.startswith("''", j):
+                        j += 2
+                        continue
+                    j += 1
+                    break
+                j += 1
+            yield i, j, "estring"
+            i = j
+            continue
+
+        if c == "'":
+            j = i + 1
+            while j < n:
+                if sql[j] == "'":
+                    if sql.startswith("''", j):
+                        j += 2
+                        continue
+                    j += 1
+                    break
+                j += 1
+            yield i, j, "plain"
+            i = j
+            continue
+
+        i += 1
+
+
+def _sql_literal_texts(sql: str) -> list[str]:
+    """Return the source text of every string literal in *sql*, in order."""
+    return [sql[start:end] for start, end, _ in _iter_sql_literals(sql)]
+
+
+# Placeholder standing in for a masked E'...' literal.  It is a plain literal
+# so that sqlglot sees a string where a string was, and lays the statement out
+# the same way it would have for the real one.
+_ESTR_PLACEHOLDER = "execsqlestr"
+_ESTR_RESTORE_RE = re.compile(rf"'{_ESTR_PLACEHOLDER}(\d+)'")
+
+
+def _protect_estrings(sql: str) -> tuple[str, list[str]]:
+    """Replace ``E'...'`` literals with placeholders, return (protected, originals).
+
+    sqlglot's Postgres tokenizer consumes backslash escapes inside an escape
+    string but its generator never re-emits them, so ``E'\\\\s+'`` round-trips
+    to ``e'\\s+'`` — a different string (tobymao/sqlglot#8191).  Masking these
+    literals keeps them out of the round trip entirely and restores them
+    byte-for-byte, independently of the installed sqlglot version.
+    """
+    originals: list[str] = []
+    out: list[str] = []
+    last = 0
+    for start, end, kind in _iter_sql_literals(sql):
+        if kind != "estring":
+            continue
+        out.append(sql[last:start])
+        out.append(f"'{_ESTR_PLACEHOLDER}{len(originals)}'")
+        originals.append(sql[start:end])
+        last = end
+    if not originals:
+        return sql, []
+    out.append(sql[last:])
+    return "".join(out), originals
+
+
+def _restore_estrings(sql: str, originals: list[str]) -> str | None:
+    """Put masked ``E'...'`` literals back; return None if any went missing.
+
+    A missing placeholder means sqlglot dropped or mangled the literal, so the
+    caller must fall back to the unformatted text rather than emit SQL with a
+    placeholder left in it.
+    """
+    if not originals:
+        return sql
+    seen: set[int] = set()
+
+    def replace(m: re.Match[str]) -> str:
+        idx = int(m.group(1))
+        if idx >= len(originals):
+            return m.group(0)
+        seen.add(idx)
+        return originals[idx]
+
+    restored = _ESTR_RESTORE_RE.sub(replace, sql)
+    if len(seen) != len(originals) or _ESTR_PLACEHOLDER in restored:
+        return None
+    return restored
+
+
 def _protect_variables(sql: str) -> tuple[str, list[tuple[str, str]]]:
     """Replace execsql substitutions with valid SQL identifiers, return (protected, replacements)."""
     replacements: list[tuple[str, str]] = []
@@ -224,6 +389,9 @@ def _sqlglot_format(
 
     text = "\n".join(sql_lines)
     protected, replacements = _protect_variables(text)
+    # Keep E'...' literals out of the round trip; sqlglot loses their
+    # backslash escapes (see _protect_estrings).
+    protected, estrings = _protect_estrings(protected)
 
     # Count semicolons in input as a rough statement count.
     input_semis = protected.count(";")
@@ -275,8 +443,29 @@ def _sqlglot_format(
         output_alnum_len = len(_alnum.sub("", joined))
         if input_alnum_len and output_alnum_len < input_alnum_len * 0.7:
             return sql_lines
+
+        # Literal round-trip check.  The alphanumeric check above is a
+        # gross-token-loss detector: it deletes every non-alphanumeric
+        # character before counting, so a transformation that changes only
+        # punctuation — a dropped backslash, a swapped quote — is invisible to
+        # it at any threshold.  Requiring every literal to survive verbatim
+        # closes that blind spot for the whole class, not just for the E'...'
+        # case masked above.
+        #
+        # Containment, not equality: sqlglot rewrites dialect-specific
+        # constructs into Postgres equivalents that can legitimately repeat a
+        # literal (``SUBSTRING_INDEX(d, ',', 1)`` expands into a form using
+        # ``','`` more than once), so the output may hold more literals than
+        # the input.  What must never happen is an input literal coming back
+        # altered or not at all — that is content loss, and it falls back.
+        if set(_sql_literal_texts(protected)) - set(_sql_literal_texts(joined)):
+            return sql_lines
+
         joined = re.sub(r"\bINTO TEMPORARY\b(?!\s+TABLE)", "INTO TEMPORARY TABLE", joined)
-        return _restore_variables(joined, replacements).split("\n")
+        restored = _restore_estrings(joined, estrings)
+        if restored is None:
+            return sql_lines
+        return _restore_variables(restored, replacements).split("\n")
     except Exception:
         return sql_lines