execsql2 2.16.16__tar.gz → 2.16.17__tar.gz

{execsql2-2.16.16 → execsql2-2.16.17}/CHANGELOG.md

@@ -13,6 +13,15 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.16.17] - 2026-05-04
+
+### Fixed
+
+- Formatter no longer treats inline `IF (cond) { command }` metacommands as block openers. Previously every line below an inline `IF` was indented one extra level forever, since the formatter incremented its block depth as if the inline form required an `ENDIF`.
+- Formatter no longer escapes blank lines that appear inside `-- !x! BEGIN SQL` / `-- !x! BEGIN BATCH` blocks. Blanks immediately after `BEGIN SQL` (and between SQL statements inside the block) were emitted flush-left, visually severing the block; they are now held with the SQL accumulator and consumed by the SQL pretty-printer.
+
+______________________________________________________________________
+
 ## [2.16.16] - 2026-05-02
 
 ### Added

{execsql2-2.16.16 → execsql2-2.16.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.16.16
+Version: 2.16.17
 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.16 → execsql2-2.16.17}/pyproject.toml

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

{execsql2-2.16.16 → execsql2-2.16.17}/src/execsql/format.py

@@ -82,6 +82,14 @@ BLOCK_CLOSE = frozenset({"ENDIF", "END LOOP", "ENDLOOP", "END SCRIPT", "END BATC
 PIVOT = frozenset({"ELSE", "ELSEIF"})  # decrease depth before emit, increase after
 CONTINUATION = frozenset({"ANDIF", "ORIF"})  # emit at depth-1, no depth change
 
+# Inline IF: "IF (cond) { command }" — self-contained, no ENDIF, no depth change.
+# Mirrors src/execsql/cli/lint.py:_RX_IF_INLINE so formatter and linter agree.
+_IF_INLINE_RE = re.compile(r"^\s*IF\s*\(\s*.+\s*\)\s*\{.+\}\s*$", re.I)
+# BLOCK_OPEN keywords whose bodies are guaranteed-SQL (not metacommand-driven).
+# Blank lines inside these belong to the SQL accumulator, not the output stream.
+_SQL_BODY_BLOCKS = frozenset({"BEGIN SQL", "BEGIN BATCH"})
+_SQL_BODY_BLOCK_CLOSES = frozenset({"END SQL", "END BATCH"})
+
 
 # ---------------------------------------------------------------------------
 # Keyword parsing
@@ -488,6 +496,10 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
     # the accumulator — doing so would split a single statement into
     # fragments that sqlglot cannot parse.
     in_sql_statement = False
+    # True between BEGIN SQL/BATCH and END SQL/BATCH.  Blank lines inside
+    # these blocks belong to the SQL accumulator so they re-emit at the
+    # block's indent depth, not flush-left in the output stream.
+    in_explicit_sql_block = False
 
     def flush_sql() -> None:
         nonlocal in_dollar_quote, in_sql_statement
@@ -520,12 +532,13 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
         m = METACOMMAND_RE.match(raw_line)
 
         if not stripped_line:
-            if not in_dollar_quote and not in_sql_statement:
+            if not in_dollar_quote and not in_sql_statement and not in_explicit_sql_block:
                 flush_sql()
                 output.append("")
             else:
-                # Mid-statement blank line stays in the accumulator and
-                # will appear in the output when the block is formatted.
+                # Mid-statement OR mid-explicit-SQL-block blank line stays in
+                # the accumulator and will appear in the output at the block's
+                # indent depth when the SQL is formatted.
                 sql_acc.append(raw_line)
 
         elif m:
@@ -536,6 +549,8 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
             if keyword in BLOCK_CLOSE:
                 depth = max(0, depth - 1)
                 output.append(format_metacommand(payload, depth, indent))
+                if keyword in _SQL_BODY_BLOCK_CLOSES:
+                    in_explicit_sql_block = False
 
             elif keyword in PIVOT:
                 depth = max(0, depth - 1)
@@ -547,7 +562,10 @@ def format_file(source: str, indent: int = 4, use_sql: bool = True, leading_comm
 
             elif keyword in BLOCK_OPEN:
                 output.append(format_metacommand(payload, depth, indent))
-                depth += 1
+                if not (keyword == "IF" and _IF_INLINE_RE.match(payload)):
+                    depth += 1
+                if keyword in _SQL_BODY_BLOCKS:
+                    in_explicit_sql_block = True
 
             else:
                 output.append(format_metacommand(payload, depth, indent))

{execsql2-2.16.16 → execsql2-2.16.17}/tests/test_format.py

@@ -688,6 +688,107 @@ class TestFormatFileEdgeCases:
         assert lines[1] == "    -- !x! WRITE 'inside'"
         assert lines[2] == "-- !x! END SCRIPT"
 
+    # ---- Inline IF (no ENDIF) — must not increment depth ---------------
+
+    def test_inline_if_does_not_indent_following_lines(self):
+        """Inline `IF (cond) { cmd }` is self-contained; subsequent lines stay at the same depth."""
+        source = "-- !x! IF (1=1) { halt message \"stop\" }\n-- !x! WRITE 'after'\n"
+        result = format_file(source, use_sql=False)
+        lines = result.splitlines()
+        assert lines[0].startswith("-- !x! IF (1=1)")
+        assert lines[1] == "-- !x! WRITE 'after'"
+
+    def test_inline_if_with_substitution_vars(self):
+        """Reproduces the user-reported case with substitution variables in the inline body."""
+        source = (
+            "-- !x! IF (not hasrows(cmp_primary_key_columns)) { "
+            'halt message "Table !!#table!! has no primary key columns." }\n'
+            "-- !x! WRITE 'after'\n"
+        )
+        result = format_file(source, use_sql=False)
+        lines = result.splitlines()
+        assert "IF (not hasrows" in lines[0]
+        assert "!!#table!!" in lines[0]
+        assert lines[1] == "-- !x! WRITE 'after'"
+
+    def test_inline_if_inside_block(self):
+        """An inline IF nested inside a block-form IF emits at the current depth and does not push deeper."""
+        source = "-- !x! IF 1=1\n-- !x! IF (cond) { halt message \"x\" }\n-- !x! WRITE 'still inside'\n-- !x! ENDIF\n"
+        result = format_file(source, use_sql=False)
+        lines = result.splitlines()
+        assert lines[0] == "-- !x! IF 1=1"
+        assert lines[1].startswith("    -- !x! IF (cond)")
+        assert lines[2] == "    -- !x! WRITE 'still inside'"
+        assert lines[3] == "-- !x! ENDIF"
+
+    def test_block_if_paren_form_still_indents(self):
+        """Block-form `IF (cond)` (parens, no brace) still opens an indented block."""
+        source = "-- !x! IF (1=1)\n-- !x! WRITE 'yes'\n-- !x! ENDIF\n"
+        result = format_file(source, use_sql=False)
+        lines = result.splitlines()
+        assert lines[0] == "-- !x! IF (1=1)"
+        assert lines[1] == "    -- !x! WRITE 'yes'"
+        assert lines[2] == "-- !x! ENDIF"
+
+    # ---- BEGIN SQL / BEGIN BATCH — blank lines must not escape ---------
+
+    def test_begin_sql_blank_line_after_does_not_escape(self):
+        """A blank line right after `-- !x! BEGIN SQL` must not be emitted flush-left."""
+        source = "-- !x! BEGIN SQL\n\nSELECT 1;\n-- !x! END SQL\n"
+        result = format_file(source)  # default use_sql=True; sqlglot collapses leading blank
+        lines = result.splitlines()
+        assert lines[0] == "-- !x! BEGIN SQL"
+        assert lines[-1] == "-- !x! END SQL"
+        middle = lines[1:-1]
+        assert "" not in middle, f"Flush-left blank inside BEGIN SQL block: {middle!r}"
+        select_lines = [line for line in middle if "SELECT" in line.upper()]
+        assert len(select_lines) == 1
+        assert select_lines[0].startswith("    ")
+
+    def test_begin_batch_blank_line_after_does_not_escape(self):
+        """Same fix applies to BEGIN BATCH (also a guaranteed-SQL body)."""
+        source = "-- !x! BEGIN BATCH\n\nINSERT INTO t VALUES (1);\n-- !x! END BATCH\n"
+        result = format_file(source)
+        lines = result.splitlines()
+        assert lines[0] == "-- !x! BEGIN BATCH"
+        assert lines[-1] == "-- !x! END BATCH"
+        middle = lines[1:-1]
+        assert "" not in middle, f"Flush-left blank inside BEGIN BATCH block: {middle!r}"
+
+    def test_begin_sql_blank_line_between_statements_collapsed(self):
+        """With sqlglot enabled, blanks between SQL statements inside BEGIN SQL are consumed
+        by pretty-print rather than escaping as flush-left blanks that split the block."""
+        source = "-- !x! BEGIN SQL\nSELECT 1;\n\nSELECT 2;\n-- !x! END SQL\n"
+        result = format_file(source)
+        lines = result.splitlines()
+        middle = lines[1:-1]
+        assert "" not in middle, f"Flush-left blank inside BEGIN SQL block: {middle!r}"
+        # sqlglot may pretty-print `SELECT 1` across multiple lines; check the
+        # body as a whole rather than per-line.
+        body = "\n".join(middle)
+        assert "SELECT" in body.upper()
+        assert "1;" in body and "2;" in body
+
+    def test_blank_lines_outside_explicit_sql_block_unchanged(self):
+        """Regression guard: blanks outside BEGIN SQL/BATCH (top-level, or inside IF) still emit flush-left."""
+        # Top-level blank between metacommands
+        source = "-- !x! WRITE 'a'\n\n-- !x! WRITE 'b'\n"
+        result = format_file(source, use_sql=False)
+        lines = result.splitlines()
+        assert lines[0] == "-- !x! WRITE 'a'"
+        assert lines[1] == ""
+        assert lines[2] == "-- !x! WRITE 'b'"
+
+        # Blank between metacommands inside an IF block — still flush-left
+        source = "-- !x! IF 1=1\n-- !x! WRITE 'a'\n\n-- !x! WRITE 'b'\n-- !x! ENDIF\n"
+        result = format_file(source, use_sql=False)
+        lines = result.splitlines()
+        assert lines[0] == "-- !x! IF 1=1"
+        assert lines[1] == "    -- !x! WRITE 'a'"
+        assert lines[2] == ""
+        assert lines[3] == "    -- !x! WRITE 'b'"
+        assert lines[4] == "-- !x! ENDIF"
+
     def test_only_sql_no_metacommands(self):
         source = "SELECT 1;\nSELECT 2;\n"
         result = format_file(source, use_sql=False)

{execsql2-2.16.16 → execsql2-2.16.17}/uv.lock

@@ -648,7 +648,7 @@ wheels = [
 
 [[package]]
 name = "execsql2"
-version = "2.16.16"
+version = "2.16.17"
 source = { editable = "." }
 dependencies = [
     { name = "python-dateutil" },