execsql2 2.12.0__tar.gz → 2.12.2__tar.gz

execsql2-2.12.2/.claude/agents/liaison.md

@@ -0,0 +1,107 @@
+---
+name: The Liaison
+description: Integration specialist for pg-upsert and execsql2. Tracks the pg-upsert codebase (../pg-upsert), designs the optional dependency integration, and owns the UPSERT metacommand. Reads both codebases — writes only in execsql2.
+model: sonnet
+color: yellow
+---
+
+You are a senior Python engineer who specializes in integrating the **pg-upsert** library with the **execsql2** project. You are the bridge between two codebases maintained by the same author:
+
+- **execsql2** — `/Users/cgrant/GitHub/geocoug/execsql/` (this repo)
+- **pg-upsert** — `/Users/cgrant/GitHub/geocoug/pg-upsert/` (sibling repo)
+
+Your job is to keep the integration plan current, design the `UPSERT` metacommand, and ensure changes in either codebase don't break the integration path.
+
+## Expertise
+
+You have deep, working knowledge of:
+
+**pg-upsert internals:** The `PgUpsert` class (QA checks: null, PK, FK, check constraint validation), `PostgresDB` connection wrapper, the staging-to-base upsert workflow, topological table ordering, the `ups_control` temporary table, and the `psycopg2.sql` parameterized SQL generation patterns.
+
+**execsql2 extension points:** The metacommand dispatch system (`MetaCommandList`, `build_dispatch_table()`, `x_*` handlers), `DatabasePool` connection management, substitution variables (`SubVarSet`), transaction/autocommit model, the `PostgresDatabase` adapter, and the existing upsert SQL templates in `templates/pg_upsert.sql`.
+
+**Integration patterns:** Optional dependency detection (`importlib.util.find_spec`), connection sharing between libraries, adapter patterns for bridging different transaction models, and graceful degradation when an optional package is not installed.
+
+______________________________________________________________________
+
+## First Actions (always, before doing any work)
+
+1. **Read `.claude/project_context.md`** — load the execsql2 module layout and architectural overview.
+2. **Read your briefing** if one exists at `.claude/comms/briefings/liaison-*.md` — follow the DBA's specific instructions.
+3. **Read the integration plan** at `../pg-upsert/.claude/plans/refactor-and-execsql-integration.md` — this is the canonical plan. Understand the current phase and what's been decided.
+4. **Check pg-upsert's current state** — read `../pg-upsert/src/pg_upsert/upsert.py` and `../pg-upsert/src/pg_upsert/postgres.py` to understand the latest API surface. pg-upsert is under active refactoring; the API may have changed since the plan was written.
+5. **Check execsql2's metacommand system** — read `src/execsql/metacommands/dispatch.py` to understand registration patterns.
+
+______________________________________________________________________
+
+## Key Design Decisions (established)
+
+These have been agreed upon. Do not revisit unless the human asks:
+
+1. **pg-upsert is an optional dependency** — execsql2 must work without it installed. The `UPSERT` metacommand raises a clear error if pg-upsert is missing.
+2. **Connection sharing** — the metacommand passes execsql's existing `psycopg2` connection to `PgUpsert(conn=...)`. No second connection.
+3. **Results map to substitution variables** — upsert stats (rows updated, inserted, QA errors) are exposed as `!!$UPSERT_*!!` substitution variables.
+4. **execsql's transaction model governs** — the metacommand respects execsql's `AUTOCOMMIT ON/OFF` state, not pg-upsert's `do_commit` flag.
+5. **No Tkinter dependency** — the interactive GUI is not used when called from execsql. QA results go to execsql's logging/debug REPL instead.
+
+______________________________________________________________________
+
+## pg-upsert API Surface (reference)
+
+The integration depends on these pg-upsert interfaces. If any change, the integration plan must be updated.
+
+```python
+# Core class — this is what the metacommand will call
+PgUpsert(
+    conn=psycopg2_connection,  # Shared from execsql
+    tables=["t1", "t2"],
+    staging_schema="staging",
+    base_schema="public",
+    do_commit=False,           # execsql controls commits
+    interactive=False,         # No GUI from execsql
+    upsert_method="upsert",   # "upsert" | "update" | "insert"
+    exclude_cols=["col1"],
+    exclude_null_check_cols=["col2"],
+)
+
+# Methods the metacommand will call
+.qa_all()       # Run all QA checks, returns self
+.upsert_all()   # Run upsert on all tables, returns self
+.commit()       # Commit/rollback based on do_commit + qa_passed
+.run()          # qa_all() → upsert_all() → commit()
+
+# State the metacommand will read
+.qa_passed      # bool — did all QA checks pass?
+.control_table  # str — name of temp table with per-table results
+```
+
+______________________________________________________________________
+
+## What to Produce
+
+Depending on the task, you may produce:
+
+1. **Integration status reports** — what's changed in pg-upsert, what that means for execsql integration
+2. **Metacommand design** — regex patterns, handler signatures, SQL syntax for `UPSERT` metacommand
+3. **Implementation code** — `src/execsql/metacommands/upsert.py` and dispatch registration
+4. **Compatibility notes** — API changes in pg-upsert that require adaptation
+5. **Test specifications** — what the QA agent should test for the integration
+
+______________________________________________________________________
+
+## Syndicate Protocol
+
+When working as part of the SQL Syndicate:
+
+1. Read your briefing from `.claude/comms/briefings/liaison-*.md`
+2. Do your research across both codebases
+3. Write your report to `.claude/comms/reports/liaison-{YYYY-MM-DD}.md`
+4. Write integration artifacts to `.claude/plans/` (for design) or `.claude/patches/` (for implementation)
+
+## Constraints
+
+- **Writes only in execsql2.** You may read `../pg-upsert/` freely but never modify files there.
+- **pg-upsert is a moving target.** Always re-read the current pg-upsert source before making claims about its API — don't rely on cached knowledge.
+- **Optional means optional.** Never add pg-upsert to execsql2's required dependencies. Use `extras_require` / optional dependency groups.
+- **Preserve existing upsert templates.** The SQL templates in `templates/pg_upsert.sql` must continue to work. The metacommand is an alternative, not a replacement.
+- Follow all execsql2 project constraints from CLAUDE.md (ruff, Python 3.10+, coverage floor, changelog, docs, divergence tracking).

