execsql2 2.18.0__py3-none-any.whl → 2.19.0__py3-none-any.whl

execsql/cli/__init__.py

@@ -8,8 +8,7 @@ Submodules:
 - :mod:`execsql.cli.help`      — Rich-formatted help output & console objects
 - :mod:`execsql.cli.dsn`       — Connection-string (DSN URL) parser
 - :mod:`execsql.cli.run`       — Core execution logic (``_run``, ``_connect_initial_db``, ``_ping_db``, ``_print_dry_run``, ``_print_profile``)
-- :mod:`execsql.cli.lint_ast`  — AST-based ``--lint`` static analyser
-- :mod:`execsql.cli.lint`      — Shared lint result printing (``_print_lint_results``) used by the AST linter
+- :mod:`execsql.cli.lint`      — AST-based ``--lint`` static analyser and Rich result printer
 """
 
 from __future__ import annotations
@@ -554,8 +553,7 @@ def main(
     # Lint: AST-based static analysis (no DB connection needed)
     # ------------------------------------------------------------------
     if lint:
-        from execsql.cli.lint import _print_lint_results
-        from execsql.cli.lint_ast import lint_ast
+        from execsql.cli.lint import _print_lint_results, lint as _lint_script
         from execsql.script.parser import parse_script, parse_string
 
         label = script_name or "<inline>"
@@ -576,7 +574,7 @@ def main(
             exit_code = _print_lint_results(issues, label)
             raise typer.Exit(code=exit_code) from exc
 
-        issues = lint_ast(tree, script_path=script_name)
+        issues = _lint_script(tree, script_path=script_name)
         exit_code = _print_lint_results(issues, label)
         raise typer.Exit(code=exit_code)
 

execsql/cli/lint.py

@@ -1,30 +1,63 @@
-"""Shared Rich-formatted output for ``--lint`` results.
+"""AST-based static analysis (``--lint``) for execsql scripts.
 
-The active linter is :mod:`execsql.cli.lint_ast`, which produces
-``(severity, source, line_no, message)`` tuples. This module owns the
-small surface that converts those tuples into the user-facing console
-output:
+Operates on the :class:`~execsql.script.ast.Script` tree produced by
+:func:`execsql.script.parser.parse_script` / ``parse_string``. Runs as
+an early CLI exit — no DB connection and no ``_state`` initialisation
+required.
 
-- :class:`_Issue` — the issue tuple type alias.
-- :func:`_error` / :func:`_warning` — issue constructors.
-- :func:`_print_lint_results` — Rich console formatter; returns the
-  ``--lint`` exit code (``1`` if any error, else ``0``).
+Checks performed:
 
-This module previously hosted a flat-CommandList walker
-(``_lint_script`` / ``_lint_cmdlist`` and friends) that pre-dated the
-AST. The walker was removed once the CLI fully migrated to the AST
-linter; the rename of ``_state.savedscripts`` → ``_state.ast_scripts``
-had silently turned its EXECUTE-SCRIPT flow analysis into a no-op.
+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.
+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
+   ``$VAR`` names discovered from the package source and the
+   non-``$`` sigils (``~``, ``#``, ``+``, ``@``, ``&``) that resolve at
+   runtime.
+4. **Missing INCLUDE files** — warns when the resolved target does not
+   exist on disk (skipped when ``IF EXISTS`` is present).
+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).
 
-Exit-code contract (honoured by the AST linter):
+Public surface:
 
-- ``1`` when at least one error-severity issue is found.
-- ``0`` when only warnings (or nothing) are found.
+- :func:`lint` — entry point; returns a list of
+  ``(severity, source, line_no, message)`` tuples.
+- :func:`_print_lint_results` — Rich console formatter for those
+  tuples; returns the ``--lint`` process exit code (``1`` when any
+  error-severity issue is present, ``0`` otherwise).
+- :data:`_Issue`, :func:`_error`, :func:`_warning` — tuple type alias
+  and constructors used by the walker and the formatter.
 """
 
 from __future__ import annotations
 
