execsql2 2.22.7__tar.gz → 2.22.9__tar.gz

{execsql2-2.22.7 → execsql2-2.22.9}/CHANGELOG.md

@@ -13,6 +13,24 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.22.9] - 2026-09-24
+
+### Fixed
+
+- `EMAIL`, and the `ON ERROR_HALT EMAIL` and `ON CANCEL_HALT EMAIL` hooks, failed with `AttributeError: 'SMTP' object has no attribute 'ehlo_or_hello_if_needed'` instead of sending. Every send was affected, on every server and TLS setting.
+- An `[email]` `username` with no `password` or `enc_password` now reports a configuration error instead of failing with a `TypeError` from `smtplib`.
+
+______________________________________________________________________
+
+## [2.22.8] - 2026-09-17
+
+### Fixed
+
+- `execsql-format` no longer leaves a space before a `;` when a comment precedes the closing statement line. `1 = 1;` came back as `1 = 1 ;` and was corrected only on the next run, so `--check` failed on a file the formatter had just written.
+- `execsql-format` no longer moves a comment into the middle of the expression it describes. A comment above a select item containing a parenthesized composite-field access — `COALESCE((a.meas_value).undetected, FALSE)` — was relocated between the operand and the closing paren, and the file then reformatted differently on the next run, so `pre-commit` could not pass. Comments around `CASE` branches were relocated the same way.
+
+______________________________________________________________________
+
 ## [2.22.7] - 2026-09-17
 
 ### Fixed

{execsql2-2.22.7 → execsql2-2.22.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.22.7
+Version: 2.22.9
 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.7
+    rev: v2.22.9
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.7 → execsql2-2.22.9}/README.md

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

{execsql2-2.22.7 → execsql2-2.22.9}/docs/about/divergence.md

