execsql2 2.25.1__tar.gz → 2.26.0__tar.gz

{execsql2-2.25.1 → 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.1 → 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.1 → 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.1 → execsql2-2.26.0}/CHANGELOG.md

@@ -13,6 +13,19 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: execsql2
-Version: 2.25.1
+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.1
+    rev: v2.26.0
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.25.1 → 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.1
+    rev: v2.26.0
     hooks:
       - id: execsql-format
       - id: execsql-lint

{execsql2-2.25.1 → 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.1 → 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.1
+    rev: v2.26.0
     hooks:
       - id: execsql-format
       - id: execsql-lint # optional: fail the commit on lint errors

{execsql2-2.25.1 → 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.1 → 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.1
+    rev: v2.26.0
     hooks:
       - id: execsql-lint
         args: [--ignore, V002] # optional: any execsql lint option

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

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

{execsql2-2.25.1 → 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.1 → 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.1 → 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]

{execsql2-2.25.1 → execsql2-2.26.0}/src/execsql/format.py

@@ -16,6 +16,7 @@ import io
 import re
 from collections.abc import Iterator
 from pathlib import Path
+from types import ModuleType
 
 __all__ = ["collect_paths", "format_file", "open_dollar_quote", "parse_keyword", "run_formatter"]
 
@@ -509,10 +510,47 @@ def _is_comment_line(line: str, in_block: bool) -> tuple[bool, bool]:
     return False, False
 
 
+def _statement_sources(sqlglot: ModuleType, sql: str) -> list[str]:
+    """The text of each statement in *sql*, split at the semicolons sqlglot's tokenizer sees.
+
+    Comments before a statement belong to it; a semicolon inside a string or
+    a quoted name is not a split.  A part holding no tokens (``;;``) is not a
+    statement, matching the ``None`` sqlglot's parser returns for it.
+    """
+    sources: list[str] = []
+    start = 0
+    has_tokens = False
+    for token in sqlglot.tokenize(sql, read="postgres"):
+        if token.token_type.name == "SEMICOLON":
+            if has_tokens:
+                sources.append(sql[start : token.start])
+            start, has_tokens = token.end + 1, False
+        else:
+            has_tokens = True
+    if has_tokens:
+        sources.append(sql[start:])
+    return sources
+
+
+def _layout_tokens(sqlglot: ModuleType, sql: str) -> list[str]:
+    """*sql*'s tokens with everything the formatter may change taken out.
+
+    Whitespace and comments are not tokens.  Keywords and unquoted names are
+    compared without case; strings and quoted names exactly.
+    """
+    return [
+        token.text
+        if token.token_type.name.endswith("STRING") or token.token_type.name == "IDENTIFIER"
+        else token.text.upper()
+        for token in sqlglot.tokenize(sql, read="postgres")
+    ]
+
+
 def _sqlglot_format(
     sql_lines: list[str],
     sql_indent: int = 4,
     leading_comma: bool = False,  # noqa: ARG001 — leading-comma layout is applied as a textual post-pass on the assembled output; sqlglot's own `leading_comma=True` is non-idempotent under inline comments.
+    rewrite_sql: bool = False,
 ) -> list[str]:
     """Format a list of SQL-only lines (no comment-only lines) via sqlglot.
 
@@ -521,6 +559,12 @@ def _sqlglot_format(
     ``format_file``. sqlglot's own ``leading_comma=True`` reshuffles inline
     comments and is therefore non-idempotent on SQL with mid-statement
     comments, which is the dominant real-world case.
+
+    sqlglot also rewrites SQL into its preferred form (``x::int`` ->
+    ``CAST(x AS INT)``, ``BTRIM`` -> ``TRIM``, an alias gains ``AS``), and
+    which rewrites it makes changes between its releases (#72).  Unless
+    *rewrite_sql*, a statement whose tokens would change beyond keyword case
+    is kept as written.
     """
     sqlglot = _require_sqlglot()
     import sqlglot.errors as sqlglot_errors
@@ -551,24 +595,28 @@ def _sqlglot_format(
             # understood the whole statement, so ask it: input that does not
             # parse is left exactly as written.
             ast = sqlglot.parse(protected, read="postgres", error_level=sqlglot_errors.ErrorLevel.RAISE)
+            nodes = [node for node in ast if node is not None]
+            sources = None if rewrite_sql else _statement_sources(sqlglot, protected)
+            if sources is not None and len(sources) != len(nodes):
+                return sql_lines
             statements: list[str] = []
-            for node in ast:
-                if node is None:
-                    continue
+            for i, node in enumerate(nodes):
                 # For Command nodes (psql backslash commands, ERROR:, etc.)
                 # use unpretty output to avoid mangling.
                 if type(node).__name__ == "Command":
-                    statements.append(node.sql(dialect="postgres"))
+                    generated = node.sql(dialect="postgres")
                 else:
-                    statements.append(
-                        node.sql(
-                            dialect="postgres",
-                            pretty=True,
-                            pad=sql_indent,
-                            indent=sql_indent,
-                            max_text_width=120,
-                        ),
+                    generated = node.sql(
+                        dialect="postgres",
+                        pretty=True,
+                        pad=sql_indent,
+                        indent=sql_indent,
+                        max_text_width=120,
                     )
+                generated = re.sub(r"\bINTO TEMPORARY\b(?!\s+TABLE)", "INTO TEMPORARY TABLE", generated)
+                if sources is not None and _layout_tokens(sqlglot, generated) != _layout_tokens(sqlglot, sources[i]):
+                    generated = sources[i].lstrip("\n").rstrip()  # layout only: keep it as written
+                statements.append(generated)
         stmts = [s for s in statements if s]
         if not stmts:
             return sql_lines
@@ -613,7 +661,6 @@ def _sqlglot_format(
         if set(_sql_literal_texts(protected)) - set(_sql_literal_texts(joined)):
             return sql_lines
 
-        joined = re.sub(r"\bINTO TEMPORARY\b(?!\s+TABLE)", "INTO TEMPORARY TABLE", joined)
         restored = _restore_estrings(joined, estrings)
         if restored is None:
             return sql_lines
@@ -701,6 +748,7 @@ def _format_preserving_comments(
     lines: list[str],
     sql_indent: int = 4,
     leading_comma: bool = False,
+    rewrite_sql: bool = False,
 ) -> list[str]:
     """Format SQL with interleaved comments via marker-based round-tripping.
 
@@ -744,8 +792,12 @@ def _format_preserving_comments(
             pending_markers.append(mid)
         else:
             # SQL line — prepend any pending markers as inline comments
+            # After the line's indentation, not before it: a statement that
+            # comes back as written (unparsable, or kept by layout-only) has
+            # its indentation read from this line once the marker is removed.
             prefix = " ".join(f"/* {m} */" for m in pending_markers)
-            processed.append(f"{prefix} {line}" if prefix else line)
+            body = line.lstrip()
+            processed.append(f"{line[: len(line) - len(body)]}{prefix} {body}" if prefix else line)
             for m in pending_markers:
                 anchor_sql[m] = stripped
                 anchor_line[m] = len(processed) - 1
@@ -760,7 +812,7 @@ def _format_preserving_comments(
     anchor_depth: dict[str, int] = {m: in_depths[i] for m, i in anchor_line.items()}
 
     # ---- Step 2: format through sqlglot ---------------------------------
-    formatted = _sqlglot_format(processed, sql_indent=sql_indent, leading_comma=leading_comma)
+    formatted = _sqlglot_format(processed, sql_indent=sql_indent, leading_comma=leading_comma, rewrite_sql=rewrite_sql)
 
     # ---- Step 3: restore surviving markers to comment lines -------------
     found_markers: set[str] = set()
@@ -908,6 +960,7 @@ def format_sql_block(
     indent: int,
     use_sql: bool,
     leading_comma: bool = False,
+    rewrite_sql: bool = False,
 ) -> list[str]:
     """Re-indent a SQL block to the current depth, optionally formatting via sqlglot."""
     if not lines:
@@ -940,7 +993,12 @@ def format_sql_block(
     # which preserves both comments AND sqlglot formatting.  When all
     # comments are between statements, the simpler segmentation works.
     if _has_mid_statement_comments(rebased):
-        formatted_lines = _format_preserving_comments(rebased, sql_indent=indent, leading_comma=leading_comma)
+        formatted_lines = _format_preserving_comments(
+            rebased,
+            sql_indent=indent,
+            leading_comma=leading_comma,
+            rewrite_sql=rewrite_sql,
+        )
         return [target_prefix + line if line.strip() else "" for line in formatted_lines]
 
     result: list[str] = []
@@ -954,7 +1012,7 @@ def format_sql_block(
         if seg_is_comment:
             result.extend(seg)
         else:
-            result.extend(_sqlglot_format(seg, sql_indent=indent, leading_comma=leading_comma))
+            result.extend(_sqlglot_format(seg, sql_indent=indent, leading_comma=leading_comma, rewrite_sql=rewrite_sql))
         seg.clear()
 
     for line in rebased:
@@ -1076,8 +1134,19 @@ def _apply_leading_comma(text: str) -> str:
     return "\n".join(lines)
 
 
-def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comma: bool = False) -> str:
-    """Format the source text of an execsql script and return the result."""
+def format_file(
+    source: str,
+    indent: int = 4,
+    use_sql: bool = True,
+    leading_comma: bool = False,
+    rewrite_sql: bool = False,
+) -> str:
+    """Format the source text of an execsql script and return the result.
+
+    SQL is laid out by sqlglot.  A statement sqlglot would also rewrite
+    (``x::int`` as ``CAST(x AS INT)``, ``BTRIM`` as ``TRIM``, an alias with
+    ``AS``) is kept as written unless *rewrite_sql*.
+    """
     # Normalize any leading-comma SQL in the source to trailing commas so
     # that sqlglot always sees the same comma shape regardless of how
     # the user saved the file. The post-pass at the bottom of this
@@ -1124,7 +1193,16 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
             # `sql_acc_contains_dollar_quote` catches the case where the region
             # already closed (`... $$;`) so `in_dollar_quote` is False at flush.
             safe_for_sqlglot = use_sql and not in_dollar_quote and not sql_acc_contains_dollar_quote
-            output.extend(format_sql_block(sql_acc, depth, indent, safe_for_sqlglot, leading_comma=leading_comma))
+            output.extend(
+                format_sql_block(
+                    sql_acc,
+                    depth,
+                    indent,
+                    safe_for_sqlglot,
+                    leading_comma=leading_comma,
+                    rewrite_sql=rewrite_sql,
+                ),
+            )
             sql_acc.clear()
         in_sql_statement = False
         sql_acc_contains_dollar_quote = False
@@ -1243,6 +1321,7 @@ def run_formatter(
     no_sql: bool = False,
     indent: int = 4,
     leading_comma: bool = False,
+    rewrite_sql: bool = False,
     encoding: str = "utf-8",
     diff: bool = False,
 ) -> int:
@@ -1290,7 +1369,13 @@ def run_formatter(
             any_errors = True
             continue
 
-        formatted = format_file(source, indent=indent, use_sql=use_sql, leading_comma=leading_comma)
+        formatted = format_file(
+            source,
+            indent=indent,
+            use_sql=use_sql,
+            leading_comma=leading_comma,
+            rewrite_sql=rewrite_sql,
+        )
 
         if diff:
             if formatted != source:

{execsql2-2.25.1 → execsql2-2.26.0}/tests/cli/test_cli_surface.py

@@ -86,6 +86,7 @@ SURFACE: dict[str, dict[str, object]] = {
             "--diff",
             "--indent",
             "--leading-comma --no-leading-comma",
+            "--rewrite-sql --no-rewrite-sql",
             "--sql --no-sql",
             "-f --script-encoding",
             "-i --in-place",

{execsql2-2.25.1 → execsql2-2.26.0}/tests/cli/test_commands.py

@@ -436,6 +436,14 @@ class TestFormatConfig:
         assert "\n    , b" in with_config
         assert "\n    , b" not in overridden
 
+    def test_rewrite_sql_from_config_and_turned_off_by_flag(self, isolated):
+        pytest.importorskip("sqlglot")
+        (isolated / "s.sql").write_text("select x::int from t;\n")
+        assert runner.invoke(app, ["format", "s.sql"]).output == "select x::int from t;\n"  # kept as written
+        (isolated / "execsql.conf").write_text("[format]\nrewrite_sql = yes\n")
+        assert "CAST(x AS INT)" in runner.invoke(app, ["format", "s.sql"]).output
+        assert runner.invoke(app, ["format", "--no-rewrite-sql", "s.sql"]).output == "select x::int from t;\n"
+
     def test_config_option_file(self, isolated, tmp_path):
         conf = tmp_path / "ci.conf"
         conf.write_text("[format]\nindent = 2\nsql = no\n")

{execsql2-2.25.1 → execsql2-2.26.0}/tests/test_format.py

@@ -2804,3 +2804,57 @@ class TestRegressions:
         result = format_file(source, use_sql=True)
         for col in ["id", "name", "value"]:
             assert col in result, f"Column '{col}' dropped from INSERT"
+
+
+class TestLayoutOnly:
+    """By default only layout and keyword case change; sqlglot's rewrites need rewrite_sql (#72)."""
+
+    @pytest.fixture(autouse=True)
+    def _sqlglot(self):
+        pytest.importorskip("sqlglot")
+
+    @pytest.mark.parametrize(
+        "statement",
+        [
+            "select x::int from t;",
+            "select count(*) n from t;",
+            "create table t (a integer, b numeric(10,2));",
+            "select btrim(name) from t;",
+            "select a from t where a != b;",
+        ],
+    )
+    def test_a_statement_sqlglot_would_rewrite_is_kept_as_written(self, statement):
+        assert format_file(statement + "\n") == statement + "\n"
+
+    def test_rewrite_sql_accepts_the_rewrite(self):
+        assert "CAST(x AS INT)" in format_file("select x::int from t;\n", rewrite_sql=True)
+
+    def test_only_the_rewritten_statement_is_kept(self):
+        out = format_file("select a, b from t;\nselect btrim(n) from u;\nselect c from v;\n")
+        assert out == "SELECT\n    a,\n    b\nFROM t;\nselect btrim(n) from u;\nSELECT\n    c\nFROM v;\n"
+
+    def test_a_statement_already_in_sqlglot_form_is_formatted(self):
+        assert format_file("select cast(x as int) as n from t;\n") == "SELECT\n    CAST(x AS INT) AS n\nFROM t;\n"
+
+    def test_keyword_case_alone_is_not_a_rewrite(self):
+        assert format_file("select a from t where b = 'Mixed Case';\n") == (
+            "SELECT\n    a\nFROM t\nWHERE\n    b = 'Mixed Case';\n"
+        )
+
+    def test_a_kept_statement_keeps_its_comments_and_is_stable(self):
+        source = "select\n    x::int, -- the id\n    -- the name\n    y\nfrom t;\n"
+        once = format_file(source)
+        assert once == source
+        assert format_file(once) == once
+
+    def test_inside_a_block_the_kept_statement_is_stable(self):
+        source = "-- !x! IF(True)\nselect x::int from t;\nselect a from u;\n-- !x! ENDIF\n"
+        once = format_file(source)
+        assert "select x::int from t;" in once
+        assert format_file(once) == once
+
+    @pytest.mark.parametrize("rewrite_sql", [False, True])
+    def test_both_modes_are_idempotent(self, rewrite_sql):
+        source = "select x::int, count(*) n from t where a != b;\nselect a, b from u;\n"
+        once = format_file(source, rewrite_sql=rewrite_sql)
+        assert format_file(once, rewrite_sql=rewrite_sql) == once