{execsql2-2.12.0 → execsql2-2.12.2}/CHANGELOG.md

@@ -13,6 +13,34 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.12.2] - 2026-04-02
+
+### Added
+
+- Documentation: keyring setup guide for headless Linux servers (encrypted and plaintext file backends) in the Security reference page, with a cross-reference from the Installation page.
+
+### Changed
+
+- `ASSERT` failures now report `**** Assertion failed.` instead of `**** Error in metacommand.` to distinguish intentional script-level checks from actual metacommand errors.
+
+______________________________________________________________________
+
+## [2.12.1] - 2026-04-02
+
+### Changed
+
+- Performance: removed dead `_compiled_patterns` dict from `SubVarSet` — eliminated 3 unused regex compilations per `add_substitution` call (~20 calls per statement in typical scripts).
+- Performance: cached `source_dir` and `source_name` on `ScriptCmd` at construction time — eliminated per-statement `Path.resolve()` filesystem calls.
+- Performance: `select_rowdict()` now uses batched `fetchmany()` instead of row-at-a-time `fetchone()`, matching `select_rowsource()` behavior for template exports.
+- Performance: removed redundant `$CURRENT_TIME` set in `set_system_vars()` — now set once per statement in `run_and_increment()`.
+- Performance: removed no-op `copy.copy()` on immutable string in `substitute_vars()`.
+
+### Fixed
+
+- Fixed cursor leak in `select_rowsource()` — generator now closes the cursor in a `finally` block when exhausted or abandoned.
+
+______________________________________________________________________
+
 ## [2.12.0] - 2026-04-01
 
 ### Added

{execsql2-2.12.0 → execsql2-2.12.2}/CLAUDE.md

@@ -22,6 +22,7 @@ A multi-agent system where specialized agents collaborate to improve, extend, de
 - `.claude/docs-drafts/` — Scribe's documentation drafts
 - `.claude/releases/` — Herald's release notes and changelog entries
 - `.claude/state/` — Shared state (current phase, active task, agent status)
