execsql2 2.16.12__tar.gz → 2.16.14__tar.gz

{execsql2-2.16.12 → execsql2-2.16.14}/CHANGELOG.md

@@ -13,12 +13,55 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.16.14] - 2026-05-01
+
+### Fixed
+
+- ELSEIF conditions now support ANDIF/ORIF modifiers. Previously, ANDIF/ORIF after an ELSEIF were silently attached to the parent IF condition instead of the ELSEIF clause, meaning the compound condition was never evaluated correctly. ELSEIF + ANDIF/ORIF now works the same way as IF + ANDIF/ORIF.
+- Unknown AST node types now raise an error instead of being silently ignored during execution.
+- Cursor leak in `select_rowsource()` and `select_rowdict()`: cursor is now closed on query execution failure. High-traffic callers (EXPORT, COPY) now explicitly close the row generator on error instead of relying on garbage collection.
+
+______________________________________________________________________
+
+## [2.16.13] - 2026-05-01
+
+### Added
+
+- `execsql-format`: The `--indent` flag now controls SQL indentation in addition to metacommand indentation. Previously only metacommand depth was affected; now sqlglot's `pad` and `indent` parameters follow the same value (default 4).
+- `execsql-format`: New `--leading-comma` flag places commas at the start of lines instead of the end (e.g., `  , col2` instead of `col1,`).
+
+### Fixed
+
+- `execsql-format`: Fixed SQL corruption when formatting scripts with comments interleaved within multi-line SQL statements (e.g., `SELECT` with comment lines between columns, `CASE` with comments before `WHEN` clauses). Previously, the formatter split statements at comment boundaries and sent each fragment to sqlglot independently, which produced broken output (commas became semicolons, CASE expressions were split apart, content was silently dropped). The formatter now uses a marker-based round-trip: comments are replaced with inline markers before formatting so sqlglot sees the complete statement, then markers are restored to their original `--` comment style and position in the output. Comments that sqlglot's AST drops (e.g., inside CASE expressions) are detected and re-inserted at the best matching position using token-based heuristics.
+- `execsql-format`: Fixed `/* */` block comments containing `-- !x!` metacommand markers being incorrectly processed as real metacommands. This caused the block comment to be broken apart, with `*/` becoming `* /` and commented-out code being mangled. The formatter now tracks block comment boundaries and skips metacommand processing inside them.
+- `execsql-format`: Fixed blank lines within multi-line SQL statements (e.g., between column groups in a large `SELECT`) incorrectly splitting the statement into separate formatting blocks, causing each fragment to be formatted independently and producing invalid SQL.
+- `execsql-format`: Added safety checks to the sqlglot formatting pass — if sqlglot produces more statements than the input contained or drops significant content, the formatter now falls back to the original text instead of emitting corrupted SQL.
+
+______________________________________________________________________
+
 ## [2.16.12] - 2026-05-01
 
+### Changed
+
+- Lowered coverage threshold from 90% to 89% — SCRIPT introspection code is tested via subprocess integration tests which don't contribute to in-process coverage, and Windows CI skips TTY/POSIX tests that contribute ~1% on other platforms.
+
+### Added
+
+- Unit tests for `_parse_param_defs`, `_format_script_signature`, `_format_script_source`, and `SHOW SCRIPTS`/`SHOW SCRIPT` handlers.
+- Parser coverage tests for default parameters and docstring extraction.
+
 ______________________________________________________________________
 
 ## [2.16.11] - 2026-05-01
 
+### Fixed
+
+- Multi-line `/* */` block comment docstrings in `BEGIN SCRIPT` blocks now capture all lines correctly. Previously, the doc collection guard ran on block comment continuation lines, classified them as "non-comment", and stopped doc collection before the block comment handler could process them.
+
+### Added
+
+- 12 parser tests covering default parameters and docstring extraction (single-line, multi-line, block comments, empty separators, metacommand termination, required-after-optional validation).
+
 ______________________________________________________________________
 
 ## [2.16.10] - 2026-05-01

