execsql2 2.16.16__tar.gz → 2.16.18__tar.gz

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

@@ -13,6 +13,28 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.16.18] - 2026-05-05
+
+### Fixed
+
+- `BEGIN SCRIPT` parameter defaults now correctly strip surrounding quotes when stored, mirroring the quote-handling already applied to passed arguments at the call site. Previously a default written as `default_unit_set="Default"` bound the literal string `"Default"` (with quotes intact), so a body like `WRITE "!!#default_unit_set!!"` produced `WRITE ""Default""` and failed. Defaults and passed arguments now resolve to the same value for the same source token.
+
+### Changed
+
+- `SHOW SCRIPTS <name>` metacommand and `.scripts <name>` debug REPL command now display the full source path to the script's source file (including `<inline>` for scripts loaded via `execsql -c`). The list views (`SHOW SCRIPTS` and `.scripts` without a name) continue to show the basename for compact column-aligned output.
+- `BEGIN SCRIPT WITH PARAMETERS (...)` now accepts quoted default values containing spaces, commas, and other special characters — e.g. `proc(msg="hello, world", path="/var/log/app.log")`. Both single and double quotes are supported. Unquoted values continue to be accepted but cannot start with a quote character; an unterminated quoted value is now rejected as malformed instead of being silently stored as an unquoted literal.
+
+______________________________________________________________________
+
+## [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.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.16.16
+Version: 2.16.18
 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.18}/docs/about/divergence.md

@@ -58,16 +58,18 @@ ______________________________________________________________________
 
 ### SCRIPT Enhancements
 
-| Feature            | Description                                                                                                                                                                                                  |
-| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| Default parameters | `BEGIN SCRIPT load(schema, table, batch=1000)` — parameters with defaults can be omitted at call site. Required parameters must precede optional parameters.                                                 |
-| Docstrings         | Comments (`--` or `/* */`) immediately following `BEGIN SCRIPT` are captured as documentation. A blank line terminates the docstring. Displayed by `SHOW SCRIPTS <name>` and `.scripts <name>` REPL command. |
+| Feature            | Description                                                                                                                                                                                                                                                                                                                                            |
+| ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Default parameters | `BEGIN SCRIPT load(schema, table, batch=1000)` — parameters with defaults can be omitted at call site. Required parameters must precede optional parameters.                                                                                                                                                                                           |
+| Quoted defaults    | Default values may be quoted with single or double quotes to embed spaces, commas, or other special characters: `BEGIN SCRIPT proc(msg="hello, world", path="/var/log/app.log")`. Surrounding quotes are stripped at parse time so the bound substitution variable holds the value itself, matching the call-site quote-handling for passed arguments. |
+| Docstrings         | Comments (`--` or `/* */`) immediately following `BEGIN SCRIPT` are captured as documentation. A blank line terminates the docstring. Displayed by `SHOW SCRIPTS <name>` and `.scripts <name>` REPL command.                                                                                                                                           |
 
 ### Bug Fixes
 
-| Fix                             | Description                                                                                                                                               |
-| ------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Variable EXECUTE SCRIPT targets | `EXECUTE SCRIPT !!#var!!` now works — the parser accepts substitution variable patterns as script identifiers, and the executor resolves them at runtime. |
+| Fix                             | Description                                                                                                                                                                                                                                                                                                              |
+| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| Variable EXECUTE SCRIPT targets | `EXECUTE SCRIPT !!#var!!` now works — the parser accepts substitution variable patterns as script identifiers, and the executor resolves them at runtime.                                                                                                                                                                |
+| Quoted parameter defaults       | `BEGIN SCRIPT proc(name="value")` previously stored the literal `"value"` (with surrounding quotes), causing substitutions like `WRITE "!!#name!!"` to expand to `WRITE ""value""` and fail. Defaults now strip surrounding quotes at parse time, matching the `wo_quotes` handling already applied to passed arguments. |
 
 ### Conditional Tests
 

{execsql2-2.16.16 → execsql2-2.16.18}/docs/reference/metacommands.md

