execsql2 2.23.1__py3-none-any.whl → 2.25.0__py3-none-any.whl

execsql/manifest.py

@@ -0,0 +1,200 @@
+"""The run manifest: a JSON record of one ``execsql run``, for ``--manifest FILE``.
+
+The manifest says what a run did — the script, the database, how many
+statements ran, the files it read, wrote and deleted, the connections it
+opened, and how it ended — in a form an orchestrator or an audit can read
+without parsing the log. It is written when the run ends, whether it
+succeeded, failed or was cancelled.
+
+Files are recorded as the executor runs each metacommand, after variable
+substitution, so paths are the ones actually used. What a metacommand touches
+is decided by :mod:`execsql.metacommands.effects`. Variable values and passwords are never written:
+the run log hides ``-a`` and ``--var`` values because they can be secrets, and
+the manifest lists only their names.
+
+One recorder is active per run; :func:`current` returns it, or ``None`` when
+no manifest was asked for, so the executor's hooks cost one check. Writing the
+manifest ends the recording, so a later run in the same process starts clean.
+"""
+
+from __future__ import annotations
+
+import atexit
+import datetime
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+from typing import Any
+
+from execsql import __version__
+
+__all__ = ["RunManifest", "check_writable", "current", "start"]
+
+
+def current() -> RunManifest | None:
+    """The active run's manifest recorder, or ``None`` when ``--manifest`` was not given.
+
+    Held on the run's :class:`~execsql.state.RuntimeContext`, so a library
+    ``execsql.run()`` in the same process never records into a CLI manifest.
+    """
+    import execsql.state as _state
+
+    return _state.manifest
+
+
+def check_writable(path: str) -> str | None:
+    """Why a manifest cannot be written to *path*, or ``None`` if it can.
+
+    Checked before a run starts, so a bad ``--manifest`` path fails before any
+    SQL runs rather than after.
+    """
+    target = Path(path)
+    if target.is_dir():
+        return f"{path} is a directory"
+    try:
+        target.parent.mkdir(parents=True, exist_ok=True)
+        fd, probe = tempfile.mkstemp(dir=target.parent, prefix=f".{target.name}.", suffix=".tmp")
+        os.close(fd)
+        os.unlink(probe)
+    except OSError as exc:
+        return exc.strerror or str(exc)
+    return None
+
+
+def start(path: str, script: str | None, variables: list[str]) -> RunManifest:
+    """Begin recording a run; the manifest is written to *path* when it ends.
+
+    If nothing else writes it (``exit_now`` on an error, the end of a run), an
+    ``atexit`` fallback does.
+    """
+    import execsql.state as _state
+
+    manifest = RunManifest(path, script, variables)
+    _state.manifest = manifest
+    atexit.register(manifest.finish, None)
+    return manifest
+
+
+def _now() -> datetime.datetime:
+    return datetime.datetime.now(tz=datetime.timezone.utc)
+
+
+class RunManifest:
+    """Collects what one run does and writes it as JSON when the run ends."""
+
+    def __init__(self, path: str, script: str | None, variables: list[str]) -> None:
+        self.path = Path(path)
+        self.script = script or "<inline>"
+        self.variables = variables
+        self.started = _now()
+        self.config_files: list[str] = []
+        self.database: dict[str, Any] | None = None
+        self.sql_statements = 0
+        self.metacommands = 0
+        self.reads: list[dict[str, Any]] = []
+        self.writes: list[dict[str, Any]] = []
+        self.deletes: list[dict[str, Any]] = []
+        self.connections: list[dict[str, Any]] = []
+        self.errors: list[dict[str, Any]] = []
+        self.written = False
+
+    # -- recording -------------------------------------------------------------
+
+    def set_database(self, db: Any) -> None:
+        """Record the initial connection: DBMS, server, database or file, user — no password."""
+        self.database = {
+            "dbms": db.type.dbms_id if getattr(db, "type", None) else None,
+            "server": getattr(db, "server_name", None),
+            "database": getattr(db, "db_name", None),
+            "user": getattr(db, "user", None),
+        }
+
+    def record_sql(self) -> None:
+        self.sql_statements += 1
+
+    def record_metacommand(self, command: str, source: str, line: int, metacommandlist: Any) -> None:
+        """Count a metacommand that ran, and record the files and connections it touched.
+
+        *command* is the text after substitution, so paths are the ones used.
+        """
+        from execsql.metacommands.effects import effects
+
+        self.metacommands += 1
+        hit = metacommandlist.get_match(command)
+        if hit is None:
+            return
+        mc, m = hit
+        by = mc.description or command.split(None, 1)[0].upper()
+        for effect in effects(mc.exec_fn.__name__, m.groupdict()):
+            entry = {"source": source, "line": line, "by": by}
+            if effect.role in ("connect", "use"):
+                self.connections.append(
+                    {**entry, "by": effect.role.upper(), "target": effect.target, "detail": effect.detail},
+                )
+            else:
+                {"read": self.reads, "write": self.writes, "delete": self.deletes}[effect.role].append(
+                    {**entry, "path": effect.target},
+                )
+
+    def record_include(self, path: str, source: str, line: int) -> None:
+        self.reads.append({"source": source, "line": line, "by": "INCLUDE", "path": path})
+
+    # -- finishing -------------------------------------------------------------
+
+    def add_error(self, error: Any) -> None:
+        """Record *error* (an :class:`ErrInfo`) in the manifest's ``errors``."""
+        # str(ErrInfo) is its concise message; errmsg() is the multi-line
+        # console block with a timestamp, which a reader of JSON does not want.
+        self.errors.append(
+            {
+                "message": " ".join(str(error).split()),
+                "type": getattr(error, "type", None),
+                "source": getattr(error, "script_file", None),
+                "line": getattr(error, "script_line_no", None),
+                "command": getattr(error, "cmd", None) or getattr(error, "command", None),
+            },
+        )
+
+    def finish(self, exit_status: int | None, error: Any = None) -> None:
+        """Write the manifest once. Later calls (the atexit fallback) do nothing."""
+        if self.written:
+            return
+        if error is not None:
+            self.add_error(error)
+        finished = _now()
+        data = {
+            "execsql_version": __version__,
+            "script": self.script,
+            "started": self.started.isoformat(timespec="seconds"),
+            "finished": finished.isoformat(timespec="seconds"),
+            "duration_s": round((finished - self.started).total_seconds(), 3),
+            "exit_status": exit_status,
+            "config_files": self.config_files,
+            "database": self.database,
+            "variables": self.variables,
+            "statements": {"sql": self.sql_statements, "metacommands": self.metacommands},
+            "files_read": self.reads,
+            "files_written": self.writes,
+            "files_deleted": self.deletes,
+            "connections": self.connections,
+            "errors": self.errors,
+        }
+        self.written = True
+        import execsql.state as _state
+
+        if _state.manifest is self:
+            _state.manifest = None
+        atexit.unregister(self.finish)
+        try:
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            # Write beside the target and rename, so a reader never sees half a file.
+            fd, tmp = tempfile.mkstemp(dir=self.path.parent, prefix=f".{self.path.name}.", suffix=".tmp")
+            with os.fdopen(fd, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, default=str)
+                f.write("\n")
+            os.replace(tmp, self.path)
+        except OSError as exc:
+            # The run itself is over; report the lost manifest without a traceback.
+            sys.stderr.write(f"execsql: could not write --manifest {self.path}: {exc.strerror or exc}\n")