+- `../pg-upsert/.claude/plans/` — pg-upsert integration plan (read by The Liaison)
 
 ## Communication Protocol
 

{execsql2-2.12.0 → execsql2-2.12.2}/PKG-INFO

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.12.0
+Version: 2.12.2
 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
 Project-URL: Issues, https://github.com/geocoug/execsql/issues
 Author-email: Dreas Nielsen <cortice@tutanota.com>

{execsql2-2.12.0 → execsql2-2.12.2}/docs/about/divergence.md

@@ -174,6 +174,7 @@ All 33 mutable runtime globals in `state.py` have been consolidated into a `Runt
 
 - **Exception hierarchy** — All custom exceptions inherit from `ExecSqlError`, enabling `except ExecSqlError` to catch any execsql-originated error.
 - **Exception chaining** — All `raise` statements inside `except` blocks preserve the original traceback via `from`.
+- **ASSERT error type** — `ASSERT` failures now use a dedicated `"assert"` error type that produces `**** Assertion failed.` instead of `**** Error in metacommand.`. This distinguishes intentional script-level checks from actual metacommand errors. Upstream did not have `ASSERT`.
 
 ______________________________________________________________________
 

{execsql2-2.12.0 → execsql2-2.12.2}/docs/getting-started/installation.md

@@ -30,3 +30,7 @@ pip install "execsql2[all]"         # Everything
 ```
 
 In addition to the *execsql* program itself, additional Python libraries may need to be installed to use *execsql* with specific types of DBMSs and spreadsheets. The additional libraries that may be needed are listed in the [Requirements](requirements.md#requirements) section.
+
+!!! tip "Keyring on headless Linux"
+
+    If you install `execsql2[auth]` on a headless Linux server (no desktop environment), the keyring backend needs manual configuration. See [Keyring Platform Setup](../reference/security.md#keyring_setup) for instructions.

{execsql2-2.12.0 → execsql2-2.12.2}/docs/reference/metacommands.md

@@ -56,7 +56,9 @@ ASSERT <condition> "<failure message>"
 ASSERT <condition> '<failure message>'
 ```
 
-Evaluates `<condition>` using the same expression engine as [IF](#if_cmd). If the condition is `True`, execution continues silently (and the result is written to the log). If the condition is `False`, an error is raised with the provided failure message. If no message is supplied, the default message is `Assertion failed: <condition>`.
+Evaluates `<condition>` using the same expression engine as [IF](#if_cmd). If the condition is `True`, execution continues silently (and the result is written to the log). If the condition is `False`, an assertion error is raised with the provided failure message. If no message is supplied, the default message is `Assertion failed: <condition>`.
+
+A failed assertion produces `**** Assertion failed.` (not `**** Error in metacommand.`) to make it clear that the script's own check caught a problem, not that execsql encountered an internal error.
 
 When [HALT_ON_METACOMMAND_ERROR](#config) is `ON` (the default), a failed assertion halts the script. When it is `OFF`, execution continues after the failure is logged.
 

{execsql2-2.12.0 → execsql2-2.12.2}/docs/reference/security.md

@@ -29,7 +29,7 @@ When execsql needs a database password and none is stored or configured, it prom
 
 ### OS credential store (keyring)
 
-When the optional `keyring` package is installed (`pip install execsql2[auth]`), execsql checks the OS credential store before prompting. After a successful interactive prompt, the password is automatically stored for future use. Supported stores are macOS Keychain, Windows Credential Manager, and Linux SecretService. Keyring service names follow the pattern:
+When the optional `keyring` package is installed (`pip install execsql2[auth]`), execsql checks the OS credential store before prompting. After a successful interactive prompt, the password is automatically stored for future use. Keyring service names follow the pattern:
 
 ```text
 execsql/<db_type>/<server>/<database>
@@ -37,6 +37,64 @@ execsql/<db_type>/<server>/<database>
 
 To disable keyring integration, set `use_keyring = No` in the `[connect]` section of `execsql.conf`.
 
+#### Platform setup { #keyring_setup }
+
+**macOS** — Works out of the box. Keyring uses the macOS Keychain automatically.
+
+**Windows** — Works out of the box. Keyring uses the Windows Credential Manager automatically.
+
+**Linux (desktop with GNOME/KDE)** — Works out of the box if a SecretService provider (GNOME Keyring or KWallet) is running.
+
+**Linux (headless / remote / server)** — No secret service is typically available, so keyring silently fails to store passwords. You need to configure a file-based backend. There are two options:
+
+##### Option A: Encrypted file backend (recommended) { #keyring_encrypted }
+
+Passwords are stored encrypted on disk. Requires a master password the first time keyring is used per session.
+
+```bash
+pip install keyrings.alt pycryptodome
+mkdir -p ~/.config/python_keyring
+cat > ~/.config/python_keyring/keyringrc.cfg << 'EOF'
+[backend]
+default-keyring=keyrings.alt.file.EncryptedKeyring
+EOF
+```
+
+The encrypted keyring file is stored at `~/.local/share/python_keyring/crypted_pass.cfg`. You will be prompted for a master password once per session (e.g., when you first run execsql after logging in).
+
+##### Option B: Plaintext file backend (no prompts) { #keyring_plaintext }
+
+Passwords are stored in plain text on disk. No master password is needed — execsql will never prompt for a password after the first successful entry.
+
+```bash
+pip install keyrings.alt
+mkdir -p ~/.config/python_keyring
+cat > ~/.config/python_keyring/keyringrc.cfg << 'EOF'
+[backend]
+default-keyring=keyrings.alt.file.PlaintextKeyring
+EOF
+```
+
+Passwords are stored at `~/.local/share/python_keyring/keyring_pass.cfg`. Restrict access to this file:
+
+```bash
+chmod 600 ~/.local/share/python_keyring/keyring_pass.cfg
+```
+
+!!! warning "Plaintext storage"
+
+    The plaintext backend stores passwords without encryption. Only use this on machines where the filesystem is already secured (encrypted disk, single-user access, restricted permissions). Prefer the encrypted backend when possible.
+
+##### Verifying keyring setup { #keyring_verify }
+
+After configuring a backend, verify it works:
+
+```bash
+python -c "import keyring; keyring.set_password('test', 'user', 'pw'); print(keyring.get_password('test', 'user'))"
+```
+
+This should print `pw` without errors. If it does, the next time execsql prompts for a database password, it will store it and skip the prompt on future runs.
+
 ### `enc_password` in execsql.conf
 
 !!! warning "Obfuscation only — not encryption"

{execsql2-2.12.0 → execsql2-2.12.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.12.0"
+version = "2.12.2"
 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" }
@@ -91,6 +91,7 @@ execsql = "execsql.cli:_legacy_main"
 execsql-format = "execsql.format:main"
 
 [project.urls]
+Homepage = "https://execsql2.readthedocs.io"
 Repository = "https://github.com/geocoug/execsql"
 Issues = "https://github.com/geocoug/execsql/issues"
 
@@ -158,7 +159,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.12.0"
+current_version = "2.12.2"
 commit = true
 commit_args = "--no-verify"
 tag = true

{execsql2-2.12.0 → execsql2-2.12.2}/src/execsql/db/base.py

@@ -234,18 +234,22 @@ class Database(ABC):
             pass  # Non-critical: some drivers lack rowcount support.
 
         def decode_row() -> Generator:
-            while True:
-                rows = curs.fetchmany()
-                if not rows:
-                    break
-                else:
-                    for row in rows:
-                        if self.encoding:
-                            yield [
-                                c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row
-                            ]
-                        else:
-                            yield row
+            try:
+                while True:
+                    rows = curs.fetchmany()
+                    if not rows:
+                        break
+                    else:
+                        for row in rows:
+                            if self.encoding:
+                                yield [
+                                    c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c
+                                    for c in row
+                                ]
+                            else:
+                                yield row
+            finally:
+                curs.close()
 
         return [d[0] for d in curs.description], decode_row()
 
@@ -253,6 +257,10 @@ class Database(ABC):
         """Execute *sql* and return ``(column_names, row_iterator)`` where each row is a ``dict``."""
         # Return an iterable that yields dictionaries of row data
         curs = self.cursor()
+        try:
+            curs.arraysize = _state.conf.export_row_buffer
+        except Exception:
+            pass  # Non-critical: not all drivers support arraysize.
         try:
             curs.execute(sql)
         except Exception:
@@ -264,18 +272,24 @@ class Database(ABC):
             pass  # Non-critical: some drivers lack rowcount support.
         hdrs = [d[0] for d in curs.description]
 
-        def dict_row() -> dict | None:
-            row = curs.fetchone()
-            if row:
-                if self.encoding:
-                    r = [c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row]
-                else:
-                    r = row
-                return dict(zip(hdrs, r))
-            else:
-                return None
+        def dict_rows() -> Generator:
+            try:
+                while True:
+                    rows = curs.fetchmany()
+                    if not rows:
+                        break
+                    for row in rows:
+                        if self.encoding:
+                            r = [
+                                c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row
+                            ]
+                        else:
+                            r = row
+                        yield dict(zip(hdrs, r))
+            finally:
+                curs.close()
 
-        return hdrs, iter(dict_row, None)
+        return hdrs, dict_rows()
 
     def schema_exists(self, schema_name: str) -> bool:
         """Return ``True`` if *schema_name* exists in this database."""

{execsql2-2.12.0 → execsql2-2.12.2}/src/execsql/exceptions.py

@@ -132,6 +132,8 @@ class ErrInfo(ExecSqlError):
 
         if self.type == "db":
             self.error_message = "**** Error in SQL statement."
+        elif self.type == "assert":
+            self.error_message = "**** Assertion failed."
         elif self.type == "cmd":
             self.error_message = "**** Error in metacommand."
         elif self.type == "log":

{execsql2-2.12.0 → execsql2-2.12.2}/src/execsql/metacommands/control.py

@@ -66,7 +66,7 @@ def x_assert(**kwargs: Any) -> None:
         if _state.exec_log is not None:
             _state.exec_log.log_user_msg(f"ASSERT passed: {condition}")
     else:
-        raise ErrInfo(type="cmd", other_msg=message)
+        raise ErrInfo(type="assert", other_msg=message)
 
 
 def x_if(**kwargs: Any) -> None:

{execsql2-2.12.0 → execsql2-2.12.2}/src/execsql/script/engine.py

@@ -397,6 +397,15 @@ class ScriptCmd:
         self.line_no = command_line_no
         self.command_type = command_type
         self.command = script_command
+        # MIGRATION NOTE: differs from monolith (execsql.py) — source_dir and source_name are
+        # resolved once at construction rather than on every statement execution.  For absolute
+        # paths (the common case) the result is identical.  For relative paths the value is
+        # anchored to the CWD at script-load time rather than at each statement's execution time;
+        # the original per-statement resolve could yield inconsistent values across statements of
+        # the same script if a CD metacommand ran between them.
+        _p = Path(command_source_name)
+        self.source_dir: str = str(_p.resolve().parent) + os.sep
+        self.source_name: str = _p.name
 
     def __repr__(self) -> str:
         return f"ScriptCmd({self.source!r}, {self.line_no!r}, {self.command_type!r}, {repr(self.command)!r})"
@@ -498,9 +507,9 @@ class CommandList:
             _state.subvars.add_substitution("$CURRENT_SCRIPT", cmditem.source)
             _state.subvars.add_substitution(
                 "$CURRENT_SCRIPT_PATH",
-                str(Path(cmditem.source).resolve().parent) + os.sep,
+                cmditem.source_dir,
             )
-            _state.subvars.add_substitution("$CURRENT_SCRIPT_NAME", Path(cmditem.source).name)
+            _state.subvars.add_substitution("$CURRENT_SCRIPT_NAME", cmditem.source_name)
             _state.subvars.add_substitution("$CURRENT_SCRIPT_LINE", str(cmditem.line_no))
             _state.subvars.add_substitution("$SCRIPT_LINE", str(cmditem.line_no))
             if _state.step_mode:
@@ -709,7 +718,7 @@ def set_system_vars() -> None:
         "ON" if _state.conf.gui_wait_on_error_halt else "OFF",
     )
     _state.subvars.add_substitution("$CONSOLE_WAIT_WHEN_DONE_STATE", "ON" if _state.conf.gui_wait_on_exit else "OFF")
-    _state.subvars.add_substitution("$CURRENT_TIME", datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
+    # $CURRENT_TIME is set per-statement in run_and_increment() for accuracy.
     _state.subvars.add_substitution("$CURRENT_DIR", str(Path(".").resolve()))
     _state.subvars.add_substitution("$CURRENT_PATH", str(Path(".").resolve()) + os.sep)
     _state.subvars.add_substitution("$CURRENT_ALIAS", _state.dbs.current_alias())
@@ -742,7 +751,7 @@ def substitute_vars(command_str: str, localvars: SubVarSet | None = None) -> str
         subs = _state.subvars.merge(localvars)
     else:
         subs = _state.subvars
-    cmdstr = copy.copy(command_str)
+    cmdstr = command_str
     subs_made = True
     iterations = 0
     while subs_made:

{execsql2-2.12.0 → execsql2-2.12.2}/src/execsql/script/variables.py

@@ -89,7 +89,6 @@ class SubVarSet:
     # compatibility with external code.
     def __init__(self) -> None:
         self._subs_dict: dict[str, Any] = {}
-        self._compiled_patterns: dict[str, tuple] = {}
         self.prefix_list: list[str] = ["$", "&", "@"]
         # Don't construct/compile on init because deepcopy() can't handle compiled regexes.
         self.var_rx = None
@@ -106,21 +105,6 @@ class SubVarSet:
             self._subs_dict = dict(value)
         else:
             self._subs_dict = dict(value)
-        self._rebuild_all_patterns()
-
-    def _compile_patterns_for(self, varname: str) -> tuple:
-        """Compile and return the three regex patterns (plain, single-quoted, double-quoted) for *varname*."""
-        match_escaped = "\\" + varname if varname[0] == "$" else varname
-        pat = re.compile(f"!!{match_escaped}!!", re.I)
-        patq = re.compile(f"!'!{match_escaped}!'!", re.I)
-        patdq = re.compile(f'!"!{match_escaped}!"!', re.I)
-        return (pat, patq, patdq)
-
-    def _rebuild_all_patterns(self) -> None:
-        """Rebuild compiled patterns for every variable currently stored."""
-        self._compiled_patterns = {}
-        for varname in self._subs_dict:
-            self._compiled_patterns[varname] = self._compile_patterns_for(varname)
 
     def compile_var_rx(self) -> None:
         """Compile the variable-name validation regex from the current prefix list."""
@@ -141,14 +125,12 @@ class SubVarSet:
         self.check_var_name(template_str)
         old_sub = template_str.lower()
         self._subs_dict.pop(old_sub, None)
-        self._compiled_patterns.pop(old_sub, None)
 
     def add_substitution(self, varname: str, repl_str: Any) -> None:
-        """Add or overwrite a substitution variable, compiling its match patterns."""
+        """Add or overwrite a substitution variable."""
         self.check_var_name(varname)
         varname = varname.lower()
         self._subs_dict[varname] = repl_str
-        self._compiled_patterns[varname] = self._compile_patterns_for(varname)
 
     def append_substitution(self, varname: str, repl_str: str) -> None:
         self.check_var_name(varname)
@@ -186,15 +168,10 @@ class SubVarSet:
         return template_str.lower() in self._subs_dict
 
     def merge(self, other_subvars: SubVarSet | None) -> SubVarSet:
-        """Return a new SubVarSet with this object's variables merged with other_subvars.
-
-        Copies dictionaries and pre-compiled patterns directly instead of
-        re-adding variables one at a time, avoiding O(V) regex recompilation.
-        """
+        """Return a new SubVarSet with this object's variables merged with other_subvars."""
         if other_subvars is not None:
             newsubs = SubVarSet()
             newsubs._subs_dict = {**self._subs_dict, **other_subvars._subs_dict}
-            newsubs._compiled_patterns = {**self._compiled_patterns, **other_subvars._compiled_patterns}
             newsubs.prefix_list = list(set(self.prefix_list + other_subvars.prefix_list))
             newsubs.compile_var_rx()
             return newsubs

{execsql2-2.12.0 → execsql2-2.12.2}/tests/db/test_base.py

@@ -628,9 +628,9 @@ class TestSelectRowdictEncoding:
         mock_curs = MagicMock()
         mock_curs.description = [("name",)]
         mock_curs.rowcount = 1
-        mock_curs.fetchone.side_effect = [
-            (b"encoded value",),
-            None,
+        mock_curs.fetchmany.side_effect = [
+            [(b"encoded value",)],
+            [],
         ]
 
         with patch.object(db, "cursor", return_value=mock_curs):
@@ -648,7 +648,7 @@ class TestSelectRowdictEncoding:
         mock_curs = MagicMock()
         mock_curs.description = [("score",)]
         mock_curs.rowcount = 1
-        mock_curs.fetchone.side_effect = [(99,), None]
+        mock_curs.fetchmany.side_effect = [[(99,)], []]
 
         with patch.object(db, "cursor", return_value=mock_curs):
             _, it = db.select_rowdict("SELECT score FROM fake;")
@@ -664,7 +664,7 @@ class TestSelectRowdictEncoding:
         mock_curs = MagicMock()
         mock_curs.description = [("x",)]
         mock_curs.rowcount = 1
-        mock_curs.fetchone.side_effect = [("plain",), None]
+        mock_curs.fetchmany.side_effect = [[("plain",)], []]
 
         with patch.object(db, "cursor", return_value=mock_curs):
             _, it = db.select_rowdict("SELECT x FROM fake;")

{execsql2-2.12.0 → execsql2-2.12.2}/tests/metacommands/test_assert.py

@@ -71,9 +71,22 @@ class TestXAssertRaisesOnFalseCondition:
         with (
             patch.object(_state, "xcmd_test", return_value=False),
             patch.object(_state, "exec_log", mock_log),
-            pytest.raises(ErrInfo),
+            pytest.raises(ErrInfo) as exc_info,
         ):
             x_assert(condtest="ROWCOUNT > 0", message=None, metacommandline="ASSERT ROWCOUNT > 0")
+        assert exc_info.value.type == "assert"
+
+    def test_false_condition_eval_err_says_assertion_failed(self) -> None:
+        mock_log = _make_exec_log()
+        with (
+            patch.object(_state, "xcmd_test", return_value=False),
+            patch.object(_state, "exec_log", mock_log),
+            pytest.raises(ErrInfo) as exc_info,
+        ):
+            x_assert(condtest="ROWCOUNT > 0", message='"expected rows"', metacommandline="ASSERT ROWCOUNT > 0")
+        err_msg = exc_info.value.eval_err()
+        assert err_msg.startswith("**** Assertion failed.")
+        assert "expected rows" in err_msg
 
     def test_false_condition_with_double_quoted_message(self) -> None:
         mock_log = _make_exec_log()

{execsql2-2.12.0 → execsql2-2.12.2}/tests/test_engine.py

@@ -706,7 +706,8 @@ class TestSetSystemVars:
         set_system_vars()
         assert _state.subvars.varvalue("$DB_USER") == "testuser"
 
-    def test_populates_current_time(self, engine_state):
+    def test_current_time_not_set_by_set_system_vars(self, engine_state):
+        """$CURRENT_TIME is set per-statement in run_and_increment, not in set_system_vars."""
         pool = MagicMock()
         pool.current.return_value = self._make_db()
         pool.current_alias.return_value = "main"
@@ -715,9 +716,7 @@ class TestSetSystemVars:
         mock_timer.elapsed.return_value = 0
         _state.timer = mock_timer
         set_system_vars()
-        t = _state.subvars.varvalue("$CURRENT_TIME")
-        assert t is not None
-        assert len(t) == 16  # "YYYY-MM-DD HH:MM"
+        assert _state.subvars.varvalue("$CURRENT_TIME") is None
 
     def test_populates_version_numbers(self, engine_state):
         pool = MagicMock()

{execsql2-2.12.0 → execsql2-2.12.2}/tests/test_exceptions.py

@@ -83,6 +83,7 @@ class TestErrInfo:
         "err_type,expected_text",
         [
             ("db", "**** Error in SQL statement."),
+            ("assert", "**** Assertion failed."),
             ("cmd", "**** Error in metacommand."),
             ("log", "**** Error in logging."),
             ("error", "**** General error."),