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

execsql/cli/lint.py

@@ -7,10 +7,10 @@ required.
 
 Checks performed:
 
-1. **Parse errors** — the AST parser rejects unmatched IF / LOOP /
-   BATCH / SCRIPT blocks at parse time with precise source spans;
-   ``cli/__init__.py`` reports any parse failure as a lint error before
-   :func:`lint` is even called.
+1. **Parse errors** — :func:`lint_source` parses with error recovery, so
+   every unmatched or unclosed IF / LOOP / BATCH / SCRIPT / SQL block is a
+   ``P001`` at its own line and the remaining checks run on the recovered
+   tree.
 2. **Empty scripts** — warns when no nodes were parsed.
 3. **Potentially undefined variables** — flags ``!!$VAR!!`` references
    with no preceding ``SUB``-family definition, ignoring built-in
@@ -22,6 +22,12 @@ Checks performed:
 5. **EXECUTE SCRIPT target resolution** — warns when a target name does
    not correspond to a :class:`ScriptBlock` in the same file (skipped
    when ``IF EXISTS`` is present).
+6. **Unknown metacommands** — reports a metacommand that no entry in the
+   dispatch table ``execsql run`` uses (plus installed plugins) matches,
+   skipping commands that contain a substitution variable.
+7. **Unknown conditions** — parses (never evaluates) every IF, ELSEIF,
+   ANDIF, ORIF, LOOP and EXECUTE SCRIPT ... WHILE/UNTIL condition, and the
+   condition in ASSERT and WAIT_UNTIL, against the conditional-test table.
 
 Every check has a rule code (:data:`RULES`), so a caller can select or
 ignore rules and machine-readable output can name them.
@@ -31,6 +37,8 @@ Public surface:
 - :func:`lint` — entry point; returns a list of :class:`Issue`.
 - :data:`RULES` / :class:`Rule` — the rule registry: code, name, severity.
 - :func:`parse_error` — the :class:`Issue` for a script that fails to parse.
+- :func:`lint_source` — parse script text and lint it: every block-structure
+  error as a ``P001``, plus every other rule on the recovered tree.
 - :func:`resolve_selectors` / :func:`filter_issues` — ``--select`` and
   ``--ignore`` handling.
 - :func:`print_text`, :func:`print_concise`, :func:`print_statistics`,
@@ -45,7 +53,7 @@ import re
 from collections import Counter
 from collections.abc import Iterable
 from pathlib import Path