execsql/metacommands/conditions.py

@@ -22,7 +22,7 @@ registration time for quoted, unquoted, and bracketed arguments):
   ``xf_row_count_eq``, ``xf_row_count_lt``.
 - Runtime state: ``xf_sqlerror``, ``xf_dialogcanceled``, ``xf_dbms``.
 
-The full list is also surfaced by ``execsql --dump-keywords``.
+The full list is also surfaced by ``execsql list keywords``.
 """
 
 import os
@@ -100,12 +100,11 @@ def xf_hasrows(**kwargs: Any) -> bool:
     return bool(nrows > 0)
 
 
-def _row_count(queryname: str, sql_context: str, metacommandline: str) -> int:
+def _row_count(queryname: str, metacommandline: str) -> int:
     """Return the number of rows in *queryname*, raising ErrInfo on failure.
 
     Args:
         queryname: Table or view name to count rows in.
-        sql_context: The SQL string to include in error messages.
         metacommandline: The full metacommand line for error context.
 
     Returns:
@@ -167,7 +166,7 @@ def xf_row_count_gt(**kwargs: Any) -> bool:
     queryname = kwargs["queryname"]
     mcl = kwargs["metacommandline"]
     n = _parse_row_count_n(kwargs["n"], mcl)
-    return _row_count(queryname, f"select count(*) from {queryname};", mcl) > n
+    return _row_count(queryname, mcl) > n
 
 
 def xf_row_count_gte(**kwargs: Any) -> bool:
