execsql2 2.25.0__tar.gz → 2.26.0__tar.gz

{execsql2-2.25.0 → execsql2-2.26.0}/.github/dependabot.yml

@@ -28,8 +28,13 @@ updates:
       directory: /
       schedule:
           interval: weekly
+      # sqlglot is pinned (pyproject formatter extra, .pre-commit-hooks.yaml):
+      # its output changes between releases, so a bump is deliberate. Bump all
+      # three together, `uv lock --upgrade-package sqlglot==<new>`, and run the
+      # formatter corpus (CLAUDE.md) before merging.
       ignore:
           - dependency-name: ruff
+          - dependency-name: sqlglot
       groups:
           python-minor-and-patch:
               patterns:

{execsql2-2.25.0 → execsql2-2.26.0}/.github/workflows/ci-cd.yml

@@ -57,7 +57,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"

{execsql2-2.25.0 → execsql2-2.26.0}/.pre-commit-hooks.yaml

@@ -6,7 +6,10 @@
   types: [file]
   files: \.sql$
   args: [--in-place]
-  additional_dependencies: ["sqlglot>=25.0,<31"]
+  # One sqlglot: its output changes between releases, so an unpinned hook
+  # formats differently depending on when its env was built (#72). Keep equal
+  # to the formatter extra and uv.lock (tests/test_tooling_versions.py).
+  additional_dependencies: ["sqlglot==30.21.0"]
 
 - id: execsql-lint
   name: execsql-lint

{execsql2-2.25.0 → execsql2-2.26.0}/CHANGELOG.md

@@ -13,6 +13,28 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.26.0] - 2026-10-09
+
+### Added
+
+- **`execsql format --rewrite-sql`** (`[format] rewrite_sql`): accept sqlglot's rewrites of SQL text, such as `x::int` as `CAST(x AS INT)`.
+
+### Changed
+
+- **`execsql format` changes only layout and keyword case by default:** a statement sqlglot would rewrite (`x::int` as `CAST(x AS INT)`, an alias gaining `AS`, `BTRIM` as `TRIM`) is kept as written. Pass `--rewrite-sql`, or set `rewrite_sql = Yes` under `[format]`, for the previous behavior.
+- **`execsql format` and the `execsql-format` pre-commit hook use one sqlglot release:** the `[formatter]` extra requires sqlglot 30.21.x and the hook installs 30.21.0, so a script formats the same everywhere. The first run after upgrading can reformat files formatted with an older sqlglot, such as `BTRIM(x)` written as `TRIM(x)`; see [sqlglot version](https://execsql2.readthedocs.io/en/latest/guides/formatter/#sqlglot-version).
+
+______________________________________________________________________
+
+## [2.25.1] - 2026-10-09
+
+### Fixed
+
+- **`execsql lint` `V001` / `V002` and nested variable names:** `!!N_!!CHECK_GROUP!!_CHECKS!!` no longer reports `!!N_!!` and `!!_CHECKS!!` as undefined; the inner `!!CHECK_GROUP!!` is checked, and counts as used.
+- **`execsql lint` and `SUB_INI`:** a script whose `SUB_INI` names a FIFO or device (`/dev/zero`) no longer hangs lint, and an INI file that does not parse no longer stops it.
+
+______________________________________________________________________
+
 ## [2.25.0] - 2026-10-09
 
 ### Added

{execsql2-2.25.0 → execsql2-2.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.25.0
+Version: 2.26.0
 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
@@ -58,7 +58,7 @@ Requires-Dist: psycopg[binary]<4,>=3.1; extra == 'all'
 Requires-Dist: pymysql>=1.1; extra == 'all'
 Requires-Dist: pyodbc>=5.0; extra == 'all'
 Requires-Dist: pyyaml>=6.0; extra == 'all'
-Requires-Dist: sqlglot>=25.0; extra == 'all'
+Requires-Dist: sqlglot<30.22,>=30.21.0; extra == 'all'
 Requires-Dist: tables>=3.10; extra == 'all'
 Requires-Dist: tkintermapview>=1.29; extra == 'all'
 Requires-Dist: xlrd>=2.0; extra == 'all'
@@ -92,7 +92,7 @@ Requires-Dist: pre-commit>=3.5.0; extra == 'dev'
 Requires-Dist: pytest-cov>=5.0.0; extra == 'dev'
 Requires-Dist: pyyaml>=6.0; extra == 'dev'
 Requires-Dist: ruff>=0.4; extra == 'dev'
-Requires-Dist: sqlglot>=25.0; extra == 'dev'
+Requires-Dist: sqlglot<30.22,>=30.21.0; extra == 'dev'
 Requires-Dist: tables>=3.10; extra == 'dev'
 Requires-Dist: tox-uv>=1.13.1; extra == 'dev'
 Requires-Dist: twine>=6.1.0; extra == 'dev'
@@ -112,7 +112,7 @@ Requires-Dist: pyyaml>=6.0; extra == 'formats'
 Requires-Dist: tables>=3.10; extra == 'formats'
 Requires-Dist: xlrd>=2.0; extra == 'formats'
 Provides-Extra: formatter
-Requires-Dist: sqlglot>=25.0; extra == 'formatter'
+Requires-Dist: sqlglot<30.22,>=30.21.0; extra == 'formatter'
 Provides-Extra: map
 Requires-Dist: tkintermapview>=1.29; extra == 'map'
 Provides-Extra: mssql
@@ -451,7 +451,7 @@ execsql format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.25.0
+    rev: v2.26.0
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.25.0 → execsql2-2.26.0}/README.md

@@ -320,7 +320,7 @@ execsql format --no-sql --in-place scripts/
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.25.0
+    rev: v2.26.0
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.25.0 → execsql2-2.26.0}/docs/about/divergence.md