-from typing import NamedTuple
+from typing import TYPE_CHECKING, NamedTuple
 
 from execsql.exceptions import ErrInfo
 from execsql.script.ast import (
@@ -62,6 +70,10 @@ from execsql.script.ast import (
     SqlStatement,
 )
 
+if TYPE_CHECKING:
+    from execsql.script.engine import MetaCommandList
+    from execsql.script.ast import ConditionModifier
+
 __all__ = [
     "RULES",
     "Issue",
@@ -69,6 +81,7 @@ __all__ = [
     "exit_code",
     "filter_issues",
     "lint",
+    "lint_source",
     "parse_error",
     "print_concise",
     "print_statistics",
@@ -109,6 +122,24 @@ RULES: dict[str, Rule] = {
             "error",
             "The script cannot be parsed, for example an IF, LOOP, BATCH or SCRIPT block that is never closed.",
         ),
+        Rule(
+            "P002",
+            "split-dollar-quote",
+            "error",
+            "A dollar-quoted body ($$ ... $$) is split into separate statements at a line ending in ';'.",
+        ),
+        Rule(
+            "P003",
+            "unknown-metacommand",
+            "error",
+            "A metacommand is misspelled or malformed: no form of any metacommand matches it.",
+        ),
+        Rule(
+            "P004",
+            "unknown-condition",
+            "error",
+            "A condition (IF, ELSEIF, ANDIF, ORIF, LOOP, ASSERT, ...) uses an unknown test or cannot be parsed.",
+        ),
         Rule("S001", "empty-script", "warning", "The script contains no statements."),
         Rule(
             "V001",
@@ -194,10 +225,22 @@ _RX_SUB_INI = re.compile(
 )
 _RX_SELECTSUB = re.compile(r"^\s*(?:SELECT_?SUB|PROMPT\s+SELECT_?SUB)\s+", re.I)
 _RX_SUB_LOCAL = re.compile(r"^\s*SUB_LOCAL\s+(?P<name>\w+)\s+", re.I)
-_RX_SUB_TEMPFILE = re.compile(r"^\s*SUB_TEMPFILE\s+(?P<name>\w+)\s", re.I)
-_RX_SUB_DECRYPT = re.compile(r"^\s*SUB_DECRYPT\s+(?P<name>\w+)\s+", re.I)
-_RX_SUB_ENCRYPT = re.compile(r"^\s*SUB_ENCRYPT\s+(?P<name>\w+)\s+", re.I)
-_RX_SUB_QUERYSTRING = re.compile(r"^\s*SUB_QUERYSTRING\s+(?P<name>\w+)\s+", re.I)
+_RX_SUB_TEMPFILE = re.compile(r"^\s*SUB_TEMPFILE\s+(?P<name>[+~]?\w+)\s*$", re.I)
+_RX_SUB_DECRYPT = re.compile(r"^\s*SUB_DECRYPT\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_ENCRYPT = re.compile(r"^\s*SUB_ENCRYPT\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_QUERYSTRING = re.compile(r"^\s*SUB_QUERYSTRING\s+(?P<qstr>.+?)\s*$", re.I)
+# The prompts that store the answer in a variable.
+_RX_ASK_SUB = re.compile(r"""^\s*(?:PROMPT\s+)?ASK\s+(?:'.*'|".*")\s+SUB\s+(?P<name>~?\w+)(?:\s|$)""", re.I)
+_RX_PROMPT_ENTER_SUB = re.compile(r"^\s*PROMPT\s+ENTER_SUB\s+(?P<name>~?\w+)\s", re.I)
+_RX_PROMPT_DIRECTORY = re.compile(r"^\s*PROMPT\s+DIRECTORY\s+SUB\s+(?P<name>~?\w+)(?:\s|$)", re.I)
+_RX_PROMPT_FILE = re.compile(
+    r"^\s*PROMPT\s+(?:OPENFILE|SAVEFILE)\s+SUB\s+(?P<names>~?\w+(?:\s+~?\w+){0,4})(?=\s+FROM\s|\s*$)",
+    re.I,
+)
+_RX_PROMPT_CREDENTIALS = re.compile(
+    r'^\s*PROMPT(?:\s+MESSAGE)?(?:\s+"[^"]*")?\s+CREDENTIALS\s+(?P<user>\w+)\s+(?P<pw>\w+)\s*$',
+    re.I,
+)
 
 _RX_VAR_REF = re.compile(r"!!([$@&~#+]?\w+)!!", re.I)
 
@@ -245,6 +288,39 @@ def _get_builtin_vars() -> frozenset[str]:
     return _BUILTIN_VARS
 
 
+_DISPATCH_TABLE: MetaCommandList | None = None
+
+
+def _dispatch_table() -> MetaCommandList:
+    """Return the metacommand table ``execsql run`` dispatches from, built on first call.
+
+    A private copy, with installed metacommand plugins registered, so that
+    linting never adds entries to the table a run in this process uses.
+    """
+    global _DISPATCH_TABLE
+    if _DISPATCH_TABLE is None:
+        from execsql.metacommands.dispatch import build_dispatch_table
+        from execsql.plugins import discover_metacommand_plugins
+
+        table = build_dispatch_table()
+        discover_metacommand_plugins(table)
+        _DISPATCH_TABLE = table
+    return _DISPATCH_TABLE
+
+
+_CONDITIONAL_TABLE: MetaCommandList | None = None
+
+
+def _conditional_table() -> MetaCommandList:
+    """Return the table of conditional tests ``execsql run`` evaluates with, built on first call."""
+    global _CONDITIONAL_TABLE
+    if _CONDITIONAL_TABLE is None:
+        from execsql.metacommands.conditions import build_conditional_table
+
+        _CONDITIONAL_TABLE = build_conditional_table()
+    return _CONDITIONAL_TABLE
+
+
 # ---------------------------------------------------------------------------
 # AST walker helpers
 # ---------------------------------------------------------------------------
@@ -302,7 +378,7 @@ def _extract_var_definition(
     script_dir: Path | None,
     defined: set[str],
 ) -> None:
-    """Extract variable name from a SUB-family metacommand into *defined*."""
+    """Add the variable(s) a metacommand defines to *defined*: the SUB family and the prompts that store an answer."""
     for rx in (
         _RX_SUB,
         _RX_SUB_EMPTY,
@@ -313,13 +389,32 @@ def _extract_var_definition(
         _RX_SUB_TEMPFILE,
         _RX_SUB_DECRYPT,
         _RX_SUB_ENCRYPT,
-        _RX_SUB_QUERYSTRING,
+        _RX_ASK_SUB,
+        _RX_PROMPT_ENTER_SUB,
+        _RX_PROMPT_DIRECTORY,
     ):
         m = rx.match(command)
         if m:
             defined.add(m.group("name").lstrip("+~").upper())
             return
 
+    m = _RX_PROMPT_FILE.match(command)
+    if m:
+        defined.update(name.lstrip("~").upper() for name in m.group("names").split())
+        return
+
+    m = _RX_PROMPT_CREDENTIALS.match(command)
+    if m:
+        defined.update((m.group("user").upper(), m.group("pw").upper()))
+        return
+
+    m = _RX_SUB_QUERYSTRING.match(command)
+    if m:
+        from urllib.parse import parse_qsl
+
+        defined.update(key.upper() for key, _value in parse_qsl(m.group("qstr")))
+        return
+
     # SUB_INI bulk-defines from INI file — read keys at lint time
     ini_m = _RX_SUB_INI.match(command)
     if ini_m:
@@ -370,20 +465,13 @@ def _check_var_ref(
     if sigil in ("@", "&", "~", "#", "+"):
         return
 
-    # $ARG_N is set via -a/--assign-arg at invocation time
-    if re.match(r"^ARG_\d+$", name, re.I):
-        return
-
-    # $COUNTER_N is managed by CounterVars
-    if re.match(r"^COUNTER_\d+$", name, re.I):
-        return
-
-    # Built-in system variables
-    if name.upper() in _get_builtin_vars():
-        return
-
-    # User-defined via SUB
-    if name.upper() in defined_vars:
+    if sigil == "$":
+        # System variables: $ARG_N is set with -a/--assign-arg, $COUNTER_N by
+        # CounterVars, the rest by execsql itself.  A SUB cannot define one.
+        if re.match(r"^(?:ARG|COUNTER)_\d+$", name, re.I) or name.upper() in _get_builtin_vars():
+            return
+    elif name.upper() in defined_vars:
+        # User variables, defined by a SUB-family metacommand or a prompt.
         return
 
     issues.append(
@@ -427,8 +515,8 @@ def _check_include_path(
 #: Conditions whose value is fixed at parse time.  ``IF(True)`` is a real and
 #: reasonable thing to write while developing; leaving it in is what makes
 #: every other branch dead code.
-_RX_CONST_TRUE = re.compile(r"^\s*\(?\s*(?:true|1\s*=\s*1|yes)\s*\)?\s*$", re.I)
-_RX_CONST_FALSE = re.compile(r"^\s*\(?\s*(?:false|0\s*=\s*1|1\s*=\s*0|no)\s*\)?\s*$", re.I)
+_RX_CONST_TRUE = re.compile(r"^\s*\(?\s*(?:true|yes)\s*\)?\s*$", re.I)
+_RX_CONST_FALSE = re.compile(r"^\s*\(?\s*(?:false|no)\s*\)?\s*$", re.I)
 
 #: Metacommands after which nothing in the same block can run.
 _RX_TERMINAL = re.compile(r"^\s*HALT\b(?!\s+DISPLAY)", re.I)
@@ -482,6 +570,138 @@ def _check_constant_condition(node: IfBlock, issues: list[_Issue]) -> None:
         )
 
 
+def _check_split_dollar_quotes(nodes: list[Node], issues: list[_Issue]) -> None:
+    """Report a dollar-quoted body that the script splits into several statements.
+
+    A statement ends at any line ending in ``;``, even inside ``$$ ... $$``,
+    so a function body is sent to the database in pieces: the first piece
+    fails, and with ERROR_HALT OFF the statements inside the body then run
+    on their own.  One issue is reported where the body opens; the pieces
+    that follow until it closes are part of the same problem.
+    """
+    from execsql.format import open_dollar_quote
+
+    open_tag: str | None = None
+    for node in nodes:
+        if not isinstance(node, SqlStatement):
+            continue
+        was_open = open_tag
+        open_tag = open_dollar_quote(node.text, open_tag)
+        if was_open is None and open_tag is not None:
+            issues.append(
+                _issue(
+                    "P002",
+                    node.span.file,
+                    node.span.start_line,
+                    f"dollar-quoted body {open_tag} is split at the first line ending in ';'; "
+                    "put the statement between BEGIN SQL and END SQL",
+                ),
+            )
+
+
+# A command holding a variable (!!v!!, !'!v!'!, !"!v!"! or deferred !{v}!) is
+# only known after substitution at run time.
+_RX_ANY_VAR = re.compile(r"!(['\"]?)![$&@~#+]?\w+!\1!|!\{[$&@~#+]?\w+\}!")
+
+
+#: Values a variable is tried as: a boolean (a whole condition), a number
+#: (``ROW_COUNT_EQ(t, !!n!!)``) and a name (a table or column).  Between them
+#: they fit wherever a variable can stand in a condition or a metacommand.
+_PLACEHOLDERS = ("TRUE", "1", "x")
+
+
+def _with_placeholders(text: str, value: str = "TRUE") -> str:
+    """Replace each substitution variable with the literal *value*."""
+    return _RX_ANY_VAR.sub(value, text)
+
+
+def _placeholder_forms(text: str) -> list[str]:
+    """*text* with its variables replaced by each of :data:`_PLACEHOLDERS` in turn.
+
+    What none of them makes valid is not valid with any value, such as
+    ``!!flag!! = TRUE`` (there is no ``=`` comparison).
+    """
+    return [_with_placeholders(text, value) for value in _PLACEHOLDERS]
+
+
+# Named groups that capture a condition in a metacommand's pattern: ASSERT,
+# WAIT_UNTIL, and the WHILE / UNTIL of ON ... EXECUTE SCRIPT.
+_CONDITION_GROUPS = ("condtest", "condition", "loopcond")
+
+
+def _check_metacommand(node: MetaCommandStatement, issues: list[_Issue]) -> None:
+    """Report a metacommand that no dispatch-table entry matches, or whose condition does not parse.
+
+    ``execsql run`` halts on such a command with "Unknown metacommand",
+    whether the keyword is misspelled or the arguments don't fit any form.
+    """
+    match = _dispatch_table().get_match(node.command)
+    if match is None and _RX_ANY_VAR.search(node.command):
+        # A variable can stand for a keyword or a whole clause: try the
+        # command with placeholders, and judge it only if one matches.
+        match = next(
+            (m for form in _placeholder_forms(node.command) if (m := _dispatch_table().get_match(form)) is not None),
+            None,
+        )
+        if match is None:
+            return
+    if match is None:
+        issues.append(
+            _issue(
+                "P003",
+                node.span.file,
+                node.span.start_line,
+                f"unknown or malformed metacommand: {node.command.strip()}",
+            ),
+        )
+        return
+    groups = match[1].groupdict()
+    for name in _CONDITION_GROUPS:
+        if groups.get(name):
+            _check_condition(groups[name], node.span.file, node.span.start_line, issues)
+
+
+def _check_condition(condition: str, source: str, line_no: int, issues: list[_Issue]) -> None:
+    """Report a condition that the conditional-expression parser rejects.
+
+    Only parses: no test is evaluated, so nothing touches a database.  A
+    condition with variables is reported only when it parses with none of
+    the placeholder values (:func:`_placeholder_forms`).
+    """
+    from execsql.exceptions import CondParserError
+    from execsql.parser import CondParser
+
+    forms = _placeholder_forms(condition) if _RX_ANY_VAR.search(condition) else [condition]
+    for form in forms:
+        try:
+            CondParser(form, _conditional_table()).parse()
+        except (CondParserError, RecursionError):  # RecursionError: nested past the parser's depth
+            continue
+        return
+    issues.append(
+        _issue("P004", source, line_no, f"unknown or malformed condition: {condition.strip()}"),
+    )
+
+
+def _check_modifiers(modifiers: list[ConditionModifier], issues: list[_Issue]) -> None:
+    for mod in modifiers:
+        _check_condition(mod.condition, mod.span.file, mod.span.start_line, issues)
+
+
+def _check_block_conditions(node: Node, issues: list[_Issue]) -> None:
+    """Check the conditions an IF (with its ANDIF / ORIF / ELSEIF), LOOP or EXECUTE SCRIPT carries."""
+    if isinstance(node, IfBlock):
+        _check_condition(node.condition, node.span.file, node.span.start_line, issues)
+        _check_modifiers(node.condition_modifiers, issues)
+        for clause in node.elseif_clauses:
+            _check_condition(clause.condition, clause.span.file, clause.span.start_line, issues)
+            _check_modifiers(clause.condition_modifiers, issues)
+    elif isinstance(node, LoopBlock):
+        _check_condition(node.condition, node.span.file, node.span.start_line, issues)
+    elif isinstance(node, IncludeDirective) and node.loop_condition:
+        _check_condition(node.loop_condition, node.span.file, node.span.start_line, issues)
+
+
 def _check_unreachable_after_halt(nodes: list[Node], issues: list[_Issue]) -> None:
     """Report statements that follow an unconditional HALT in the same block.
 
@@ -507,12 +727,18 @@ def _check_unreachable_after_halt(nodes: list[Node], issues: list[_Issue]) -> No
         return
 
 
+# The conditional tests that read a variable by its bare name.
+_RX_VAR_TEST = re.compile(r"\bSUB_(?:DEFINED|EMPTY)\s*\(\s*([$&@~#]?\w+)\s*\)", re.I)
+
+
 def _collect_var_references(nodes: list[Node], seen: set[str]) -> None:
-    """Record every ``!!var!!`` reference anywhere beneath *nodes*."""
+    """Record every variable read anywhere beneath *nodes*: ``!!var!!``, or ``sub_defined(var)`` / ``sub_empty(var)``."""
     for node in nodes:
         for text in _referencing_text(node):
             for m in _RX_VAR_REF.finditer(text):
                 seen.add(m.group(1).lstrip("$@&~#+").upper())
+            for m in _RX_VAR_TEST.finditer(text):
+                seen.add(m.group(1).lstrip("$@&~#+").upper())
         for child in node.children():
             _collect_var_references([child], seen)
 
@@ -591,10 +817,12 @@ def _lint_nodes(
         visited_scripts = set()
 
     _check_unreachable_after_halt(nodes, issues)
+    _check_split_dollar_quotes(nodes, issues)
 
     for node in nodes:
         src = node.span.file
         lno = node.span.start_line
+        _check_block_conditions(node, issues)
 
         # -- Variable references in SQL --
         if isinstance(node, SqlStatement):
@@ -603,6 +831,7 @@ def _lint_nodes(
 
         # -- Metacommand checks --
         elif isinstance(node, MetaCommandStatement):
+            _check_metacommand(node, issues)
             for m in _RX_VAR_REF.finditer(node.command):
                 _check_var_ref(m.group(1), src, lno, defined_vars, issues)
 
@@ -711,6 +940,20 @@ def lint(
     return issues
 
 
+def lint_source(source: str, label: str, script_path: str | None = None) -> list[_Issue]:
+    """Parse *source* and lint it, unfiltered.
+
+    Each block-structure error (an IF without ENDIF, a stray END LOOP, ...)
+    is a ``P001`` at its own line.  The parser recovers from them, so every
+    other rule still runs on the rest of the script.
+    """
+    from execsql.script.parser import parse_string
+
+    errors: list[ErrInfo] = []
+    tree = parse_string(source, label, errors=errors)
+    return [parse_error(label, exc) for exc in errors] + lint(tree, script_path=script_path)
+
+
 # ---------------------------------------------------------------------------
 # Selecting rules
 # ---------------------------------------------------------------------------

execsql/cli/options.py

@@ -50,7 +50,7 @@ DsnOpt = Annotated[
         metavar="URL",
         help=(
             "Database connection URL, e.g. postgresql://user:pass@host:5432/db. "
-            "Supported schemes: postgresql, mysql, mssql, oracle, firebird, sqlite, duckdb. "
+            "Supported schemes: postgresql (postgres), mysql (mariadb), mssql (sqlserver), oracle, firebird, sqlite, duckdb. "
             "Overrides -t/-u/-p and positional server/db args."
         ),
     ),

execsql/cli/run.py

@@ -514,7 +514,8 @@ def _setup_logging(
     opts_dict = {
         k: v
         for k, v in {
-            "sub_vars": sub_vars,
+            # Count only: -a values are opaque and often secrets.
+            "sub_vars": f"{len(sub_vars)} value(s)" if sub_vars else None,
             "boolean_int": boolean_int,
             "make_dirs": make_dirs,
             "database_encoding": database_encoding,
@@ -535,7 +536,7 @@ def _setup_logging(
     }
     logger = Logger(
         script_name or "<inline>",
-        conf.db or "",
+        conf.db or conf.db_file or "",
         conf.server,
         opts_dict,
         conf.user_logfile,
@@ -552,6 +553,9 @@ def _setup_logging(
         )
 
     subvars.add_substitution("$RUN_ID", logger.run_id)
+    # Passwords from the DSN or config files, known before the first connection.
+    logger.add_redaction_value(getattr(conf, "db_password", None))
+    logger.add_redaction_value(getattr(conf, "smtp_password", None))
 
     if sub_vars:
         for n, repl in enumerate(sub_vars):
@@ -740,27 +744,13 @@ def _run(
         manifest = _manifest.start(manifest_path, script_name, variables)
         manifest.config_files = list(conf.files_read)
 
-    import execsql.utils.fileio as _fileio
-
     if _state.filewriter is None or not _state.filewriter.is_alive():
-        # Drain stale messages from the queues so a previously-dead subprocess
-        # can't leak responses or unconsumed commands into the new one. On
-        # macOS (`spawn`) the OS pipe buffer is small enough that retained
-        # entries from a crashed writer would deadlock the next put().
-        for q in (_fileio.fw_input, _fileio.fw_output):
-            try:
-                while True:
-                    q.get_nowait()
-            except Exception:
-                pass
-        _fileio.filewriter = _state.filewriter = FileWriter(
-            _fileio.fw_input,
-            _fileio.fw_output,
+        _state.filewriter = FileWriter(
             file_encoding=conf.output_encoding,
             open_timeout=getattr(conf, "outfile_open_timeout", 10),
         )
         _state.filewriter.start()
-        atexit.register(filewriter_end)
+        atexit.register(filewriter_end, _state.filewriter)
 
     # ------------------------------------------------------------------
     # Logging
@@ -856,6 +846,28 @@ def _run(
 # ---------------------------------------------------------------------------
 
 
+def _end_run_on_sigterm() -> None:
+    """Make SIGTERM end the process through ``SystemExit`` (exit status 143).
+
+    Python's default SIGTERM action stops the process without running
+    ``atexit`` handlers, so the run's log (buffered until close) was lost,
+    the open transaction was not rolled back explicitly, and a running
+    ``SYSTEM_CMD`` was left behind.  ``timeout``, ``docker stop``, systemd
+    and CI cancellation all send SIGTERM.  Installed by the console entry
+    point only: ``execsql.run()`` leaves the host program's signals alone.
+    """
+    import signal
+
+    def _terminate(signum: int, _frame: Any) -> None:
+        import execsql.state as _state
+
+        if _state.exec_log is not None:
+            _state.exec_log.log_exit_terminated()
+        raise SystemExit(128 + signum)
+
+    signal.signal(signal.SIGTERM, _terminate)
+
+
 def _execute_script_ast(
     tree: Any,
     conf: ConfigData,
@@ -883,7 +895,8 @@ def _execute_script_ast(
     try:
         execute(tree)
     except SystemExit as exc:
-        if gui_console_isrunning() and conf.gui_wait_on_exit:
+        terminated = _state.exec_log is not None and _state.exec_log.exit_type == "terminated"
+        if gui_console_isrunning() and conf.gui_wait_on_exit and not terminated:
             gui_console_wait_user(
                 "Script complete; close the console window to exit execsql.",
             )
@@ -895,6 +908,9 @@ def _execute_script_ast(
         sys.exit(exc.code)
     except ConfigError:
         raise
+    except KeyboardInterrupt:
+        _state.exec_log.log_exit_interrupted()
+        raise
     except ErrInfo as exc:
         from execsql.utils.errors import exit_now
 
@@ -908,6 +924,7 @@ def _execute_script_ast(
         exit_now(1, ErrInfo("exception", exception_msg=msg))
 
     _state.dbs.do_rollback = False
+    _flush_output_files()
     if gui_console_isrunning() and conf.gui_wait_on_exit:
         gui_console_wait_user(
             "Script complete; close the console window to exit execsql.",
@@ -970,10 +987,30 @@ def _execute_script_textual_console(tree: Any, conf: ConfigData) -> None:
             exit_now(1, ErrInfo("exception", exception_msg=msg))
 
     _state.dbs.do_rollback = False
+    _flush_output_files()
     _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
     _state.exec_log.log_exit_end()
 
 
+def _flush_output_files() -> None:
+    """Flush file output at the normal end of a script; lost output fails the run.
+
+    A WRITE/EXPORT target that stays locked past ``outfile_open_timeout`` has
+    its output discarded.  That must not end in a successful exit status.
+    """
+    from execsql.utils.fileio import filewriter_close_all_after_write
+
+    try:
+        filewriter_close_all_after_write()
+    except ErrInfo as exc:
+        from execsql.utils.errors import exit_now
+
+        # The loss belongs to no particular statement; keep exit_now from
+        # attributing it to whatever line happened to run last.
+        exc.script_file = ""
+        exit_now(1, exc)
+
+
 # ---------------------------------------------------------------------------
 # Utility: build the database connection for the initial/default database
 # ---------------------------------------------------------------------------

execsql/config.py

@@ -372,6 +372,8 @@ class ConfigData:
         self._get_str(cp, self._EMAIL_SECTION, "password", "smtp_password")
         self._get_bool(cp, self._EMAIL_SECTION, "use_ssl", "smtp_ssl")
         self._get_bool(cp, self._EMAIL_SECTION, "use_tls", "smtp_tls")
+        self._get_bool(cp, self._EMAIL_SECTION, "verify_certificate", "smtp_verify_certificate")
+        self._get_str(cp, self._EMAIL_SECTION, "ca_file", "smtp_ca_file")
         self._get_str(cp, self._EMAIL_SECTION, "message_css", "email_css")
         # --- [format] and [lint]: read by `execsql format` / `execsql lint`; a run ignores them ---
         self._get_int(cp, self._FORMAT_SECTION, "indent", "format_indent")
@@ -523,6 +525,8 @@ class ConfigData:
         self.smtp_password: str | None = None
         self.smtp_ssl = False
         self.smtp_tls = False
+        self.smtp_verify_certificate = True
+        self.smtp_ca_file: str | None = None
         self.email_format = "plain"
         self.email_css: str | None = None
         self.include_req: list = []
@@ -727,13 +731,12 @@ class WriteHooks:
     """
 
     def __repr__(self) -> str:
-        return f"WriteHooks({self.write_func!r}, {self.err_func!r}, {self.status_func!r})"
+        return f"WriteHooks({self.write_func!r}, {self.err_func!r})"
 
     def __init__(
         self,
         standard_output_func: Callable[[str], object] | None = None,
         error_output_func: Callable[[str], object] | None = None,
-        status_output_func: Callable[[str], object] | None = None,
     ) -> None:
         """Store optional hook callables; ``None`` means use the default stream.
 
@@ -742,8 +745,6 @@ class WriteHooks:
                 ``None`` to use ``sys.stdout``.
             error_output_func: Callable to receive error-output text, or
                 ``None`` to use ``sys.stderr``.
-            status_output_func: Callable to receive status-line text, or
-                ``None`` to suppress.
         """
         # Arguments should be functions that take a single string and
         # write it to the desired destination.  Both stdout and stderr can be hooked.
@@ -752,7 +753,6 @@ class WriteHooks:
         # The purpose is to allow writing to be redirected to a GUI.
         self.write_func = standard_output_func
         self.err_func = error_output_func
-        self.status_func = status_output_func
         self.tee_stderr = True
 
     def reset(self) -> None:
@@ -770,15 +770,6 @@ class WriteHooks:
         self.err_func = error_output_func
         self.tee_stderr = tee
 
-    def redir(
-        self,
-        standard_output_func: Callable[[str], object],
-        error_output_func: Callable[[str], object],
-    ) -> None:
-        """Redirect both stdout and stderr hooks in one call."""
-        self.redir_stdout(standard_output_func)
-        self.redir_stderr(error_output_func)
-
     def write(self, strval: str) -> None:
         """Write a string to the standard-output hook, or to sys.stdout if unset."""
         if self.write_func:
@@ -799,8 +790,3 @@ class WriteHooks:
         else:
             sys.stderr.write(strval)
             sys.stderr.flush()
-
-    def write_status(self, strval: str) -> None:
-        """Forward a status string to the status hook if one is registered."""
-        if self.status_func:
-            self.status_func(strval)