execsql2 2.17.0__py3-none-any.whl → 2.17.3__py3-none-any.whl

execsql/__init__.py

@@ -3,8 +3,12 @@ execsql — a maintained fork of the execsql SQL scripting tool.
 
 This package provides the ``execsql`` CLI command (distributed as the
 ``execsql2`` package on PyPI) and the ``execsql`` importable module.
-The top-level package exposes only the package version; all public
-functionality lives in sub-modules.
+
+The top-level package re-exports the public Python API for programmatic
+use: :func:`run`, :class:`ScriptResult`, :class:`ScriptError`, and the
+:class:`ExecSqlError` exception that :meth:`ScriptResult.raise_on_error`
+raises. Internal sub-modules carry the rest of the implementation
+(``cli``, ``db``, ``script``, ``metacommands``, etc.).
 """
 
 from __future__ import annotations

execsql/api.py

@@ -76,8 +76,12 @@ class ScriptResult:
         commands_run: Number of SQL statements and metacommands executed.
         elapsed: Wall-clock execution time in seconds.
         errors: List of errors encountered (empty on success).
-        variables: Final state of all user-defined substitution variables
-            (``$``-prefixed names, without the ``$``).
+        variables: Final state of substitution variables, keyed by name
+            without any sigil. Includes user-defined variables (no prefix)
+            and system variables (the leading ``$`` is stripped, so
+            ``$DATE_TAG`` appears as ``"DATE_TAG"``). Environment (``&``),
+            column-data (``@``), script-local (``~``), and script-parameter
+            (``#``) variables are excluded.
     """
 
     success: bool
@@ -100,7 +104,20 @@ class ScriptResult:
 
 
 class ExecSqlError(Exception):
-    """Raised by :meth:`ScriptResult.raise_on_error` when a script fails."""
+    """Raised by :meth:`ScriptResult.raise_on_error` when a script fails.
+
+    Note:
+        This is a separate class from :class:`execsql.exceptions.ExecSqlError`,
+        which is the internal base of the in-process exception hierarchy
+        (``ErrInfo``, ``ConfigError``, etc.). The library API never
+        propagates those — internal exceptions are caught and converted
+        to :class:`ScriptError` entries on the returned :class:`ScriptResult`.
+        Only ``raise_on_error()`` raises this public exception.
+
+    Attributes:
+        result: The :class:`ScriptResult` that triggered the raise. The
+            full error list is available on ``result.errors``.
+    """
 
     def __init__(self, message: str, result: ScriptResult) -> None:
         super().__init__(message)