@@ -260,6 +260,24 @@ A required parameter after an optional parameter is a parse error:
 -- !x! BEGIN SCRIPT bad(schema, batch=1000, table)
 ```
 
+Default values may be quoted with single or double quotes when they contain spaces, commas, or other special characters. Surrounding quotes are stripped at parse time, so the bound substitution variable holds the value itself, not the quoted source token. This matches the quote-handling already applied to passed arguments at the call site:
+
+```sql
+-- !x! BEGIN SCRIPT std_chem_units (
+--     selected_lr_rows,
+--     output_table="std_chem",
+--     default_unit_set="Default",
+--     logfile="/tmp/run.log",
+--     description="hello, world"
+-- )
+-- !!#default_unit_set!! resolves to: Default   (no surrounding quotes)
+-- !!#description!!     resolves to: hello, world
+-- !x! WRITE "Unit set: !!#default_unit_set!!"
+-- !x! END SCRIPT
+```
+
+Unquoted default values cannot contain whitespace and must not begin with a quote character. An unterminated quoted value (e.g. `name="value`) is rejected as a parse error rather than being silently stored as a literal.
+
 ### Docstrings
 
 Comments (`--` or `/* */`) immediately following the BEGIN SCRIPT line are captured as the script's docstring. A blank line terminates the docstring. Docstrings are displayed by [SHOW SCRIPT](#show_script), [SHOW SCRIPTS](#show_scripts), and the `.scripts` REPL command.
@@ -2770,7 +2788,7 @@ The numeric expression may consist of the simple algebraic operations of additio
 SHOW SCRIPTS [<name>]
 ```
 
-Without a name, lists all registered SCRIPT definitions with their parameter signatures and source locations. With a name, shows detail for that script including parameters, source file/line range, and docstring.
+Without a name, lists all registered SCRIPT definitions with their parameter signatures and source locations (basename only, for compact column-aligned output). With a name, shows detail for that script including parameters, full source path, line range, and docstring.
 
 This is useful for discovering what scripts are available at runtime, especially when scripts are loaded from INCLUDEEd files whose paths are determined dynamically.
 
@@ -2796,7 +2814,7 @@ Registered scripts (3):
 
 ```
 Script: load_data(schema, table, batch_size=1000)
-Source: pipeline.sql:15-42
+Source: /home/user/etl/pipeline.sql:15-42
 Parameters:
   schema      (required)
   table       (required)