@@ -183,7 +182,7 @@ def xf_row_count_gte(**kwargs: Any) -> bool:
     queryname = kwargs["queryname"]
     mcl = kwargs["metacommandline"]
     n = _parse_row_count_n(kwargs["n"], mcl)
-    return _row_count(queryname, f"select count(*) from {queryname};", mcl) >= n
+    return _row_count(queryname, mcl) >= n
 
 
 def xf_row_count_eq(**kwargs: Any) -> bool:
@@ -199,7 +198,7 @@ def xf_row_count_eq(**kwargs: Any) -> bool:
     queryname = kwargs["queryname"]
     mcl = kwargs["metacommandline"]
     n = _parse_row_count_n(kwargs["n"], mcl)
-    return _row_count(queryname, f"select count(*) from {queryname};", mcl) == n
+    return _row_count(queryname, mcl) == n
 
 
 def xf_row_count_lt(**kwargs: Any) -> bool:
@@ -215,7 +214,7 @@ def xf_row_count_lt(**kwargs: Any) -> bool:
     queryname = kwargs["queryname"]
     mcl = kwargs["metacommandline"]
     n = _parse_row_count_n(kwargs["n"], mcl)
-    return _row_count(queryname, f"select count(*) from {queryname};", mcl) < n
+    return _row_count(queryname, mcl) < n
 
 
 def xf_sqlerror(**kwargs: Any) -> bool:
@@ -428,7 +427,7 @@ def xf_newer_date(**kwargs: Any) -> bool:
     datestr = unquoted(kwargs["datestr"])
     if not Path(file1).exists():
         raise ErrInfo(type="cmd", other_msg=f"File {file1} does not exist.")
-    dt_value = parse_datetime(datestr)
+    dt_value = parse_datetime(datestr, strict=False)
     if not dt_value:
         raise ErrInfo(type="cmd", other_msg=f"{datestr} can't be interpreted as a date/time.")
     return os.stat(file1).st_mtime > time.mktime(dt_value.timetuple())

execsql/metacommands/control.py

