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

execsql/models.py

@@ -268,7 +268,6 @@ class DataTable:
 
         self.inputrows = 0  # Total number of rows in the row source.
         self.datarows = 0  # Number of non-empty rows (with data values).
-        self.shortrows = 0  # Number of rows without as many data values as column names.
         self.cols: list = []  # List of Column objects.
         for n in column_names:
             self.cols.append(Column(n, infer_strings=infer_strings))
@@ -281,7 +280,6 @@ class DataTable:
                 self.datarows += 1
                 chkcols = len(self.cols)
                 if dataitems < chkcols:
-                    self.shortrows += 1
                     chkcols = len(datarow)
                 else:
                     if dataitems > chkcols:
@@ -307,6 +305,9 @@ class DataTable:
                             raise DataTableError(errmsg)
                 for i in range(chkcols):
                     self.cols[i].eval_types(datarow[i])
+                # Trailing values left off a short row are imported as NULL.
+                for i in range(chkcols, len(self.cols)):
+                    self.cols[i].eval_types(None)
         for col in self.cols:
             col.column_type()
 

execsql/parser.py

@@ -215,10 +215,17 @@ class CondParser(CondTokens):
     """Recursive-descent parser for boolean conditional expressions."""
 
     # Takes a conditional expression string.
-    def __init__(self, condexpr: str) -> None:
-        """Initialise the parser with the conditional expression string."""
+    def __init__(self, condexpr: str, conditionallist: Any = None) -> None:
+        """Initialise the parser with the conditional expression string.
+
+        *conditionallist* is the table of conditional tests to match against;
+        ``None`` means the current run's ``conditionallist``.  Passing one lets
+        a caller with no run in progress, such as ``execsql lint``, parse
+        (without evaluating) a condition.
+        """
         self.condexpr = condexpr
         self.cond_expr = SourceString(condexpr)
+        self.conditionallist = conditionallist
 
     def match_not(self) -> int | None:
         """Match a NOT operator and return its token type, or None."""
@@ -251,10 +258,12 @@ class CondParser(CondTokens):
             m1 = self.factor()
             return CondAstNode(self.NOT, m1, None)
         # Find the matching metacommand -- get a tuple consisting of (metacommand, groupdict)
-        # conditionallist is a module-level global in the main execsql module
-        import execsql.state as _state
+        conditionallist = self.conditionallist
+        if conditionallist is None:
+            import execsql.state as _state
 
-        matched_metacommand = self.cond_expr.match_metacommand(_state.conditionallist)
+            conditionallist = _state.conditionallist
+        matched_metacommand = self.cond_expr.match_metacommand(conditionallist)
         if matched_metacommand is not None:
             matched_metacommand[1]["metacommandline"] = self.condexpr
             return CondAstNode(self.CONDITIONAL, matched_metacommand, None)

execsql/plugins.py

@@ -61,6 +61,8 @@ adds entries::
 from __future__ import annotations
 
 import logging
+import threading
+import weakref
 from collections.abc import Callable
 from importlib.metadata import entry_points
 from typing import Any
