execsql2 2.16.17__tar.gz → 2.16.18__tar.gz

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

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

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

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

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

{execsql2-2.16.17 → 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.17 → 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.17 → 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.17 → 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.17 → 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.17 → 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.18/tests/test_parser_params.py

@@ -0,0 +1,124 @@
+"""Direct unit tests for parser parameter and docstring internals."""
+
+from __future__ import annotations
+
+import pytest
+
+from execsql.exceptions import ErrInfo
+from execsql.script.ast import ParamDef
+from execsql.script.parser import _parse_param_defs
+
+
+class TestParseParamDefs:
+    """Tests for _parse_param_defs — the parameter definition parser."""
+
+    def test_single_required(self):
+        result = _parse_param_defs("a", 1, "test.sql")
+        assert result == [ParamDef("a")]
+
+    def test_multiple_required(self):
+        result = _parse_param_defs("a, b, c", 1, "test.sql")
+        assert result == [ParamDef("a"), ParamDef("b"), ParamDef("c")]
+
+    def test_single_optional(self):
+        result = _parse_param_defs("a=100", 1, "test.sql")
+        assert result == [ParamDef("a", "100")]
+
+    def test_mixed_required_optional(self):
+        result = _parse_param_defs("schema, table, batch=1000, dry_run=false", 1, "test.sql")
+        assert result == [
+            ParamDef("schema"),
+            ParamDef("table"),
+            ParamDef("batch", "1000"),
+            ParamDef("dry_run", "false"),
+        ]
+
+    def test_required_after_optional_raises(self):
+        with pytest.raises(ErrInfo, match="Required parameter.*after optional"):
+            _parse_param_defs("a=1, b", 5, "bad.sql")
+
+    def test_required_after_optional_names_params(self):
+        """Error message includes the parameter names."""
+        with pytest.raises(ErrInfo, match="'b'.*'a'"):
+            _parse_param_defs("a=1, b", 5, "bad.sql")
+
+    def test_all_optional(self):
+        result = _parse_param_defs("x=1, y=2, z=3", 1, "test.sql")
+        assert all(p.default is not None for p in result)
+
+    def test_whitespace_handling(self):
+        result = _parse_param_defs("  a  ,  b = 100  ", 1, "test.sql")
+        assert result == [ParamDef("a"), ParamDef("b", "100")]
+
+    def test_required_property(self):
+        defs = _parse_param_defs("a, b=10", 1, "test.sql")
+        assert defs[0].required is True
+        assert defs[1].required is False
+
+
+class TestParseParamDefsQuotedDefaults:
+    """Quoted default values: surrounding quotes are stripped, spaces and
+    commas inside quotes are preserved, and both quote styles are accepted."""
+
+    def test_double_quoted_default_strips_quotes(self):
+        """`name="value"` stores `value`, not `"value"`."""
+        result = _parse_param_defs('name="Default"', 1, "test.sql")
+        assert result == [ParamDef("name", "Default")]
+
+    def test_single_quoted_default_strips_quotes(self):
+        result = _parse_param_defs("name='Default'", 1, "test.sql")
+        assert result == [ParamDef("name", "Default")]
+
+    def test_quoted_default_with_spaces(self):
+        """Embedded spaces are preserved when quoted."""
+        result = _parse_param_defs('msg="hello world"', 1, "test.sql")
+        assert result == [ParamDef("msg", "hello world")]
+
+    def test_quoted_default_with_comma(self):
+        """Embedded commas don't split the token when inside quotes."""
+        result = _parse_param_defs('list="a, b, c"', 1, "test.sql")
+        assert result == [ParamDef("list", "a, b, c")]
+
+    def test_quoted_default_with_special_chars(self):
+        """Slashes, equals, and other special chars survive."""
+        result = _parse_param_defs('logfile="/dev/null"', 1, "test.sql")
+        assert result == [ParamDef("logfile", "/dev/null")]
+
+    def test_quoted_default_with_empty_string(self):
+        """`name=""` stores an empty string."""
+        result = _parse_param_defs('name=""', 1, "test.sql")
+        assert result == [ParamDef("name", "")]
+
+    def test_unquoted_default_unchanged(self):
+        """Unquoted values are stored verbatim — no quote-stripping false positive."""
+        result = _parse_param_defs("count=100", 1, "test.sql")
+        assert result == [ParamDef("count", "100")]
+
+    def test_mixed_quoted_and_unquoted(self):
+        """User's reported case: a real-world signature."""
+        result = _parse_param_defs(
+            'rows, output_table="std_chem", default_unit_set="Default", logfile="/dev/null"',
+            1,
+            "test.sql",
+        )
+        assert result == [
+            ParamDef("rows"),
+            ParamDef("output_table", "std_chem"),
+            ParamDef("default_unit_set", "Default"),
+            ParamDef("logfile", "/dev/null"),
+        ]
+
+    def test_mismatched_quotes_treated_as_unquoted(self):
+        """`name="value` (no closing quote) is rejected as malformed."""
+        with pytest.raises(ErrInfo, match="Invalid parameter token"):
+            _parse_param_defs('name="value', 1, "test.sql")
+
+    def test_double_quotes_inside_single_quoted(self):
+        """Single-quoted value can contain double quotes."""
+        result = _parse_param_defs("""msg='say "hi"'""", 1, "test.sql")
+        assert result == [ParamDef("msg", 'say "hi"')]
+
+    def test_single_quotes_inside_double_quoted(self):
+        """Double-quoted value can contain single quotes (apostrophes)."""
+        result = _parse_param_defs("""msg=\"it's\"""", 1, "test.sql")
+        assert result == [ParamDef("msg", "it's")]

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

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

execsql2-2.16.17/tests/test_parser_params.py

@@ -1,56 +0,0 @@
-"""Direct unit tests for parser parameter and docstring internals."""
-
-from __future__ import annotations
-
-import pytest
-
-from execsql.exceptions import ErrInfo
-from execsql.script.ast import ParamDef
-from execsql.script.parser import _parse_param_defs
-
-
-class TestParseParamDefs:
-    """Tests for _parse_param_defs — the parameter definition parser."""
-
-    def test_single_required(self):
-        result = _parse_param_defs("a", 1, "test.sql")
-        assert result == [ParamDef("a")]
-
-    def test_multiple_required(self):
-        result = _parse_param_defs("a, b, c", 1, "test.sql")
-        assert result == [ParamDef("a"), ParamDef("b"), ParamDef("c")]
-
-    def test_single_optional(self):
-        result = _parse_param_defs("a=100", 1, "test.sql")
-        assert result == [ParamDef("a", "100")]
-
-    def test_mixed_required_optional(self):
-        result = _parse_param_defs("schema, table, batch=1000, dry_run=false", 1, "test.sql")
-        assert result == [
-            ParamDef("schema"),
-            ParamDef("table"),
-            ParamDef("batch", "1000"),
-            ParamDef("dry_run", "false"),
-        ]
-
-    def test_required_after_optional_raises(self):
-        with pytest.raises(ErrInfo, match="Required parameter.*after optional"):
-            _parse_param_defs("a=1, b", 5, "bad.sql")
-
-    def test_required_after_optional_names_params(self):
-        """Error message includes the parameter names."""
-        with pytest.raises(ErrInfo, match="'b'.*'a'"):
-            _parse_param_defs("a=1, b", 5, "bad.sql")
-
-    def test_all_optional(self):
-        result = _parse_param_defs("x=1, y=2, z=3", 1, "test.sql")
-        assert all(p.default is not None for p in result)
-
-    def test_whitespace_handling(self):
-        result = _parse_param_defs("  a  ,  b = 100  ", 1, "test.sql")
-        assert result == [ParamDef("a"), ParamDef("b", "100")]
-
-    def test_required_property(self):
-        defs = _parse_param_defs("a, b=10", 1, "test.sql")
-        assert defs[0].required is True
-        assert defs[1].required is False