@@ -77,9 +77,8 @@ def x_assert(**kwargs: Any) -> None:
 def _ast_only_stub(name: str):
     """Return an ErrInfo for a metacommand the AST executor handles structurally.
 
-    These handlers stay registered in the dispatch table so ``--dump-keywords``,
-    the VS Code grammar generator, and ``--list-keywords`` still see the
-    keyword.  The AST parser converts the source form (``IF`` / ``ENDIF`` /
+    These handlers stay registered in the dispatch table so ``execsql list
+    keywords`` and the VS Code grammar generator still see the keyword.  The AST parser converts the source form (``IF`` / ``ENDIF`` /
     ``LOOP`` / ``BEGIN BATCH`` / ``BREAK`` / ``ELSE`` / ``ELSEIF`` / ``ANDIF``
     / ``ORIF``) into structural AST nodes that the executor walks directly —
     none of these dispatch handlers fire for parsed scripts.  Reaching one

execsql/metacommands/data.py

@@ -36,6 +36,7 @@ from execsql.parser import NumericParser
 from execsql.script import current_script_line
 from execsql.utils.crypto import Encrypt
 from execsql.utils.errors import exception_desc, exit_now
+from execsql.utils.fileio import register_secret
 from execsql.utils.gui import GUI_SELECTSUB, GuiSpec, enable_gui
 from execsql.utils.strings import get_subvarset, unquoted
 
@@ -126,7 +127,9 @@ def x_sub_encrypt(**kwargs: Any) -> None:
 def x_sub_decrypt(**kwargs: Any) -> None:
     varname = kwargs["match"]
     subvarset, varname = get_subvarset(varname, kwargs["metacommandline"])
-    subvarset.add_substitution(varname, Encrypt().decrypt(kwargs["crypttext"]))
+    plaintext = Encrypt().decrypt(kwargs["crypttext"])
+    register_secret(plaintext)
+    subvarset.add_substitution(varname, plaintext)
     return None
 
 

execsql/metacommands/debug.py

@@ -52,10 +52,8 @@ def x_debug_commandliststack(**kwargs: Any) -> None:
     ``<main>`` script, ``EXECUTE SCRIPT`` calls, ``INCLUDE``'d files,
     ``IF``/``ELSEIF``/``ELSE`` branches, ``LOOP`` iterations (with iteration
     count), and ``BATCH`` blocks. Each frame shows source file and line.
-
-    The legacy ``commandliststack`` is reported separately as a secondary view
-    because it only records SCRIPT call frames; the unified ``ast_exec_stack``
-    is the authoritative debugger view.
+    The metacommand keeps its upstream name; what it prints is the AST
+    executor's ``ast_exec_stack``.
     """
     stack = getattr(_state, "ast_exec_stack", None) or []
     _state.output.write(f"Execution Stack (depth: {len(stack)}):\n")

execsql/metacommands/effects.py