@@ -272,57 +272,60 @@ 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.                                                                                                                                                                                                                                                                                                                                                                                |
-| `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| Formatter indents inside multi-line literals          | Block indentation was applied to every line of a multi-line literal (`$$…$$` body or a `'…'` string spanning lines), so a literal inside an `IF`, `LOOP`, or `BEGIN SQL` block gained the block's leading whitespace on each continuation line — changing the value stored by the database. Lines that begin inside a dollar-quoted literal are now emitted verbatim and excluded from the indent arithmetic. Neither the literal round-trip guard (which covers only the sqlglot round trip) nor the existing idempotency test (which compares pass 1 to pass 2, while the indent is applied once and then stable) could detect it.                                                                                                                                                                               |
-| Comma passes rewrite multi-line literals              | `--leading-comma` and the trailing-comma normalization that precedes it moved a comma across a line break inside a multi-line literal, changing the stored value. Both now skip every line such a literal touches.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| Formatter never converged on unparsable statements    | Comments are hidden from sqlglot as `/* marker */ line`. Removing the marker left the injected separator space behind, which was then measured as indentation — so a statement sqlglot could not parse (and therefore returned verbatim) gained one space on every run and never reached a fixed point, leaving `--check` permanently failing. Adjacent comments compounded it, leaving residue mid-expression that took a second pass to normalise. Marker runs are now removed together with the whitespace they introduced, and indentation is read from the line itself.                                                                                                                                                                                                                                       |
-| Formatter dropped clauses from unparsable SQL         | The sqlglot parse ran at `ErrorLevel.IGNORE`, which answers a statement it cannot parse with a partial AST rather than an error — the tokens it failed on are absent, and regenerating from that AST wrote back SQL the author never had. `INSERT ... CROSS JOIN LATERAL (VALUES ...) AS g(a, b) ON CONFLICT (a) DO NOTHING` came back without its `DO NOTHING`, a syntax error that `--in-place` reported as `reformatted`. Every guard passed it: one statement for one semicolon, 88% of the input's alphanumeric characters, and no string literals to round-trip. The guards are quantitative and the loss is qualitative — a dropped `DISTINCT`, `CASCADE`, `DESC`, or `NOT` is smaller still — so the parse now runs at `ErrorLevel.RAISE` and SQL that does not fully parse is emitted exactly as written. |
+| 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| Formatter indents inside multi-line literals                       | Block indentation was applied to every line of a multi-line literal (`$$…$$` body or a `'…'` string spanning lines), so a literal inside an `IF`, `LOOP`, or `BEGIN SQL` block gained the block's leading whitespace on each continuation line — changing the value stored by the database. Lines that begin inside a dollar-quoted literal are now emitted verbatim and excluded from the indent arithmetic. Neither the literal round-trip guard (which covers only the sqlglot round trip) nor the existing idempotency test (which compares pass 1 to pass 2, while the indent is applied once and then stable) could detect it.                                                                                                                                                                               |
+| Comma passes rewrite multi-line literals                           | `--leading-comma` and the trailing-comma normalization that precedes it moved a comma across a line break inside a multi-line literal, changing the stored value. Both now skip every line such a literal touches.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| Formatter never converged on unparsable statements                 | Comments are hidden from sqlglot as `/* marker */ line`. Removing the marker left the injected separator space behind, which was then measured as indentation — so a statement sqlglot could not parse (and therefore returned verbatim) gained one space on every run and never reached a fixed point, leaving `--check` permanently failing. Adjacent comments compounded it, leaving residue mid-expression that took a second pass to normalise. Marker runs are now removed together with the whitespace they introduced, and indentation is read from the line itself.                                                                                                                                                                                                                                       |
+| Formatter dropped clauses from unparsable SQL                      | The sqlglot parse ran at `ErrorLevel.IGNORE`, which answers a statement it cannot parse with a partial AST rather than an error — the tokens it failed on are absent, and regenerating from that AST wrote back SQL the author never had. `INSERT ... CROSS JOIN LATERAL (VALUES ...) AS g(a, b) ON CONFLICT (a) DO NOTHING` came back without its `DO NOTHING`, a syntax error that `--in-place` reported as `reformatted`. Every guard passed it: one statement for one semicolon, 88% of the input's alphanumeric characters, and no string literals to round-trip. The guards are quantitative and the loss is qualitative — a dropped `DISTINCT`, `CASCADE`, `DESC`, or `NOT` is smaller still — so the parse now runs at `ErrorLevel.RAISE` and SQL that does not fully parse is emitted exactly as written. |
+| Formatter moved a comment into the middle of an expression         | Comments are hidden from sqlglot as `/* marker */ line`, and sqlglot attaches the marker to an AST node. When it then reflows that node across several lines the marker surfaces deep inside the expression — `COALESCE((a.meas_value).undetected, FALSE)` carried it onto the `).undetected, FALSE)` continuation line — so restoring the comment above the marker split the expression around it, and the resulting layout reformatted differently on the next run. Comments whose markers sqlglot dropped entirely (inside a `CASE`) were re-inserted by token matching, which picked continuation lines the same way. Both paths now place the comment above the line where its expression opens, found by walking back to the parenthesis depth the comment sat at in the input.                              |
+| Formatter left a space before punctuation where a comment had been | Marker runs are replaced by the one space that keeps their neighbours apart, so `AND /* m */ RTRIM(` does not become `ANDRTRIM(`. Where sqlglot placed the run against a `;`, `,`, `)`, or `.` that space was residue rather than a separator: `1 = 1 /* m */;` came back as `1 = 1 ;`, normalised only on the next run, so `--check` failed on output the formatter had just produced. The run is now removed without a space at the ends of a line and against punctuation that binds to the token before it.                                                                                                                                                                                                                                                                                                    |
+| `EMAIL` SMTP login without a password                              | Upstream calls `smtplib.login()` with only a username when `[email] password` and `enc_password` are both unset, which raises `TypeError` from the stdlib — `login()` has no single-argument form. execsql2 reports a configuration error naming the missing password instead.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 
 ______________________________________________________________________
 

{execsql2-2.22.7 → execsql2-2.22.9}/docs/dev/architecture.md

@@ -353,6 +353,20 @@ At runtime, scripts can modify configuration via `CONFIG` metacommands (e.g., `C
 
 ______________________________________________________________________
 
+## Formatter Corpus
+
+`tests/test_format.py` checks four invariants against a corpus of real `.sql` files rather than hand-written snippets alone: no string literal is lost, no comment changes parenthesis depth, formatting is idempotent, and nothing raises. The corpus is every `.sql` file in the repository, which means `tests/data/formatter_shapes/` is the place to add a construct that has broken the formatter — files dropped anywhere in the repo are picked up automatically.
+
+Every formatter bug so far was reported from a production script and reproduced from a construct the project's own scripts do not contain, so the in-repo corpus can only catch a class of bug after someone has already hit it. To run the same checks over a private library of real SQL:
+
+```sh
+EXECSQL_FORMAT_CORPUS=~/sql-library uv run pytest tests/test_format.py -k corpus
+```
+
+Several directories may be given, separated by `:` (`;` on Windows). Unset — which is what CI sees — the in-repo corpus is used alone. Nothing is written to the corpus directories; the files are read and formatted in memory.
+
+______________________________________________________________________
+
 ## Further Reading
 
 - [Adding Metacommands](adding_metacommands.md) -- Step-by-step guide for new metacommands

{execsql2-2.22.7 → execsql2-2.22.9}/docs/guides/formatter.md

@@ -85,6 +85,10 @@ Comments interleaved within SQL statements (e.g. `--` comments between SELECT co
 1. Markers are restored to their original `--` comment style and position.
 1. Comments that sqlglot's AST drops (e.g. inside CASE WHEN) are detected and re-inserted at the best matching position.
 
+A comment written on its own line stays on its own line, above the expression it preceded — even when sqlglot reflows that expression across several lines. sqlglot attaches the marker to an AST node, and reformatting can carry it onto a continuation line deep inside the expression; the formatter walks back to the line where the expression opens, matching the parenthesis depth the comment sat at in the source. Without that, a comment above `COALESCE((a.meas_value).undetected, FALSE)` landed between the operand and its closing paren.
+
+A comment that genuinely sits inside parentheses — between the columns of an `INSERT` list, or inside a `WHERE (...)` group — stays inside them.
+
 Block comments (`/* */`) that contain `-- !x!` metacommand markers (e.g. commented-out code blocks) are recognized and passed through without metacommand processing.
 
 #### Variable preservation
@@ -184,7 +188,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.7
+    rev: v2.22.9
     hooks:
       - id: execsql-format
 ```

{execsql2-2.22.7 → execsql2-2.22.9}/docs/reference/configuration.md

@@ -266,7 +266,7 @@ The section and property names that may be used in a configuration file are list
 
 `username`
 
-:   The name of the user if the SMTP server requires login authentication.
+:   The name of the user if the SMTP server requires login authentication. If `username` is set, either `password` or `enc_password` must also be set; execsql reports an error rather than attempting an incomplete login.
 
 `password`
 

{execsql2-2.22.7 → execsql2-2.22.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.22.7"
+version = "2.22.9"
 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.7"
+current_version = "2.22.9"
 commit = true
 tag = true
 tag_name = "v{new_version}"
@@ -256,6 +256,10 @@ fo = "fo"
 odf = "odf"
 # Latin-1 test data: b"caf\xe9" decodes to "café"
 caf = "caf"
+# SMTP verb: EHLO-or-HELO, not the English word. Correcting it to "hello"
+# renames smtplib.ehlo_or_helo_if_needed() into a method that does not exist,
+# which is exactly how every EMAIL send broke in 2.22.9.
+helo = "helo"
 
 [tool.tox]
 required = ["tox-uv"]

{execsql2-2.22.7 → execsql2-2.22.9}/src/execsql/data/execsql.conf.template

@@ -242,6 +242,7 @@
 # Settings for the EMAIL metacommand.
 
 # SMTP server connection.
+# If username is set, password (or enc_password, below) is required too.
 #host=
 #port=
 #username=