@@ -71,6 +73,7 @@ __all__ = [
     "ImporterEntry",
     "ImporterRegistry",
     "discover_metacommand_plugins",
+    "register_metacommand_plugins_once",
     "discover_exporter_plugins",
     "discover_importer_plugins",
     "discover_all_plugins",
@@ -344,6 +347,27 @@ def discover_metacommand_plugins(mcl: Any) -> int:
     return loaded
 
 
+_registered_tables: weakref.WeakSet[Any] = weakref.WeakSet()
+_registration_lock = threading.Lock()
+
+
+def register_metacommand_plugins_once(mcl: Any) -> int:
+    """Register metacommand plugins into *mcl* unless that was already done.
+
+    Every run in a process shares one dispatch table, so registering on each
+    run would prepend another copy of every plugin command each time, while
+    other threads may be dispatching from the table.
+
+    Returns:
+        Number of plugins loaded by this call (0 if *mcl* already had them).
+    """
+    with _registration_lock:
+        if mcl in _registered_tables:
+            return 0
+        _registered_tables.add(mcl)
+        return discover_metacommand_plugins(mcl)
+
+
 def discover_exporter_plugins(registry: ExporterRegistry | None = None) -> int:
     """Discover and register exporter plugins.
 

execsql/script/__init__.py

@@ -23,9 +23,6 @@ Key classes:
   handler function + flags).
 - :class:`MetaCommandList` — ordered list of :class:`MetaCommand` entries
   with a keyword index for fast dispatch.
-- :class:`SqlStmt` / :class:`MetacommandStmt` / :class:`ScriptCmd` —
-  statement wrappers carried in the AST and used by ``ctx.last_command``
-  for source-location tracking.
 - :class:`ScriptExecSpec` — specification for deferred script execution
   (used by ``ON ERROR_HALT`` / ``ON CANCEL_HALT EXECUTE SCRIPT``).
 
@@ -46,10 +43,7 @@ from execsql.script.control import BatchLevels
 from execsql.script.engine import (
     MetaCommand,
     MetaCommandList,
-    MetacommandStmt,
-    ScriptCmd,
     ScriptExecSpec,
-    SqlStmt,
     current_script_line,
     set_dynamic_system_vars,
     set_static_system_vars,
@@ -84,9 +78,6 @@ __all__ = [
     "ScriptArgSubVarSet",
     "MetaCommand",
     "MetaCommandList",
-    "SqlStmt",
-    "MetacommandStmt",
-    "ScriptCmd",
     "ScriptExecSpec",
     "set_dynamic_system_vars",
     "set_static_system_vars",

execsql/script/ast.py

@@ -6,7 +6,7 @@ Defines the node types that make up the execsql AST.
 
 Design principles:
     - Every node carries a :class:`SourceSpan` so that error messages,
-      ``--lint``, and the formatter can report precise source locations.
+      ``execsql lint``, and the formatter can report precise source locations.
     - Block structures (IF, LOOP, BATCH, SCRIPT) are represented as nodes
       whose ``body`` (and optional ``else_body``, ``elseif_clauses``) contain
       child nodes, forming the tree structure.

execsql/script/engine.py

@@ -11,9 +11,6 @@ live in :mod:`execsql.script.parser` and
 Classes:
 - :class:`MetaCommand` — one entry in the metacommand dispatch table.
 - :class:`MetaCommandList` — ordered list of :class:`MetaCommand` entries with a keyword index.
-- :class:`SqlStmt` — wraps a single SQL string for execution.
-- :class:`MetacommandStmt` — wraps a metacommand line for dispatch.
-- :class:`ScriptCmd` — pairs a statement with its source-file location.
 - :class:`ScriptExecSpec` — specification for deferred script execution.
 
 Functions:
@@ -28,7 +25,7 @@ import os
 import re
 import uuid
 from pathlib import Path
-from typing import Any, cast
+from typing import Any
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
@@ -38,9 +35,6 @@ from execsql.utils.errors import exception_desc
 __all__ = [
     "MetaCommand",
     "MetaCommandList",
-    "SqlStmt",
-    "MetacommandStmt",
-    "ScriptCmd",
     "ScriptExecSpec",
     "set_system_vars",
     "substitute_vars",
@@ -56,12 +50,16 @@ __all__ = [
 class MetaCommand:
     """A single entry in the metacommand dispatch table.
 
-    Holds a compiled regex, a handler function, and execution-control flags.
-    Call :meth:`run` with a raw command string to attempt a match and invoke
-    the handler.
+    Holds a regex, a handler function, and execution-control flags.  Call
+    :meth:`run` with a raw command string to attempt a match and invoke the
+    handler.
+
+    *rx* is a compiled pattern, or a pattern string that is compiled
+    (case-insensitively) the first time :attr:`rx` is read.  The dispatch
+    table registers some 1,700 patterns and a script uses a few dozen, so
+    compiling them all up front cost most of a second on every run.
     """
 
-    # A compiled metacommand that can be run if it matches a metacommand command string.
     def __init__(
         self,
         rx: Any,
@@ -70,6 +68,8 @@ class MetaCommand:
         set_error_flag: bool = True,
         category: str | None = None,
     ) -> None:
+        self._pattern: str
+        self._rx: Any = None
         self.rx = rx
         self.exec_fn = exec_func
         self.description = description
@@ -77,8 +77,32 @@ class MetaCommand:
         self.category = category
         self.hitcount = 0
 
+    @property
+    def rx(self) -> Any:
+        """The compiled pattern, compiled on first use."""
+        if self._rx is None:
+            self._rx = re.compile(self._pattern, re.I)
+        return self._rx
+
+    @rx.setter
+    def rx(self, value: Any) -> None:
+        if isinstance(value, str):
+            self._pattern, self._rx = value, None
+        else:
+            self._pattern, self._rx = value.pattern, value
+
+    @property
+    def pattern(self) -> str:
+        """The pattern string, without compiling it."""
+        return self._pattern
+
+    @property
+    def compiled(self) -> bool:
+        """Whether :attr:`rx` has been compiled yet."""
+        return self._rx is not None
+
     def __repr__(self) -> str:
-        return f"MetaCommand({self.rx.pattern!r}, {self.exec_fn!r}, {self.description!r})"
+        return f"MetaCommand({self.pattern!r}, {self.exec_fn!r}, {self.description!r})"
 
     def run(self, cmd_str: str) -> tuple:
         """Match *cmd_str* against this entry's regex and, if it matches, invoke the handler.
@@ -97,8 +121,9 @@ class MetaCommand:
                 raise
             except ErrInfo as errinf:
                 er = errinf
-            except Exception:
+            except Exception as exc:
                 er = ErrInfo("cmd", command_text=cmd_str, exception_msg=exception_desc())
+                er.__cause__ = exc
             if er:
                 if _state.status.halt_on_metacommand_err:
                     from execsql.utils.errors import exit_now
@@ -170,18 +195,17 @@ class MetaCommandList:
         """Register one or more regex patterns as a new :class:`MetaCommand` entry.
 
         *matching_regexes* may be a single pattern string or a list/tuple of
-        patterns; each compiles into a separate :class:`MetaCommand` prepended to
-        the dispatch list so that later registrations take priority.
+        patterns; each becomes a separate :class:`MetaCommand` prepended to
+        the dispatch list so that later registrations take priority.  The
+        patterns are compiled when first matched, not here.
         """
         if isinstance(matching_regexes, (tuple, list)):
             raw_patterns = list(matching_regexes)
-            regexes = [re.compile(rx, re.I) for rx in raw_patterns]
         else:
             raw_patterns = [matching_regexes]
-            regexes = [re.compile(matching_regexes, re.I)]
-        for rx, raw in zip(regexes, raw_patterns):
+        for raw in raw_patterns:
             mc = MetaCommand(
-                rx,
+                raw,
                 exec_func,
                 description,
                 set_error_flag,
@@ -205,7 +229,7 @@ class MetaCommandList:
     def keywords_by_category(self) -> dict[str, list[str]]:
         """Return ``{category: [keyword, ...]}`` from entries that have both.
 
-        Used by ``--dump-keywords`` to introspect the dispatch table.
+        Used by ``execsql list keywords`` to introspect the dispatch table.
         """
         result: dict[str, list[str]] = {}
         for mc in self._commands:
@@ -239,89 +263,6 @@ class MetaCommandList:
         return None
 
 
-# ---------------------------------------------------------------------------
-# SqlStmt / MetacommandStmt
-# ---------------------------------------------------------------------------
-
-
-class SqlStmt:
-    """A single SQL statement ready to be executed against the active database.
-
-    Data class only — the legacy ``.run()`` method was removed when the AST
-    executor became the sole engine.  SQL execution now goes through
-    :func:`execsql.script.executor._exec_sql`.
-    """
-
-    def __init__(self, sql_statement: str) -> None:
-        self.statement = re.sub(r"\s*;(\s*;\s*)+$", ";", sql_statement)
-
-    def __repr__(self) -> str:
-        return f"SqlStmt({self.statement})"
-
-    def commandline(self) -> str:
-        """Return the raw SQL statement text."""
-        return self.statement
-
-
-class MetacommandStmt:
-    """A single execsql metacommand line.
-
-    Data class only — the legacy ``.run()`` method was removed when the AST
-    executor became the sole engine.  Metacommand dispatch now goes through
-    :func:`execsql.script.executor._exec_metacommand`.
-    """
-
-    def __init__(self, metacommand_statement: str) -> None:
-        self.statement = metacommand_statement
-
-    def __repr__(self) -> str:
-        return f"MetacommandStmt({self.statement})"
-
-    def commandline(self) -> str:
-        """Return the metacommand line in its canonical ``-- !x! ...`` form."""
-        return "-- !x! " + self.statement
-
-
-# ---------------------------------------------------------------------------
-# ScriptCmd
-# ---------------------------------------------------------------------------
-
-
-class ScriptCmd:
-    """A parsed script item: either a :class:`SqlStmt` or a :class:`MetacommandStmt`, with source location."""
-
-    # A SQL script object that is either a SQL statement or a metacommand.
-    def __init__(
-        self,
-        command_source_name: str,
-        command_line_no: int,
-        command_type: str,
-        script_command: Any,
-    ) -> None:
-        self.source = command_source_name
-        self.line_no = command_line_no
-        self.command_type = command_type
-        self.command = script_command
-        # MIGRATION NOTE: differs from monolith (execsql.py) — source_dir and source_name are
-        # resolved once at construction rather than on every statement execution.  For absolute
-        # paths (the common case) the result is identical.  For relative paths the value is
-        # anchored to the CWD at script-load time rather than at each statement's execution time;
-        # the original per-statement resolve could yield inconsistent values across statements of
-        # the same script if a CD metacommand ran between them.
-        _p = Path(command_source_name)
-        self.source_dir: str = str(_p.resolve().parent) + os.sep
-        self.source_name: str = _p.name
-
-    def __repr__(self) -> str:
-        return f"ScriptCmd({self.source!r}, {self.line_no!r}, {self.command_type!r}, {repr(self.command)!r})"
-
-    def current_script_line(self) -> tuple[str, int]:
-        return (self.source, self.line_no)
-
-    def commandline(self) -> str:
-        return cast(str, self.command.statement if self.command_type == "sql" else "-- !x! " + self.command.statement)
-
-
 # ---------------------------------------------------------------------------
 # ScriptExecSpec
 # ---------------------------------------------------------------------------
@@ -509,7 +450,8 @@ def current_script_line() -> tuple[str, int]:
     """Return ``(source_name, line_number)`` for the command currently executing.
 
     Reads from ``_state.last_command``, which the AST executor updates on
-    every statement via the ``_FakeScriptCmd`` shim.  Returns ``("", 0)``
+    every statement via :class:`~execsql.script.executor.ExecutingStatement`.
+    Returns ``("", 0)``
     when nothing has executed yet (e.g. during early initialization errors).
     """
     last = getattr(_state, "last_command", None)