{execsql2-2.16.12 → execsql2-2.16.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.16.12
+Version: 2.16.14
 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

{execsql2-2.16.12 → execsql2-2.16.14}/docs/about/divergence.md

@@ -93,9 +93,9 @@ New options in `execsql.conf`:
 
 ### Tools
 
-| Tool             | Description                                                                                                                                                                                    |
-| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `execsql-format` | Standalone CLI for normalizing metacommand indentation and uppercasing SQL keywords. Supports `--check` and `--in-place` modes. Also available as a [pre-commit hook](../guides/formatter.md). |
+| Tool             | Description                                                                                                                                                                                                                                                                                                 |
+| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `execsql-format` | Standalone CLI for normalizing metacommand indentation and uppercasing SQL keywords. Supports `--check`, `--in-place`, `--indent N` (controls both metacommand and SQL indentation), and `--leading-comma` (commas at start of lines) modes. Also available as a [pre-commit hook](../guides/formatter.md). |
 
 ### GUI
 
@@ -310,6 +310,8 @@ These are behavioral changes driven by security or correctness issues in the ups
 | 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"`. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| 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. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                                                                                  |
 | 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. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                 |
 | 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. Inherited from upstream.                                                                                                                                                                                                                                                                                                                             |

{execsql2-2.16.12 → execsql2-2.16.14}/docs/guides/formatter.md

@@ -24,13 +24,14 @@ By default, formatted output is written to stdout. Use `--in-place` to overwrite
 
 ### Options { #options }
 
-| Option             | Default  | Description                                                                                         |
-| ------------------ | -------- | --------------------------------------------------------------------------------------------------- |
-| `FILE_OR_DIR`      | required | One or more files or directories to format. Directories are searched recursively for `*.sql` files. |
-| `--check`          | off      | Exit with code 1 if any file would be reformatted. Does not write any changes. Useful in CI.        |
-| `-i`, `--in-place` | off      | Modify files in place instead of writing to stdout.                                                 |
-| `--no-sql`         | off      | Skip SQL reformatting via sqlglot. Only normalizes metacommand indentation and keyword casing.      |
-| `--indent N`       | `4`      | Number of spaces per indent level.                                                                  |
+| Option             | Default  | Description                                                                                                    |
+| ------------------ | -------- | -------------------------------------------------------------------------------------------------------------- |
+| `FILE_OR_DIR`      | required | One or more files or directories to format. Directories are searched recursively for `*.sql` files.            |
+| `--check`          | off      | Exit with code 1 if any file would be reformatted. Does not write any changes. Useful in CI.                   |
+| `-i`, `--in-place` | off      | Modify files in place instead of writing to stdout.                                                            |
+| `--no-sql`         | off      | Skip SQL reformatting via sqlglot. Only normalizes metacommand indentation and keyword casing.                 |
+| `--indent N`       | `4`      | Spaces per indent level. Controls both metacommand block depth and SQL indentation (columns, subqueries, etc). |
+| `--leading-comma`  | off      | Place commas at the start of lines instead of the end (e.g. `  , col2` instead of `col1,`).                    |
 
 ## What Gets Formatted { #what-gets-formatted }
 
@@ -64,11 +65,28 @@ Metacommands that open a block (`IF`, `LOOP`, `BEGIN SCRIPT`, `BEGIN BATCH`, `BE
 
 ### SQL block formatting { #sql-formatting }
 
-SQL statements between metacommands are re-indented to match the current block depth and reformatted using [sqlglot](https://sqlglot.com/) in PostgreSQL dialect with pretty-printing enabled. Comment-only lines (single-line `--` and block `/* */` comments) are passed through without being sent to sqlglot.
+SQL statements between metacommands are re-indented to match the current block depth and reformatted using [sqlglot](https://sqlglot.com/) in PostgreSQL dialect with pretty-printing enabled.
 
-execsql substitution variables (`!!varname!!`, `!{varname}!`) are replaced with valid SQL identifiers before formatting, then restored afterward, so the formatter does not corrupt them.
+The `--indent` flag controls SQL indentation in addition to metacommand depth. For example, `--indent 4` (the default) produces 4-space indented column lists, subqueries, and CASE branches. `--indent 2` gives a more compact style.
 
-If sqlglot cannot parse a SQL statement, the original text is preserved unchanged.
+#### Comment handling
+
+Comments interleaved within SQL statements (e.g. `--` comments between SELECT columns, or inside CASE expressions) are preserved through formatting using a marker-based round-trip:
+
+1. Each comment line is replaced with a unique inline marker attached to the next SQL line.
+1. sqlglot formats the complete statement (no fragmentation).
+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.
+
+Block comments (`/* */`) that contain `-- !x!` metacommand markers (e.g. commented-out code blocks) are recognized and passed through without metacommand processing.
+
+#### Variable preservation
+
+execsql substitution variables (`!!varname!!`, `!{varname}!`) are replaced with valid SQL identifiers before formatting, then restored afterward, so the formatter does not corrupt them — including in schema-qualified names (`!!staging!!.!!table!!`), CASE expressions, JOIN conditions, and string concatenation.
+
+#### Fallback behavior
+
+If sqlglot cannot parse a SQL statement, or if safety checks detect that formatting would corrupt the SQL (e.g. statement count changes, significant content loss), the original text is preserved unchanged.
 
 Use `--no-sql` to skip SQL reformatting entirely and only normalize metacommands.
 
@@ -112,6 +130,22 @@ Exit code is `0` if all files are already formatted, `1` if any file would chang
 execsql-format --indent 2 --in-place myscript.sql
 ```
 
+### Use leading commas
+
+```bash
+execsql-format --leading-comma --in-place myscript.sql
+```
+
+This places commas at the start of each line instead of the end:
+
+```sql
+SELECT
+    a
+    , b
+    , c
+FROM t;
+```
+
 ### Skip SQL reformatting
 
 Format only metacommand indentation and casing, leaving SQL statements untouched:
@@ -143,13 +177,14 @@ select id,name,created_at from users where active = true order by name;
 -- !x! IF(EQUAL(!!schema!!, "public"))
     -- !x! WRITE "Checking public schema..."
     SELECT
-      id,
-      name,
-      created_at
+        id,
+        name,
+        created_at
     FROM users
     WHERE
-      active = TRUE
-    ORDER BY name;
+        active = TRUE
+    ORDER BY
+        name;
 -- !x! ENDIF
 ```
 
@@ -180,6 +215,10 @@ The hook runs on `*.sql` files. Pass any CLI options via `args`:
 # Custom indent width
 - id: execsql-format
   args: [--in-place, --indent, "2"]
+
+# Leading commas
+- id: execsql-format
+  args: [--in-place, --leading-comma]
 ```
 
 ## Exit Codes { #exit-codes }

{execsql2-2.16.12 → execsql2-2.16.14}/docs/reference/metacommands.md

@@ -1372,7 +1372,7 @@ ENDIF
 
 Multiple ELSEIF clauses can be used within a single multi-line IF metacommand. An ELSE clause can be used in combination with ELSEIF clauses, but this is not recommended because the results are not likely to be what you expect---the ELSE keyword only inverts the current truth state, it does not provide an alternative to all preceding ELSEIF clauses. To achieve the effect of a case or switch statement, use only ELSEIF clauses without a final ELSE clause.
 
-The ANDIF metacommand allows you to test for the conjunction of two conditional expressions using two separate metacommands instead of one. This may be beneficial for clarity. The simplest form of usage of the ANDIF clause is:
+The ANDIF metacommand allows you to test for the conjunction of two conditional expressions using two separate metacommands instead of one. This may be beneficial for clarity. ANDIF and ORIF can follow either an IF or an ELSEIF metacommand. The simplest form of usage of the ANDIF clause is:
 
 ```
 IF(<conditional expression>)
@@ -1381,7 +1381,7 @@ ANDIF(<conditional expression>)
 ENDIF
 ```
 
-The ANDIF metacommand does not have to immediately follow the IF metacommand. It could instead follow an ELSE statement, or appear anywhere at all within a multi-line IF metacommand. Usage patterns other than that illustrated above may be difficult to interpret, however, and nested IF metacommands may be preferable to complex uses of the ANDIF clause.
+The ANDIF metacommand does not have to immediately follow the IF metacommand. It could instead follow an ELSEIF statement. Usage patterns other than those illustrated here may be difficult to interpret, however, and nested IF metacommands may be preferable to complex uses of the ANDIF clause.
 
 The ORIF metacommand is similar to the ANDIF clause, but allows you to test for the disjunction of two conditional expressions using two different metacommands. The simplest form of usage of the ORIF clause is:
 
@@ -1392,6 +1392,17 @@ ORIF(<conditional expression>)
 ENDIF
 ```
 
+ANDIF and ORIF can also compound an ELSEIF condition:
+
+```
+IF(<conditional expression>)
+    <SQL statements and metacommands>
+ELSEIF(<conditional expression>)
+ANDIF(<conditional expression>)
+    <SQL statements and metacommands>
+ENDIF
+```
+
 The IF metacommands can be used not only to control a single stream of script commands, but also to loop over sets of SQL statements and metacommands, as shown in [Example 6](../guides/examples.md#example6).
 
 The IF metacommands cannot be used within a SQL statement (nor can any other metacommands). This restriction prohibits constructions such as:

{execsql2-2.16.12 → execsql2-2.16.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.16.12"
+version = "2.16.14"
 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" }
@@ -165,7 +165,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.16.12"
+current_version = "2.16.14"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.16.12 → execsql2-2.16.14}/src/execsql/db/base.py

@@ -226,6 +226,7 @@ class Database(ABC):
         try:
             curs.execute(sql)
         except Exception:
+            curs.close()
             self.rollback()
             raise
         try:
@@ -264,6 +265,7 @@ class Database(ABC):
         try:
             curs.execute(sql)
         except Exception:
+            curs.close()
             self.rollback()
             raise
         try: