execsql2 2.22.9__tar.gz → 2.23.1__tar.gz

{execsql2-2.22.9 → execsql2-2.23.1}/.github/workflows/ci-cd.yml

@@ -20,7 +20,7 @@ jobs:
         permissions:
             contents: read
         steps:
-            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
                   python-version: "3.13"
@@ -34,7 +34,7 @@ jobs:
         permissions:
             contents: read
         steps:
-            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
                   python-version: "3.13"
@@ -49,7 +49,7 @@ jobs:
         permissions:
             contents: read
         steps:
-            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
                   python-version: "3.13"
@@ -67,7 +67,7 @@ jobs:
         permissions:
             contents: read
         steps:
-            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
                   python-version: "3.13"
@@ -97,13 +97,13 @@ jobs:
             contents: read
         steps:
             - name: Check out repository code
-              uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+              uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - name: Setup Python ${{ matrix.python-version }}
               uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
                   python-version: ${{ matrix.python-version }}
             - name: Cache pip dependencies
-              uses: actions/cache@2c8a9bd7457de244a408f35966fab2fb45fda9c8  # v6.0.0
+              uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9  # v6.1.0
               with:
                   path: ~/.cache/pip
                   key: ${{ runner.os }}-pip-${{ matrix.python-version }}-${{
@@ -135,13 +135,13 @@ jobs:
                   tox -e py
             - name: Upload coverage to Codecov
               if: matrix.os == 'ubuntu-latest' && matrix.python-version == '3.13'
-              uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
+              uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5  # v7.1.1
               with:
                   token: ${{ secrets.CODECOV_TOKEN }}
                   files: coverage.xml
 
     integration-tests:
-        name: integration-tests-py${{ matrix.python-version }}
+        name: tier1-live-db-tests-py${{ matrix.python-version }}
         runs-on: ubuntu-latest
         strategy:
             fail-fast: false
@@ -188,7 +188,7 @@ jobs:
                     --health-interval 10s --health-timeout 5s --health-retries 20
         steps:
             - name: Check out repository code
-              uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+              uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - name: Setup Python ${{ matrix.python-version }}
               uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
@@ -203,6 +203,13 @@ jobs:
                   sudo ACCEPT_EULA=Y apt-get install -y msodbcsql18 unixodbc-dev
                   odbcinst -j
                   odbcinst -q -d
+            - name: Enable MySQL LOAD DATA LOCAL INFILE
+              # The MySQL importer uses LOAD DATA LOCAL INFILE, which MySQL 8
+              # disables server-side by default. A service container takes no
+              # command line, so it is switched on here; without it the import
+              # round-trip tests skip instead of running.
+              run: |
+                  mysql -h 127.0.0.1 -P 3306 -u root -proot -e "SET GLOBAL local_infile = 1;"
             - name: Install dependencies
               run: |
                   python -m pip install --upgrade pip
@@ -216,13 +223,13 @@ jobs:
               run: |
                   python -m pytest --cov=execsql --cov-branch --cov-report=xml --cov-fail-under=86
             - name: Upload coverage to Codecov
-              uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
+              uses: codecov/codecov-action@303a32d7a59b442fa8d48b6a1cc6825c09c847a5  # v7.1.1
               with:
                   token: ${{ secrets.CODECOV_TOKEN }}
                   files: coverage.xml
 
     access-tests-windows:
-        name: access-tests-windows
+        name: tier2-access-tests-windows
         runs-on: windows-latest
         # The Access engine install step is best-effort (the redistributable
         # download from Microsoft can be flaky on hosted runners). The
@@ -236,7 +243,7 @@ jobs:
         permissions:
             contents: read
         steps:
-            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
                   python-version: ${{ matrix.python-version }}
@@ -288,7 +295,7 @@ jobs:
         permissions:
             contents: read
         steps:
-            - uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+            - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - name: Set up Python
               uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97  # v7.0.0
               with:
@@ -343,14 +350,14 @@ jobs:
             contents: write
         steps:
             - name: Checkout
-              uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0  # v7.0.0
+              uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1  # v7.0.1
             - name: Download dist
               uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c  # v8.0.1
               with:
                   name: ${{ github.event.repository.name }}
                   path: dist/
             - name: Create release
-              uses: softprops/action-gh-release@718ea10b132b3b2eba29c1007bb80653f286566b  # v3.0.1
+              uses: softprops/action-gh-release@efb35369e0ad2afab669f228072c1b0d510eae64  # v3.0.3
               with:
                   draft: false
                   prerelease: false

{execsql2-2.22.9 → execsql2-2.23.1}/.gitignore

@@ -51,6 +51,7 @@ _execsql/
 CLAUDE.md
 AUDIT.md
 DOC_AUDIT.md
+ROADMAP.md
 PROMPTS.md
 audit/
 AGENTS.md

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

@@ -13,6 +13,56 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.23.1] - 2026-09-29
+
+### Added
+
+- A warning when MySQL, MariaDB or Oracle commits a statement on its own while `AUTOCOMMIT` is `OFF` or a batch is open — `CREATE TABLE`, `DROP`, `TRUNCATE` and other DDL, which the server commits together with everything before it, so none of it can be rolled back.
+- A warning when `AUTOCOMMIT OFF` or `BEGIN BATCH` cannot hold statements at all: an ODBC DSN whose driver has no transactions, or an MS Access `CREATE TEMPORARY QUERY`, which reopens the connection and rolls back what was not yet committed.
+
+### Fixed
+
+- SQLite: `CREATE TABLE`, `DROP` and other DDL run while `AUTOCOMMIT` is `OFF` or inside `BEGIN BATCH` are held until commit. They were committed at once, so `AUTOCOMMIT ON WITH ROLLBACK` and `ROLLBACK BATCH` left them in place.
+- DuckDB: `AUTOCOMMIT OFF` and `BEGIN BATCH` hold statements until commit. Every statement, rows included, was committed as it ran, so nothing could be rolled back. A script's own `BEGIN;` and `COMMIT;` now work too; `COMMIT;` failed with "no transaction is active".
+- DuckDB: `$LAST_ROWCOUNT` holds the number of rows an `INSERT`, `UPDATE` or `DELETE` changed. It was always `-1`.
+
+______________________________________________________________________
+
+## [2.23.0] - 2026-09-29
+
+### Added
+
+- Database support tiers. PostgreSQL, MySQL/MariaDB, MS SQL Server, SQLite, and DuckDB are **supported** — verified against a live server or real database file on every CI run. MS Access, Firebird, Oracle, and ODBC DSN are **best effort** — present, unverified in CI, and may break. No adapter changes behavior or is scheduled for removal.
+- `support_tier_notice` configuration option (`[interface]` section, default `Yes`). Opening a best-effort database connection writes one line to stderr naming the tier, once per DBMS per run. Set it to `No` to silence.
+
+### Changed
+
+- MySQL and MariaDB connections now default to `utf8mb4` instead of `latin1`. A latin1 connection could not carry CJK, emoji, Greek, or Cyrillic at all — inserting such text raised `UnicodeEncodeError` before reaching the server — so scripts had to pass `-e utf8mb4` to move most of Unicode. Existing latin1 databases are unaffected: the connection charset governs only client/server transfer, and MySQL transcodes to and from each column's own charset. Pass `-e latin1` to restore the previous behavior.
+
+### Fixed
+
+- `execsql.api.run()` no longer discards every `WRITE ... TO <file>` and `TEE` to a file. Those metacommands hand their output to a FileWriter subprocess that only the CLI started, so under the library API the file was never created and the run still reported success ([#46](https://github.com/geocoug/execsql/issues/46)). `run()` now starts the writer, and flushes and closes every file before returning, so output is readable as soon as it hands back control. A writer the caller started themselves is left untouched.
+- File output that cannot be written because no FileWriter is running now reports a warning instead of being dropped in silence. The write is still skipped — queueing to a subprocess that is not draining the queue deadlocks the caller — but a script's logfile no longer comes back empty with no indication anything was missed.
+- `IMPORT` reads CSV files containing a quoted field with a newline. RFC 4180 allows it and execsql's own CSV export produces it, but format diagnosis scanned physical lines, so the delimiter looked inconsistent and was rejected: the header arrived as a single column and the record split into two rows with the quote characters still in the data. Exporting a multi-line value and importing it back now round-trips.
+- `IMPORT` to MySQL writes an empty field as NULL instead of the column's zero value. `LOAD DATA` coerced an empty numeric to `0` and an empty date to `0000-00-00`, so the same file imported to MySQL differed from every other backend.
+- `IMPORT ... WITH QUOTE NONE` to PostgreSQL keeps double quotes in the data. `Well "A" 12` was stored as `Well A 12`, and the same happened when no quote character was detected ([#54](https://github.com/geocoug/execsql/issues/54)).
+- `IMPORT` to PostgreSQL honors a detected backslash escape. A quoted field containing `\"` was stored with the backslash and without the quote, so `"Well \"A\" 12"` became `Well \A\ 12`.
+- `IMPORT` to MySQL reads CRLF files correctly. `LOAD DATA` defaults to `\n` as its line terminator, so every row's last field kept a trailing carriage return — enough to turn an empty date column into `0000-00-00`.
+- `EXPORT ... AS CSV` (and the other delimited formats) no longer corrupts values containing a newline when run on Windows. Universal-newline translation rewrote every `\n` as `\r\n` on write, including newlines *inside* a quoted field, so an exported value did not match the one in the database. Delimited files now use `\n` row terminators on every platform, so the same query produces the same bytes everywhere.
+- `EXPORT ... AS TAB`/console pretty-printing keeps every row on one line. A newline or tab inside a value split the row across physical lines and misaligned every column after it; both are now shown as `\\n` and `\\t`, so the table stays square and the break is still visible.
+- `EXPORT ... AS VALUES` quotes dates, timestamps, and every other non-numeric value in the generated `INSERT`. Only strings were quoted, so a date was written bare as `2026-09-24` — which SQL reads as arithmetic, not a date. PostgreSQL accepted the statement and stored `1993` without complaint; a timestamp, carrying a space, was a syntax error instead. Numbers are still written bare, and `NULL` is unchanged.
+- `EXPORT ... AS LATEX` escapes every LaTeX special character, not only `_`. An `&` in a value acted as a column separator and produced a table with the wrong number of columns, which LaTeX refuses to compile ("Extra alignment tab has been changed to \\cr"); a `%` commented out the rest of the row. `\\ & % $ # _ { } ~ ^` are now all escaped.
+- `EXPORT ... AS LATEX` writes NULL as an empty cell instead of the literal text `None`.
+- `EXPORT ... AS HTML` renders zero and other falsy values instead of blank cells. Cells were written with `str(v) if v else ''`, so `0`, `False`, and empty strings came out empty — a zero measurement was indistinguishable from a NULL in the output.
+- `EXPORT ... AS MARKDOWN` no longer breaks the table when a value contains a newline. A GitHub-flavoured Markdown row is a single line, so a literal newline ended the row mid-cell and left the remaining values on a stray line outside the table. Line breaks are now written as `<br>`.
+- `EXPORT ... AS ODS` writes `numeric`/`decimal` columns as typed numbers. PostgreSQL, MySQL, and DuckDB return `Decimal` for those columns, which was written with an `office:value` but no `office:value-type` — not valid ODF, leaving a reader free to treat the number as text or ignore it.
+- `EXPORT ... AS ODS` keeps newlines inside a value instead of replacing them with spaces. Multi-line text is now written as one line per `<text:p>`, which is how ODF represents it; previously the exported cell did not match the value in the database.
+- `EXPORT ... AS XLSX` writes `numeric`/`decimal` columns as numbers instead of text. PostgreSQL, MySQL, and DuckDB return `Decimal` for those columns, which fell through to a string cell — a measurement column arrived in Excel as text and could not be summed, sorted, or charted. Integer and float columns were unaffected.
+- Exports and copies to DuckDB no longer lose floating-point precision. `DT_Float` is IEEE double precision and a Python float always is one, but DuckDB columns were declared `REAL` — single precision — so `1234.567` came back as `1234.5670166015625`. DuckDB columns are now `DOUBLE`, matching every other backend. Affects `EXPORT ... AS DUCKDB` and `COPY` into a DuckDB database.
+- Jinja2 report templates with an `.html`, `.htm`, or `.xml` extension now escape the values rendered into them. Autoescaping was off, so a database value containing markup — `<script>`, `&`, a quote — became live markup in the generated report. Templates with any other extension (`.csv`, `.tex`, `.txt`, `.sql`, `.md`) are unchanged, since escaping those would corrupt them. A template that means to emit markup uses `{{ value|safe }}`.
+
+______________________________________________________________________
+
 ## [2.22.9] - 2026-09-24
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.22.9
+Version: 2.23.1
 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
@@ -224,17 +224,26 @@ execsql script.sql                          # read connection from config file
 
 ### Supported Databases
 
-| Flag | Database        |
-| ---- | --------------- |
-| `p`  | PostgreSQL      |
-| `m`  | MySQL / MariaDB |
-| `s`  | MS SQL Server   |
-| `l`  | SQLite          |
-| `k`  | DuckDB          |
-| `a`  | MS Access       |
-| `f`  | Firebird        |
-| `o`  | Oracle          |
-| `d`  | ODBC DSN        |
+| Flag | Database        | Support                                          |
+| ---- | --------------- | ------------------------------------------------ |
+| `p`  | PostgreSQL      | Supported — verified against a live server in CI |
+| `m`  | MySQL / MariaDB | Supported — verified against a live server in CI |
+| `s`  | MS SQL Server   | Supported — verified against a live server in CI |
+| `l`  | SQLite          | Supported — verified against real files in CI    |
+| `k`  | DuckDB          | Supported — verified against real files in CI    |
+| `a`  | MS Access       | Best effort — not verified in CI                 |
+| `f`  | Firebird        | Best effort — not verified in CI                 |
+| `o`  | Oracle          | Best effort — not verified in CI                 |
+| `d`  | ODBC DSN        | Best effort — not verified in CI                 |
+
+**Supported** adapters run against a live server or a real database file on
+every CI run; a regression blocks the release and bugs get fixed. **Best
+effort** adapters are carried forward from the upstream monolith and are not
+exercised anywhere in CI — the code is there and may work, but nothing proves
+it still does. Issues and pull requests are welcome for them; no guarantee is
+made. Opening a best-effort connection prints one informational line, which
+`support_tier_notice=No` in the `[interface]` section of `execsql.conf`
+silences.
 
 ### Common options
 
@@ -384,7 +393,7 @@ execsql-format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.22.9
+    rev: v2.23.1
     hooks:
       - id: execsql-format
 ```

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

@@ -93,17 +93,26 @@ execsql script.sql                          # read connection from config file
 
 ### Supported Databases
 
-| Flag | Database        |
-| ---- | --------------- |
-| `p`  | PostgreSQL      |
-| `m`  | MySQL / MariaDB |
-| `s`  | MS SQL Server   |
-| `l`  | SQLite          |
-| `k`  | DuckDB          |
-| `a`  | MS Access       |
-| `f`  | Firebird        |
-| `o`  | Oracle          |
-| `d`  | ODBC DSN        |
+| Flag | Database        | Support                                          |
+| ---- | --------------- | ------------------------------------------------ |
+| `p`  | PostgreSQL      | Supported — verified against a live server in CI |
+| `m`  | MySQL / MariaDB | Supported — verified against a live server in CI |
+| `s`  | MS SQL Server   | Supported — verified against a live server in CI |
+| `l`  | SQLite          | Supported — verified against real files in CI    |
+| `k`  | DuckDB          | Supported — verified against real files in CI    |
+| `a`  | MS Access       | Best effort — not verified in CI                 |
+| `f`  | Firebird        | Best effort — not verified in CI                 |
+| `o`  | Oracle          | Best effort — not verified in CI                 |
+| `d`  | ODBC DSN        | Best effort — not verified in CI                 |
+
+**Supported** adapters run against a live server or a real database file on
+every CI run; a regression blocks the release and bugs get fixed. **Best
+effort** adapters are carried forward from the upstream monolith and are not
+exercised anywhere in CI — the code is there and may work, but nothing proves
+it still does. Issues and pull requests are welcome for them; no guarantee is
+made. Opening a best-effort connection prints one informational line, which
+`support_tier_notice=No` in the `[interface]` section of `execsql.conf`
+silences.
 
 ### Common options
 
@@ -253,7 +262,7 @@ execsql-format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.22.9
+    rev: v2.23.1
     hooks:
       - id: execsql-format
 ```

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

@@ -184,6 +184,18 @@ The CLI framework changed from `optparse` to [Typer](https://typer.tiangolo.com/
 
 Seven upstream long-form flags were renamed underscore → hyphen and the underscore forms are **not** accepted: `--database-encoding`, `--script-encoding`, `--output-encoding`, `--import-encoding`, `--import-buffer`, `--user-logfile`, `--visible-prompts` (upstream wrote these with underscores). Scripts and CI pipelines that invoke the long-form flags must update the spelling; the short letters (`-e`, `-f`, `-g`, `-i`, `-l`, `-v`, `-z`) are unchanged.
 
+### MySQL Connection Encoding
+
+Upstream opened MySQL and MariaDB connections as `latin1`, and execsql2 did the same until this was measured against a live server. A latin1 connection cannot carry CJK, emoji, Greek, or Cyrillic — pymysql raises `UnicodeEncodeError` before the server is reached — so any script moving text outside Latin-1 had to pass `-e utf8mb4` explicitly or fail.
+
+The default is now `utf8mb4`. This does not change stored data or column charsets: the connection charset governs only how text moves between client and server, and MySQL transcodes to and from each column's own charset. A latin1 column read over a utf8mb4 connection returns the same string it always did. `-e latin1` restores the upstream behavior.
+
+### Database Support Tiers
+
+Upstream documented all nine DBMS adapters with equal confidence. execsql2 splits them by what is actually verified: **Supported** (PostgreSQL, MySQL/MariaDB, MS SQL Server, SQLite, DuckDB) run against a live server or a real database file on every CI run, while **best effort** (MS Access, Firebird, Oracle, ODBC DSN) are carried forward from the monolith and are exercised nowhere in CI.
+
+No adapter is removed, deprecated, or changed in behavior — the tiers describe verification, not intent. Opening a best-effort connection writes one informational line to stderr per DBMS per run, which `support_tier_notice=No` in the `[interface]` section silences. Adapters declare their own tier through `Database.support_tier`, and `tests/db/test_tiers.py` fails if the code and the documented tables disagree.
+
 ### Default Database Type
 
 The default database type (`-t`) changed from Access (`a`) to SQLite (`l`). Upstream defaulted to Access, which requires Windows and pyodbc. SQLite is cross-platform, ships with Python, and is the most common use case. Users targeting Access databases should pass `-t a` explicitly.
@@ -216,7 +228,9 @@ All 33 mutable runtime globals in `state.py` have been consolidated into a `Runt
 - **Connection timeouts** — PostgreSQL and SQLite adapters accept a connection timeout parameter (default 30 seconds).
 - **DuckDB temporal types** — `TIMESTAMPTZ`, `TIMESTAMP`, `DATE`, `TIME` now map to native DuckDB types instead of `TEXT`.
 - **SQLite `DT_Long` mapping** — `DT_Long` maps to `"hugeint"` in the SQLite type table. SQLite does not have a native `HUGEINT` type; the value receives `TEXT` affinity. In practice this is harmless because SQLite's type affinity system handles large integers transparently, but the mapping name differs from upstream.
-- **`Database.auto_commits_ddl()` not provided** — 2.18.0 shipped this capability hook on the base `Database` class with `True` overrides on Oracle, MySQL, SQL Server, and MS Access (to signal that DDL on those drivers implicitly commits, so `rollback()` is a silent no-op across the DDL boundary). No call site ever consumed the hook, so 2.19.0 removed it. The asymmetry it described is still real — DDL inside a `BEGIN BATCH … END BATCH` block on Oracle / MySQL / SQL Server / MS Access cannot be rolled back — but execsql does not currently warn callers about it. (The companion hook `Database.needs_explicit_commit_after_ddl()`, used by the Firebird import path, remains.)
+- **`Database.auto_commits_ddl()` not provided** — 2.18.0 shipped this capability hook on the base `Database` class with `True` overrides on Oracle, MySQL, SQL Server, and MS Access. No call site ever consumed the hook, so 2.19.0 removed it. Its replacement is `Database.implicit_commit_rx`: MySQL and Oracle name the statements their server commits on its own (DDL), and a warning is written when one runs while `AUTOCOMMIT` is `OFF` or a batch is open. SQL Server holds DDL in a transaction like any other statement. (The companion hook `Database.needs_explicit_commit_after_ddl()`, used by the Firebird import path, remains.)
+- **Statements are held until commit on every adapter** — while `AUTOCOMMIT` is `OFF` or a batch is open, `Database.before_statement()` makes sure each statement is inside a transaction. Most drivers already opened one; SQLite's (Python's `sqlite3`) opened one only before `INSERT`/`UPDATE`/`DELETE`/`REPLACE`, and DuckDB's never did, so upstream committed SQLite DDL, and every DuckDB statement, at once. SQLite now begins a transaction before other statements (except `VACUUM`, `ATTACH`, `DETACH`, `PRAGMA`); DuckDB begins one itself, tracks it, and runs statements on the connection rather than on cursors while it is open, since a DuckDB cursor is a separate connection with its own transaction.
+- **DuckDB `$LAST_ROWCOUNT`** — the duckdb driver's `rowcount` is always `-1`; DuckDB answers an `INSERT`, `UPDATE` or `DELETE` with a one-column `Count` result instead. The DuckDB adapter reads that result, so `$LAST_ROWCOUNT` holds the rows changed, as on the other adapters. Upstream set it to `-1`.
 
 ### Execution Engine
 
@@ -253,14 +267,15 @@ These are behavioral changes driven by security or correctness issues in the ups
 
 ### Template and Export Safety
 
-| Area                   | Fix                                                                                                                                                                                                                                                                                                                                                                   |
-| ---------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Jinja2 sandboxing      | Templates run in `SandboxedEnvironment` instead of the default `jinja2.Template`.                                                                                                                                                                                                                                                                                     |
-| HTML export            | Column headers and cell values are escaped with `html.escape()` to prevent XSS.                                                                                                                                                                                                                                                                                       |
-| XML export             | Values are escaped with `xml.sax.saxutils.escape()`. Invalid XML element name characters are replaced.                                                                                                                                                                                                                                                                |
-| JSON export            | The `description` field and all column names use `json.dumps()` instead of string interpolation.                                                                                                                                                                                                                                                                      |
-| XLSX zip-bomb defence  | `EXPORT … FORMAT xlsx`, `EXPORT … FORMAT xls`, and (as of 2.19.0) `IMPORT … FORMAT xlsx` reject zip-based workbooks whose decompression ratio exceeds 100:1 per member or whose aggregate uncompressed size exceeds 500 MB. Helper at `execsql.utils.fileio.check_zip_decompression_ratio`. Legacy `.xls` (OLE-CDF, not zip) is unaffected — the helper no-ops on it. |
-| ODS XML attack defence | `EXPORT … FORMAT ods` / `IMPORT … FORMAT ods` defuse the stdlib XML parsers via `defusedxml.defuse_stdlib()` on first `OdsFile` construction, protecting odfpy from billion-laughs and external-entity attacks.                                                                                                                                                       |
+| Area                   | Fix                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| ---------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Jinja2 reports         | `SandboxedEnvironment` was created without `autoescape`, so Jinja2's default (off) applied and a value from the database rendered into an HTML report as live markup — a `<script>` in a text column became a script tag. The sandbox guards against a hostile template; nothing guarded against hostile data. Autoescaping is now selected by the template's extension: `html`, `htm` and `xml` escape, every other extension renders byte-identically to before, and a template that means to emit markup asks with \`{{ value |
+| Jinja2 sandboxing      | Templates run in `SandboxedEnvironment` instead of the default `jinja2.Template`.                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| HTML export            | Column headers and cell values are escaped with `html.escape()` to prevent XSS.                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| XML export             | Values are escaped with `xml.sax.saxutils.escape()`. Invalid XML element name characters are replaced.                                                                                                                                                                                                                                                                                                                                                                                                                           |
+| JSON export            | The `description` field and all column names use `json.dumps()` instead of string interpolation.                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| XLSX zip-bomb defence  | `EXPORT … FORMAT xlsx`, `EXPORT … FORMAT xls`, and (as of 2.19.0) `IMPORT … FORMAT xlsx` reject zip-based workbooks whose decompression ratio exceeds 100:1 per member or whose aggregate uncompressed size exceeds 500 MB. Helper at `execsql.utils.fileio.check_zip_decompression_ratio`. Legacy `.xls` (OLE-CDF, not zip) is unaffected — the helper no-ops on it.                                                                                                                                                            |
+| ODS XML attack defence | `EXPORT … FORMAT ods` / `IMPORT … FORMAT ods` defuse the stdlib XML parsers via `defusedxml.defuse_stdlib()` on first `OdsFile` construction, protecting odfpy from billion-laughs and external-entity attacks.                                                                                                                                                                                                                                                                                                                  |
 
 ### Credential and Logging Safety
 
@@ -299,6 +314,8 @@ These are behavioral changes driven by security or correctness issues in the ups
 | `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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| PostgreSQL `IMPORT` with no quote character                        | The `COPY` fast path uses COPY's CSV format, whose quote character is `"` unless another is named. With `QUOTE NONE`, or when no quote character was detected, none was named, so `"` was treated as a quote and stripped: `Well "A" 12` was stored as `Well A 12`. Such files now take the row-by-row path, which keeps every character (#54).                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| PostgreSQL `IMPORT` with a detected escape character               | The `COPY` fast path was never told about a detected escape character, so `\"` inside a quoted field was stored as `\`. Such files now take the row-by-row path, which reads the detected format.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
 | 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.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
@@ -325,6 +342,20 @@ These are behavioral changes driven by security or correctness issues in the ups
 | 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.                                                                                                                                                                                                                                                                                                    |
+| Delimited export corrupted embedded newlines on Windows            | `EncodedFile.open()` passed `newline=None`, so Python rewrote every `\n` written as `os.linesep`. That is right for row terminators and wrong for data: a newline inside a quoted CSV field was rewritten too, and the value read back was not the value exported. Python's own `csv` documentation calls for `newline=""` for exactly this reason. The delimited writer now opts out of translation, so row terminators are `\n` on every platform and a query produces identical bytes everywhere. Found by exporting a value containing a newline — nothing in the suite had ever done so — which failed on all five Windows runners and none of the others.                                                                                                                                                    |
+| CSV import could not read a quoted field containing a newline      | `diagnose_delim()` iterated physical lines, so a record split across two of them gave inconsistent delimiter counts and the real delimiter was rejected. The header came back as one column and the record as two rows with the quotes retained. Lines are now joined while a quote is open, so diagnosis sees logical records. RFC 4180 allows the construct, the stdlib reads it, and execsql's own CSV writer produces it — so this was a failure to read back what it had just written.                                                                                                                                                                                                                                                                                                                        |
+| MySQL import turned empty fields into zero values                  | `LOAD DATA` coerces an empty field to the column's zero value: an empty numeric became `0` and an empty date `0000-00-00`, while every other backend produced NULL. Columns are now read into user variables and `NULLIF`-ed back.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| MySQL import left a carriage return on the last field of each row  | `LOAD DATA` defaults to `\n` as its line terminator, so a CRLF file — what Python's `csv` writer produces by default — left `\r` on each row's final value. It was not empty, so the `NULLIF` above could not see it, and a date column became `0000-00-00`. The statement now declares `lines terminated by '\r\n'` when the file is CRLF.                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| Pretty-printed tables were broken by a newline or tab in a value   | The fixed-width writer emitted string values as-is, so a newline ended the row mid-cell — the remaining columns appeared on a line with no table structure — and a tab misaligned everything after it. Both are now rendered as their two-character escapes. This is a display format, so the escape keeps the row on one line, keeps the columns square, and still shows the reader that a break is present.                                                                                                                                                                                                                                                                                                                                                                                                      |
+| DuckDB float columns were single precision                         | `dbt_duckdb` mapped `DT_Float` to `REAL`. `DT_Float` is documented as IEEE double precision and a Python float always is one, so every float written to DuckDB was narrowed: `1234.567` was stored and returned as `1234.5670166015625`. PostgreSQL, SQLite, SQL Server, MySQL, Access, Firebird and DSN all map `DT_Float` to a double; DuckDB was the only backend that did not, and is now `DOUBLE`.                                                                                                                                                                                                                                                                                                                                                                                                            |
+| VALUES export wrote dates and timestamps unquoted                  | The literal renderer quoted `str` and emitted `NULL` for `None`, but sent everything else through `str()` bare. A `date` became `2026-09-24` in the generated `INSERT`, which is not a syntax error — it is a valid SQL expression evaluating to 1993, so PostgreSQL inserted that and reported nothing. A `timestamp` contains a space and failed outright. Quoting is now the default and only numbers are emitted bare, so a type the renderer has not been taught about is safe rather than silently wrong.                                                                                                                                                                                                                                                                                                    |
+| LaTeX export escaped only the underscore                           | Cells were written as `str(c).replace("_", r"\_")`, leaving every other LaTeX special raw. `&` is the column separator this exporter itself emits, so an ampersand in a value added a column and the `.tex` no longer compiled; `%` commented out the rest of the row. All of `\ & % $ # _ { } ~ ^` are now escaped, in both the header and the body.                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
+| LaTeX export wrote NULL as the literal "None"                      | `str(c)` was applied to every value including `None`, so a NULL appeared in the typeset table as the word None. It is now an empty cell, matching every other exporter.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| HTML export rendered zero as an empty cell                         | Cells were written as `html.escape(str(v)) if v else ''`. `0`, `False`, and `""` are all falsy, so a zero measurement rendered exactly like a NULL and the two could not be told apart in the output. The test is now `if v is not None`. Both `export_html` and `export_cgi_html` were affected.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| Markdown export broke the table on an embedded newline             | `_cell()` escaped pipes but not newlines, and a GFM table row is a single line: a value containing one ended the row mid-cell and left the rest of that row's values on a stray line outside the table entirely. Newlines are now written as `<br>`, which is how GFM expresses a line break inside a cell.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ODS export wrote `numeric` columns with no type                    | The cell-type dispatch tested \`isinstance(item, float                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| ODS export replaced newlines inside a value with spaces            | String cells were written after `item.replace("\n", " ")`, so an exported value silently differed from the one in the database. An XML parser does normalise a newline inside an attribute, so `office:string-value` cannot carry one — but ODF represents a multi-line cell as one `<text:p>` per line, which is what LibreOffice writes and what execsql2 now writes. Single-line values still use the attribute.                                                                                                                                                                                                                                                                                                                                                                                                |
+| XLSX export wrote `numeric` columns as text                        | `_cell_value()` passed `int` and `float` straight to openpyxl but let every other type fall through to `str()`. PostgreSQL, MySQL, and DuckDB all return `Decimal` for `numeric`/`decimal` columns, so measurement values arrived in Excel as text cells — invisible in a screenshot, useless in a formula, a sort, or a chart. openpyxl lists `Decimal` in its own `NUMERIC_TYPES` and stores it as a real numeric cell, so the conversion was never needed. Found by exporting from a live PostgreSQL container and checking `cell.data_type` rather than `cell.value`.                                                                                                                                                                                                                                          |
 | `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.9 → execsql2-2.23.1}/docs/api/index.md

@@ -48,6 +48,23 @@ for t in threads:
 
 Each thread gets its own database connections, IF/LOOP stacks, substitution variables, and error state. No locking is required.
 
+### File Output { #file-output }
+
+`WRITE ... TO <file>`, `TEE`, and the other metacommands that write text files hand their output to a separate FileWriter process. `run()` starts one if none is running, and flushes and closes every file before returning — so a file a script wrote is on disk and complete the moment `run()` hands back control.
+
+```python
+from execsql import run
+
+result = run(sql='-- !x! WRITE "done" to report.txt\nselect 1;\n', dsn="sqlite:///data.db")
+open("report.txt").read()   # "done\n" — readable immediately
+```
+
+The writer process stays up afterwards and is reused by later `run()` calls, exactly as the CLI keeps one for the life of the process; it is shut down automatically at interpreter exit. A writer you started yourself is left alone — `run()` neither replaces nor stops it.
+
+!!! warning "Interactive interpreters"
+
+    On macOS and Windows, Python starts subprocesses with the `spawn` method, which re-imports the calling program's `__main__` module. That fails in a REPL, a notebook, or `python -c`, so the writer cannot start and file output is discarded — with a warning on stderr rather than in silence. Run scripts that write files from a `.py` file, guarded by `if __name__ == "__main__":`.
+
 ## Extension Guides
 
 | Extension type       | Guide                                                    | API reference                   |

{execsql2-2.22.9 → execsql2-2.23.1}/docs/getting-started/requirements.md

@@ -36,6 +36,32 @@ Multiple extras can be combined: `pip install "execsql2[postgres,duckdb,formats]
 
 The specific libraries installed by each extra are:
 
+### Database support tiers { #support-tiers }
+
+execsql2 ships nine DBMS adapters, but they are not all verified to the same
+standard. The tier tells you which ones have actually been run.
+
+| Tier            | Databases                                                | What it means                                                                                                                                                                                       |
+| --------------- | -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **Supported**   | PostgreSQL, MySQL/MariaDB, MS SQL Server, SQLite, DuckDB | Exercised against a live server (or a real database file) on every CI run. A regression blocks the release, and bugs are fixed.                                                                     |
+| **Best effort** | MS Access, Firebird, Oracle, ODBC DSN                    | Carried forward from the upstream monolith and not exercised in CI. The code is present and may work; nothing proves it still does. Issues and pull requests are welcome, but no guarantee is made. |
+
+Opening a best-effort connection writes one informational line to stderr, once
+per DBMS per run:
+
+```
+Note: Firebird support is best-effort — it is not verified in CI and may break.
+Set support_tier_notice=No in the [interface] section of execsql.conf to silence this.
+```
+
+It goes to stderr rather than stdout, so it cannot corrupt piped query output.
+To turn it off, set [`support_tier_notice`](../reference/configuration.md#support_tier_notice)
+to `No`.
+
+No adapter is deprecated or scheduled for removal. The tiers describe what is
+verified, not what is wanted — a best-effort adapter moves up when it gains
+tests that run against something real.
+
 ### Database drivers
 
 | Database / Format | Extra      | Library                                                         |

{execsql2-2.22.9 → execsql2-2.23.1}/docs/guides/encoding.md

@@ -8,7 +8,7 @@ If no encodings are specified, the following default encodings are used:
 
 > - Script file: utf8
 > - Firebird: latin1
-> - MySQL and MariaDB: latin1
+> - MySQL and MariaDB: utf8mb4
 > - SQL Server: latin1
 > - Access: windows_1252
 > - DSN: None

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

@@ -188,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.9
+    rev: v2.23.1
     hooks:
       - id: execsql-format
 ```

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

@@ -233,6 +233,10 @@ The section and property names that may be used in a configuration file are list
 
 :   Determines whether warning messages are written to the console as well as to the log file. The default value is "No", indicating that warnings will not be written to the console. If it is set to "Yes", warnings will be written to the console.
 
+`support_tier_notice` { #support_tier_notice }
+
+:   Determines whether opening a connection to a [best-effort database](../getting-started/requirements.md#support-tiers) — MS Access, Firebird, Oracle, or an ODBC DSN — writes an informational line to stderr saying that the adapter is not verified in CI. The default value is "Yes". Set it to "No" to silence the notice. The message is written once per DBMS per run, and always to stderr rather than stdout, so it cannot corrupt piped query output. It is recorded in the log file regardless of this setting.
+
 `write_prefix`
 
 :   Text that will be prefixed to any output from the WRITE metacommand, with a space separator. If substitution variables are used, deferred substitution may be appropriate.

{execsql2-2.22.9 → execsql2-2.23.1}/docs/reference/metacommands.md

@@ -115,6 +115,19 @@ SQL statements that were issued while AUTOCOMMIT is OFF can also be committed us
 
 The AUTOCOMMIT metacommand is database-specific, and affects only the database in use when the metacommand is used. This contrasts with the [BATCH](#batch) metacommand, which affects all databases.
 
+**What each DBMS can hold back.** While AUTOCOMMIT is OFF, or inside a [batch](#batch), *execsql* keeps every statement in a transaction until it is committed or rolled back, including `CREATE TABLE` and other DDL. Some databases commit certain statements on their own regardless:
+
+| DBMS | While AUTOCOMMIT is OFF or a batch is open |
+| --- | --- |
+| PostgreSQL, SQL Server, SQLite, DuckDB, Firebird | Every statement is held, DDL included, and can be rolled back. |
+| MySQL / MariaDB | The server commits DDL (`CREATE`, `ALTER`, `DROP`, `RENAME`, `TRUNCATE`, `GRANT`, …) and `BEGIN` / `START TRANSACTION` at once, together with every statement before them. `CREATE TEMPORARY TABLE` is held. *execsql* writes a warning naming each such statement. |
+| Oracle | The server commits every DDL statement at once, together with every statement before it. *execsql* writes a warning naming each one. |
+| SQLite | `VACUUM`, `ATTACH`, `DETACH` and `PRAGMA` run outside a transaction, since SQLite refuses or ignores them inside one. |
+| ODBC DSN | If the ODBC driver has no transactions, each statement is committed as it runs; *execsql* warns once. |
+| MS Access | `CREATE TEMPORARY QUERY` reopens the connection, which rolls back statements not yet committed; *execsql* warns once. |
+
+Before execsql2 fixed it, SQLite committed DDL at once and DuckDB committed every statement, even with AUTOCOMMIT OFF.
+
 
 The [IMPORT](#import) and [COPY](#copy) metacommands do not commit data changes while AUTOCOMMIT is off (except when the NEW or REPLACEMENT clauses are used with Firebird; in those cases the 'create table' statement that *execsql* generates and runs will be committed). The SQL statements generated by the [IMPORT](#import) and [COPY](#copy) metacommands are sent to the database, however. Therefore the AUTOCOMMIT metacommand is recommended when explicit transaction control is to be applied to the [IMPORT](#import) and [COPY](#copy) metacommands.
 
@@ -196,6 +209,8 @@ BEGIN BATCH marks the beginning of a set of SQL statements to be executed in a s
 
 Metacommands may be included inside a batch, but note that the [IMPORT](#import) and [COPY](#copy) metacommands always commit the changes they make, unless [AUTOCOMMIT](#autocommit) is OFF, so if IMPORT or COPY metacommands are used inside a batch, any preceding SQL statements in the batch will also be committed unless AUTOCOMMIT is OFF.
 
+What a batch can hold back depends on the DBMS; see the table under [AUTOCOMMIT](#autocommit). MySQL and Oracle commit DDL inside a batch at once, with everything before it, and *execsql* warns when that happens.
+
 When the END BATCH metacommand is processed by *execsql*, a commit command is sent to all databases that have been used inside the batch. Multiple databases may be used inside a batch if the [USE](#use) metacommand is used inside the batch. The BATCH metacommands therefore provide a limited sort of cross-database transaction control — note, however, that the commit statements are issued sequentially, and if a later commit statement fails, this will not roll back changes to databases for which the commit has already succeeded.
 
 The BEGIN/END BATCH metacommands can be nested. However, the inner END BATCH metacommand will ordinarily commit all changes to the databases that have been used, which may include databases used in the outer batch as well. (This behavior may be DBMS-specific, and also depend on whether any additional explicit transaction control is being used.) Therefore completion of a nested batch may result in premature commitment of some or all SQL statements in the outer batch. Similarly, a ROLLBACK BATCH metacommand within the inner batch will also roll back any SQL commands sent to the same databases in the outer batch. Thus, although the BATCH commands can be nested, database transactions may not be, depending on the DBMS in use. Nesting of BATCH metacommands allows a script file or a [SCRIPT](#beginscript) containing a batch to be [INCLUDEEd](#include) or [EXECUTEEd](#executescript), respectively, within another batch.

{execsql2-2.22.9 → execsql2-2.23.1}/docs/reference/substitution_vars.md

@@ -148,7 +148,7 @@ $LAST_ERROR
 :   The text of the last SQL statement or metacommand that caused an error. This value will only be available if the [ERROR_HALT OFF](metacommands.md#error_halt) or [METACOMMAND_ERROR_HALT OFF](metacommands.md#metacommanderrorhalt) metacommand has been used, or in an [ON ERROR_HALT EMAIL](metacommands.md#error_halt_email), [ON ERROR_HALT WRITE](metacommands.md#error_halt_write), or [ON ERROR_HALT EXECUTE SCRIPT](metacommands.md#error_halt_exec) metacommand.
 
 $LAST_ROWCOUNT
-:   The number of rows that were affected by the last INSERT, UPDATE, or SELECT statement. Note that support for $LAST_ROWCOUNT varies among DBMSs. For example, for SELECT statements, Postgres provides an accurate count, SQLite always returns -1, Firebird always returns 0, and DuckDB does not provide a value.
+:   The number of rows that were affected by the last INSERT, UPDATE, or SELECT statement. Note that support for $LAST_ROWCOUNT varies among DBMSs. For example, for SELECT statements, Postgres provides an accurate count, SQLite and DuckDB always return -1, and Firebird always returns 0. For INSERT, UPDATE and DELETE, every supported DBMS reports the number of rows changed.
 
 $LAST_SQL
 :   The text of the last SQL statement that ran without error.