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

execsql/metacommands/upsert.py

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

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/engine.py

@@ -50,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,
@@ -64,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
@@ -71,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.
@@ -165,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,

execsql/script/executor.py

@@ -69,7 +69,7 @@ from execsql import manifest as _manifest
 from execsql.script.engine import set_dynamic_system_vars, set_static_system_vars, substitute_vars
 from execsql.script.variables import SubVarSet
 from execsql.state import ExecFrame, RuntimeContext, active_context, get_context, xcmd_test
-from execsql.utils.errors import exception_desc, exit_now, stamp_errinfo
+from execsql.utils.errors import exception_desc, exit_now, logged_error, stamp_errinfo
 
 __all__ = ["execute", "execute_input"]
 
@@ -254,8 +254,10 @@ def _exec_sql(
     effective_locals = _stack_localvars(ctx) or localvars
     cmd = substitute_vars(text, effective_locals, ctx=ctx)
     if _VARLIKE.search(cmd):
+        from execsql.utils.fileio import redact
+
         output.write(
-            f"Warning: There is a potential un-substituted variable in the command\n     {cmd}\n",
+            f"Warning: There is a potential un-substituted variable in the command\n     {redact(cmd)}\n",
         )
     e = None
     result = None
@@ -282,7 +284,7 @@ def _exec_sql(
         subvars.add_substitution("$ERROR_MESSAGE", e.errmsg())
         status.sql_error = True
         if ctx.exec_log is not None:
-            ctx.exec_log.log_status_info(f"SQL error: {e.errmsg()}")
+            ctx.exec_log.log_status_info(f"SQL error: {logged_error(e)}")
         if status.halt_on_err:
             exit_now(1, e)
         status.error_history.append((source, line_no, cmd, e.errmsg()))
@@ -321,8 +323,10 @@ def _exec_metacommand(
     assert subvars is not None
 
     if _VARLIKE.search(cmd):
+        from execsql.utils.fileio import redact
+
         output.write(
-            f"Warning: There is a potential un-substituted variable in the command\n     {cmd}\n",
+            f"Warning: There is a potential un-substituted variable in the command\n     {redact(cmd)}\n",
         )
     e = None
     try:
@@ -344,7 +348,7 @@ def _exec_metacommand(
         subvars.add_substitution("$LAST_ERROR", cmd)
         subvars.add_substitution("$ERROR_MESSAGE", e.errmsg())
         if ctx.exec_log is not None:
-            ctx.exec_log.log_status_info(f"Metacommand error: {e.errmsg()}")
+            ctx.exec_log.log_status_info(f"Metacommand error: {logged_error(e)}")
         if status.halt_on_metacommand_err:
             raise e
         status.error_history.append((source, line_no, cmd, e.errmsg()))