-__all__ = ["_Issue", "_error", "_print_lint_results", "_warning"]
+import re
+from pathlib import Path
+
+from execsql.script.ast import (
+    BatchBlock,
+    IfBlock,
+    IncludeDirective,
+    LoopBlock,
+    MetaCommandStatement,
+    Node,
+    Script,
+    ScriptBlock,
+    SqlBlock,
+    SqlStatement,
+)
+
+__all__ = ["_Issue", "_error", "_print_lint_results", "_warning", "lint"]
+
+
+# ---------------------------------------------------------------------------
+# Issue tuple type and constructors
+# ---------------------------------------------------------------------------
 
 
 _Issue = tuple[str, str, int, str]  # (severity, source, line_no, message)
@@ -38,6 +71,388 @@ def _warning(source: str, line_no: int, message: str) -> _Issue:
     return ("warning", source, line_no, message)
 
 
+# ---------------------------------------------------------------------------
+# Variable-related patterns
+# ---------------------------------------------------------------------------
+
+_RX_SUB = re.compile(r"^\s*SUB\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_EMPTY = re.compile(r"^\s*SUB_EMPTY\s+(?P<name>[+~]?\w+)\s*$", re.I)
+_RX_SUB_ADD = re.compile(r"^\s*SUB_ADD\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_APPEND = re.compile(r"^\s*SUB_APPEND\s+(?P<name>[+~]?\w+)\s", re.I)
+_RX_SUBDATA = re.compile(r"^\s*SUBDATA\s+(?P<name>[+~]?\w+)\s+", re.I)
+_RX_SUB_INI = re.compile(
+    r'^\s*SUB_INI\s+(?:FILE\s+)?(?:"(?P<qfile>[^"]+)"|(?P<file>\S+))'
+    r"(?:\s+SECTION)?\s+(?P<section>\w+)\s*$",
+    re.I,
+)
+_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_VAR_REF = re.compile(r"!!([$@&~#+]?\w+)!!", re.I)
+
+
+# ---------------------------------------------------------------------------
+# Built-in variable discovery
+# ---------------------------------------------------------------------------
+
+
+def _discover_builtin_vars() -> frozenset[str]:
+    """Scan the execsql package source for ``$VARNAME`` system variables."""
+    import importlib.util
+
+    _rx_add_sub = re.compile(r'(?:(?<!\w)add_substitution|(?<!\w)sv)\s*\(\s*["\'](\$\w+)["\']')
+    _rx_lazy = re.compile(r'register_lazy\s*\(\s*["\'](\$\w+)["\']')
+
+    names: set[str] = set()
+
+    spec = importlib.util.find_spec("execsql")
+    if spec is None or spec.submodule_search_locations is None:
+        return frozenset(names)
+
+    pkg_dir = Path(spec.submodule_search_locations[0])
+    for src_file in pkg_dir.rglob("*.py"):
+        try:
+            text = src_file.read_text(encoding="utf-8")
+        except OSError:
+            continue
+        for m in _rx_add_sub.finditer(text):
+            names.add(m.group(1).lstrip("$").upper())
+        for m in _rx_lazy.finditer(text):
+            names.add(m.group(1).lstrip("$").upper())
+
+    return frozenset(names)
+
+
+_BUILTIN_VARS: frozenset[str] | None = None
+
+
+def _get_builtin_vars() -> frozenset[str]:
+    """Return the cached set of built-in variable names, discovering on first call."""
+    global _BUILTIN_VARS
+    if _BUILTIN_VARS is None:
+        _BUILTIN_VARS = _discover_builtin_vars()
+    return _BUILTIN_VARS
+
+
+# ---------------------------------------------------------------------------
+# AST walker helpers
+# ---------------------------------------------------------------------------
+
+
+def _collect_script_blocks(script: Script) -> dict[str, ScriptBlock]:
+    """Build a name → ScriptBlock lookup from all ScriptBlock nodes in the tree."""
+    blocks: dict[str, ScriptBlock] = {}
+    for node in script.walk():
+        if isinstance(node, ScriptBlock):
+            blocks[node.name] = node
+    return blocks
+
+
+def _collect_defined_vars_from_nodes(
+    nodes: list[Node],
+    script_blocks: dict[str, ScriptBlock],
+    script_dir: Path | None,
+    defined: set[str],
+    visited: set[str] | None = None,
+) -> None:
+    """Walk nodes and collect variable definitions into *defined*."""
+    if visited is None:
+        visited = set()
+
+    for node in nodes:
+        if isinstance(node, MetaCommandStatement):
+            _extract_var_definition(node.command, script_dir, defined)
+
+        elif isinstance(node, IncludeDirective) and node.is_execute_script:
+            target = node.target.lower()
+            if target in script_blocks and target not in visited:
+                visited.add(target)
+                _collect_defined_vars_from_nodes(
+                    script_blocks[target].body,
+                    script_blocks,
+                    script_dir,
+                    defined,
+                    visited,
+                )
+
+        # Recurse into block children
+        if isinstance(node, (IfBlock, LoopBlock, BatchBlock, ScriptBlock, SqlBlock)):
+            _collect_defined_vars_from_nodes(
+                list(node.children()),
+                script_blocks,
+                script_dir,
+                defined,
+                visited,
+            )
+
+
+def _extract_var_definition(
+    command: str,
+    script_dir: Path | None,
+    defined: set[str],
+) -> None:
+    """Extract variable name from a SUB-family metacommand into *defined*."""
+    for rx in (
+        _RX_SUB,
+        _RX_SUB_EMPTY,
+        _RX_SUB_ADD,
+        _RX_SUB_APPEND,
+        _RX_SUBDATA,
+        _RX_SUB_LOCAL,
+        _RX_SUB_TEMPFILE,
+        _RX_SUB_DECRYPT,
+        _RX_SUB_ENCRYPT,
+        _RX_SUB_QUERYSTRING,
+    ):
+        m = rx.match(command)
+        if m:
+            defined.add(m.group("name").lstrip("+~").upper())
+            return
+
+    # SUB_INI bulk-defines from INI file — read keys at lint time
+    ini_m = _RX_SUB_INI.match(command)
+    if ini_m:
+        ini_file = ini_m.group("qfile") or ini_m.group("file")
+        ini_section = ini_m.group("section")
+        if ini_file and not _RX_VAR_REF.search(ini_file):
+            _read_ini_vars(ini_file, ini_section, script_dir, defined)
+
+
+def _read_ini_vars(
+    ini_file: str,
+    section: str,
+    script_dir: Path | None,
+    defined_vars: set[str],
+) -> None:
+    """Read an INI file and register its section keys as defined variables."""
+    from configparser import ConfigParser
+
+    p = Path(ini_file)
+    if not p.is_absolute() and script_dir is not None:
+        p = script_dir / p
+
+    if not p.exists():
+        return
+
+    cp = ConfigParser()
+    cp.read(p)
+    if cp.has_section(section):
+        for key, _value in cp.items(section):
+            defined_vars.add(key.upper())
+
+
+def _check_var_ref(
+    raw_name: str,
+    source: str,
+    line_no: int,
+    defined_vars: set[str],
+    issues: list[_Issue],
+) -> None:
+    """Emit a warning if *raw_name* looks like an undefined user variable."""
+    if not raw_name:
+        return
+
+    sigil = raw_name[0] if raw_name[0] in ("$", "@", "&", "~", "#", "+") else ""
+    name = raw_name[len(sigil) :]
+
+    # Skip non-$ sigil prefixes — resolved at runtime
+    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:
+        return
+
+    issues.append(
+        _warning(
+            source,
+            line_no,
+            f"Potentially undefined variable: !!{raw_name}!! "
+            "(not defined by a preceding SUB; may be set by a config file or -a arg)",
+        ),
+    )
+
+
+def _check_include_path(
+    raw_path: str,
+    script_dir: Path | None,
+    source: str,
+    line_no: int,
+    issues: list[_Issue],
+) -> None:
+    """Warn if the INCLUDE target does not exist on disk."""
+    p = Path(raw_path)
+    if not p.is_absolute() and script_dir is not None:
+        p = script_dir / p
+
+    if not p.exists():
+        issues.append(
+            _warning(source, line_no, f"INCLUDE target does not exist: {raw_path!r}"),
+        )
+
+
+# ---------------------------------------------------------------------------
+# Core lint walk
+# ---------------------------------------------------------------------------
+
+
+def _lint_nodes(
+    nodes: list[Node],
+    script_dir: Path | None,
+    defined_vars: set[str],
+    script_blocks: dict[str, ScriptBlock],
+    issues: list[_Issue],
+    *,
+    visited_scripts: set[str] | None = None,
+) -> None:
+    """Walk a list of AST nodes and collect lint issues."""
+    if visited_scripts is None:
+        visited_scripts = set()
+
+    for node in nodes:
+        src = node.span.file
+        lno = node.span.start_line
+
+        # -- Variable references in SQL --
+        if isinstance(node, SqlStatement):
+            for m in _RX_VAR_REF.finditer(node.text):
+                _check_var_ref(m.group(1), src, lno, defined_vars, issues)
+
+        # -- Metacommand checks --
+        elif isinstance(node, MetaCommandStatement):
+            for m in _RX_VAR_REF.finditer(node.command):
+                _check_var_ref(m.group(1), src, lno, defined_vars, issues)
+
+        # -- IncludeDirective checks --
+        elif isinstance(node, IncludeDirective):
+            if node.is_execute_script:
+                target = node.target.lower()
+                if target not in script_blocks:
+                    if not node.if_exists:
+                        issues.append(
+                            _warning(src, lno, f"EXECUTE SCRIPT target not found: '{target}'"),
+                        )
+                elif target not in visited_scripts:
+                    visited_scripts.add(target)
+                    _lint_nodes(
+                        script_blocks[target].body,
+                        script_dir,
+                        defined_vars,
+                        script_blocks,
+                        issues,
+                        visited_scripts=visited_scripts,
+                    )
+            else:
+                # INCLUDE file existence check
+                if not node.if_exists:
+                    raw_path = node.target.strip().strip("\"'")
+                    if not _RX_VAR_REF.search(raw_path):
+                        _check_include_path(raw_path, script_dir, src, lno, issues)
+
+        # -- Recurse into block children --
+        if isinstance(node, IfBlock):
+            _lint_nodes(node.body, script_dir, defined_vars, script_blocks, issues, visited_scripts=visited_scripts)
+            for clause in node.elseif_clauses:
+                _lint_nodes(
+                    clause.body,
+                    script_dir,
+                    defined_vars,
+                    script_blocks,
+                    issues,
+                    visited_scripts=visited_scripts,
+                )
+            _lint_nodes(
+                node.else_body,
+                script_dir,
+                defined_vars,
+                script_blocks,
+                issues,
+                visited_scripts=visited_scripts,
+            )
+        elif isinstance(node, (LoopBlock, BatchBlock, SqlBlock)):
+            _lint_nodes(node.body, script_dir, defined_vars, script_blocks, issues, visited_scripts=visited_scripts)
+        elif isinstance(node, ScriptBlock):
+            # Lint script block body (structural errors already caught by parser)
+            if node.name not in visited_scripts:
+                visited_scripts.add(node.name)
+                sub_issues: list[_Issue] = []
+                _lint_nodes(
+                    node.body,
+                    script_dir,
+                    defined_vars,
+                    script_blocks,
+                    sub_issues,
+                    visited_scripts=visited_scripts,
+                )
+                for sev, ssrc, slno, msg in sub_issues:
+                    issues.append((sev, ssrc, slno, f"[script '{node.name}'] {msg}"))
+
+
+# ---------------------------------------------------------------------------
+# Public entry point
+# ---------------------------------------------------------------------------
+
+
+def lint(
+    script: Script,
+    script_path: str | None = None,
+) -> list[_Issue]:
+    """Perform static analysis on an AST-parsed script.
+
+    Args:
+        script: The parsed :class:`Script` tree.
+        script_path: Path to the source file (for resolving relative
+            INCLUDE paths).  ``None`` for inline scripts.
+
+    Returns:
+        List of ``(severity, source, line_no, message)`` issue tuples.
+    """
+    issues: list[_Issue] = []
+
+    if not script.body:
+        issues.append(_warning("<script>", 0, "Script is empty — no commands found"))
+        return issues
+
+    script_dir = Path(script_path).resolve().parent if script_path else None
+    script_blocks = _collect_script_blocks(script)
+
+    # Pass 1: collect all variable definitions
+    all_defined: set[str] = set()
+    _collect_defined_vars_from_nodes(script.body, script_blocks, script_dir, all_defined)
+
+    # Pass 2: lint for variable and include issues
+    _lint_nodes(
+        script.body,
+        script_dir,
+        all_defined,
+        script_blocks,
+        issues,
+    )
+
+    return issues
+
+
+# ---------------------------------------------------------------------------
+# Result printing
+# ---------------------------------------------------------------------------
+
+
 def _print_lint_results(issues: list[_Issue], script_label: str) -> int:
     """Print lint issues to the console using Rich formatting.
 

execsql/cli/run.py

@@ -65,12 +65,21 @@ def _print_dry_run(tree: object) -> None:
         else:
             ctype = "METACMD"
             raw = "-- !x! " + node.command
-        source_info = f"[dim]{node.span.file}:{node.span.start_line}[/dim]"
+        file_loc = f"{node.span.file}:{node.span.start_line}"
         try:
             expanded = substitute_vars(raw)
         except Exception:
             expanded = raw
-        _console.print(f"  [dim]{i:>4}[/dim]  [bold green]{ctype}[/bold green]  {source_info}  {expanded}")
+        lines = expanded.splitlines() or [""]
+        first, *continuations = lines
+        _console.print(
+            f"  [dim]{i:>4}[/dim]  [bold green]{ctype}[/bold green]  [dim]{file_loc}[/dim]  {first}",
+        )
+        if continuations:
+            prefix_width = 2 + 4 + 2 + 7 + 2 + len(file_loc) + 2
+            pad = " " * prefix_width
+            for cont in continuations:
+                _console.print(f"{pad}{cont}")
 
 
 # ---------------------------------------------------------------------------
@@ -411,6 +420,12 @@ def _route_positionals(
     ping: bool,
 ) -> None:
     """Apply remaining positional CLI arguments to *conf* as server/db/db_file."""
+    # When --ping is set, the script-file positional is ignored (ping has no
+    # script).  Users who add --ping to an existing invocation often leave the
+    # script in place — drop it from positional routing so the connection args
+    # behind it are interpreted correctly.
+    if ping and positional and Path(positional[0]).is_file() and positional[0].lower().endswith(".sql"):
+        positional = positional[1:]
     off = 0 if (command is not None or ping) else 1
     if len(positional) == off + 1:
         if conf.db_type in ("a", "l", "k"):
@@ -648,6 +663,33 @@ def _run(
 
     _state.output = WriteHooks()
 
+    # ------------------------------------------------------------------
+    # Early exits — modes that touch nothing besides parsing/connecting.
+    # Keep these before FileWriter / log / atexit so --dry-run and --ping
+    # honor their "no side effects" contracts.
+    # ------------------------------------------------------------------
+    if dry_run:
+        # Seed -a assign-args so substitute_vars in the dry-run print can
+        # expand them; the normal path does this inside _setup_logging,
+        # which we are skipping.
+        if sub_vars:
+            for n, repl in enumerate(sub_vars):
+                _state.subvars.add_substitution(f"$ARG_{n + 1}", repl)
+        _ast_tree = _load_script(command, script_name, conf.script_encoding)
+        _print_dry_run(_ast_tree)
+        raise SystemExit(0)
+
+    if ping:
+        if conf.server is None and conf.db is None and conf.db_file is None:
+            from execsql.utils.errors import fatal_error
+
+            fatal_error(
+                "Database not specified for --ping in configuration files or command-line arguments.",
+            )
+        db = _connect_initial_db(conf)
+        _state.dbs.add("initial", db)
+        _ping_db(db)  # raises SystemExit
+
     import execsql.utils.fileio as _fileio
 
     if _state.filewriter is None or not _state.filewriter.is_alive():
@@ -696,16 +738,9 @@ def _run(
     )
 
     # ------------------------------------------------------------------
-    # Load the SQL script (skipped in --ping mode)
+    # Load the SQL script (--dry-run / --ping already exited above)
     # ------------------------------------------------------------------
-    _ast_tree = None if ping else _load_script(command, script_name, conf.script_encoding)
-
-    # ------------------------------------------------------------------
-    # Dry-run: print command list and exit without connecting to DB
-    # ------------------------------------------------------------------
-    if dry_run:
-        _print_dry_run(_ast_tree)
-        raise SystemExit(0)
+    _ast_tree = _load_script(command, script_name, conf.script_encoding)
 
     # ------------------------------------------------------------------
     # NOTE: --lint is handled as an early exit in cli/__init__.py (AST
@@ -741,12 +776,6 @@ def _run(
     _state.subvars.add_substitution("$DB_SERVER", db.server_name)
     _state.subvars.add_substitution("$SYSTEM_CMD_EXIT_STATUS", "0")
 
-    # ------------------------------------------------------------------
-    # --ping: report connection details and exit (no script executed)
-    # ------------------------------------------------------------------
-    if ping:
-        _ping_db(db)  # raises SystemExit(0) on success
-
     # ------------------------------------------------------------------
     # Execute the script
     # ------------------------------------------------------------------

execsql/data/execsql.conf.template

@@ -1,6 +1,6 @@
 # execsql.conf — Configuration file for execsql
 #
-# Documentation: https://execsql2.readthedocs.io/reference/configuration/
+# Documentation: https://execsql2.readthedocs.io/en/latest/reference/configuration/
 #
 # This file uses INI format. Section names are case-sensitive (lowercase).
 # Property names are not case-sensitive. Lines starting with # are comments.
@@ -263,7 +263,7 @@
 #message_css=
 
 # Obfuscated password (XOR, not cryptographically secure — use keyring instead).
-# See: https://execsql2.readthedocs.io/reference/security/#credentials
+# See: https://execsql2.readthedocs.io/en/latest/reference/security/#credentials
 #enc_password=
 
 
@@ -279,6 +279,38 @@
 # Values: Yes or No.  Default: Yes.
 #allow_system_cmd=Yes
 
+# Whether to allow the RM_FILE metacommand (which deletes a file).
+# Set to No to prevent scripts from deleting files.
+# Also controllable via --no-rm-file CLI flag.
+# Values: Yes or No.  Default: Yes.
+#allow_rm_file=Yes
+
+# Whether to allow the SERVE metacommand (which opens an HTTP server on
+# a local port to serve a single file). Set to No to disable.
+# Also controllable via --no-serve CLI flag.
+# Values: Yes or No.  Default: Yes.
+#allow_serve=Yes
+
+# Root directory under which INCLUDE / EXECUTE SCRIPT targets must
+# resolve. When set, attempts to include files outside this root via
+# ../, absolute paths, drive letters, or UNC paths are rejected with
+# an error. Default: no containment (any readable path is permitted).
+#include_root=
+
+# Root directory under which SERVE targets must resolve. Same
+# containment semantics as include_root. Default: no containment.
+#serve_root=
+
+# Root directory under which Jinja2 / string.Template loader paths
+# must resolve. Same containment semantics as include_root.
+# Default: no containment.
+#template_root=
+
+# Maximum byte size of any single substitution-variable expansion,
+# enforced by the substitute_vars() engine to defeat exponential-
+# expansion bombs. Default: 10 MB (10485760).
+#max_substitution_bytes=10485760
+
 # Whether to log all data variable assignments.
 # Values: Yes or No.  Default: Yes.
 #log_datavars=Yes

execsql/db/access.py

@@ -88,12 +88,6 @@ class AccessDatabase(Database):
     def __repr__(self) -> str:
         return f"AccessDatabase({self.db_name}, {self.encoding})"
 
-    def auto_commits_ddl(self) -> bool:
-        """MS Access (via Jet/ACE on pyodbc) implicitly commits DDL —
-        ``rollback()`` is a silent no-op for any transaction whose
-        boundary the DDL crossed."""
-        return True
-
     def open_db(self) -> None:
         """Open an ODBC connection to the Access database."""
         # Open an ODBC connection.

execsql/db/base.py

@@ -253,19 +253,6 @@ class Database(ABC):
         """
         return False
 
-    def auto_commits_ddl(self) -> bool:
-        """Return True if this adapter's driver implicitly commits DDL.
-
-        Oracle, MySQL, SQL Server, and MS Access all auto-commit DDL —
-        ``rollback()`` is a silent no-op for any transaction whose
-        boundary the DDL crossed. Callers that wrap DDL inside an
-        explicit ``BEGIN BATCH … END BATCH`` block on these adapters
-        get weaker rollback guarantees than on PostgreSQL / SQLite, and
-        should be aware of the asymmetry. See
-        ``docs/about/divergence.md`` for the full per-DBMS matrix.
-        """
-        return False
-
     def schema_qualified_table_name(self, schema_name: str | None, table_name: str) -> str:
         """Return the quoted, optionally schema-qualified form of *table_name*."""
         table_name = self.type.quoted(table_name)