@@ -128,14 +128,14 @@ command, naming their replacement (`execsql run --ping` for `--ping`). The one e
 today — a script named exactly like a command — is recorded under
 [Changed Behavior](#cli-interface).
 
-| Command          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `execsql run`    | The explicit spelling of the upstream positional form. Identical behavior.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
-| `execsql format` | The formatter, reached through the main command. It replaced the standalone `execsql-format` console script, which was removed. The published pre-commit hook **id** is still `execsql-format`, so downstream `.pre-commit-config.yaml` files need no change — only the hook's internal `entry` moved. Formatter for normalizing metacommand indentation and uppercasing SQL keywords. Supports `--check`, `--in-place`, `--indent N` (controls both metacommand and SQL indentation), `--leading-comma` (commas at start of lines), `--no-sql` (skip SQL reformatting), `-f`/`--script-encoding` (formerly `--encoding`, still accepted), and `--config`; `-` formats stdin to stdout. Also available as a [pre-commit hook](../guides/formatter.md) — the published hook defaults to `args: [--in-place]` so downstream consumers get formatting on commit without extra wiring. SQL reformatting (the optional sqlglot pass) requires the `[formatter]` extra as of 2.19.0; `--no-sql` works without it. |
-| `execsql lint`   | Static checks over files *and directories*, walking directories recursively for `*.sql`; `-` reads stdin. Scripts are read with `-f`/`--script-encoding` or `[encoding] script` from config, like `run`. Every issue carries a [rule code](../reference/lint.md#rules); `--select` / `--ignore` choose rules, `--output-format json` feeds tools, and `--statistics` counts issues per rule. It replaced the `--lint` flag, which checked only the one script it was given.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
-| `execsql config` | List every config option with its current value, default, and the file that set it, resolved as a run would (pass a script to include its directory's `execsql.conf`). Passwords are masked. `--init` prints the template (replaces `--init-config`). `--validate` reports every problem in every config file a run reads, with file and line: invalid values and unparsable files as errors, unknown or misplaced sections and keys as warnings — upstream stopped at the first bad value and ignored unknown names silently.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `execsql list`   | `metacommands`, `encodings`, `plugins` or `keywords`, as text or JSON. Replaces `-m`, `-y`, `--list-plugins` and `--dump-keywords`; `-m` and `-y` are upstream flags and keep working as hidden aliases, deprecated when used without a command.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
-| `execsql init`   | Set up a project: `execsql.conf` from the template, a script with a header (from the upstream script template), and the `execsql-format` / `execsql-lint` pre-commit hooks. Never overwrites without `--force`, and never rewrites an existing `.pre-commit-config.yaml`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| Command          | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `execsql run`    | The explicit spelling of the upstream positional form. Identical behavior.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `execsql format` | The formatter, reached through the main command. It replaced the standalone `execsql-format` console script, which was removed. The published pre-commit hook **id** is still `execsql-format`, so downstream `.pre-commit-config.yaml` files need no change — only the hook's internal `entry` moved. Formatter for normalizing metacommand indentation and uppercasing SQL keywords. Supports `--check`, `--in-place`, `--indent N` (controls both metacommand and SQL indentation), `--leading-comma` (commas at start of lines), `--no-sql` (skip SQL reformatting), `--rewrite-sql` (accept sqlglot's rewrites of SQL text; off by default, so only layout changes), `-f`/`--script-encoding` (formerly `--encoding`, still accepted), and `--config`; `-` formats stdin to stdout. Also available as a [pre-commit hook](../guides/formatter.md) — the published hook defaults to `args: [--in-place]` so downstream consumers get formatting on commit without extra wiring. SQL reformatting (the optional sqlglot pass) requires the `[formatter]` extra as of 2.19.0; `--no-sql` works without it. |
+| `execsql lint`   | Static checks over files *and directories*, walking directories recursively for `*.sql`; `-` reads stdin. Scripts are read with `-f`/`--script-encoding` or `[encoding] script` from config, like `run`. Every issue carries a [rule code](../reference/lint.md#rules); `--select` / `--ignore` choose rules, `--output-format json` feeds tools, and `--statistics` counts issues per rule. It replaced the `--lint` flag, which checked only the one script it was given.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `execsql config` | List every config option with its current value, default, and the file that set it, resolved as a run would (pass a script to include its directory's `execsql.conf`). Passwords are masked. `--init` prints the template (replaces `--init-config`). `--validate` reports every problem in every config file a run reads, with file and line: invalid values and unparsable files as errors, unknown or misplaced sections and keys as warnings — upstream stopped at the first bad value and ignored unknown names silently.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
+| `execsql list`   | `metacommands`, `encodings`, `plugins` or `keywords`, as text or JSON. Replaces `-m`, `-y`, `--list-plugins` and `--dump-keywords`; `-m` and `-y` are upstream flags and keep working as hidden aliases, deprecated when used without a command.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `execsql init`   | Set up a project: `execsql.conf` from the template, a script with a header (from the upstream script template), and the `execsql-format` / `execsql-lint` pre-commit hooks. Never overwrites without `--force`, and never rewrites an existing `.pre-commit-config.yaml`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
 
 Formatter correctness notes added in the 2.19.x line:
 

{execsql2-2.25.0 → execsql2-2.26.0}/docs/guides/formatter.md

@@ -80,6 +80,7 @@ one run.
 | `--sql`, `--no-sql`                     | `[format] sql`, else `--sql`       | Reformat SQL via sqlglot, or skip it and only normalize metacommand indentation and keyword casing. `--no-sql` works without the `[formatter]` extra.                                                                                                                                   |
 | `--indent N`                            | `[format] indent`, else `4`        | Spaces per indent level. Controls both metacommand block depth and SQL indentation (columns, subqueries, etc).                                                                                                                                                                          |
 | `--leading-comma`, `--no-leading-comma` | `[format] leading_comma`, else off | Place commas at the start of lines instead of the end (e.g. `  , col2` instead of `col1,`).                                                                                                                                                                                             |
+| `--rewrite-sql`, `--no-rewrite-sql`     | `[format] rewrite_sql`, else off   | Also let sqlglot rewrite SQL text (`x::int` as `CAST(x AS INT)`, an alias with `AS`). Off, a statement sqlglot would rewrite is kept as written. See [Layout only](#layout-only).                                                                                                       |
 | `-f`, `--script-encoding NAME`          | config, else `utf-8`               | Text encoding used to read and write SQL files. Pass `cp1252`, `latin-1`, `shift_jis`, etc. for files saved by non-UTF-8 editors. Without it, `[encoding] script` from a [config file](../reference/configuration.md#configuration) applies. The old spelling `--encoding` still works. |
 | `--config FILE`                         | —                                  | An extra config file to read `[encoding] script` from. Config files are read once, from the system, user and working-directory locations plus this file — not from each script's directory.                                                                                             |
 
@@ -121,6 +122,33 @@ SQL statements between metacommands are re-indented to match the current block d
 
 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.
 
+#### sqlglot version { #sqlglot-version }
+
+The SQL layout comes from sqlglot, and sqlglot's output changes between its releases. So that the same script formats the same way on every machine, in CI and in the pre-commit hook, execsql2 pins it: the `[formatter]` extra requires sqlglot 30.21.x and the `execsql-format` hook installs exactly 30.21.0. A new execsql2 release may move the pin; its changelog says so, and the first run after upgrading can reformat files whose content did not change.
+
+Conditions joined by `AND` / `OR` go on one line when their combined text is at most 120 characters, and one per line otherwise. sqlglot measures the conditions without the indentation and the spaces between them, so a joined line can run a few characters past 120.
+
+#### Layout only, or rewrite { #layout-only }
+
+sqlglot does more than lay SQL out: it writes the SQL it parsed in its own preferred form. By default the formatter changes only layout and keyword case. A statement sqlglot would also rewrite is kept exactly as written, while the statements around it are still formatted.
+
+| You wrote                   | sqlglot writes                        |
+| --------------------------- | ------------------------------------- |
+| `x::int`                    | `CAST(x AS INT)`                      |
+| `count(*) n`                | `COUNT(*) AS n`                       |
+| `integer`, `numeric(10,2)`  | `INT`, `DECIMAL(10, 2)`               |
+| `BTRIM(x)`, `LTRIM(x, 'a')` | `TRIM(x)`, `TRIM(LEADING 'a' FROM x)` |
+| `a != b`                    | `a <> b`                              |
+
+Each pair means the same to PostgreSQL. To accept sqlglot's form, so every statement is formatted, pass `--rewrite-sql` or set it in a config file:
+
+```ini
+[format]
+rewrite_sql = Yes
+```
+
+With it on, the rewrites a statement gets can change when the pinned sqlglot changes (see above). Turning it off later does not undo rewrites already written; it only stops new ones.
+
 #### 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:
@@ -233,7 +261,7 @@ select id,name,created_at from users where active = true order by name;
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.25.0
+    rev: v2.26.0
     hooks:
       - id: execsql-format
       - id: execsql-lint # optional: fail the commit on lint errors

{execsql2-2.25.0 → execsql2-2.26.0}/docs/reference/configuration.md

@@ -405,6 +405,9 @@ the command line always wins. A run ignores this section.
 `sql`
 :   Reformat SQL with sqlglot (needs the `[formatter]` extra). `No` normalizes metacommands only. Default: Yes. Equivalent to `--sql` / `--no-sql`.
 
+`rewrite_sql`
+:   Also let sqlglot rewrite SQL text, such as `x::int` as `CAST(x AS INT)` or an alias with `AS`. With `No`, a statement sqlglot would rewrite is kept as written (see [Layout only](../guides/formatter.md#layout-only)). Default: No. Equivalent to `--rewrite-sql` / `--no-rewrite-sql`.
+
 ## Section `lint` { #config_lint }
 
 Rule selection for [`execsql lint`](lint.md#config). A run ignores this section.

{execsql2-2.25.0 → execsql2-2.26.0}/docs/reference/lint.md

@@ -158,7 +158,7 @@ The `execsql-lint` [pre-commit](https://pre-commit.com/) hook runs `execsql lint
 ```yaml
 repos:
   - repo: https://github.com/geocoug/execsql
-    rev: v2.25.0
+    rev: v2.26.0
     hooks:
       - id: execsql-lint
         args: [--ignore, V002] # optional: any execsql lint option
@@ -313,7 +313,7 @@ A `!!variable!!` is referenced, but nothing in the script defines it. At run tim
 
 A definition is any metacommand in the same file that sets a variable:
 
-- the SUB family: `SUB`, `SUB_EMPTY`, `SUB_ADD`, `SUB_APPEND`, `SUBDATA`, `SUB_LOCAL`, `SUB_TEMPFILE`, `SUB_ENCRYPT`, `SUB_DECRYPT`, the keys of `SUB_QUERYSTRING`, and the keys of a `SUB_INI` file that exists at lint time;
+- the SUB family: `SUB`, `SUB_EMPTY`, `SUB_ADD`, `SUB_APPEND`, `SUBDATA`, `SUB_LOCAL`, `SUB_TEMPFILE`, `SUB_ENCRYPT`, `SUB_DECRYPT`, the keys of `SUB_QUERYSTRING`, and the keys of a `SUB_INI` file that lint can read (a regular file of at most 1 MiB that parses as INI);
 - the prompts that store an answer: `PROMPT ENTER_SUB`, `ASK ... SUB`, `PROMPT ASK ... SUB` (with or without `COMPARE`), `PROMPT OPENFILE SUB`, `PROMPT SAVEFILE SUB` and `PROMPT DIRECTORY SUB` (every variable named after `SUB`), and both variables of `PROMPT CREDENTIALS`.
 
 Definitions inside `BEGIN SCRIPT` blocks that the file runs with `EXECUTE SCRIPT` count too, and so does a definition that comes after the first use.
@@ -324,6 +324,7 @@ Not reported:
 
 - System variables (`!!$DATE_TAG!!`, `!!$DB_NAME!!`, …), `!!$ARG_n!!` set with `-a`, and `!!$COUNTER_n!!`.
 - References with the `&` (environment), `@` (column), `~` (local), `#` and `+` prefixes, which resolve only at run time.
+- A name built from another variable, such as `!!N_!!CHECK_GROUP!!_CHECKS!!`. execsql substitutes `!!CHECK_GROUP!!` first, so the outer name is only known at run time. Lint checks the inner variable: if `CHECK_GROUP` is undefined, `!!CHECK_GROUP!!` is reported, not the fragments `!!N_!!` and `!!_CHECKS!!`.
 
 Variables defined somewhere lint cannot see are reported: in a configuration file, on the command line other than as `$ARG_n`, or in a file pulled in with `INCLUDE` (lint does not read `INCLUDE`d files for definitions). If that is how a library works, `--ignore V001` for those scripts.
 

{execsql2-2.25.0 → execsql2-2.26.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.25.0"
+version = "2.26.0"
 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" }
@@ -71,7 +71,7 @@ auth-plaintext = ["keyring>=25.0", "keyrings.alt>=5.0"]
 auth-encrypted = ["keyring>=25.0", "keyrings.alt>=5.0", "pycryptodome>=3.20"]
 upsert = ["pg-upsert>=1.25.0"]
 map = ["tkintermapview>=1.29"]
-formatter = ["sqlglot>=25.0"]
+formatter = ["sqlglot>=30.21.0,<30.22"]  # pinned: output changes between sqlglot releases (#72)
 # Convenience groups
 all-db = [
     "psycopg[binary]>=3.1,<4",
@@ -177,7 +177,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.25.0"
+current_version = "2.26.0"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.25.0 → execsql2-2.26.0}/src/execsql/cli/commands/format.py

@@ -51,6 +51,15 @@ def format_cmd(
         help="Commas at the start of lines instead of the end. Default: [format] leading_comma, else off.",
         show_default=False,
     ),
+    rewrite_sql: bool | None = typer.Option(
+        None,
+        "--rewrite-sql/--no-rewrite-sql",
+        help=(
+            "Also let sqlglot rewrite SQL text (x::int as CAST(x AS INT), BTRIM as TRIM, an alias with AS); "
+            "without it such a statement is kept as written. Default: [format] rewrite_sql, else off."
+        ),
+        show_default=False,
+    ),
     script_encoding: ScriptEncodingOpt = None,
     # The old spelling of --script-encoding, kept working but out of --help.
     encoding: str | None = typer.Option(None, "--encoding", metavar="NAME", hidden=True),
@@ -92,6 +101,7 @@ def format_cmd(
             no_sql=no_sql,
             indent=conf.format_indent if indent is None else indent,
             leading_comma=conf.format_leading_comma if leading_comma is None else leading_comma,
+            rewrite_sql=conf.format_rewrite_sql if rewrite_sql is None else rewrite_sql,
             encoding=script_encoding or encoding or _configured_script_encoding(conf) or "utf-8",
         ),
     )

{execsql2-2.25.0 → execsql2-2.26.0}/src/execsql/cli/lint.py

@@ -243,6 +243,12 @@ _RX_PROMPT_CREDENTIALS = re.compile(
 )
 
 _RX_VAR_REF = re.compile(r"!!([$@&~#+]?\w+)!!", re.I)
+# Every candidate reference, including one nested in another's name
+# (``!!N_!!GROUP!!_CHECKS!!``), which _RX_VAR_REF's left-to-right scan skips.
+_RX_VAR_REF_ANY = re.compile(r"(?=!!([$@&~#+]?\w+)!!)")
+# Stands for a substituted value in _unresolved_var_refs: a word character
+# (so an enclosing name still matches) that no script name contains.
+_SUBSTITUTED = "ª"
 
 
 # ---------------------------------------------------------------------------
@@ -424,54 +430,108 @@ def _extract_var_definition(
             _read_ini_vars(ini_file, ini_section, script_dir, defined)
 
 
+# Larger than any real SUB_INI file; lint reads no more than this.
+_MAX_INI_BYTES = 1024 * 1024
+
+
 def _read_ini_vars(
     ini_file: str,
     section: str,
     script_dir: Path | None,
     defined_vars: set[str],
 ) -> None:
-    """Read an INI file and register its section keys as defined variables."""
+    """Read an INI file and register its section keys as defined variables.
+
+    Only a regular file up to :data:`_MAX_INI_BYTES` is read, so a script
+    naming a FIFO or a device (``/dev/zero``) cannot hang lint or the
+    language server; a file that is unreadable or not valid INI defines
+    nothing.
+    """
     from configparser import ConfigParser
+    from configparser import Error as ConfigError
 
     p = Path(ini_file)
     if not p.is_absolute() and script_dir is not None:
         p = script_dir / p
 
-    if not p.exists():
-        return
-
     cp = ConfigParser()
-    cp.read(p)
+    try:
+        if not p.is_file() or p.stat().st_size > _MAX_INI_BYTES:
+            return
+        cp.read_string(p.read_text(encoding="utf-8"), source=str(p))
+    except (OSError, UnicodeDecodeError, ConfigError):
+        return
     if cp.has_section(section):
         for key, _value in cp.items(section):
             defined_vars.add(key.upper())
 
 
-def _check_var_ref(
-    raw_name: str,
-    source: str,
-    line_no: int,
-    defined_vars: set[str],
-    issues: list[_Issue],
-) -> None:
-    """Emit a warning if *raw_name* looks like an undefined user variable."""
-    if not raw_name:
-        return
-
+def _is_known_var(raw_name: str, defined_vars: set[str]) -> bool:
+    """Whether execsql may substitute *raw_name* (as written, with its sigil) at run time."""
     sigil = raw_name[0] if raw_name[0] in ("$", "@", "&", "~", "#", "+") else ""
     name = raw_name[len(sigil) :]
 
     # Skip non-$ sigil prefixes — resolved at runtime
     if sigil in ("@", "&", "~", "#", "+"):
-        return
+        return True
 
     if sigil == "$":
         # System variables: $ARG_N is set with -a/--assign-arg, $COUNTER_N by
         # CounterVars, the rest by execsql itself.  A SUB cannot define one.
-        if re.match(r"^(?:ARG|COUNTER)_\d+$", name, re.I) or name.upper() in _get_builtin_vars():
-            return
-    elif name.upper() in defined_vars:
-        # User variables, defined by a SUB-family metacommand or a prompt.
+        return bool(re.match(r"^(?:ARG|COUNTER)_\d+$", name, re.I)) or name.upper() in _get_builtin_vars()
+    # User variables, defined by a SUB-family metacommand or a prompt.
+    return name.upper() in defined_vars
+
+
+def _unresolved_var_refs(text: str, defined_vars: set[str]) -> list[str]:
+    """The variable names in *text* that execsql would leave unsubstituted, as written.
+
+    execsql substitutes a known variable wherever ``!!name!!`` appears and
+    repeats until nothing changes, so a variable written inside another's
+    name (``!!N_!!GROUP!!_CHECKS!!``) is replaced first, and the outer name
+    is only known at run time: it is not checked.  Here each known variable
+    is replaced by a placeholder character, a name holding one counts as
+    known, and that repeats until nothing is replaced.
+
+    In a run of unknown candidates that share delimiters, the inner ones
+    (every second, from the second) are reported: with ``GROUP`` undefined,
+    ``!!N_!!GROUP!!_CHECKS!!`` reports ``GROUP``, not the fragments ``N_``
+    and ``_CHECKS``.
+    """
+    while True:
+        parts: list[str] = []
+        end = 0
+        for m in _RX_VAR_REF_ANY.finditer(text):
+            name = m.group(1)
+            if m.start() >= end and (_SUBSTITUTED in name or _is_known_var(name, defined_vars)):
+                parts += [text[end : m.start()], _SUBSTITUTED]
+                end = m.start() + len(name) + 4
+        if not parts:
+            break
+        text = "".join([*parts, text[end:]])
+
+    unresolved: list[str] = []
+    run: list[str] = []
+    end = -1
+    for m in _RX_VAR_REF_ANY.finditer(text):
+        if run and m.start() != end - 2:  # not sharing the previous candidate's closing !!
+            unresolved.extend(run if len(run) == 1 else run[1::2])
+            run = []
+        run.append(m.group(1))
+        end = m.start() + len(m.group(1)) + 4
+    unresolved.extend(run if len(run) == 1 else run[1::2])
+    return unresolved
+
+
+def _check_var_ref(
+    raw_name: str,
+    source: str,
+    line_no: int,
+    defined_vars: set[str],
+    issues: list[_Issue],
+) -> None:
+    """Emit a warning if *raw_name* looks like an undefined user variable."""
+    if not raw_name or _is_known_var(raw_name, defined_vars):
         return
 
     issues.append(
@@ -735,7 +795,7 @@ def _collect_var_references(nodes: list[Node], seen: set[str]) -> None:
     """Record every variable read anywhere beneath *nodes*: ``!!var!!``, or ``sub_defined(var)`` / ``sub_empty(var)``."""
     for node in nodes:
         for text in _referencing_text(node):
-            for m in _RX_VAR_REF.finditer(text):
+            for m in _RX_VAR_REF_ANY.finditer(text):
                 seen.add(m.group(1).lstrip("$@&~#+").upper())
             for m in _RX_VAR_TEST.finditer(text):
                 seen.add(m.group(1).lstrip("$@&~#+").upper())
@@ -826,14 +886,14 @@ def _lint_nodes(
 
         # -- Variable references in SQL --
         if isinstance(node, SqlStatement):
-            for m in _RX_VAR_REF.finditer(node.text):
-                _check_var_ref(m.group(1), src, lno, defined_vars, issues)
+            for name in _unresolved_var_refs(node.text, defined_vars):
+                _check_var_ref(name, src, lno, defined_vars, issues)
 
         # -- Metacommand checks --
         elif isinstance(node, MetaCommandStatement):
             _check_metacommand(node, issues)
-            for m in _RX_VAR_REF.finditer(node.command):
-                _check_var_ref(m.group(1), src, lno, defined_vars, issues)
+            for name in _unresolved_var_refs(node.command, defined_vars):
+                _check_var_ref(name, src, lno, defined_vars, issues)
 
         # -- IncludeDirective checks --
         elif isinstance(node, IncludeDirective):

{execsql2-2.25.0 → execsql2-2.26.0}/src/execsql/config.py

@@ -379,6 +379,7 @@ class ConfigData:
         self._get_int(cp, self._FORMAT_SECTION, "indent", "format_indent")
         self._get_bool(cp, self._FORMAT_SECTION, "leading_comma", "format_leading_comma")
         self._get_bool(cp, self._FORMAT_SECTION, "sql", "format_sql")
+        self._get_bool(cp, self._FORMAT_SECTION, "rewrite_sql", "format_rewrite_sql")
         self._get_str(cp, self._LINT_SECTION, "select", "lint_select")
         self._get_str(cp, self._LINT_SECTION, "ignore", "lint_ignore")
         self._get_bool(cp, self._LINT_SECTION, "strict", "lint_strict")
@@ -555,6 +556,7 @@ class ConfigData:
         self.format_indent = 4
         self.format_leading_comma = False
         self.format_sql = True
+        self.format_rewrite_sql = False
         self.lint_select: str | None = None
         self.lint_ignore: str | None = None
         self.lint_strict = False

{execsql2-2.25.0 → execsql2-2.26.0}/src/execsql/data/execsql.conf.template

@@ -369,6 +369,9 @@
 #leading_comma=No
 # Reformat SQL with sqlglot (needs the [formatter] extra). No = metacommands only.
 #sql=Yes
+# Also let sqlglot rewrite SQL text: x::int as CAST(x AS INT), BTRIM as TRIM,
+# an alias with AS. No = a statement it would rewrite is kept as written.
+#rewrite_sql=No
 
 
 [lint]