@@ -338,8 +355,10 @@ def run(
             error.  If ``False``, capture errors and continue.
         new_db: If ``True``, create the database if it does not exist
             (SQLite, PostgreSQL, DuckDB).
-        allow_system_cmd: If ``False``, the SYSTEM_CMD (SHELL) metacommand
-            is disabled and will raise an error if encountered.
+        allow_system_cmd: If ``False``, the SYSTEM_CMD metacommand is
+            disabled and will raise an error if encountered. Matches the
+            ``--no-system-cmd`` CLI flag and the ``allow_system_cmd``
+            config option.
 
     Returns:
         A :class:`ScriptResult` with execution outcome, timing, errors,
@@ -449,7 +468,7 @@ def run(
     ctx.exec_log = _NoOpLogger()
 
     with active_context(ctx):
-        # Initialize singletons (IfLevels, CounterVars, Timer, DatabasePool, etc.)
+        # Initialize singletons (CounterVars, Timer, DatabasePool, BatchLevels, etc.)
         from execsql.state import initialize
 
         initialize(conf, DISPATCH_TABLE, CONDITIONAL_TABLE)

execsql/cli/__init__.py

@@ -5,9 +5,11 @@ initialisation, database connection, and script execution.
 
 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
+- :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`      — Lint result printing (``_print_lint_results``); the flat-CommandList ``_lint_cmdlist`` it also contains is legacy and no longer reached from the CLI
 """
 
 from __future__ import annotations

execsql/cli/lint.py

@@ -1,37 +1,33 @@
-"""Static analysis (lint) for execsql scripts.
-
-:func:`_lint_script` inspects a parsed :class:`~execsql.script.CommandList`
-for common structural problems without connecting to a database or executing
-any commands.
-
-Checks performed
-----------------
-1. **Unmatched IF / ENDIF** — mismatched nesting depth (error).
-2. **Unmatched LOOP / END LOOP** — mismatched nesting depth (error).
-3. **Unmatched BEGIN BATCH / END BATCH** — mismatched nesting depth (error).
-4. **Potentially undefined variables** — ``!!$VAR!!`` tokens not preceded by a
-   ``SUB`` (or ``SUB_EMPTY``, ``SUB_ADD``, ``SUB_APPEND``, ``SUBDATA``)
-   metacommand in the same parsed command list and not in the set of built-in
-   variables (warning).  Note: ``SUB_INI`` and ``SELECT_SUB`` define variables
-   whose names are not statically knowable — those may produce false-positive
-   warnings.
-5. **EXECUTE SCRIPT flow analysis** — when an ``EXECUTE SCRIPT <name>``
-   metacommand is encountered, the linter descends into the named script
-   block (if found in ``_state.savedscripts``) and merges any variables it
-   defines back into the caller's scope.
-6. **Missing INCLUDE files** — INCLUDE target does not exist on disk relative
-   to the script directory (warning).
-7. **Empty script** — no commands found (warning).
-
-The function walks ``CommandList.cmdlist`` and also descends into any
-``CommandList`` objects stored in ``_state.savedscripts`` (i.e. named scripts
-defined with ``BEGIN SCRIPT … END SCRIPT`` in the same file).  SCRIPT blocks
-are analysed in isolation; nesting counters reset for each block.
-
-Exit-code contract
-------------------
-- Returns ``1`` when at least one **error**-severity issue is found.
-- Returns ``0`` when only warnings (or nothing) are found.
+"""Legacy flat-CommandList linter and shared result printer for execsql.
+
+The active ``--lint`` implementation is in :mod:`execsql.cli.lint_ast`,
+which works against the AST produced by
+:func:`execsql.script.parser.parse_script`. The CLI reaches that
+linter directly; the ``_lint_cmdlist`` walker in this module is
+unreached from the CLI now and is retained for reference / potential
+reuse only.
+
+What's still used from this module:
+
+- :func:`_print_lint_results` — shared Rich-formatted output for both
+  the AST linter and any code that still constructs lint issues
+  manually. Called from ``cli/__init__.py`` and re-exported via
+  ``cli/run.py``.
+- :class:`_Issue` and the ``_error()`` / ``_warning()`` constructors
+  — used by both linters.
+
+The flat-CommandList ``_lint_cmdlist``, ``_collect_defined_vars``, and
+``_discover_builtin_vars`` helpers below covered the same checks the
+AST linter now performs (unmatched IF/LOOP/BATCH, undefined ``!!$VAR!!``
+references, missing INCLUDE files, EXECUTE SCRIPT flow analysis, empty
+script). They operate on the legacy
+:class:`~execsql.script.engine.CommandList`; no CLI path constructs
+that representation any more.
+
+Exit-code contract (still honoured by the AST linter):
+
+- ``1`` when at least one error-severity issue is found.
+- ``0`` when only warnings (or nothing) are found.
 """
 
 from __future__ import annotations

execsql/cli/run.py

@@ -630,6 +630,16 @@ def _run(
     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,

execsql/config.py

@@ -74,6 +74,17 @@ class ConfigData:
     _INCLUDE_REQ_SECTION = "include_required"
     _INCLUDE_OPT_SECTION = "include_optional"
 
+    # Schema registry: maps attribute name -> (section, ini_key, type_label).
+    # Populated by the _get_* methods on every option they read.  This is the
+    # canonical source for DEBUG WRITE CONFIG / DEBUG LOG CONFIG output —
+    # adding a new option below automatically makes it appear in the dump.
+    _schema: dict[str, tuple[str, str, str]] = {}
+
+    @classmethod
+    def _register_option(cls, section: str, key: str, attr: str, type_label: str) -> None:
+        """Record ``attr`` in the schema registry so config introspection sees it."""
+        cls._schema[attr] = (section, key, type_label)
+
     def _get_str(self, cp: ConfigParser, section: str, key: str, attr: str, *, required: bool = False) -> None:
         """Read a string option and set ``self.<attr>``.
 
@@ -84,6 +95,7 @@ class ConfigData:
             attr: Attribute name to set on ``self``.
             required: If ``True``, raise :class:`ConfigError` when the value is ``None``.
         """
+        self._register_option(section, key, attr, "str")
         if cp.has_option(section, key):
             val = cp.get(section, key)
             if required and val is None:
@@ -110,6 +122,7 @@ class ConfigData:
             choices: Tuple of permitted values.
             lower: If ``True`` (default), lower-case the raw value before validation.
         """
+        self._register_option(section, key, attr, "enum")
         if cp.has_option(section, key):
             val = cp.get(section, key)
             if lower:
@@ -130,6 +143,7 @@ class ConfigData:
         Raises:
             ConfigError: If the value cannot be parsed as a boolean.
         """
+        self._register_option(section, key, attr, "bool")
         if cp.has_option(section, key):
             try:
                 setattr(self, attr, cp.getboolean(section, key))
@@ -159,6 +173,7 @@ class ConfigData:
         Raises:
             ConfigError: If the value cannot be parsed as an integer.
         """
+        self._register_option(section, key, attr, "int")
         if cp.has_option(section, key):
             try:
                 val = cp.getint(section, key) * multiply
@@ -189,6 +204,7 @@ class ConfigData:
         Raises:
             ConfigError: If the value cannot be parsed as a float, or is below ``min_val``.
         """
+        self._register_option(section, key, attr, "float")
         if cp.has_option(section, key):
             try:
                 val = cp.getfloat(section, key)
@@ -198,6 +214,127 @@ class ConfigData:
                 raise ConfigError(f"Invalid {key}: {val}; must be >= {min_val}.")
             setattr(self, attr, val)
 
+    def _read_known_options(self, cp: ConfigParser) -> None:
+        """Apply every schema-registered option from ``cp`` to ``self``.
+
+        Single source of truth for which options ``ConfigData`` knows about.
+        Called once with an empty ``ConfigParser`` at the start of ``__init__``
+        so :attr:`_schema` is populated even when no config files exist on the
+        system, then again from the file-merge loop for each real config file
+        (which actually sets attribute values).
+
+        Options with special-case validation (``db_type``, ``write_prefix``,
+        ``gui_level``, ``gui_framework``, ``dao_flush_delay_secs``,
+        ``enc_password``, ``email_format``) stay inline in ``__init__`` to
+        preserve their exact error messages and side effects.
+        """
+        # --- [connect] ---
+        self._get_str(cp, self._CONNECT_SECTION, "server", "server", required=True)
+        self._get_str(cp, self._CONNECT_SECTION, "db", "db", required=True)
+        self._get_int(cp, self._CONNECT_SECTION, "port", "port")
+        self._get_str(cp, self._CONNECT_SECTION, "database", "db", required=True)
+        self._get_str(cp, self._CONNECT_SECTION, "db_file", "db_file", required=True)
+        self._get_str(cp, self._CONNECT_SECTION, "username", "username", required=True)
+        self._get_str(cp, self._CONNECT_SECTION, "access_username", "access_username")
+        self._get_bool(cp, self._CONNECT_SECTION, "password_prompt", "passwd_prompt")
+        self._get_bool(cp, self._CONNECT_SECTION, "use_keyring", "use_keyring")
+        self._get_bool(cp, self._CONNECT_SECTION, "new_db", "new_db")
+        # --- [encoding] ---
+        self._get_str(cp, self._ENCODING_SECTION, "database", "db_encoding")
+        self._get_str(cp, self._ENCODING_SECTION, "script", "script_encoding", required=True)
+        self._get_str(cp, self._ENCODING_SECTION, "import", "import_encoding", required=True)
+        self._get_str(cp, self._ENCODING_SECTION, "output", "output_encoding", required=True)
+        self._get_enum(
+            cp,
+            self._ENCODING_SECTION,
+            "error_response",
+            "enc_err_disposition",
+            ("ignore", "replace", "xmlcharrefreplace", "backslashreplace"),
+        )
+        # --- [input] ---
+        self._get_int(cp, self._INPUT_SECTION, "max_int", "max_int")
+        self._get_bool(cp, self._INPUT_SECTION, "boolean_int", "boolean_int")
+        self._get_bool(cp, self._INPUT_SECTION, "boolean_words", "boolean_words")
+        self._get_bool(cp, self._INPUT_SECTION, "empty_strings", "empty_strings")
+        self._get_bool(cp, self._INPUT_SECTION, "only_strings", "only_strings")
+        self._get_bool(cp, self._INPUT_SECTION, "empty_rows", "empty_rows")
+        self._get_bool(cp, self._INPUT_SECTION, "delete_empty_columns", "del_empty_cols")
+        self._get_bool(cp, self._INPUT_SECTION, "create_column_headers", "create_col_hdrs")
+        self._get_enum(
+            cp,
+            self._INPUT_SECTION,
+            "trim_column_headers",
+            "trim_col_hdrs",
+            ("none", "both", "left", "right"),
+        )
+        self._get_bool(cp, self._INPUT_SECTION, "clean_column_headers", "clean_col_hdrs")
+        self._get_enum(
+            cp,
+            self._INPUT_SECTION,
+            "fold_column_headers",
+            "fold_col_hdrs",
+            ("no", "lower", "upper"),
+        )
+        self._get_bool(cp, self._INPUT_SECTION, "dedup_column_headers", "dedup_col_hdrs")
+        self._get_bool(cp, self._INPUT_SECTION, "trim_strings", "trim_strings")
+        self._get_bool(cp, self._INPUT_SECTION, "replace_newlines", "replace_newlines")
+        self._get_int(cp, self._INPUT_SECTION, "import_row_buffer", "import_row_buffer")
+        self._get_int(cp, self._INPUT_SECTION, "import_progress_interval", "import_progress_interval")
+        self._get_bool(cp, self._INPUT_SECTION, "show_progress", "show_progress")
+        self._get_bool(cp, self._INPUT_SECTION, "access_use_numeric", "access_use_numeric")
+        self._get_bool(cp, self._INPUT_SECTION, "import_only_common_columns", "import_common_cols_only")
+        self._get_bool(cp, self._INPUT_SECTION, "import_common_columns_only", "import_common_cols_only")
+        self._get_int(cp, self._INPUT_SECTION, "scan_lines", "scan_lines")
+        self._get_int(cp, self._INPUT_SECTION, "import_buffer", "import_buffer", multiply=1024)
+        # --- [output] ---
+        self._get_bool(cp, self._OUTPUT_SECTION, "log_write_messages", "tee_write_log")
+        self._get_int(cp, self._OUTPUT_SECTION, "hdf5_text_len", "hdf5_text_len")
+        self._get_str(cp, self._OUTPUT_SECTION, "css_file", "css_file", required=True)
+        self._get_str(cp, self._OUTPUT_SECTION, "css_styles", "css_styles", required=True)
+        self._get_bool(cp, self._OUTPUT_SECTION, "make_export_dirs", "make_export_dirs")
+        self._get_bool(cp, self._OUTPUT_SECTION, "quote_all_text", "quote_all_text")
+        self._get_int(cp, self._OUTPUT_SECTION, "outfile_open_timeout", "outfile_open_timeout")
+        self._get_int(cp, self._OUTPUT_SECTION, "export_row_buffer", "export_row_buffer")
+        self._get_enum(
+            cp,
+            self._OUTPUT_SECTION,
+            "template_processor",
+            "template_processor",
+            ("jinja",),
+        )
+        self._get_int(cp, self._OUTPUT_SECTION, "zip_buffer_mb", "zip_buffer_mb")
+        # --- [interface] ---
+        self._get_bool(cp, self._INTERFACE_SECTION, "write_warnings", "write_warnings")
+        self._get_int(cp, self._INTERFACE_SECTION, "console_height", "gui_console_height", min_val=5)
+        self._get_int(cp, self._INTERFACE_SECTION, "console_width", "gui_console_width", min_val=20)
+        self._get_bool(cp, self._INTERFACE_SECTION, "console_wait_when_done", "gui_wait_on_exit")
+        self._get_bool(cp, self._INTERFACE_SECTION, "console_wait_when_error_halt", "gui_wait_on_error_halt")
+        # --- [config] ---
+        self._get_bool(cp, self._CONFIG_SECTION, "user_logfile", "user_logfile")
+        self._get_bool(cp, self._CONFIG_SECTION, "log_datavars", "log_datavars")
+        self._get_bool(cp, self._CONFIG_SECTION, "log_sql", "log_sql")
+        self._get_int(cp, self._CONFIG_SECTION, "max_log_size_mb", "max_log_size_mb")
+        self._get_bool(cp, self._CONFIG_SECTION, "allow_system_cmd", "allow_system_cmd")
+        # --- [email] ---
+        self._get_str(cp, self._EMAIL_SECTION, "host", "smtp_host")
+        self._get_int(cp, self._EMAIL_SECTION, "port", "smtp_port")
+        self._get_str(cp, self._EMAIL_SECTION, "username", "smtp_username")
+        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_str(cp, self._EMAIL_SECTION, "message_css", "email_css")
+
+        # Register options whose loading lives inline in __init__ (because they
+        # need special-case validation or side effects) so they still appear in
+        # DEBUG WRITE CONFIG.
+        self._register_option(self._CONNECT_SECTION, "db_type", "db_type", "enum")
+        self._register_option(self._INTERFACE_SECTION, "write_prefix", "write_prefix", "str")
+        self._register_option(self._INTERFACE_SECTION, "write_suffix", "write_suffix", "str")
+        self._register_option(self._INTERFACE_SECTION, "gui_level", "gui_level", "int")
+        self._register_option(self._INTERFACE_SECTION, "gui_framework", "gui_framework", "enum")
+        self._register_option(self._CONFIG_SECTION, "dao_flush_delay_secs", "dao_flush_delay_secs", "float")
+        self._register_option(self._EMAIL_SECTION, "email_format", "email_format", "enum")
+
     def __init__(
         self,
         script_path: str,
@@ -309,6 +446,13 @@ class ConfigData:
         _MAX_CONFIG_CHAIN = 20  # Guard against circular config_file references.
         config_queue: deque[str] = deque(config_files)
         self.files_read: list = []
+        # Warm the schema registry by running the option reader against an
+        # empty ConfigParser. cp.has_option() is False for everything so no
+        # attribute values change, but every _get_* call registers its
+        # (section, ini_key, attr) tuple in ConfigData._schema. This means
+        # DEBUG WRITE CONFIG / DEBUG LOG CONFIG see the full option set even
+        # when no execsql.conf files exist on the system.
+        self._read_known_options(ConfigParser())
         while config_queue:
             configfile = config_queue.popleft()
             if len(self.files_read) >= _MAX_CONFIG_CHAIN:
@@ -323,82 +467,7 @@ class ConfigData:
                     if t not in ("a", "d", "f", "k", "l", "m", "o", "p", "s"):
                         raise ConfigError(f"Invalid database type: {t}")
                     self.db_type = t
-                self._get_str(cp, self._CONNECT_SECTION, "server", "server", required=True)
-                self._get_str(cp, self._CONNECT_SECTION, "db", "db", required=True)
-                self._get_int(cp, self._CONNECT_SECTION, "port", "port")
-                self._get_str(cp, self._CONNECT_SECTION, "database", "db", required=True)
-                self._get_str(cp, self._CONNECT_SECTION, "db_file", "db_file", required=True)
-                self._get_str(cp, self._CONNECT_SECTION, "username", "username", required=True)
-                self._get_str(cp, self._CONNECT_SECTION, "access_username", "access_username")
-                self._get_bool(cp, self._CONNECT_SECTION, "password_prompt", "passwd_prompt")
-                self._get_bool(cp, self._CONNECT_SECTION, "use_keyring", "use_keyring")
-                self._get_bool(cp, self._CONNECT_SECTION, "new_db", "new_db")
-                # --- [encoding] ---
-                self._get_str(cp, self._ENCODING_SECTION, "database", "db_encoding")
-                self._get_str(cp, self._ENCODING_SECTION, "script", "script_encoding", required=True)
-                self._get_str(cp, self._ENCODING_SECTION, "import", "import_encoding", required=True)
-                self._get_str(cp, self._ENCODING_SECTION, "output", "output_encoding", required=True)
-                self._get_enum(
-                    cp,
-                    self._ENCODING_SECTION,
-                    "error_response",
-                    "enc_err_disposition",
-                    ("ignore", "replace", "xmlcharrefreplace", "backslashreplace"),
-                )
-                # --- [input] ---
-                self._get_int(cp, self._INPUT_SECTION, "max_int", "max_int")
-                self._get_bool(cp, self._INPUT_SECTION, "boolean_int", "boolean_int")
-                self._get_bool(cp, self._INPUT_SECTION, "boolean_words", "boolean_words")
-                self._get_bool(cp, self._INPUT_SECTION, "empty_strings", "empty_strings")
-                self._get_bool(cp, self._INPUT_SECTION, "only_strings", "only_strings")
-                self._get_bool(cp, self._INPUT_SECTION, "empty_rows", "empty_rows")
-                self._get_bool(cp, self._INPUT_SECTION, "delete_empty_columns", "del_empty_cols")
-                self._get_bool(cp, self._INPUT_SECTION, "create_column_headers", "create_col_hdrs")
-                self._get_enum(
-                    cp,
-                    self._INPUT_SECTION,
-                    "trim_column_headers",
-                    "trim_col_hdrs",
-                    ("none", "both", "left", "right"),
-                )
-                self._get_bool(cp, self._INPUT_SECTION, "clean_column_headers", "clean_col_hdrs")
-                self._get_enum(
-                    cp,
-                    self._INPUT_SECTION,
-                    "fold_column_headers",
-                    "fold_col_hdrs",
-                    ("no", "lower", "upper"),
-                )
-                self._get_bool(cp, self._INPUT_SECTION, "dedup_column_headers", "dedup_col_hdrs")
-                self._get_bool(cp, self._INPUT_SECTION, "trim_strings", "trim_strings")
-                self._get_bool(cp, self._INPUT_SECTION, "replace_newlines", "replace_newlines")
-                self._get_int(cp, self._INPUT_SECTION, "import_row_buffer", "import_row_buffer")
-                self._get_int(cp, self._INPUT_SECTION, "import_progress_interval", "import_progress_interval")
-                self._get_bool(cp, self._INPUT_SECTION, "show_progress", "show_progress")
-                self._get_bool(cp, self._INPUT_SECTION, "access_use_numeric", "access_use_numeric")
-                self._get_bool(cp, self._INPUT_SECTION, "import_only_common_columns", "import_common_cols_only")
-                self._get_bool(cp, self._INPUT_SECTION, "import_common_columns_only", "import_common_cols_only")
-                self._get_int(cp, self._INPUT_SECTION, "scan_lines", "scan_lines")
-                self._get_int(cp, self._INPUT_SECTION, "import_buffer", "import_buffer", multiply=1024)
-                # --- [output] ---
-                self._get_bool(cp, self._OUTPUT_SECTION, "log_write_messages", "tee_write_log")
-                self._get_int(cp, self._OUTPUT_SECTION, "hdf5_text_len", "hdf5_text_len")
-                self._get_str(cp, self._OUTPUT_SECTION, "css_file", "css_file", required=True)
-                self._get_str(cp, self._OUTPUT_SECTION, "css_styles", "css_styles", required=True)
-                self._get_bool(cp, self._OUTPUT_SECTION, "make_export_dirs", "make_export_dirs")
-                self._get_bool(cp, self._OUTPUT_SECTION, "quote_all_text", "quote_all_text")
-                self._get_int(cp, self._OUTPUT_SECTION, "outfile_open_timeout", "outfile_open_timeout")
-                self._get_int(cp, self._OUTPUT_SECTION, "export_row_buffer", "export_row_buffer")
-                self._get_enum(
-                    cp,
-                    self._OUTPUT_SECTION,
-                    "template_processor",
-                    "template_processor",
-                    ("jinja",),
-                )
-                self._get_int(cp, self._OUTPUT_SECTION, "zip_buffer_mb", "zip_buffer_mb")
-                # --- [interface] ---
-                self._get_bool(cp, self._INTERFACE_SECTION, "write_warnings", "write_warnings")
+                self._read_known_options(cp)
                 # write_prefix / write_suffix have special "clear" → None handling
                 if cp.has_option(self._INTERFACE_SECTION, "write_prefix"):
                     try:
@@ -425,10 +494,6 @@ class ConfigData:
                     if fw not in ("tkinter", "textual"):
                         raise ConfigError("gui_framework must be 'tkinter' or 'textual'.")
                     self.gui_framework = fw
-                self._get_int(cp, self._INTERFACE_SECTION, "console_height", "gui_console_height", min_val=5)
-                self._get_int(cp, self._INTERFACE_SECTION, "console_width", "gui_console_width", min_val=20)
-                self._get_bool(cp, self._INTERFACE_SECTION, "console_wait_when_done", "gui_wait_on_exit")
-                self._get_bool(cp, self._INTERFACE_SECTION, "console_wait_when_error_halt", "gui_wait_on_error_halt")
                 # --- [config] ---
                 # config_file / OS-specific config files retain special chaining logic
                 if cp.has_option(self._CONFIG_SECTION, "config_file"):
@@ -464,7 +529,6 @@ class ConfigData:
                         conffile = str(Path(conffile) / self.config_file_name)
                     if Path(conffile).is_file():
                         config_queue.appendleft(conffile)
-                self._get_bool(cp, self._CONFIG_SECTION, "user_logfile", "user_logfile")
                 # dao_flush_delay_secs has a specific error message — keep inline
                 if cp.has_option(self._CONFIG_SECTION, "dao_flush_delay_secs"):
                     self.dao_flush_delay_secs = cp.getfloat(self._CONFIG_SECTION, "dao_flush_delay_secs")
@@ -472,15 +536,7 @@ class ConfigData:
                         raise ConfigError(
                             f"Invalid DAO flush delay: {self.dao_flush_delay_secs}; must be >= 5.0.",
                         )
-                self._get_bool(cp, self._CONFIG_SECTION, "log_datavars", "log_datavars")
-                self._get_bool(cp, self._CONFIG_SECTION, "log_sql", "log_sql")
-                self._get_int(cp, self._CONFIG_SECTION, "max_log_size_mb", "max_log_size_mb")
-                self._get_bool(cp, self._CONFIG_SECTION, "allow_system_cmd", "allow_system_cmd")
                 # --- [email] ---
-                self._get_str(cp, self._EMAIL_SECTION, "host", "smtp_host")
-                self._get_int(cp, self._EMAIL_SECTION, "port", "smtp_port")
-                self._get_str(cp, self._EMAIL_SECTION, "username", "smtp_username")
-                self._get_str(cp, self._EMAIL_SECTION, "password", "smtp_password")
                 # enc_password has special decryption logic — keep inline
                 if cp.has_option(self._EMAIL_SECTION, "enc_password"):
                     import warnings
@@ -492,15 +548,12 @@ class ConfigData:
                         stacklevel=1,
                     )
                     self.smtp_password = Encrypt().decrypt(cp.get(self._EMAIL_SECTION, "enc_password"))
-                self._get_bool(cp, self._EMAIL_SECTION, "use_ssl", "smtp_ssl")
-                self._get_bool(cp, self._EMAIL_SECTION, "use_tls", "smtp_tls")
                 # email_format has a specific error message — keep inline
                 if cp.has_option(self._EMAIL_SECTION, "email_format"):
                     fmt = cp.get(self._EMAIL_SECTION, "email_format").lower()
                     if fmt not in ("plain", "html"):
                         raise ConfigError(f"Invalid email format: {fmt}")
                     self.email_format = fmt
-                self._get_str(cp, self._EMAIL_SECTION, "message_css", "email_css")
                 if cp.has_section(self._VARIABLES_SECTION) and variable_pool:
                     varsect = cp.items(self._VARIABLES_SECTION)
                     for sub, repl in varsect:

execsql/db/access.py

@@ -109,13 +109,15 @@ class AccessDatabase(Database):
                 try:
                     self.conn = pyodbc.connect(connstr)
                 except Exception:
-                    _state.exec_log.log_status_info(
-                        f"Could not connect via ODBC using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
-                    )
+                    if _state.exec_log is not None:
+                        _state.exec_log.log_status_info(
+                            f"Could not connect via ODBC using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
+                        )
                 else:
-                    _state.exec_log.log_status_info(
-                        f"Connected via ODBC using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
-                    )
+                    if _state.exec_log is not None:
+                        _state.exec_log.log_status_info(
+                            f"Connected via ODBC using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
+                        )
                     self.jet4 = jet4flag
                     return True
             return False
@@ -162,9 +164,11 @@ class AccessDatabase(Database):
                     else:
                         self.dao_conn = daoEngine.OpenDatabase(self.db_name)
                 except Exception:
-                    _state.exec_log.log_status_info(f"Could not connect via DAO using: {engine}")
+                    if _state.exec_log is not None:
+                        _state.exec_log.log_status_info(f"Could not connect via DAO using: {engine}")
                 else:
-                    _state.exec_log.log_status_info(f"Connected via DAO using: {engine}")
+                    if _state.exec_log is not None:
+                        _state.exec_log.log_status_info(f"Connected via DAO using: {engine}")
                     return True
             return False
 
@@ -307,23 +311,31 @@ class AccessDatabase(Database):
         return headers, iter(dict_row, None)
 
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
-        """Return True if the named table exists in the Access database."""
+        """Return True if the named table exists in the Access database.
+
+        Uses ODBC's catalog function (``cursor.tables()``) instead of
+        querying ``MSysObjects`` directly. Access 2016+ refuses ad-hoc
+        queries on the system catalog with the error
+        ``Record(s) cannot be read; no read permission on 'MSysObjects'``;
+        the ODBC catalog path is permission-clean and matches the table
+        view that ``CREATE TABLE`` modifies, unlike DAO ``TableDefs``
+        which caches independently.
+        """
         self.dao_flush_check()
-        sql = "select Name from MSysObjects where Name=? And Type In (1,4,6);"
-        with self._cursor() as curs:
-            try:
-                curs.execute(sql, (table_name,))
-            except ErrInfo:
-                raise
-            except Exception as e:
-                raise ErrInfo(
-                    type="db",
-                    command_text=sql,
-                    exception_msg=exception_desc(),
-                    other_msg=f"Failure on test for existence of Access table {table_name}",
-                ) from e
-            rows = curs.fetchall()
-        return len(rows) > 0
+        try:
+            with self._cursor() as curs:
+                rows = list(curs.tables(table=table_name, tableType="TABLE"))
+                # Access identifiers are case-insensitive; the catalog
+                # returns whatever case the table was created with.
+                lname = table_name.lower()
+                return any(r.table_name.lower() == lname for r in rows)
+        except Exception as e:
+            raise ErrInfo(
+                type="db",
+                command_text=f"ODBC SQLTables for {table_name}",
+                exception_msg=exception_desc(),
+                other_msg=f"Failure on test for existence of Access table {table_name}",
+            ) from e
 
     def column_exists(
         self,
@@ -352,23 +364,25 @@ class AccessDatabase(Database):
             return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
-        """Return True if the named view or query exists in the Access database."""
+        """Return True if the named view or query exists in the Access database.
+
+        Uses DAO ``QueryDefs`` (Access's saved queries play the role of views)
+        rather than querying ``MSysObjects`` directly — see :meth:`table_exists`
+        for the permission rationale.
+        """
         self.dao_flush_check()
-        sql = "select Name from MSysObjects where Name=? And Type = 5;"
-        with self._cursor() as curs:
-            try:
-                curs.execute(sql, (view_name,))
-            except ErrInfo:
-                raise
-            except Exception as e:
-                raise ErrInfo(
-                    type="db",
-                    command_text=sql,
-                    exception_msg=exception_desc(),
-                    other_msg=f"Test for existence of Access view/query {view_name}",
-                ) from e
-            rows = curs.fetchall()
-        return len(rows) > 0
+        try:
+            with self._cursor() as curs:
+                rows = list(curs.tables(table=view_name, tableType="VIEW"))
+                lname = view_name.lower()
+                return any(r.table_name.lower() == lname for r in rows)
+        except Exception as e:
+            raise ErrInfo(
+                type="db",
+                command_text=f"ODBC SQLTables for view {view_name}",
+                exception_msg=exception_desc(),
+                other_msg=f"Test for existence of Access view/query {view_name}",
+            ) from e
 
     def schema_exists(self, schema_name: str) -> bool:
         """Return False; Access does not support schemas."""