execsql2 2.16.17__tar.gz → 2.17.0__tar.gz

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

@@ -13,6 +13,31 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.17.0] - 2026-05-07
+
+### Changed
+
+- **Behavior change.** `PG_UPSERT`, `PG_UPSERT QA`, and `PG_UPSERT CHECK` no longer raise a metacommand error when QA checks fail. The outcome is reported via `$PG_UPSERT_QA_PASSED` (and the per-table `$PG_UPSERT_TABLE_QA_PASSED`) along with `$PG_UPSERT_RESULT_JSON`, so the script controls flow with `IF` or `ASSERT` instead of being forced into execsql's halt-on-error path. `EXPORT_FAILURES` still runs on QA failure, and the upsert is still skipped (no commit). Scripts that previously relied on a hard halt should add `ASSERT !!$PG_UPSERT_QA_PASSED!! = TRUE` (or branch via `IF`) at the call site.
+
+### Fixed
+
+- `!!$COUNTER_N!!` references inside metacommands (e.g. `WRITE`, `IF`, `SUB`) now return the documented sequence `1, 2, 3, …` starting at 1. The AST executor was calling `substitute_vars()` twice per metacommand — once to detect a `BREAK` token before dispatch, then again inside the dispatch handler — which double-incremented every counter reference so the first read returned 2 and subsequent reads stepped by 2. Counter references in plain SQL statements were unaffected (they already substituted exactly once). The duplicate substitution also re-rolled `!!$RANDOM!!` and `!!$UUID!!` for any metacommand that referenced them, so those values are now stable across BREAK detection and dispatch as well.
+
+______________________________________________________________________
+
+## [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.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.16.17
+Version: 2.17.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

{execsql2-2.16.17 → execsql2-2.17.0}/docs/about/divergence.md

@@ -46,28 +46,30 @@ ______________________________________________________________________
 
 ### Metacommands
 
