execsql2 2.11.1__py3-none-any.whl → 2.12.1__py3-none-any.whl

execsql/cli/__init__.py

@@ -278,6 +278,11 @@ def main(
         "--profile",
         help="Record per-statement execution times and print a timing summary after the script completes.",
     ),
+    profile_limit: int = typer.Option(
+        20,
+        "--profile-limit",
+        help="Number of top statements to show in the --profile timing summary (default: 20).",
+    ),
     debug: bool = typer.Option(
         False,
         "--debug",
@@ -449,6 +454,7 @@ def main(
         output_dir=output_dir,
         progress=progress,
         profile=profile,
+        profile_limit=profile_limit,
         ping=ping,
         lint=lint,
         debug=debug,

execsql/cli/run.py

@@ -71,12 +71,14 @@ def _print_dry_run(cmdlist: object) -> None:
 # ---------------------------------------------------------------------------
 
 
-def _print_profile(profile_data: list[tuple]) -> None:
+def _print_profile(profile_data: list[tuple], limit: int = 20) -> None:
     """Print a per-statement timing summary to stdout.
 
     Args:
         profile_data: List of ``(source, line_no, command_type, elapsed_secs,
             command_text_preview)`` tuples collected during execution.
+        limit: Maximum number of top statements to display (default: 20).
+            All statements are included in totals regardless of this value.
     """
     if not profile_data:
         _console.print("[dim]Profile: no statements recorded.[/dim]")
@@ -85,9 +87,9 @@ def _print_profile(profile_data: list[tuple]) -> None:
     total_secs = sum(row[3] for row in profile_data)
     n = len(profile_data)
 
-    # Sort descending by elapsed time; show top 20 (or all if <= 20).
+    # Sort descending by elapsed time; show top `limit` (or all if <= limit).
     sorted_data = sorted(profile_data, key=lambda r: r[3], reverse=True)
-    display = sorted_data[:20]
+    display = sorted_data[:limit]
 
     _console.print()
     _console.print(f"[bold cyan]Profile:[/bold cyan] {n} statement{'s' if n != 1 else ''} in {total_secs:.3f}s")
@@ -115,10 +117,10 @@ def _print_profile(profile_data: list[tuple]) -> None:
             f"{preview_short}",
         )
 
-    if len(sorted_data) > 20:
-        omitted = len(sorted_data) - 20
+    if len(sorted_data) > limit:
+        omitted = len(sorted_data) - limit
         _console.print(
-            f"[dim]  ... {omitted} more statement{'s' if omitted != 1 else ''} not shown (top 20 by time)[/dim]",
+            f"[dim]  ... {omitted} more statement{'s' if omitted != 1 else ''} not shown (top {limit} by time)[/dim]",
         )
 
     _console.print()
@@ -213,6 +215,7 @@ def _run(
     output_dir: str | None = None,
     progress: bool = False,
     profile: bool = False,
+    profile_limit: int = 20,
     ping: bool = False,
     lint: bool = False,
     debug: bool = False,
@@ -552,7 +555,7 @@ def _run(
     if debug:
         _state.step_mode = True
 
-    _execute_script_direct(conf, profile=profile)
+    _execute_script_direct(conf, profile=profile, profile_limit=profile_limit)
 
 
 # ---------------------------------------------------------------------------
@@ -611,7 +614,7 @@ def _execute_script_textual_console(conf: ConfigData) -> None:
     _state.exec_log.log_exit_end()
 
 
-def _execute_script_direct(conf: ConfigData, *, profile: bool = False) -> None:
+def _execute_script_direct(conf: ConfigData, *, profile: bool = False, profile_limit: int = 20) -> None:
     """Run runscripts() in the current (main) thread — used when Textual is not active.
 
     Args:
@@ -619,6 +622,8 @@ def _execute_script_direct(conf: ConfigData, *, profile: bool = False) -> None:
         profile: When ``True``, print a per-statement timing summary after the
             script completes.  Timing data must already have been activated on
             ``_state.profile_data`` before this function is called.
+        profile_limit: Maximum number of top statements to display in the
+            profile summary (default: 20).
     """
     import execsql.state as _state
     import execsql.utils.gui as _gui
@@ -645,7 +650,7 @@ def _execute_script_direct(conf: ConfigData, *, profile: bool = False) -> None:
                 gui_console_off()
         _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
         if profile and _state.profile_data is not None:
-            _print_profile(_state.profile_data)
+            _print_profile(_state.profile_data, limit=profile_limit)
         sys.exit(exc.code)
     except ConfigError:
         raise
@@ -673,7 +678,7 @@ def _execute_script_direct(conf: ConfigData, *, profile: bool = False) -> None:
             gui_console_off()
     _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
     if profile and _state.profile_data is not None:
-        _print_profile(_state.profile_data)
+        _print_profile(_state.profile_data, limit=profile_limit)
     _state.exec_log.log_exit_end()
 
 

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."""

execsql/debug/__init__.py

@@ -0,0 +1,6 @@
+"""Debug utilities for execsql.
+
+This package contains interactive debugging tools for execsql scripts:
+
+- :mod:`execsql.debug.repl` — the ``BREAKPOINT`` metacommand REPL.
+"""

execsql/debug/repl.py

@@ -0,0 +1,472 @@
+from __future__ import annotations
+
+"""Interactive debug REPL metacommand handler for execsql.
+
+Implements ``x_breakpoint`` — the ``BREAKPOINT`` metacommand — which pauses
+script execution and drops into an interactive read-eval-print loop.
+
+The REPL allows the user to:
+
+- Inspect and print substitution variables.
+- Run ad-hoc SQL queries against the current database.
+- Step through the script one statement at a time.
+- Resume or abort execution.
+
+All REPL commands are dot-prefixed (``.continue``, ``.vars``, ``.next``)
+to avoid ambiguity with variable names and SQL.  Anything not starting
+with ``.`` is treated as either a variable lookup (if it matches a known
+variable) or SQL (if it ends with ``;``).
+
+In non-interactive environments (CI, piped input, ``sys.stdin.isatty()`` is
+``False``) the metacommand is silently skipped so automated pipelines are not
+blocked.
+"""
+
+import os
+import sys
+from pathlib import Path
+from typing import Any
+
+import execsql.state as _state
+
+__all__ = ["x_breakpoint"]
+
+# ---------------------------------------------------------------------------
+# ANSI color support — auto-detected, respects NO_COLOR / EXECSQL_NO_COLOR
+# ---------------------------------------------------------------------------
+
+_RESET = "\033[0m"
+_BOLD = "\033[1m"
+_DIM = "\033[2m"
+_ITALIC = "\033[3m"
+_RED = "\033[31m"
+_GREEN = "\033[32m"
+_YELLOW = "\033[33m"
+_CYAN = "\033[36m"
+
+
+def _use_color() -> bool:
+    """Return True if the output stream supports ANSI color.
+
+    Checks ``NO_COLOR`` and ``EXECSQL_NO_COLOR`` environment variables first
+    (either set → color off).  Then tests whether the active output stream
+    reports itself as a TTY.
+    """
+    if os.environ.get("NO_COLOR") is not None:
+        return False
+    if os.environ.get("EXECSQL_NO_COLOR") is not None:
+        return False
+    output = _state.output
+    if output is not None and hasattr(output, "isatty"):
+        return output.isatty()
+    # WriteHooks (the default _state.output) has no isatty — fall through
+    # to check the underlying stream it would write to.
+    return sys.stdout.isatty()
+
+
+def _c(code: str, text: str) -> str:
+    """Wrap *text* in an ANSI escape sequence when color is enabled.
+
+    Returns plain *text* unchanged when ``_use_color()`` is False so that
+    tests and non-TTY environments receive undecorated strings.
+
+    Args:
+        code: One or more ANSI escape codes (e.g. ``_BOLD + _CYAN``).
+        text: The text to colorize.
+
+    Returns:
+        ``f"{code}{text}{_RESET}"`` when color is on, else *text* unchanged.
+    """
+    if not _use_color():
+        return text
+    return f"{code}{text}{_RESET}"
+
+
+# ---------------------------------------------------------------------------
+# Public handler
+# ---------------------------------------------------------------------------
+
+_HELP_COMMANDS = [
+    (".continue", ".c", "Resume script execution"),
+    (".abort", ".q", "Halt the script (exit 1)"),
+    (".vars", ".v", "List user, system, local, and counter variables"),
+    (".vars all", ".v all", "Include environment variables (&) in the listing"),
+    (".next", ".n", "Execute the next statement then pause again (step mode)"),
+    (".where", ".w", "Show the current script location and upcoming statement"),
+    (".stack", "", "Show the command-list stack (script name, line, depth)"),
+    (".set VAR VAL", ".s", "Set or update a substitution variable"),
+    (".help", ".h", "Show this help text"),
+]
+
+_HELP_OTHER = [
+    ("varname", "Print a variable's value (e.g. logfile, $ARG_1, &HOME)"),
+    ("SELECT ...;", "Run SQL ending with ';' (expects columns returned, e.g. SELECT)"),
+]
+
+_HELP_CMD_WIDTH = 13  # width of the command column
+_HELP_SHORT_WIDTH = 7  # width of the shortcut column
+
+
+def _format_help() -> str:
+    """Build the help text with optional ANSI color."""
+    lines: list[str] = []
+    lines.append(f"{_c(_BOLD, 'execsql debug REPL')} {_c(_DIM, '— all commands start with')} {_c(_CYAN, '.')}")
+    lines.append("")
+    for cmd, short, desc in _HELP_COMMANDS:
+        cmd_col = _c(_CYAN, cmd.ljust(_HELP_CMD_WIDTH))
+        short_col = _c(_CYAN, short.ljust(_HELP_SHORT_WIDTH)) if short else " " * _HELP_SHORT_WIDTH
+        lines.append(f"  {cmd_col}  {short_col}  {desc}")
+    lines.append("")
+    lines.append(f"{_c(_BOLD, 'Everything else:')}")
+    for cmd, desc in _HELP_OTHER:
+        cmd_col = _c(_DIM, cmd.ljust(_HELP_CMD_WIDTH + _HELP_SHORT_WIDTH + 2))
+        lines.append(f"  {cmd_col}  {desc}")
+    lines.append("")
+    return "\n".join(lines) + "\n"
+
+
+_WHERE_TRUNCATE = 120
+
+
+def x_breakpoint(**kwargs: Any) -> None:
+    """Pause execution and enter the interactive debug REPL.
+
+    If ``sys.stdin`` is not a TTY (CI, piped input), the metacommand is
+    silently skipped — scripts will not hang in automation.
+
+    Args:
+        **kwargs: Keyword arguments injected by the dispatch table (unused).
+    """
+    if not sys.stdin.isatty():
+        return
+    _debug_repl()
+
+
+# ---------------------------------------------------------------------------
+# REPL core
+# ---------------------------------------------------------------------------
+
+
+def _write_rule(label: str) -> None:
+    """Print a horizontal rule with an embedded label.
+
+    The rule is ``──<label>`` followed by a fixed-width suffix of dashes,
+    giving a consistent visual separator regardless of terminal width.
+
+    Args:
+        label: Text (may include ANSI codes) to embed in the rule.
+    """
+    _write(f"{_c(_DIM, '──')}{label}{_c(_DIM, '─' * 40)}\n")
+
+
+def _debug_repl(*, step: bool = False) -> None:
+    """Interactive read-eval-print loop for script debugging.
+
+    Reads commands from stdin until the user types ``.continue`` or ``.abort``,
+    or until EOF / KeyboardInterrupt.
+
+    Args:
+        step: When ``True``, the entry banner says "Step" instead of
+            "Breakpoint" to indicate the REPL was re-entered via step mode.
+    """
+    try:
+        import readline as _readline  # noqa: F401 — side-effect: enables history/arrow keys
+    except ImportError:
+        pass  # readline not available on Windows; continue without it
+
+    label_word = "Step" if step else "Breakpoint"
+    lc = _state.last_command
+    if lc is not None:
+        location = f"{Path(lc.source).name}:{lc.line_no}"
+        type_tag = lc.command_type
+        text = lc.command.commandline()
+        if len(text) > _WHERE_TRUNCATE:
+            text = text[:_WHERE_TRUNCATE] + "..."
+        rule_label = f" {_c(_BOLD + _YELLOW, label_word)} {_c(_DIM, '──')} {_c(_CYAN, location)} "
+    else:
+        type_tag = None
+        text = None
+        location = "(position unknown)"
+        rule_label = f" {_c(_BOLD + _YELLOW, label_word)} "
+
+    _write("\n")
+    _write_rule(rule_label)
+    if type_tag and text:
+        _write(f"  {_c(_DIM + _GREEN, '(' + type_tag + ')')} {text}\n")
+    _hint_help = _c(_DIM, "'.help'")
+    _hint_c = _c(_DIM, "'.c'")
+    _write(f"  Type {_hint_help} for commands, {_hint_c} to resume.\n\n")
+
+    while True:
+        try:
+            line = input("execsql debug> ").strip()
+        except EOFError:
+            _write("\n")
+            return  # Ctrl-D → continue
+        except KeyboardInterrupt:
+            _write("\n")
+            return  # Ctrl-C → continue
+
+        if not line:
+            continue
+
+        # Dot-prefixed → REPL command
+        if line.startswith("."):
+            cmd = line[1:].strip().lower()
+            _handle_dot_command(line)
+            if cmd in ("continue", "c"):
+                return
+            if cmd in ("abort", "q", "quit"):
+                # _handle_dot_command already raised SystemExit, but guard anyway
+                return
+            if cmd in ("next", "n"):
+                return
+            continue
+
+        # SQL (ends with semicolon)
+        if line.rstrip().endswith(";"):
+            _run_sql(line)
+            continue
+
+        # Everything else → variable lookup
+        _print_var(line)
+
+
+def _handle_dot_command(line: str) -> None:
+    """Dispatch a dot-prefixed REPL command."""
+    # Strip the leading dot and normalize
+    cmd = line[1:].strip().lower()
+
+    if cmd in ("continue", "c"):
+        return  # caller checks and returns from _debug_repl
+    elif cmd in ("abort", "q", "quit"):
+        raise SystemExit(1)
+    elif cmd in ("help", "h"):
+        _write(_format_help())
+    elif cmd in ("vars all", "v all"):
+        _print_all_vars(include_env=True)
+    elif cmd in ("vars", "v"):
+        _print_all_vars()
+    elif cmd in ("where", "w"):
+        _print_where()
+    elif cmd == "stack":
+        _print_stack()
+    elif cmd in ("next", "n"):
+        _enable_step_mode()
+    elif cmd.startswith("set ") or cmd == "set":
+        # .set VAR VAL — set or update a substitution variable
+        rest = cmd[4:].strip() if cmd.startswith("set ") else ""
+        if not rest:
+            _write("  Usage: .set VAR VALUE\n")
+        else:
+            parts = rest.split(None, 1)
+            varname = parts[0]
+            value = parts[1] if len(parts) > 1 else ""
+            _set_var(varname, value)
+    elif cmd.startswith("s ") or cmd == "s":
+        # .s VAR VAL — shorthand for .set
+        rest = cmd[2:].strip() if cmd.startswith("s ") else ""
+        if not rest:
+            _write("  Usage: .s VAR VALUE\n")
+        else:
+            parts = rest.split(None, 1)
+            varname = parts[0]
+            value = parts[1] if len(parts) > 1 else ""
+            _set_var(varname, value)
+    else:
+        _write(f"  {_c(_RED, 'Unknown command:')} {line!r}. Type '.help' for available commands.\n")
+
+
+# ---------------------------------------------------------------------------
+# REPL command implementations
+# ---------------------------------------------------------------------------
+
+
+def _write(text: str) -> None:
+    """Write *text* to the execsql output stream (falls back to stdout)."""
+    output = _state.output
+    if output is not None:
+        output.write(text)
+    else:
+        sys.stdout.write(text)
+        sys.stdout.flush()
+
+
+def _print_where() -> None:
+    """Print the current script location and the upcoming statement.
+
+    Reads ``_state.last_command`` (a :class:`ScriptCmd`) and displays the
+    filename, line number, command type, and (truncated) statement text.
+    If ``last_command`` is ``None``, reports that the position is unknown.
+    """
+    lc = _state.last_command
+    if lc is None:
+        _write("  (position unknown)\n")
+        return
+    filename = Path(lc.source).name
+    location = f"{filename}:{lc.line_no}"
+    rule_label = f" {_c(_BOLD + _YELLOW, 'Location')} {_c(_DIM, '──')} {_c(_CYAN, location)} "
+    _write_rule(rule_label)
+    text = lc.command.commandline()
+    if len(text) > _WHERE_TRUNCATE:
+        text = text[:_WHERE_TRUNCATE] + "..."
+    _write(f"  {_c(_DIM + _GREEN, '(' + lc.command_type + ')')} {text}\n\n")
+
+
+def _print_all_vars(*, include_env: bool = False) -> None:
+    """Print substitution variables grouped by type."""
+    subvars = _state.subvars
+    if subvars is None:
+        _write("  (no substitution variables defined)\n\n")
+        return
+    items = subvars.substitutions  # list of (name, value) tuples
+    if not items:
+        _write("  (no substitution variables defined)\n\n")
+        return
+
+    # Group by prefix.
+    user_vars: list[tuple[str, str]] = []
+    system_vars: list[tuple[str, str]] = []
+    counter_vars: list[tuple[str, str]] = []
+    local_vars: list[tuple[str, str]] = []
+    env_vars: list[tuple[str, str]] = []
+
+    for name, value in sorted(items):
+        if name.startswith("&"):
+            env_vars.append((name, value))
+        elif name.startswith("~"):
+            local_vars.append((name, value))
+        elif name.startswith("@"):
+            counter_vars.append((name, value))
+        elif name.startswith("$"):
+            system_vars.append((name, value))
+        else:
+            user_vars.append((name, value))
+
+    _write_rule(f" {_c(_BOLD + _YELLOW, 'Variables')} ")
+
+    def _print_group(label: str, group: list[tuple[str, str]]) -> None:
+        if not group:
+            return
+        _write(f"  {_c(_BOLD, label)}:\n")
+        max_name = max(len(n) for n, _ in group)
+        for name, value in group:
+            _write(f"    {_c(_CYAN, name):<{max_name}}  {_c(_DIM, '=')}  {value}\n")
+
+    _print_group("User", user_vars)
+    _print_group("System ($)", system_vars)
+    _print_group("Local (~)", local_vars)
+    _print_group("Counter (@)", counter_vars)
+    if include_env:
+        _print_group("Environment (&)", env_vars)
+
+    if not any([user_vars, system_vars, local_vars, counter_vars]):
+        if env_vars:
+            _write("  (no script variables defined — use '.vars all' to see environment variables)\n")
+        else:
+            _write("  (no variables defined)\n")
+    _write("\n")
+
+
+def _print_var(varname: str) -> None:
+    """Print the value of a single substitution variable.
+
+    Tries the name as typed, then with the sigil prefix stripped.
+    """
+    subvars = _state.subvars
+    if subvars is None:
+        _write(f"  {varname}: (substitution variables not initialised)\n")
+        return
+    # Try the name as typed first, then without the sigil prefix ($, &, @, #, ~).
+    # SUB creates variables without a prefix (e.g., "logfile"), but users
+    # may type "$logfile" at the prompt.
+    value = subvars.varvalue(varname)
+    if value is None and len(varname) > 1 and varname[0] in "$&@#~":
+        value = subvars.varvalue(varname[1:])
+    if value is None:
+        _write(f"  {_c(_CYAN, varname)}: {_c(_DIM, '(undefined)')}\n")
+    else:
+        _write(f"  {_c(_CYAN, varname)} {_c(_DIM, '=')} {value}\n")
+
+
+def _print_stack() -> None:
+    """Print the current command-list stack (script name, line number, depth)."""
+    stack = _state.commandliststack
+    if not stack:
+        _write("  (command list stack is empty)\n\n")
+        return
+    _write_rule(f" {_c(_BOLD + _YELLOW, 'Stack')} ")
+    _write(f"  {_c(_DIM, 'depth:')} {len(stack)}\n")
+    for depth, cmdlist in enumerate(stack):
+        listname = getattr(cmdlist, "listname", "<unknown>")
+        cmdptr = getattr(cmdlist, "cmdptr", 0)
+        _write(f"  [{depth}] {listname}  {_c(_DIM, f'(cursor at index {cmdptr})')}\n")
+    _write("\n")
+
+
+def _run_sql(sql: str) -> None:
+    """Execute ad-hoc SQL against the current database and pretty-print the results."""
+    dbs = _state.dbs
+    if dbs is None:
+        _write("  (no database connection is active)\n")
+        return
+    db = dbs.current()
+    if db is None:
+        _write("  (no database connection is active)\n")
+        return
+    try:
+        colnames, rows = db.select_data(sql)
+    except Exception as exc:
+        _write(f"  {_c(_RED, 'SQL error:')} {exc}\n")
+        return
+
+    if not colnames:
+        _write("  (query returned no columns)\n")
+        return
+
+    # Build a simple text table.
+    col_widths = [len(c) for c in colnames]
+    str_rows: list[list[str]] = []
+    for row in rows:
+        str_row = ["NULL" if v is None else str(v) for v in row]
+        str_rows.append(str_row)
+        for i, cell in enumerate(str_row):
+            col_widths[i] = max(col_widths[i], len(cell))
+
+    sep = _c(_DIM, "+-" + "-+-".join("-" * w for w in col_widths) + "-+")
+    # Header: column names in bold
+    header_cells = " | ".join(_c(_BOLD, c.ljust(col_widths[i])) for i, c in enumerate(colnames))
+    header = _c(_DIM, "| ") + header_cells + _c(_DIM, " |")
+    _write("  " + sep + "\n")
+    _write("  " + header + "\n")
+    _write("  " + sep + "\n")
+    for str_row in str_rows:
+        cells = " | ".join(
+            _c(_DIM + _ITALIC, "NULL".ljust(col_widths[i])) if cell == "NULL" else cell.ljust(col_widths[i])
+            for i, cell in enumerate(str_row)
+        )
+        data_line = _c(_DIM, "| ") + cells + _c(_DIM, " |")
+        _write("  " + data_line + "\n")
+    _write("  " + sep + "\n")
+    row_word = "row" if len(str_rows) == 1 else "rows"
+    _write(f"  {_c(_DIM, f'({len(str_rows)} {row_word})')}\n")
+
+
+def _enable_step_mode() -> None:
+    """Activate step mode so the engine re-enters the REPL after the next statement."""
+    _state.step_mode = True
+
+
+def _set_var(varname: str, value: str) -> None:
+    """Set or update a substitution variable in the current session.
+
+    Args:
+        varname: The variable name (without sigil prefix for user variables).
+        value: The value to assign to the variable.
+    """
+    subvars = _state.subvars
+    if subvars is None:
+        _write("  Error: substitution variables are not initialised.\n")
+        return
+    subvars.add_substitution(varname, value)
+    _write(f"  {_c(_CYAN, varname)} {_c(_DIM, '=')} {value}\n")

execsql/metacommands/__init__.py

@@ -100,7 +100,7 @@ from execsql.metacommands.debug import (
     x_debug_write_subvars,
     x_debug_write_config,
 )
-from execsql.metacommands.debug_repl import x_breakpoint
+from execsql.debug.repl import x_breakpoint
 from execsql.metacommands.io import (
     x_export,
     x_export_query,

execsql/metacommands/dispatch.py

@@ -100,7 +100,7 @@ from execsql.metacommands.debug import (
     x_debug_write_odbc_drivers,
     x_debug_write_subvars,
 )
-from execsql.metacommands.debug_repl import x_breakpoint
+from execsql.debug.repl import x_breakpoint
 from execsql.metacommands.io import (
     x_cd,
     x_copy,

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,16 +507,16 @@ 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:
                 _state.step_mode = False
-                from execsql.metacommands.debug_repl import _debug_repl
+                from execsql.debug.repl import _debug_repl
 
-                _debug_repl()
+                _debug_repl(step=True)
             _profiling = _state.profile_data is not None
             if _profiling:
                 import time as _time
@@ -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:

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.11.1.dist-info → execsql2-2.12.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.11.1
+Version: 2.12.1
 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: Repository, https://github.com/geocoug/execsql
 Project-URL: Issues, https://github.com/geocoug/execsql/issues

{execsql2-2.11.1.dist-info → execsql2-2.12.1.dist-info}/RECORD

@@ -9,14 +9,14 @@ execsql/parser.py,sha256=mbNSMiAMR1NvNvFtQAZq6nxBOupMGJZXSimLWLtZeNs,15537
 execsql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 execsql/state.py,sha256=29b3SwG4GirED2KVQc-cCC7Z_-FsGN3fEt9xQNN-Puo,15090
 execsql/types.py,sha256=HVWb4umIB9lpxCGgqk3xy1hoGYPfN39xci5mHF0Izq4,31882
-execsql/cli/__init__.py,sha256=dPKq7KOY7soD1GfBEztoRWcKuDLY5QyhzgC6PuyeyII,16270
+execsql/cli/__init__.py,sha256=YXxOVF2lNkCkifXyjoC7yWrhHJFT9PzI7cnCzsLJwT8,16488
 execsql/cli/dsn.py,sha256=svaZtrUXFRL2W5G6FRRiKtR6kehOp7urrVhIx_642Z8,2820
 execsql/cli/help.py,sha256=Sn_TgSJiQeBx-xZH0fuP5OvR_wasSTumjWF9UHfIX5k,5414
 execsql/cli/lint.py,sha256=XWuVcEsheZ8ql48VFWqICWEkAUezB2nIePX6SUiKSg8,16109
-execsql/cli/run.py,sha256=eiD_5R2ZL8WzhbW78DBcoSbcibmOXcr3po_aYYSoPwg,30250
+execsql/cli/run.py,sha256=JGfndnBnJMkEqbz26pflhEdXDScZNIdGu6b6jTRLYl8,30681
 execsql/db/__init__.py,sha256=jTbuafuKOqYtXFR1wvCOoKK5Lr3l1uErfaIbIr6UywI,1063
 execsql/db/access.py,sha256=L79gUnAnnM9EJ_f4k42jr7DI0qGcKtLOnJTlBC7uPm0,17879
-execsql/db/base.py,sha256=hfMFj8fXY0T1aXLvWJHqb0aU4EQUDFOc-YrS29HH8U4,30405
+execsql/db/base.py,sha256=CPoWu8qrxCOcQ6nh2oLyoqaPfC0yDU8bTECW_lZV9Dc,30953
 execsql/db/dsn.py,sha256=TgQUedVCxnEYA3vae7JETyhb8kK23qkNbPxsMQrNUN8,5368
 execsql/db/duckdb.py,sha256=cKeMwiSlYPyPDn1VLaJgbUD6_IEEaNqtUToLcmq7QaE,3189
 execsql/db/factory.py,sha256=YR1m_c2Hhj_GXVGGkWoSEPZBpgNu_c4FxRnbp-xV3rs,5230
@@ -26,6 +26,8 @@ execsql/db/oracle.py,sha256=AFVHhGlCzBuU7JgrAqeUG6e8TUUkk1Y80XVJQnGOqLM,10547
 execsql/db/postgres.py,sha256=oXR7ODzQhR3yO6q-aNa9_il_rO3SpOX9yYGsfIqHwLI,20139
 execsql/db/sqlite.py,sha256=2fD3AfckIGWN1oHcOaqQlQnbig26top1IlW-ejPHttI,10204
 execsql/db/sqlserver.py,sha256=mNwmIIxTzqXU-cOjpNpeFi568HjQHsAk8Xnn-tR6F_E,7563
+execsql/debug/__init__.py,sha256=j6EGUR0dHzUhWN1mHHtf1-Lhjq3Sb1V-vmnq2Ztgj1M,178
+execsql/debug/repl.py,sha256=HeQ9emFKUjo7UTouxuTcmpGCTJIR1nOLxKkRJ5mvd2c,16669
 execsql/exporters/__init__.py,sha256=-Cnji-OgodJV8ftcDcOyTof0kQMy9J5kKVC8GVFpc3o,670
 execsql/exporters/base.py,sha256=W9USFyk_2eztjJ51X6CJh7-chE1i3cSx-STOtbHXCNI,6373
 execsql/exporters/delimited.py,sha256=zMvurTRVl5W-6N8DuYtn_xILUkYLMlfflwWMfvdeaF0,30304
@@ -59,14 +61,13 @@ execsql/importers/csv.py,sha256=Mu848WNzuhVO1ade-WurPyxqGOuVNRO8UwRF3-bav_I,4845
 execsql/importers/feather.py,sha256=g2B69d2uv9vmnXcmjFyTVsMP40LYEzFYkhk3gD26mGw,1900
 execsql/importers/ods.py,sha256=MJsdsjropzCvxAA3DDZfAL_AnmZ4yij7DnrjGyDJqHQ,2843
 execsql/importers/xls.py,sha256=e0Zfe47ZiCpA1Ae3XDJ1ko3sCiH3-8U6XLKi6NvD0jQ,3683
-execsql/metacommands/__init__.py,sha256=TT1ARHgHltHqZ7qx4Y62o1h_GOPvUztZKCem-wAE560,11215
+execsql/metacommands/__init__.py,sha256=EmYUZZq1oaubbSQ26-8F9jJI_JnOJ2R697NeossXF1Q,11202
 execsql/metacommands/conditions.py,sha256=Fzrk83-pWbFOoKahYdQW7CZjQeh3zByDUbfgpTM_bjQ,29259
 execsql/metacommands/connect.py,sha256=Nsm0D91i3RX-R2rzQQ-Br-gULaI6Uvdn9fqb7DOAVfE,14804
 execsql/metacommands/control.py,sha256=xNHyTrYUM042OgDarNq7HxslY7JuQs-KOKcb-fHUngM,8510
 execsql/metacommands/data.py,sha256=tRQBGTAuW-eJ2tBNWaoZI9OjTyNNyHJISo7gOdL-sm8,11370
 execsql/metacommands/debug.py,sha256=pnT24dfvfOx8xFu86mO5czfVCGKbcvgBLyXnqaMWO4w,8184
-execsql/metacommands/debug_repl.py,sha256=XQ09I7HI-drVjfIg4XqsPndvAmZSxpSmXVKjWjLqwE4,9785
-execsql/metacommands/dispatch.py,sha256=1Mae6yqrea6wViFLBsvVt33Zgx4xP8tnhOuB_aQC89c,84054
+execsql/metacommands/dispatch.py,sha256=OQwLOo9XT3N9C96wsRt0zmu1Nn4HL-7cSBOsGCfp5V4,84041
 execsql/metacommands/io.py,sha256=Duh60caM4go9JczbGYNMKKYpcMimwPzF6EQ_tshKxdE,2971
 execsql/metacommands/io_export.py,sha256=7lkCSnPhXy9FVau9_hT1u68NOVdG2DsWmvUh9hM1QWI,18359
 execsql/metacommands/io_fileops.py,sha256=RKqbWPTYiwiqCZYG-lpih0w1JVOY4RBFdWr3BJb_pnY,9669
@@ -77,8 +78,8 @@ execsql/metacommands/script_ext.py,sha256=TUgAldB2LSJAwZrCvDDi804hQ1d9BDQD2GDqHN
 execsql/metacommands/system.py,sha256=sUR5kLL7idTVg8WXIMdd-Kv7nkERIiaeL0beWsz8NyY,7293
 execsql/script/__init__.py,sha256=pIo0EJ7-vg67rSMbOvbri_BOUgLoGoSEUfJgxUN7ZS0,3380
 execsql/script/control.py,sha256=s-1eZdGARM6H1FwZ6VDdO_f50j7bvvRtTHesfUm9tbc,6144
-execsql/script/engine.py,sha256=1_3qMn6a1nD4oYBBRNlwMU_YwZ4f2Om6-CjUGksJT4A,41087
-execsql/script/variables.py,sha256=MOT9XEHucpuuuHQZM5bklxGMBQcwHzwTBxd0q3aO0XY,11641
+execsql/script/engine.py,sha256=1qcWGfXPRqDd48PQwEbHmCO1eN4YYrQrS-0QUQb270g,41694
+execsql/script/variables.py,sha256=mklG20WPhfv1mmqSVoRQHrzZvGN7ne_bqvRd0PMx5ss,10388
 execsql/utils/__init__.py,sha256=0uR6JwVJQRX3vceByNBduCAf5dd5assKjeqJUWvpZoA,278
 execsql/utils/auth.py,sha256=onXzNkNZQZxGC5w7eey06sjvAIAX_Lf9g7nUJtcsel0,7009
 execsql/utils/crypto.py,sha256=2OnBWwn9bCBGc1ZkyRv16TvhottoCNYtXqgbE3mG3Sg,2960
@@ -91,24 +92,24 @@ execsql/utils/numeric.py,sha256=xh02ANSRk3nUpQ-rtm66ILoMqoi7HtzCoRMIOT9U8QI,1570
 execsql/utils/regex.py,sha256=diEzTZqU_HHwVMadPAvN1Vgzhl7I03eVaEFGCXyGGL8,3770
 execsql/utils/strings.py,sha256=5Dvzrk-9SIw2lpxXZQkiJbNyo1sy7iXXAtSULlZ0KG8,8488
 execsql/utils/timer.py,sha256=eDYf5VzCNFk7oo90InJucUm3XcBdhYMogjZMqeg9xzc,1899
-execsql2-2.11.1.data/data/execsql2_extras/README.md,sha256=sxwVyU0ZahCfANv56LahkyuM505kFjrMhe-1SvWE69E,4845
-execsql2-2.11.1.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
-execsql2-2.11.1.data/data/execsql2_extras/example_config_prompt.sql,sha256=SY3Jxn1qcVm4kPW9xmmTfknHfvURXmeEYTbRjYrjGSw,7487
-execsql2-2.11.1.data/data/execsql2_extras/execsql.conf,sha256=_45iJ-KWZnB8uMW_gEg067MM5pmGJ-dVl7VbAZMunAE,9530
-execsql2-2.11.1.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
-execsql2-2.11.1.data/data/execsql2_extras/md_compare.sql,sha256=B8Wd7LZ0vnMY2qvA139JIEBkPObgRH2i5xj6PejTQt8,24092
-execsql2-2.11.1.data/data/execsql2_extras/md_glossary.sql,sha256=DJRHcU5NbFpxTTX-IwH3yRlsboj1q6BBGrUAHKn4Cuo,10796
-execsql2-2.11.1.data/data/execsql2_extras/md_upsert.sql,sha256=v_7GbWh_N1mBTmw3gvTrkagOVp2q0KmXvM8hE-DlFxY,112524
-execsql2-2.11.1.data/data/execsql2_extras/pg_compare.sql,sha256=9dWa8hnfy5dVJI-z2iGpd9JzQmI4j2ziMlEdpnr66ro,24352
-execsql2-2.11.1.data/data/execsql2_extras/pg_glossary.sql,sha256=pKjIIDsROAgJq2H-1qNEcRMAWManivcZ_AEVHzUUlic,9908
-execsql2-2.11.1.data/data/execsql2_extras/pg_upsert.sql,sha256=k7AFiGTLBy3nf-qO5QIaZrEYTAKvdxxU3JDLx9jqkzs,108315
-execsql2-2.11.1.data/data/execsql2_extras/script_template.sql,sha256=1Estacb_vm1FgK41k_G9nuduP1yiA-fQ1Kn4Z4mv5Ao,11153
-execsql2-2.11.1.data/data/execsql2_extras/ss_compare.sql,sha256=TsVxWm3cEpR5-EiMYXNhtaY0arSNeKZhsJdHdLA7xeI,24833
-execsql2-2.11.1.data/data/execsql2_extras/ss_glossary.sql,sha256=cLM7nN8JOIu9ZVP9oY9qdSK3hrnWJiDcX6nZmQQbQWI,13065
-execsql2-2.11.1.data/data/execsql2_extras/ss_upsert.sql,sha256=BCqmBykXBF-BpCgOFeG1qhf2XfScKsxPD17wd1hYfHw,120647
-execsql2-2.11.1.dist-info/METADATA,sha256=cGmNeSCzZvJFmoCzDbMs_M3MjYP6YCZgQF0vNpIknVk,17381
-execsql2-2.11.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-execsql2-2.11.1.dist-info/entry_points.txt,sha256=sUOxkM-dN1eBGGpSpDLsAaE0yNXYQKWZAfxPOlMkQyk,90
-execsql2-2.11.1.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
-execsql2-2.11.1.dist-info/licenses/NOTICE,sha256=sqVrM73Ys9zfvWC_P797lHfTnoPW_ETeBSrUTFaob0A,339
-execsql2-2.11.1.dist-info/RECORD,,
+execsql2-2.12.1.data/data/execsql2_extras/README.md,sha256=sxwVyU0ZahCfANv56LahkyuM505kFjrMhe-1SvWE69E,4845
+execsql2-2.12.1.data/data/execsql2_extras/config_settings.sqlite,sha256=aY5cxR7Q7J6zJ4bC9lu5mHUrhy211Cq3MNKPQVCt02E,20480
+execsql2-2.12.1.data/data/execsql2_extras/example_config_prompt.sql,sha256=SY3Jxn1qcVm4kPW9xmmTfknHfvURXmeEYTbRjYrjGSw,7487
+execsql2-2.12.1.data/data/execsql2_extras/execsql.conf,sha256=_45iJ-KWZnB8uMW_gEg067MM5pmGJ-dVl7VbAZMunAE,9530
+execsql2-2.12.1.data/data/execsql2_extras/make_config_db.sql,sha256=WwyC6dK-Eh5CAVppiBCDHqiI1_wEI9U95Ytpr4lsZkg,8726
+execsql2-2.12.1.data/data/execsql2_extras/md_compare.sql,sha256=B8Wd7LZ0vnMY2qvA139JIEBkPObgRH2i5xj6PejTQt8,24092
+execsql2-2.12.1.data/data/execsql2_extras/md_glossary.sql,sha256=DJRHcU5NbFpxTTX-IwH3yRlsboj1q6BBGrUAHKn4Cuo,10796
+execsql2-2.12.1.data/data/execsql2_extras/md_upsert.sql,sha256=v_7GbWh_N1mBTmw3gvTrkagOVp2q0KmXvM8hE-DlFxY,112524
+execsql2-2.12.1.data/data/execsql2_extras/pg_compare.sql,sha256=9dWa8hnfy5dVJI-z2iGpd9JzQmI4j2ziMlEdpnr66ro,24352
+execsql2-2.12.1.data/data/execsql2_extras/pg_glossary.sql,sha256=pKjIIDsROAgJq2H-1qNEcRMAWManivcZ_AEVHzUUlic,9908
+execsql2-2.12.1.data/data/execsql2_extras/pg_upsert.sql,sha256=k7AFiGTLBy3nf-qO5QIaZrEYTAKvdxxU3JDLx9jqkzs,108315
+execsql2-2.12.1.data/data/execsql2_extras/script_template.sql,sha256=1Estacb_vm1FgK41k_G9nuduP1yiA-fQ1Kn4Z4mv5Ao,11153
+execsql2-2.12.1.data/data/execsql2_extras/ss_compare.sql,sha256=TsVxWm3cEpR5-EiMYXNhtaY0arSNeKZhsJdHdLA7xeI,24833
+execsql2-2.12.1.data/data/execsql2_extras/ss_glossary.sql,sha256=cLM7nN8JOIu9ZVP9oY9qdSK3hrnWJiDcX6nZmQQbQWI,13065
+execsql2-2.12.1.data/data/execsql2_extras/ss_upsert.sql,sha256=BCqmBykXBF-BpCgOFeG1qhf2XfScKsxPD17wd1hYfHw,120647
+execsql2-2.12.1.dist-info/METADATA,sha256=AKqGpfB4EU_8T-tJuyMs_r4oetvStQof5j-h34cRScQ,17381
+execsql2-2.12.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+execsql2-2.12.1.dist-info/entry_points.txt,sha256=sUOxkM-dN1eBGGpSpDLsAaE0yNXYQKWZAfxPOlMkQyk,90
+execsql2-2.12.1.dist-info/licenses/LICENSE.txt,sha256=LBdhuxejF8_bLCHZ2kWfmDXpDGUu914Gbd6_3JjCRe0,676
+execsql2-2.12.1.dist-info/licenses/NOTICE,sha256=sqVrM73Ys9zfvWC_P797lHfTnoPW_ETeBSrUTFaob0A,339
+execsql2-2.12.1.dist-info/RECORD,,

execsql/metacommands/debug_repl.py

@@ -1,289 +0,0 @@
-from __future__ import annotations
-
-"""
-Interactive debug REPL metacommand handler for execsql.
-
-Implements ``x_breakpoint`` — the ``BREAKPOINT`` metacommand — which pauses
-script execution and drops into an interactive read-eval-print loop.
-
-The REPL allows the user to:
-
-- Inspect and print substitution variables.
-- Run ad-hoc SQL queries against the current database.
-- Step through the script one statement at a time.
-- Resume or abort execution.
-
-All REPL commands are dot-prefixed (``.continue``, ``.vars``, ``.next``)
-to avoid ambiguity with variable names and SQL.  Anything not starting
-with ``.`` is treated as either a variable lookup (if it matches a known
-variable) or SQL (if it ends with ``;``).
-
-In non-interactive environments (CI, piped input, ``sys.stdin.isatty()`` is
-``False``) the metacommand is silently skipped so automated pipelines are not
-blocked.
-"""
-
-import sys
-from typing import Any
-
-import execsql.state as _state
-
-__all__ = ["x_breakpoint"]
-
-# ---------------------------------------------------------------------------
-# Public handler
-# ---------------------------------------------------------------------------
-
-_HELP_TEXT = """\
-execsql debug REPL — all commands start with '.'
-
-  .continue  .c       Resume script execution
-  .abort     .q       Halt the script (exit 1)
-  .vars               List user, system, local, and counter variables
-  .vars all           Include environment variables (&) in the listing
-  .next      .n       Execute the next statement then pause again (step mode)
-  .stack              Show the command-list stack (script name, line, depth)
-  .help               Show this help text
-
-Everything else:
-  varname             Print a variable's value (e.g. logfile, $ARG_1, &HOME)
-  SELECT ...;         Run ad-hoc SQL against the current database
-"""
-
-
-def x_breakpoint(**kwargs: Any) -> None:
-    """Pause execution and enter the interactive debug REPL.
-
-    If ``sys.stdin`` is not a TTY (CI, piped input), the metacommand is
-    silently skipped — scripts will not hang in automation.
-
-    Args:
-        **kwargs: Keyword arguments injected by the dispatch table (unused).
-    """
-    if not sys.stdin.isatty():
-        return
-    _debug_repl()
-
-
-# ---------------------------------------------------------------------------
-# REPL core
-# ---------------------------------------------------------------------------
-
-
-def _debug_repl() -> None:
-    """Interactive read-eval-print loop for script debugging.
-
-    Reads commands from stdin until the user types ``.continue`` or ``.abort``,
-    or until EOF / KeyboardInterrupt.
-    """
-    try:
-        import readline as _readline  # noqa: F401 — side-effect: enables history/arrow keys
-    except ImportError:
-        pass  # readline not available on Windows; continue without it
-
-    _write("\n[Breakpoint] Script paused. Type '.help' for commands, '.c' to resume.\n")
-
-    while True:
-        try:
-            line = input("execsql debug> ").strip()
-        except EOFError:
-            _write("\n")
-            return  # Ctrl-D → continue
-        except KeyboardInterrupt:
-            _write("\n")
-            return  # Ctrl-C → continue
-
-        if not line:
-            continue
-
-        # Dot-prefixed → REPL command
-        if line.startswith("."):
-            cmd = line[1:].strip().lower()
-            _handle_dot_command(line)
-            if cmd in ("continue", "c"):
-                return
-            if cmd in ("abort", "q", "quit"):
-                # _handle_dot_command already raised SystemExit, but guard anyway
-                return
-            if cmd in ("next", "n"):
-                return
-            continue
-
-        # SQL (ends with semicolon)
-        if line.rstrip().endswith(";"):
-            _run_sql(line)
-            continue
-
-        # Everything else → variable lookup
-        _print_var(line)
-
-
-def _handle_dot_command(line: str) -> None:
-    """Dispatch a dot-prefixed REPL command."""
-    # Strip the leading dot and normalize
-    cmd = line[1:].strip().lower()
-
-    if cmd in ("continue", "c"):
-        return  # caller checks and returns from _debug_repl
-    elif cmd in ("abort", "q", "quit"):
-        raise SystemExit(1)
-    elif cmd == "help":
-        _write(_HELP_TEXT)
-    elif cmd == "vars all":
-        _print_all_vars(include_env=True)
-    elif cmd == "vars":
-        _print_all_vars()
-    elif cmd == "stack":
-        _print_stack()
-    elif cmd in ("next", "n"):
-        _enable_step_mode()
-    else:
-        _write(f"  Unknown command: {line!r}. Type '.help' for available commands.\n")
-
-
-# ---------------------------------------------------------------------------
-# REPL command implementations
-# ---------------------------------------------------------------------------
-
-
-def _write(text: str) -> None:
-    """Write *text* to the execsql output stream (falls back to stdout)."""
-    output = _state.output
-    if output is not None:
-        output.write(text)
-    else:
-        sys.stdout.write(text)
-        sys.stdout.flush()
-
-
-def _print_all_vars(*, include_env: bool = False) -> None:
-    """Print substitution variables grouped by type."""
-    subvars = _state.subvars
-    if subvars is None:
-        _write("  (no substitution variables defined)\n")
-        return
-    items = subvars.substitutions  # list of (name, value) tuples
-    if not items:
-        _write("  (no substitution variables defined)\n")
-        return
-
-    # Group by prefix.
-    user_vars: list[tuple[str, str]] = []
-    system_vars: list[tuple[str, str]] = []
-    counter_vars: list[tuple[str, str]] = []
-    local_vars: list[tuple[str, str]] = []
-    env_vars: list[tuple[str, str]] = []
-
-    for name, value in sorted(items):
-        if name.startswith("&"):
-            env_vars.append((name, value))
-        elif name.startswith("~"):
-            local_vars.append((name, value))
-        elif name.startswith("@"):
-            counter_vars.append((name, value))
-        elif name.startswith("$"):
-            system_vars.append((name, value))
-        else:
-            user_vars.append((name, value))
-
-    def _print_group(label: str, group: list[tuple[str, str]]) -> None:
-        if not group:
-            return
-        _write(f"  {label}:\n")
-        max_name = max(len(n) for n, _ in group)
-        for name, value in group:
-            _write(f"    {name:<{max_name}}  =  {value}\n")
-
-    _print_group("User variables", user_vars)
-    _print_group("System variables ($)", system_vars)
-    _print_group("Local variables (~)", local_vars)
-    _print_group("Counter variables (@)", counter_vars)
-    if include_env:
-        _print_group("Environment variables (&)", env_vars)
-
-    if not any([user_vars, system_vars, local_vars, counter_vars]):
-        if env_vars:
-            _write("  (no script variables defined — use '.vars all' to see environment variables)\n")
-        else:
-            _write("  (no variables defined)\n")
-
-
-def _print_var(varname: str) -> None:
-    """Print the value of a single substitution variable.
-
-    Tries the name as typed, then with the sigil prefix stripped.
-    """
-    subvars = _state.subvars
-    if subvars is None:
-        _write(f"  {varname}: (substitution variables not initialised)\n")
-        return
-    # Try the name as typed first, then without the sigil prefix ($, &, @, #, ~).
-    # SUB creates variables without a prefix (e.g., "logfile"), but users
-    # may type "$logfile" at the prompt.
-    value = subvars.varvalue(varname)
-    if value is None and len(varname) > 1 and varname[0] in "$&@#~":
-        value = subvars.varvalue(varname[1:])
-    if value is None:
-        _write(f"  {varname}: (undefined)\n")
-    else:
-        _write(f"  {varname} = {value}\n")
-
-
-def _print_stack() -> None:
-    """Print the current command-list stack (script name, line number, depth)."""
-    stack = _state.commandliststack
-    if not stack:
-        _write("  (command list stack is empty)\n")
-        return
-    _write(f"  Stack depth: {len(stack)}\n")
-    for depth, cmdlist in enumerate(stack):
-        listname = getattr(cmdlist, "listname", "<unknown>")
-        cmdptr = getattr(cmdlist, "cmdptr", 0)
-        _write(f"  [{depth}] {listname}  (cursor at index {cmdptr})\n")
-
-
-def _run_sql(sql: str) -> None:
-    """Execute ad-hoc SQL against the current database and pretty-print the results."""
-    dbs = _state.dbs
-    if dbs is None:
-        _write("  (no database connection is active)\n")
-        return
-    db = dbs.current()
-    if db is None:
-        _write("  (no database connection is active)\n")
-        return
-    try:
-        colnames, rows = db.select_data(sql)
-    except Exception as exc:
-        _write(f"  SQL error: {exc}\n")
-        return
-
-    if not colnames:
-        _write("  (query returned no columns)\n")
-        return
-
-    # Build a simple text table.
-    col_widths = [len(c) for c in colnames]
-    str_rows: list[list[str]] = []
-    for row in rows:
-        str_row = [str(v) if v is not None else "NULL" for v in row]
-        str_rows.append(str_row)
-        for i, cell in enumerate(str_row):
-            col_widths[i] = max(col_widths[i], len(cell))
-
-    sep = "+-" + "-+-".join("-" * w for w in col_widths) + "-+"
-    header = "| " + " | ".join(c.ljust(col_widths[i]) for i, c in enumerate(colnames)) + " |"
-    _write(sep + "\n")
-    _write(header + "\n")
-    _write(sep + "\n")
-    for str_row in str_rows:
-        data_line = "| " + " | ".join(cell.ljust(col_widths[i]) for i, cell in enumerate(str_row)) + " |"
-        _write(data_line + "\n")
-    _write(sep + "\n")
-    row_word = "row" if len(str_rows) == 1 else "rows"
-    _write(f"  ({len(str_rows)} {row_word})\n")
-
-
-def _enable_step_mode() -> None:
-    """Activate step mode so the engine re-enters the REPL after the next statement."""
-    _state.step_mode = True