@@ -2805,6 +2823,8 @@ Parameters:
 Load data from staging into the target table.
 ```
 
+The detail view (`SHOW SCRIPTS <name>`) shows the full source path so the file can be located unambiguously when multiple scripts share a basename. Scripts loaded inline via `execsql -c '<command>'` show `<inline>` as the source.
+
 If no scripts are registered, prints `No scripts registered.` If the named script is not found, prints `No script named '<name>' is registered.`
 
 !!! tip

{execsql2-2.16.16 → execsql2-2.16.18}/pyproject.toml

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

{execsql2-2.16.16 → execsql2-2.16.18}/src/execsql/debug/repl.py

@@ -546,7 +546,7 @@ def _print_script_detail(name: str) -> None:
         return
     block = scripts[script_name]
     sig = _format_script_signature(block.name, block.param_defs)
-    src = _format_script_source(block.span)
+    src = _format_script_source(block.span, full_path=True)
     _write_rule(f" {_c(_BOLD + _YELLOW, 'Script')} {_c(_DIM, '──')} {_c(_CYAN, sig)} ")
     _write(f"  {_c(_BOLD, 'Source:')}     {src}\n")
     if block.param_defs:

{execsql2-2.16.16 → execsql2-2.16.18}/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.18}/src/execsql/metacommands/debug.py

@@ -203,9 +203,19 @@ def _format_script_signature(name: str, param_defs: Any) -> str:
     return f"{name}({', '.join(parts)})"
 
 
-def _format_script_source(span: Any) -> str:
-    """Return ``file:start-end`` from a SourceSpan."""
-    filename = Path(span.file).name if span and span.file else "<unknown>"
+def _format_script_source(span: Any, *, full_path: bool = False) -> str:
+    """Return ``file:start-end`` from a SourceSpan.
+
+    By default the filename is the basename, suitable for compact list-view
+    output.  Pass ``full_path=True`` to retain the full source path (used by
+    detail views like ``SHOW SCRIPTS <name>`` and ``.scripts <name>``).
+    """
+    if not span or not span.file:
+        filename = "<unknown>"
+    elif full_path:
+        filename = span.file
+    else:
+        filename = Path(span.file).name
     if span and span.start_line is not None:
         if span.end_line is not None and span.end_line != span.start_line:
             return f"{filename}:{span.start_line}-{span.end_line}"
@@ -235,7 +245,7 @@ def x_show_scripts(**kwargs: Any) -> None:
             return
         block = scripts[script_name]
         sig = _format_script_signature(block.name, block.param_defs)
-        src = _format_script_source(block.span)
+        src = _format_script_source(block.span, full_path=True)
         _state.output.write(f"Script: {sig}\n")
         _state.output.write(f"Source: {src}\n")
         if block.param_defs:

{execsql2-2.16.16 → execsql2-2.16.18}/src/execsql/script/parser.py

@@ -114,14 +114,48 @@ _EXEC_SCRIPT_RX = re.compile(
     re.I,
 )
 
+# A parameter default value is either a double-quoted string, a single-quoted
+# string (both may contain spaces, commas, and other special characters), or
+# a bare run of non-whitespace characters.  Unquoted values must not begin
+# with a quote — that catches mismatched / unterminated quoted values
+# (e.g. ``name="value``) instead of silently treating them as literals.
+_PARAM_VALUE = r'(?:"[^"]*"|\'[^\']*\'|[^\s\'"]\S*)'
+
 _WITH_PARAMS_RX = re.compile(
     r"(?:\s+WITH)?(?:\s+PARAM(?:ETER)?S)?\s*\(\s*(?P<params>"
-    r"\w+(?:\s*=\s*\S+)?(?:\s*,\s*\w+(?:\s*=\s*\S+)?)*"
+    rf"\w+(?:\s*=\s*{_PARAM_VALUE})?(?:\s*,\s*\w+(?:\s*=\s*{_PARAM_VALUE})?)*"
     r")\s*\)\s*$",
     re.I,
 )
 
-_PARAM_TOKEN_RX = re.compile(r"(\w+)(?:\s*=\s*(\S+))?")
+_PARAM_TOKEN_RX = re.compile(rf"(\w+)(?:\s*=\s*({_PARAM_VALUE}))?\s*\Z")
+
+
+def _split_param_tokens(params_str: str) -> list[str]:
+    """Split a parameter list on commas, respecting quoted values.
+
+    Quoted segments (``"..."`` or ``'...'``) are kept intact so that commas
+    inside quotes do not split the token.  Each returned token is stripped
+    of surrounding whitespace.
+    """
+    tokens: list[str] = []
+    current: list[str] = []
+    in_quote: str | None = None
+    for ch in params_str:
+        if in_quote is not None:
+            current.append(ch)
+            if ch == in_quote:
+                in_quote = None
+        elif ch in ('"', "'"):
+            current.append(ch)
+            in_quote = ch
+        elif ch == ",":
+            tokens.append("".join(current))
+            current = []
+        else:
+            current.append(ch)
+    tokens.append("".join(current))
+    return [t.strip() for t in tokens]
 
 
 def _parse_param_defs(
@@ -129,16 +163,21 @@ def _parse_param_defs(
     lineno: int,
     source: str,
 ) -> list[ParamDef]:
-    """Parse ``'a, b, c=100, d=false'`` into a list of :class:`ParamDef`.
+    """Parse ``'a, b, c=100, d="hello world"'`` into a list of :class:`ParamDef`.
+
+    Defaults may be unquoted (``key=value``), double-quoted (``key="v a l"``),
+    or single-quoted (``key='v,a,l'``).  Surrounding quotes are stripped so
+    that ``ParamDef.default`` always holds the resolved value, mirroring the
+    quote-handling done at the call site for passed arguments.
 
     Required parameters (no default) must precede optional parameters
     (with default).  Raises :class:`ErrInfo` if ordering is violated.
     """
-    tokens = [t.strip() for t in params_str.split(",")]
+    tokens = _split_param_tokens(params_str)
     defs: list[ParamDef] = []
     seen_optional: str | None = None  # name of first optional param
     for token in tokens:
-        m = _PARAM_TOKEN_RX.match(token.strip())
+        m = _PARAM_TOKEN_RX.match(token)
         if not m:
             raise ErrInfo(
                 type="cmd",
@@ -146,6 +185,7 @@ def _parse_param_defs(
             )
         name, default = m.group(1), m.group(2)
         if default is not None:
+            default = _strip_quotes(default)
             if seen_optional is None:
                 seen_optional = name
         elif seen_optional is not None:

{execsql2-2.16.16 → execsql2-2.16.18}/tests/metacommands/test_show_scripts.py

@@ -65,6 +65,27 @@ class TestFormatScriptSource:
         span = SourceSpan("test.sql", None)
         assert _format_script_source(span) == "test.sql"
 
+    def test_full_path_keeps_directory(self):
+        span = SourceSpan("/long/path/to/script.sql", 1, 10)
+        assert _format_script_source(span, full_path=True) == "/long/path/to/script.sql:1-10"
+
+    def test_full_path_single_line(self):
+        span = SourceSpan("/abs/lib.sql", 7)
+        assert _format_script_source(span, full_path=True) == "/abs/lib.sql:7"
+
+    def test_full_path_unknown_file(self):
+        assert _format_script_source(None, full_path=True) == "<unknown>"
+
+    def test_full_path_inline_source(self):
+        """`execsql -c <command>` parses with source_name='<inline>'."""
+        span = SourceSpan("<inline>", 1, 5)
+        assert _format_script_source(span, full_path=True) == "<inline>:1-5"
+
+    def test_basename_inline_source(self):
+        """List-view rendering of an inline source is unchanged."""
+        span = SourceSpan("<inline>", 1, 5)
+        assert _format_script_source(span) == "<inline>:1-5"
+
 
 # ---------------------------------------------------------------------------
 # Handler tests (mock _state)
@@ -162,3 +183,46 @@ class TestShowScriptsDetail:
         x_show_scripts(metacommandline="SHOW SCRIPTS")
         output = mock_state.output.getvalue()
         assert "Registered scripts (1)" in output
+
+    def test_detail_shows_full_path(self, mock_state):
+        """SHOW SCRIPTS <name> renders the full source path, not just the basename."""
+        block = ScriptBlock(
+            span=SourceSpan("/home/user/etl/lib/load.sql", 12, 30),
+            name="proc",
+            param_defs=None,
+            doc=None,
+        )
+        mock_state.ast_scripts = {"proc": block}
+        x_show_scripts(script_id="proc", metacommandline="SHOW SCRIPTS proc")
+        output = mock_state.output.getvalue()
+        assert "Source: /home/user/etl/lib/load.sql:12-30" in output
+
+    def test_detail_inline_source(self, mock_state):
+        """`execsql -c <command>` registers scripts with span.file == '<inline>'."""
+        block = ScriptBlock(
+            span=SourceSpan("<inline>", 1, 4),
+            name="proc",
+            param_defs=None,
+            doc=None,
+        )
+        mock_state.ast_scripts = {"proc": block}
+        x_show_scripts(script_id="proc", metacommandline="SHOW SCRIPTS proc")
+        output = mock_state.output.getvalue()
+        assert "Source: <inline>:1-4" in output
+
+
+class TestShowScriptsListBasenamePreserved:
+    """List view (no <name>) keeps basename — column-aligned output stays scannable."""
+
+    def test_list_uses_basename_for_long_paths(self, mock_state):
+        block = ScriptBlock(
+            span=SourceSpan("/home/user/etl/lib/load.sql", 12, 30),
+            name="proc",
+            param_defs=None,
+            doc=None,
+        )
+        mock_state.ast_scripts = {"proc": block}
+        x_show_scripts(metacommandline="SHOW SCRIPTS")
+        output = mock_state.output.getvalue()
+        assert "load.sql:12-30" in output
+        assert "/home/user/etl/lib/" not in output

{execsql2-2.16.16 → execsql2-2.16.18}/tests/test_debug_repl.py

@@ -453,6 +453,56 @@ class TestHandleDotCommand:
             _handle_dot_command(".stack")
         assert "empty" in capture.getvalue()
 
+    def test_scripts_detail_shows_full_path(self, capture):
+        """.scripts <name> renders the full source path, not just the basename."""
+        from execsql.script.ast import ScriptBlock, SourceSpan
+
+        _state.ast_scripts = {
+            "proc": ScriptBlock(
+                span=SourceSpan("/home/user/etl/lib/load.sql", 12, 30),
+                name="proc",
+                param_defs=None,
+                doc=None,
+            ),
+        }
+        with patch("execsql.debug.repl._use_color", return_value=False):
+            _handle_dot_command(".scripts proc")
+        assert "/home/user/etl/lib/load.sql:12-30" in capture.getvalue()
+
+    def test_scripts_detail_inline_source(self, capture):
+        """.scripts <name> for an `execsql -c <command>` script renders <inline>."""
+        from execsql.script.ast import ScriptBlock, SourceSpan
+
+        _state.ast_scripts = {
+            "proc": ScriptBlock(
+                span=SourceSpan("<inline>", 1, 4),
+                name="proc",
+                param_defs=None,
+                doc=None,
+            ),
+        }
+        with patch("execsql.debug.repl._use_color", return_value=False):
+            _handle_dot_command(".scripts proc")
+        assert "<inline>:1-4" in capture.getvalue()
+
+    def test_scripts_list_uses_basename(self, capture):
+        """.scripts (no name) keeps basename for compact column-aligned output."""
+        from execsql.script.ast import ScriptBlock, SourceSpan
+
+        _state.ast_scripts = {
+            "proc": ScriptBlock(
+                span=SourceSpan("/home/user/etl/lib/load.sql", 12, 30),
+                name="proc",
+                param_defs=None,
+                doc=None,
+            ),
+        }
+        with patch("execsql.debug.repl._use_color", return_value=False):
+            _handle_dot_command(".scripts")
+        output = capture.getvalue()
+        assert "load.sql:12-30" in output
+        assert "/home/user/etl/lib/" not in output
+
 
 # ---------------------------------------------------------------------------
 # x_breakpoint — public entry point

{execsql2-2.16.16 → execsql2-2.16.18}/tests/test_executor.py

@@ -1504,6 +1504,72 @@ class TestDefaultParameters:
         assert result.returncode == 0, result.stderr
         assert "load(schema, batch=1000)" in result.stdout
 
+    def test_quoted_default_strips_quotes_at_substitution(self, tmp_path):
+        """`name="Default"` binds the value `Default`, not `"Default"`.
+
+        Regression for a parser bug where quoted defaults preserved their
+        surrounding quotes — diverging from passed-args which strip them via
+        ``wo_quotes`` — so ``write "!!default_unit_set!!"`` produced
+        ``write ""Default""`` (a syntax error) instead of ``write "Default"``.
+        """
+        result = _run_ast(
+            '-- !x! BEGIN SCRIPT proc1(default_unit_set="Default")\n'
+            "INSERT INTO t VALUES ('!!#default_unit_set!!');\n"
+            "-- !x! END SCRIPT\n"
+            "CREATE TABLE t (x TEXT);\n"
+            "-- !x! EXECUTE SCRIPT proc1\n",
+            tmp_path,
+        )
+        assert result.returncode == 0, result.stderr
+        assert _query_db(tmp_path, "SELECT x FROM t") == [("Default",)]
+
+    def test_quoted_default_with_spaces(self, tmp_path):
+        """Quoted defaults with embedded spaces are preserved verbatim."""
+        result = _run_ast(
+            '-- !x! BEGIN SCRIPT proc1(msg="hello world")\n'
+            "INSERT INTO t VALUES ('!!#msg!!');\n"
+            "-- !x! END SCRIPT\n"
+            "CREATE TABLE t (x TEXT);\n"
+            "-- !x! EXECUTE SCRIPT proc1\n",
+            tmp_path,
+        )
+        assert result.returncode == 0, result.stderr
+        assert _query_db(tmp_path, "SELECT x FROM t") == [("hello world",)]
+
+    def test_quoted_default_with_special_chars(self, tmp_path):
+        """Path-like values with slashes survive parsing."""
+        result = _run_ast(
+            '-- !x! BEGIN SCRIPT proc1(logfile="/tmp/run.log")\n'
+            "INSERT INTO t VALUES ('!!#logfile!!');\n"
+            "-- !x! END SCRIPT\n"
+            "CREATE TABLE t (x TEXT);\n"
+            "-- !x! EXECUTE SCRIPT proc1\n",
+            tmp_path,
+        )
+        assert result.returncode == 0, result.stderr
+        assert _query_db(tmp_path, "SELECT x FROM t") == [("/tmp/run.log",)]
+
+    def test_quoted_default_passed_arg_consistency(self, tmp_path):
+        """A quoted default and a quoted passed-arg produce the same value.
+
+        Both code paths should resolve to the same unquoted value — this is
+        the consistency guarantee the parser fix establishes.
+        """
+        result = _run_ast(
+            '-- !x! BEGIN SCRIPT proc1(label="alpha")\n'
+            "INSERT INTO t VALUES ('!!#label!!');\n"
+            "-- !x! END SCRIPT\n"
+            "CREATE TABLE t (x TEXT);\n"
+            "-- !x! EXECUTE SCRIPT proc1\n"
+            '-- !x! EXECUTE SCRIPT proc1(label="alpha")\n',
+            tmp_path,
+        )
+        assert result.returncode == 0, result.stderr
+        assert _query_db(tmp_path, "SELECT x FROM t ORDER BY rowid") == [
+            ("alpha",),
+            ("alpha",),
+        ]
+
 
 # ---------------------------------------------------------------------------
 # Docstrings

{execsql2-2.16.16 → execsql2-2.16.18}/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)