-| Metacommand             | Description                                                                                                                                                                                                                                                                                                                                                                                                              |
-| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `ASSERT`                | Evaluate a condition and raise an error (halting the script) if it is false. Supports all IF conditions. Optional quoted failure message. Skipped in false IF blocks.                                                                                                                                                                                                                                                    |
-| `BREAKPOINT`            | Pause script execution and drop into an interactive debug REPL. See [Debugging](#debugging) below for full details.                                                                                                                                                                                                                                                                                                      |
-| `CONFIG SHOW_PROGRESS`  | Enable the Rich progress bar for IMPORT operations at runtime.                                                                                                                                                                                                                                                                                                                                                           |
-| `CONFIG LOG_SQL`        | Enable SQL query audit logging — writes executed SQL to the log file.                                                                                                                                                                                                                                                                                                                                                    |
-| `PG_UPSERT`             | QA-checked, FK-dependency-ordered upserts from staging to base schema on PostgreSQL. Integrates [pg-upsert](https://pg-upsert.readthedocs.io/) as an optional dependency. Three modes: full pipeline, QA-only, and schema check. Supports `EXPORT_FAILURES`, `EXPORT_FORMAT`, `EXPORT_MAX_ROWS`, and `STRICT_COLUMNS` keywords. `STRICT_COLUMNS` forces all missing columns to be errors (requires `pg-upsert>=1.22.0`). |
-| `IMPORT … FROM JSON`    | Import a JSON file (array of objects or NDJSON) into a database table. Nested objects are flattened with dot-separated column names; arrays are stored as JSON strings.                                                                                                                                                                                                                                                  |
-| `SHOW SCRIPTS [<name>]` | Without a name, lists all registered SCRIPT definitions with parameter signatures and source locations. With a name, shows detail including parameters (with defaults), source file/line range, and docstring.                                                                                                                                                                                                           |
+| Metacommand             | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `ASSERT`                | Evaluate a condition and raise an error (halting the script) if it is false. Supports all IF conditions. Optional quoted failure message. Skipped in false IF blocks.                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `BREAKPOINT`            | Pause script execution and drop into an interactive debug REPL. See [Debugging](#debugging) below for full details.                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
+| `CONFIG SHOW_PROGRESS`  | Enable the Rich progress bar for IMPORT operations at runtime.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `CONFIG LOG_SQL`        | Enable SQL query audit logging — writes executed SQL to the log file.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| `PG_UPSERT`             | QA-checked, FK-dependency-ordered upserts from staging to base schema on PostgreSQL. Integrates [pg-upsert](https://pg-upsert.readthedocs.io/) as an optional dependency. Three modes: full pipeline, QA-only, and schema check. Supports `EXPORT_FAILURES`, `EXPORT_FORMAT`, `EXPORT_MAX_ROWS`, and `STRICT_COLUMNS` keywords. `STRICT_COLUMNS` forces all missing columns to be errors (requires `pg-upsert>=1.22.0`). QA failure does not raise — the outcome is reported via `$PG_UPSERT_QA_PASSED` so the user's own `IF` / `ON ERROR HALT` decides control flow. |
+| `IMPORT … FROM JSON`    | Import a JSON file (array of objects or NDJSON) into a database table. Nested objects are flattened with dot-separated column names; arrays are stored as JSON strings.                                                                                                                                                                                                                                                                                                                                                                                                |
+| `SHOW SCRIPTS [<name>]` | Without a name, lists all registered SCRIPT definitions with parameter signatures and source locations. With a name, shows detail including parameters (with defaults), source file/line range, and docstring.                                                                                                                                                                                                                                                                                                                                                         |
 
 ### 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.17.0}/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.
@@ -2230,6 +2248,24 @@ Set after every `PG_UPSERT` execution:
     -- !x! WRITE `!!$PG_UPSERT_RESULT_JSON!!`
     ```
 
+### QA failure behavior
+
+`PG_UPSERT`, `PG_UPSERT QA`, and `PG_UPSERT CHECK` do **not** raise an error when QA checks fail. The outcome is reported via `$PG_UPSERT_QA_PASSED` (and the per-table `$PG_UPSERT_TABLE_QA_PASSED`), so the script controls flow with `IF` or with execsql's standard error-halt configuration. When QA fails, the metacommand still runs `EXPORT_FAILURES`, populates all `$PG_UPSERT_*` substitution variables, and skips the upsert (no commit). Pair with `ASSERT` to halt explicitly:
+
+```sql
+-- Soft failure: branch on the result, keep running.
+-- !x! PG_UPSERT FROM staging TO public TABLES books, authors EXPORT_FAILURES "qa/"
+-- !x! IF !!$PG_UPSERT_QA_PASSED!! = TRUE
+-- !x!   PG_UPSERT FROM staging TO public TABLES books, authors COMMIT
+-- !x! ELSE
+-- !x!   WRITE "QA failed — fix sheet at !!$PG_UPSERT_EXPORT_PATH!!"
+-- !x! ENDIF
+
+-- Hard failure: halt the script when QA fails.
+-- !x! PG_UPSERT QA FROM staging TO public TABLES books, authors
+-- !x! ASSERT !!$PG_UPSERT_QA_PASSED!! = TRUE "Pre-load QA failed; aborting."
+```
+
 ### Temporary objects
 
 pg-upsert creates temporary tables and views (all prefixed `ups_`) that persist after the metacommand completes. Users can query these for debugging and inspection — for example, `SELECT * FROM ups_control` shows per-table QA results and row counts.
@@ -2770,7 +2806,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 +2832,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 +2841,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.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.16.17"
+version = "2.17.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" }
@@ -165,7 +165,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.16.17"
+current_version = "2.17.0"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.16.17 → execsql2-2.17.0}/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.17.0}/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.17.0}/src/execsql/metacommands/upsert.py

@@ -201,14 +201,6 @@ def _set_subvars(result: Any) -> None:
     sv("$PG_UPSERT_EXPORT_PATH", "")
 
 
-def _qa_failure_msg(result: Any) -> str:
-    """Build a concise QA failure message listing which tables failed."""
-    failed = [t.table_name for t in result.tables if not t.qa_passed]
-    if failed:
-        return f"PG_UPSERT QA failed for: {', '.join(failed)}"
-    return "PG_UPSERT QA checks failed."
-
-
 # ---------------------------------------------------------------------------
 # Import guard + helpers
 # ---------------------------------------------------------------------------
@@ -484,13 +476,6 @@ def x_pg_upsert(**kwargs: Any) -> None:
     if opts.get("cleanup"):
         ups.cleanup()
 
-    if not result.qa_passed:
-        raise ErrInfo(
-            "cmd",
-            command_text=metacommandline,
-            other_msg=_qa_failure_msg(result),
-        )
-
 
 def x_pg_upsert_qa(**kwargs: Any) -> None:
     """PG_UPSERT QA FROM <staging> TO <base> TABLES <t1>, <t2> [options]
@@ -524,13 +509,6 @@ def x_pg_upsert_qa(**kwargs: Any) -> None:
     if opts.get("cleanup"):
         ups.cleanup()
 
-    if not result.qa_passed:
-        raise ErrInfo(
-            "cmd",
-            command_text=metacommandline,
-            other_msg=_qa_failure_msg(result),
-        )
-
 
 def x_pg_upsert_check(**kwargs: Any) -> None:
     """PG_UPSERT CHECK FROM <staging> TO <base> TABLES <t1>, <t2>
@@ -567,13 +545,6 @@ def x_pg_upsert_check(**kwargs: Any) -> None:
     if opts.get("cleanup"):
         ups.cleanup()
 
-    if not result.qa_passed:
-        raise ErrInfo(
-            "cmd",
-            command_text=metacommandline,
-            other_msg=_qa_failure_msg(result),
-        )
-
 
 # ---------------------------------------------------------------------------
 # Plugin registration

{execsql2-2.16.17 → execsql2-2.17.0}/src/execsql/script/executor.py

@@ -243,15 +243,17 @@ def _exec_sql(
 
 def _exec_metacommand(
     ctx: RuntimeContext,
-    command: str,
+    cmd: str,
     source: str,
     line_no: int,
-    localvars: SubVarSet | None = None,
 ) -> Any:
-    """Dispatch a metacommand through the dispatch table."""
-    # Build localvars from the command-list stack frame (see _exec_sql comment).
-    effective_locals = _stack_localvars(ctx) or localvars
-    cmd = substitute_vars(command, effective_locals, ctx=ctx)
+    """Dispatch a metacommand through the dispatch table.
+
+    *cmd* must already have ``!!$VAR!!`` substitution applied.  The caller is
+    responsible for expansion so that side-effecting substitutions (counter
+    increments, ``$RANDOM``, ``$UUID``) are evaluated exactly once per
+    metacommand reference.
+    """
     if _VARLIKE.search(cmd):
         ctx.output.write(
             f"Warning: There is a potential un-substituted variable in the command\n     {cmd}\n",
@@ -355,13 +357,15 @@ def _execute_node(
         command = node.command
         if in_loop:
             command = _convert_deferred_vars(command)
-        # Intercept BREAK before dispatch — it controls loop flow
+        # Substitute once: the same expanded text is used for BREAK detection
+        # and dispatch.  Calling substitute_vars twice would double-increment
+        # !!$COUNTER_N!! and re-roll !!$RANDOM!!/!!$UUID!! references.
         effective_locals = _stack_localvars(ctx) or localvars
         expanded = substitute_vars(command, effective_locals, ctx=ctx)
         if _BREAK_RX.match(expanded):
             raise _BreakLoop
         ctx.last_command = _FakeScriptCmd(node)
-        _exec_metacommand(ctx, command, node.span.file, node.span.start_line, localvars)
+        _exec_metacommand(ctx, expanded, node.span.file, node.span.start_line)
 
     elif isinstance(node, IfBlock):
         ctx.last_command = _FakeScriptCmd(node)

{execsql2-2.16.17 → execsql2-2.17.0}/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.17.0}/tests/metacommands/test_pg_upsert.py

@@ -19,7 +19,6 @@ from execsql.metacommands.upsert import (
     _FileWriterHandler,
     _build_result_from_qa_findings,
     _parse_tables_and_options,
-    _qa_failure_msg,
     x_pg_upsert,
     x_pg_upsert_check,
     x_pg_upsert_qa,
@@ -541,7 +540,9 @@ class TestFullMode:
         assert "$PG_UPSERT_FINISHED_AT" in calls
         assert "$PG_UPSERT_RESULT_JSON" in calls
 
-    def test_qa_failure_raises_errinfo(self, mock_state):
+    def test_qa_failure_does_not_raise(self, mock_state):
+        """QA failure surfaces via $PG_UPSERT_QA_PASSED; the user's own IF /
+        ON ERROR HALT decides control flow."""
         state, db = mock_state
         fake_result = FakeUpsertResult(
             tables=[
@@ -559,17 +560,15 @@ class TestFullMode:
             patch("execsql.metacommands.upsert._create_pgupsert") as mock_create,
         ):
             mock_create.return_value.run.return_value = fake_result
-            with pytest.raises(ErrInfo) as exc_info:
-                x_pg_upsert(
-                    staging_schema="staging",
-                    base_schema="public",
-                    tail="books",
-                    metacommandline="PG_UPSERT FROM staging TO public TABLES books",
-                )
-        err_msg = str(exc_info.value)
-        assert "QA failed for: books" in err_msg
-        # Subvars should still be set before the error
-        assert state.subvars.add_substitution.called
+            x_pg_upsert(
+                staging_schema="staging",
+                base_schema="public",
+                tail="books",
+                metacommandline="PG_UPSERT FROM staging TO public TABLES books",
+            )
+        calls = {c[0][0]: c[0][1] for c in state.subvars.add_substitution.call_args_list}
+        assert calls["$PG_UPSERT_QA_PASSED"] == "FALSE"
+        assert calls["$PG_UPSERT_COMMITTED"] == "FALSE"
 
     def test_commit_keyword_passed(self, mock_state):
         state, db = mock_state
@@ -868,42 +867,6 @@ class TestUserCancelled:
             assert "cancelled" in str(exc_info.value)
 
 
-# ---------------------------------------------------------------------------
-# Logging bridge test
-# ---------------------------------------------------------------------------
-
-
-class TestQAFailureMessage:
-    def test_lists_failed_tables(self):
-        result = FakeUpsertResult(
-            tables=[
-                FakeTableResult(
-                    table_name="books",
-                    _qa_findings=[FakeQAError(table="books", check_type="null", details="title (3)")],
-                ),
-                FakeTableResult(table_name="authors"),  # passes
-                FakeTableResult(
-                    table_name="genres",
-                    _qa_findings=[FakeQAError(table="genres", check_type="fk", details="parent_id (5)")],
-                ),
-            ],
-        )
-        msg = _qa_failure_msg(result)
-        assert msg == "PG_UPSERT QA failed for: books, genres"
-
-    def test_single_failed_table(self):
-        result = FakeUpsertResult(
-            tables=[
-                FakeTableResult(
-                    table_name="books",
-                    _qa_findings=[FakeQAError(table="books", check_type="pk", details="id (2)")],
-                ),
-            ],
-        )
-        msg = _qa_failure_msg(result)
-        assert msg == "PG_UPSERT QA failed for: books"
-
-
 # ---------------------------------------------------------------------------
 # Logging bridge tests
 # ---------------------------------------------------------------------------
@@ -934,7 +897,7 @@ class TestLoggingBridge:
 
 
 class TestQAModeFailure:
-    def test_qa_failure_raises_errinfo(self, mock_state):
+    def test_qa_failure_does_not_raise(self, mock_state):
         state, db = mock_state
 
         failed_result = FakeUpsertResult(
@@ -956,18 +919,19 @@ class TestQAModeFailure:
             mock_ups = mock_create.return_value
             mock_ups.qa_all.return_value = mock_ups
             mock_build.return_value = failed_result
-            with pytest.raises(ErrInfo) as exc_info:
-                x_pg_upsert_qa(
-                    staging_schema="staging",
-                    base_schema="public",
-                    tail="books",
-                    metacommandline="PG_UPSERT QA FROM staging TO public TABLES books",
-                )
-            assert "QA failed for: books" in str(exc_info.value)
+            x_pg_upsert_qa(
+                staging_schema="staging",
+                base_schema="public",
+                tail="books",
+                metacommandline="PG_UPSERT QA FROM staging TO public TABLES books",
+            )
+        calls = {c[0][0]: c[0][1] for c in state.subvars.add_substitution.call_args_list}
+        assert calls["$PG_UPSERT_QA_PASSED"] == "FALSE"
+        assert calls["$PG_UPSERT_COMMITTED"] == "FALSE"
 
 
 class TestCheckModeFailure:
-    def test_check_failure_raises_errinfo(self, mock_state):
+    def test_check_failure_does_not_raise(self, mock_state):
         state, db = mock_state
 
         failed_result = FakeUpsertResult(
@@ -990,14 +954,14 @@ class TestCheckModeFailure:
             mock_ups.qa_column_existence.return_value = mock_ups
             mock_ups.qa_type_mismatch.return_value = mock_ups
             mock_build.return_value = failed_result
-            with pytest.raises(ErrInfo) as exc_info:
-                x_pg_upsert_check(
-                    staging_schema="staging",
-                    base_schema="public",
-                    tail="books",
-                    metacommandline="PG_UPSERT CHECK FROM staging TO public TABLES books",
-                )
-            assert "QA failed for: books" in str(exc_info.value)
+            x_pg_upsert_check(
+                staging_schema="staging",
+                base_schema="public",
+                tail="books",
+                metacommandline="PG_UPSERT CHECK FROM staging TO public TABLES books",
+            )
+        calls = {c[0][0]: c[0][1] for c in state.subvars.add_substitution.call_args_list}
+        assert calls["$PG_UPSERT_QA_PASSED"] == "FALSE"
 
 
 # ---------------------------------------------------------------------------
@@ -1427,15 +1391,15 @@ class TestExportFailures:
             patch("execsql.metacommands.upsert._create_pgupsert") as mock_create,
         ):
             mock_create.return_value.run.return_value = fake_result
-            with pytest.raises(ErrInfo):
-                x_pg_upsert(
-                    staging_schema="staging",
-                    base_schema="public",
-                    tail="books EXPORT_FAILURES /tmp/out",
-                    metacommandline="PG_UPSERT FROM staging TO public TABLES books EXPORT_FAILURES /tmp/out",
-                )
-        # Export MUST have happened before the ErrInfo was raised.
+            x_pg_upsert(
+                staging_schema="staging",
+                base_schema="public",
+                tail="books EXPORT_FAILURES /tmp/out",
+                metacommandline="PG_UPSERT FROM staging TO public TABLES books EXPORT_FAILURES /tmp/out",
+            )
         assert fake_result.export_calls == [("/tmp/out", "csv")]
+        calls = {c[0][0]: c[0][1] for c in state.subvars.add_substitution.call_args_list}
+        assert calls["$PG_UPSERT_QA_PASSED"] == "FALSE"
 
     def test_no_export_when_keyword_absent(self, mock_state):
         state, db = mock_state