@@ -0,0 +1,124 @@
+"""What a matched metacommand touches: files it reads, writes or deletes, and connections.
+
+Used by ``run --manifest``, which records the metacommands a run executed.
+It classifies from the handler a metacommand dispatched to and the groups its
+regex captured, so any other reader of a script (a static inspector) can share
+the same answer.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+__all__ = ["Effect", "effects"]
+
+
+@dataclass(frozen=True)
+class Effect:
+    """One thing a metacommand touches.
+
+    Attributes:
+        role: ``"read"``, ``"write"`` or ``"delete"`` for a file;
+            ``"connect"`` or ``"use"`` for a database.
+        target: The file path, or for a connection ``alias: server/db`` or
+            ``alias: file``.
+        detail: For a connection, the DBMS and user. Never a password.
+    """
+
+    role: str
+    target: str
+    detail: str = ""
+
+
+_IMPORTS = (
+    "x_import",
+    "x_import_file",
+    "x_import_feather",
+    "x_import_json",
+    "x_import_ods",
+    "x_import_ods_pattern",
+    "x_import_parquet",
+    "x_import_xls",
+    "x_import_xls_pattern",
+    "x_sub_ini",
+    "x_serve",
+)
+_EXPORTS = (
+    "x_export",
+    "x_export_query",
+    "x_export_metadata",
+    "x_export_with_template",
+    "x_export_query_with_template",
+    "x_export_ods_multiple",
+    "x_export_xlsx_multiple",
+)
+_WRITES = (
+    "x_write",
+    "x_writescript",
+    "x_consolesave",
+    "x_cancel_halt_write",
+    "x_error_halt_write",
+    "x_debug_write_config",
+    "x_debug_write_metacommands",
+    "x_debug_write_odbc_drivers",
+    "x_debug_write_subvars",
+)
+
+#: Handler name → {regex group: role}. Groups not listed (passwords,
+#: encodings, prompt paths) are never reported.
+FILE_ROLES: dict[str, dict[str, str]] = {
+    **{name: {"filename": "read"} for name in _IMPORTS},
+    **{name: {"filename": "write", "zipfilename": "write", "template": "read"} for name in _EXPORTS},
+    **{name: {"filename": "write"} for name in _WRITES},
+    **{
+        name: {"filename": "read", "outfile": "write"}
+        for name in ("x_write_create_table", "x_write_create_table_ods", "x_write_create_table_xls")
+    },
+    "x_write_create_table_alias": {"filename": "read"},
+    **{
+        name: {"att_file": "read", "msg_file": "read"}
+        for name in ("x_email", "x_cancel_halt_email", "x_error_halt_email")
+    },
+    "x_zip": {"filename": "read", "zipfilename": "write"},
+    "x_rm_file": {"filename": "delete"},
+}
+
+DBMS = {
+    "pg": "PostgreSQL",
+    "mysql": "MySQL",
+    "ssvr": "SQL Server",
+    "ora": "Oracle",
+    "fb": "Firebird",
+    "sqlite": "SQLite",
+    "duckdb": "DuckDB",
+    "access": "MS Access",
+    "dsn": "ODBC DSN",
+}
+
+
+def _connection(handler: str, groups: dict[str, str | None]) -> Effect | None:
+    if handler == "x_use":
+        return Effect("use", groups.get("db_alias") or "")
+    if not handler.startswith("x_connect_"):
+        return None
+    kind = handler.removeprefix("x_connect_").removeprefix("user_")
+    target = groups.get("filename") or groups.get("dsn") or ""
+    if groups.get("server"):
+        target = f"{groups['server']}/{groups.get('db_name') or ''}"
+    detail = DBMS.get(kind, kind)
+    if groups.get("user"):
+        detail += f", user {groups['user']}"
+    return Effect("connect", f"{groups.get('db_alias') or ''}: {target}".strip(), detail)
+
+
+def effects(handler: str, groups: dict[str, str | None]) -> list[Effect]:
+    """Everything a metacommand dispatched to *handler* with *groups* touches."""
+    connection = _connection(handler, groups)
+    if connection is not None:
+        return [connection]
+    found = []
+    for group, role in FILE_ROLES.get(handler, {}).items():
+        value = groups.get(group)
+        if value:
+            found.append(Effect(role, value.strip().strip('"')))
+    return found

execsql/metacommands/io_fileops.py

@@ -8,14 +8,18 @@ Implements ``x_include``, ``x_copy``, ``x_copy_query``, ``x_zip``,
 from __future__ import annotations
 
 import os
+import pickle
+import struct
 import sys
-from itertools import tee
+import tempfile
+from collections.abc import Iterator
 from pathlib import Path
 from shutil import copyfileobj
-from typing import Any, Literal, cast
+from typing import Any, Literal
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
+from execsql.importers.base import refuse_existing_table
 from execsql.models import DataTable
 from execsql.script import current_script_line
 from execsql.utils.errors import exception_desc
@@ -23,6 +27,39 @@ from execsql.utils.fileio import filewriter_close
 from execsql.utils.strings import unquoted
 
 
+class _RowSpool:
+    """Pass rows through while writing each to a temporary file, to be read back once more.
+
+    ``COPY ... TO NEW`` needs every row twice, once to describe the new table
+    and once to load it, but runs the source query once.  The rows are kept
+    in memory up to *max_size* bytes and on disk beyond that.  Each row is
+    pickled on its own, so neither pass keeps a reference to earlier rows.
+    """
+
+    _LENGTH = struct.Struct("<Q")
+
+    def __init__(self, rows: Any, max_size: int = 8 * 1024 * 1024) -> None:
+        self._rows = rows
+        self._file = tempfile.SpooledTemporaryFile(max_size=max_size)  # noqa: SIM115 - closed by close()
+
+    def __iter__(self) -> Iterator[Any]:
+        for row in self._rows:
+            data = pickle.dumps(row, protocol=pickle.HIGHEST_PROTOCOL)
+            self._file.write(self._LENGTH.pack(len(data)))
+            self._file.write(data)
+            yield row
+
+    def replay(self) -> Iterator[Any]:
+        """Yield the rows passed through, in order."""
+        self._file.seek(0)
+        while header := self._file.read(self._LENGTH.size):
+            (size,) = self._LENGTH.unpack(header)
+            yield pickle.loads(self._file.read(size))
+
+    def close(self) -> None:
+        self._file.close()
+
+
 def _close_rowsource(rows: Any) -> None:
     close = getattr(rows, "close", None)
     if close:
@@ -63,29 +100,16 @@ def x_copy(**kwargs: Any) -> None:
     db2 = _state.dbs.aliased_as(alias2)
     tbl1 = db1.schema_qualified_table_name(schema1, table1)
     tbl2 = db2.schema_qualified_table_name(schema2, table2)
-    try:
-        if not db1.table_exists(table1, schema1):
-            raise ErrInfo(
-                type="cmd",
-                command_text=kwargs["metacommandline"],
-                other_msg=f"Table {tbl1} does not exist",
-            )
-    except Exception:
-        pass  # Best-effort check; some adapters lack information_schema.
+    # No check that the source exists: the database may fold an unquoted name
+    # (PostgreSQL reads Orders as orders), and the SELECT below names a missing
+    # source in the database's own words.
     if new_tbl2 and new_tbl2 == "new":
-        try:
-            if db2.table_exists(table2, schema2):
-                raise ErrInfo(
-                    type="cmd",
-                    command_text=kwargs["metacommandline"],
-                    other_msg=f"Table {tbl2} already exists",
-                )
-        except Exception:
-            pass  # Best-effort check; some adapters lack information_schema.
+        refuse_existing_table(db2, schema2, table2)
     select_stmt = f"select * from {tbl1};"
 
     get_ts_tablespec = None
     rows_to_close = None
+    spool: _RowSpool | None = None
     rows_for_insert: Any
 
     if new_tbl2:
@@ -96,9 +120,10 @@ def x_copy(**kwargs: Any) -> None:
         except Exception as e:
             raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
         rows_to_close = rows
-        rows = cast(Any, rows)
-        rows_for_schema, rows_for_insert = tee(rows)
-        get_ts_tablespec = DataTable(hdrs, rows_for_schema)
+        # Values come from a database cursor, so a text value stays text.
+        spool = _RowSpool(rows)
+        get_ts_tablespec = DataTable(hdrs, spool, infer_strings=False)
+        rows_for_insert = spool.replay()
         tbl_desc = get_ts_tablespec
         create_tbl = tbl_desc.create_table(db2.type, schema2, table2)
         if new_tbl2 == "replacement":
@@ -129,7 +154,7 @@ def x_copy(**kwargs: Any) -> None:
         nonlocal get_ts_tablespec
         if get_ts_tablespec is None:
             ts_hdrs, ts_rows = db1.select_rowsource(select_stmt)
-            get_ts_tablespec = DataTable(ts_hdrs, ts_rows)
+            get_ts_tablespec = DataTable(ts_hdrs, ts_rows, infer_strings=False)
         return get_ts_tablespec
 
     try:
@@ -138,6 +163,9 @@ def x_copy(**kwargs: Any) -> None:
     except BaseException:
         _close_rowsource(rows_to_close)
         raise
+    finally:
+        if spool is not None:
+            spool.close()
 
 
 def x_copy_query(**kwargs: Any) -> None:
@@ -164,18 +192,11 @@ def x_copy_query(**kwargs: Any) -> None:
     db2 = _state.dbs.aliased_as(alias2)
     tbl2 = db2.schema_qualified_table_name(schema2, table2)
     if new_tbl2 and new_tbl2 == "new":
-        try:
-            if db2.table_exists(table2, schema2):
-                raise ErrInfo(
-                    type="cmd",
-                    command_text=kwargs["metacommandline"],
-                    other_msg=f"Table {tbl2} already exists",
-                )
-        except Exception:
-            pass  # Best-effort check; some adapters lack information_schema.
+        refuse_existing_table(db2, schema2, table2)
 
     get_ts_tablespec = None
     rows_to_close = None
+    spool: _RowSpool | None = None
     rows_for_insert: Any
 
     if new_tbl2:
@@ -186,9 +207,10 @@ def x_copy_query(**kwargs: Any) -> None:
         except Exception as e:
             raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
         rows_to_close = rows
-        rows = cast(Any, rows)
-        rows_for_schema, rows_for_insert = tee(rows)
-        get_ts_tablespec = DataTable(hdrs, rows_for_schema)
+        # Values come from a database cursor, so a text value stays text.
+        spool = _RowSpool(rows)
+        get_ts_tablespec = DataTable(hdrs, spool, infer_strings=False)
+        rows_for_insert = spool.replay()
         tbl_desc = get_ts_tablespec
         create_tbl = tbl_desc.create_table(db2.type, schema2, table2)
         if new_tbl2 == "replacement":
@@ -219,7 +241,7 @@ def x_copy_query(**kwargs: Any) -> None:
         nonlocal get_ts_tablespec
         if get_ts_tablespec is None:
             ts_hdrs, ts_rows = db1.select_rowsource(select_stmt)
-            get_ts_tablespec = DataTable(ts_hdrs, ts_rows)
+            get_ts_tablespec = DataTable(ts_hdrs, ts_rows, infer_strings=False)
         return get_ts_tablespec
 
     try:
@@ -228,6 +250,9 @@ def x_copy_query(**kwargs: Any) -> None:
     except BaseException:
         _close_rowsource(rows_to_close)
         raise
+    finally:
+        if spool is not None:
+            spool.close()
 
 
 def x_zip(**kwargs: Any) -> None:

execsql/metacommands/io_import.py

@@ -74,7 +74,6 @@ def x_import(**kwargs: Any) -> None:
             tablename,
             filename,
             is_new,
-            skip_header_line=True,
             quotechar=quotechar,
             delimchar=delimchar,
             encoding=enc,

execsql/metacommands/prompt.py

@@ -67,6 +67,7 @@ from execsql.utils.gui import (
     pause,
     pause_win,
 )
+from execsql.utils.fileio import register_secret
 from execsql.utils.strings import unquoted
 
 
@@ -144,6 +145,7 @@ def x_prompt_enter(**kwargs: Any) -> None:
         subvarset.add_substitution(sub_var, txtval)
         script_name, lno = current_script_line()
         if as_pw:
+            register_secret(txtval)
             _state.exec_log.log_status_info(f"Password assigned to variable {{{sub_var}}} on line {lno}.")
         else:
             _state.exec_log.log_status_info(f"Variable {{{sub_var}}} set to {{{txtval}}} on line {lno}.")

execsql/metacommands/upsert.py

@@ -4,7 +4,7 @@ Integrates pg-upsert (https://pg-upsert.readthedocs.io/) as an optional
 dependency, providing QA-checked, FK-dependency-ordered upserts from a
 staging schema to a base schema on PostgreSQL.
 
-Requires: ``pip install execsql2[upsert]``
+Requires the ``upsert`` extra (``execsql2[upsert]``).
 """
 
 from __future__ import annotations
@@ -213,7 +213,10 @@ def _require_pg_upsert() -> None:
     except ImportError as exc:
         raise ErrInfo(
             "exception",
-            other_msg=("PG_UPSERT requires the pg-upsert package. Install it with: pip install execsql2[upsert]"),
+            other_msg=(
+                'PG_UPSERT requires the pg-upsert package. Install the upsert extra: uv tool install "execsql2[upsert]"'
+                ' (or pip install "execsql2[upsert]").'
+            ),
         ) from exc