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

execsql/script/parser.py

@@ -257,8 +257,15 @@ class _BlockFrame:
 # ---------------------------------------------------------------------------
 
 
-def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
-    """Core parsing logic: convert an iterable of lines into a Script AST."""
+def _parse_lines(lines: Iterable[str], source_name: str, errors: list[ErrInfo] | None = None) -> Script:
+    """Core parsing logic: convert an iterable of lines into a Script AST.
+
+    A block-structure error raises :class:`ErrInfo`, unless *errors* is a
+    list: then each error is appended to it and parsing recovers (a closing
+    keyword with nothing to close is skipped, one that skips past an open
+    block closes that block too, and blocks still open at the end are
+    closed), so the whole script is parsed.
+    """
     body: list[Node] = []
     block_stack: list[_BlockFrame] = []
     in_block_comment = False
@@ -288,6 +295,38 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             return node.body
         return body  # pragma: no cover — defensive fallback
 
+    def _structural_error(exc: ErrInfo) -> None:
+        """Raise *exc*, or record it when the caller collects errors and lets parsing recover."""
+        if errors is None:
+            raise exc
+        errors.append(exc)
+
+    def _close_block(frame: _BlockFrame, line_no: int) -> None:
+        """Give a popped block its end line and add it to the enclosing body."""
+        frame.node.span = SourceSpan(source_name, frame.start_line, line_no)
+        _current_body().append(frame.node)
+
+    def _pop_block(kind: str, line: str, line_no: int, no_match_msg: str) -> _BlockFrame | None:
+        """Pop the open block of *kind* that the closing keyword on *line* ends.
+
+        ``None`` (after reporting the error) when no such block is open.  A
+        block of another kind opened inside it and left open is an error of
+        its own; when recovering, it is closed here too.
+        """
+        if block_stack and block_stack[-1].kind == kind:
+            return block_stack.pop()
+        if errors is None:
+            msg = _unclosed_block_msg(block_stack[-1]) if block_stack else no_match_msg
+            raise ErrInfo(type="cmd", command_text=line, other_msg=msg)
+        if not any(frame.kind == kind for frame in block_stack):
+            errors.append(ErrInfo(type="cmd", command_text=line, other_msg=no_match_msg))
+            return None
+        while block_stack[-1].kind != kind:
+            frame = block_stack.pop()
+            errors.append(ErrInfo(type="cmd", command_text=line, other_msg=_unclosed_block_msg(frame)))
+            _close_block(frame, line_no)
+        return block_stack.pop()
+
     def _flush_sql(line_no: int) -> None:
         """If there's accumulated SQL text, emit a SqlStatement node."""
         nonlocal sql_accum, sql_start_line
@@ -322,6 +361,7 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                 if doc_text and isinstance(frame.node, ScriptBlock):
                     frame.node.doc = doc_text
 
+    file_lineno = 0
     for file_lineno, raw_line in enumerate(lines, 1):
         line = raw_line.rstrip()
 
@@ -485,14 +525,15 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                 _flush_sql(file_lineno)
                 in_sql_block = False
                 if not block_stack or block_stack[-1].kind != "sqlblock":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"Unmatched END SQL on line {file_lineno} of {source_name}.",
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=f"Unmatched END SQL on line {file_lineno} of {source_name}.",
+                        ),
                     )
-                frame = block_stack.pop()
-                frame.node.span = SourceSpan(source_name, frame.start_line, file_lineno)
-                _current_body().append(frame.node)
+                    continue
+                _close_block(block_stack.pop(), file_lineno)
                 continue
 
             # Inside a SQL block, non-END SQL metacommands are silently
@@ -517,12 +558,18 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                 if paramexpr:
                     wp = _WITH_PARAMS_RX.match(paramexpr)
                     if not wp:
-                        raise ErrInfo(
-                            type="cmd",
-                            command_text=line,
-                            other_msg=f"Invalid BEGIN SCRIPT metacommand on line {file_lineno} of file {source_name}.",
+                        _structural_error(
+                            ErrInfo(
+                                type="cmd",
+                                command_text=line,
+                                other_msg=f"Invalid BEGIN SCRIPT metacommand on line {file_lineno} of file {source_name}.",
+                            ),
                         )
-                    param_defs = _parse_param_defs(wp.group("params"), file_lineno, source_name)
+                    else:
+                        try:
+                            param_defs = _parse_param_defs(wp.group("params"), file_lineno, source_name)
+                        except ErrInfo as exc:
+                            _structural_error(exc)
                 block_stack.append(
                     _BlockFrame(
                         ScriptBlock(
@@ -543,38 +590,36 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                 end_name = m.group("name")
                 if end_name is not None:
                     end_name = end_name.lower()
-                if not block_stack:
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"END SCRIPT on line {file_lineno} of {source_name} has no matching BEGIN SCRIPT.",
-                    )
-                if block_stack[-1].kind != "script":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=_unclosed_block_msg(block_stack[-1]),
-                    )
-                frame = block_stack[-1]
-                script_node = cast(ScriptBlock, frame.node)
-                if end_name is not None and end_name != script_node.name:  # type: ignore[union-attr]
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"Mismatched script name in the END SCRIPT metacommand on line {file_lineno} of file {source_name}.",
+                closed = _pop_block(
+                    "script",
+                    line,
+                    file_lineno,
+                    f"END SCRIPT on line {file_lineno} of {source_name} has no matching BEGIN SCRIPT.",
+                )
+                if closed is None:
+                    continue
+                script_node = cast(ScriptBlock, closed.node)
+                if end_name is not None and end_name != script_node.name:
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=f"Mismatched script name in the END SCRIPT metacommand on line {file_lineno} of file {source_name}.",
+                        ),
                     )
                 if sql_accum:
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=(
-                            f"Incomplete SQL statement\n  ({sql_accum})\n"
-                            f"at END SCRIPT metacommand on line {file_lineno} of file {source_name}."
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=(
+                                f"Incomplete SQL statement\n  ({sql_accum})\n"
+                                f"at END SCRIPT metacommand on line {file_lineno} of file {source_name}."
+                            ),
                         ),
                     )
-                frame = block_stack.pop()
-                frame.node.span = SourceSpan(source_name, frame.start_line, file_lineno)
-                _current_body().append(frame.node)
+                    _flush_sql(file_lineno)
+                _close_block(closed, file_lineno)
                 continue
 
             # -- IF (block form) --
@@ -612,11 +657,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             m = _ELSEIF_RX.match(cmd_text)
             if m:
                 if not block_stack or block_stack[-1].kind != "if":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"ELSEIF on line {file_lineno} of {source_name} has no matching IF.",
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=f"ELSEIF on line {file_lineno} of {source_name} has no matching IF.",
+                        ),
                     )
+                    continue
                 frame = block_stack[-1]
                 frame._in_else = False
                 frame._in_elseif = True
@@ -633,11 +681,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             m = _ANDIF_RX.match(cmd_text)
             if m:
                 if not block_stack or block_stack[-1].kind != "if":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"ANDIF on line {file_lineno} of {source_name} has no matching IF.",
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=f"ANDIF on line {file_lineno} of {source_name} has no matching IF.",
+                        ),
                     )
+                    continue
                 modifier = ConditionModifier(
                     kind="AND",
                     condition=m.group("cond").strip(),
@@ -655,11 +706,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             m = _ORIF_RX.match(cmd_text)
             if m:
                 if not block_stack or block_stack[-1].kind != "if":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"ORIF on line {file_lineno} of {source_name} has no matching IF.",
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=f"ORIF on line {file_lineno} of {source_name} has no matching IF.",
+                        ),
                     )
+                    continue
                 modifier = ConditionModifier(
                     kind="OR",
                     condition=m.group("cond").strip(),
@@ -677,11 +731,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             m = _ELSE_RX.match(cmd_text)
             if m:
                 if not block_stack or block_stack[-1].kind != "if":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"ELSE on line {file_lineno} of {source_name} has no matching IF.",
+                    _structural_error(
+                        ErrInfo(
+                            type="cmd",
+                            command_text=line,
+                            other_msg=f"ELSE on line {file_lineno} of {source_name} has no matching IF.",
+                        ),
                     )
+                    continue
                 frame = block_stack[-1]
                 frame._in_else = True
                 frame._in_elseif = False
@@ -691,21 +748,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             # -- ENDIF --
             m = _ENDIF_RX.match(cmd_text)
             if m:
-                if not block_stack:
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"ENDIF on line {file_lineno} of {source_name} has no matching IF.",
-                    )
-                if block_stack[-1].kind != "if":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=_unclosed_block_msg(block_stack[-1]),
-                    )
-                frame = block_stack.pop()
-                frame.node.span = SourceSpan(source_name, frame.start_line, file_lineno)
-                _current_body().append(frame.node)
+                closed = _pop_block(
+                    "if",
+                    line,
+                    file_lineno,
+                    f"ENDIF on line {file_lineno} of {source_name} has no matching IF.",
+                )
+                if closed is not None:
+                    _close_block(closed, file_lineno)
                 continue
 
             # -- LOOP --
@@ -728,21 +778,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             # -- ENDLOOP --
             m = _ENDLOOP_RX.match(cmd_text)
             if m:
-                if not block_stack:
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"ENDLOOP on line {file_lineno} of {source_name} has no matching LOOP.",
-                    )
-                if block_stack[-1].kind != "loop":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=_unclosed_block_msg(block_stack[-1]),
-                    )
-                frame = block_stack.pop()
-                frame.node.span = SourceSpan(source_name, frame.start_line, file_lineno)
-                _current_body().append(frame.node)
+                closed = _pop_block(
+                    "loop",
+                    line,
+                    file_lineno,
+                    f"ENDLOOP on line {file_lineno} of {source_name} has no matching LOOP.",
+                )
+                if closed is not None:
+                    _close_block(closed, file_lineno)
                 continue
 
             # -- BEGIN BATCH --
@@ -761,21 +804,14 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
             # -- END BATCH --
             m = _END_BATCH_RX.match(cmd_text)
             if m:
-                if not block_stack:
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=f"END BATCH on line {file_lineno} of {source_name} has no matching BEGIN BATCH.",
-                    )
-                if block_stack[-1].kind != "batch":
-                    raise ErrInfo(
-                        type="cmd",
-                        command_text=line,
-                        other_msg=_unclosed_block_msg(block_stack[-1]),
-                    )
-                frame = block_stack.pop()
-                frame.node.span = SourceSpan(source_name, frame.start_line, file_lineno)
-                _current_body().append(frame.node)
+                closed = _pop_block(
+                    "batch",
+                    line,
+                    file_lineno,
+                    f"END BATCH on line {file_lineno} of {source_name} has no matching BEGIN BATCH.",
+                )
+                if closed is not None:
+                    _close_block(closed, file_lineno)
                 continue
 
             # -- INCLUDE --
@@ -846,24 +882,33 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
     # Flush any trailing consecutive -- comments
     _flush_line_comments()
 
-    # Unclosed blocks
-    if block_stack:
-        frame = block_stack[-1]
-        raise ErrInfo(
-            type="error",
-            other_msg=f"Unmatched {frame.kind.upper()} block starting on line {frame.start_line} at end of file {source_name}.",
+    # Unclosed blocks, innermost first
+    for frame in reversed(block_stack):
+        _structural_error(
+            ErrInfo(
+                type="error",
+                other_msg=f"Unmatched {frame.kind.upper()} block starting on line {frame.start_line} at end of file {source_name}.",
+            ),
         )
 
     # Trailing SQL without semicolon
     if sql_accum:
-        raise ErrInfo(
-            type="error",
-            other_msg=(
-                f"Incomplete SQL statement starting on line {sql_start_line} at end of file {source_name}."
-                + (" Metacommands must be prefixed with '-- !x!'." if source_name == "<inline>" else "")
+        _structural_error(
+            ErrInfo(
+                type="error",
+                other_msg=(
+                    f"Incomplete SQL statement starting on line {sql_start_line} at end of file {source_name}."
+                    + (" Metacommands must be prefixed with '-- !x!'." if source_name == "<inline>" else "")
+                ),
             ),
         )
 
+    # When recovering, keep the trailing SQL and close what is still open;
+    # otherwise both are already empty here.
+    _flush_sql(file_lineno)
+    while block_stack:
+        _close_block(block_stack.pop(), file_lineno)
+
     return Script(source=source_name, body=body)
 
 
@@ -872,7 +917,7 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
 # ---------------------------------------------------------------------------
 
 
-def parse_script(filename: str, encoding: str = "utf-8") -> Script:
+def parse_script(filename: str, encoding: str = "utf-8", *, errors: list[ErrInfo] | None = None) -> Script:
     """Parse a ``.sql`` file and return a :class:`Script` AST.
 
     Reads the file directly (no dependency on runtime state) so it can be
@@ -881,22 +926,26 @@ def parse_script(filename: str, encoding: str = "utf-8") -> Script:
     Args:
         filename: Path to the SQL script file.
         encoding: File encoding (default ``utf-8``).
+        errors: When a list, block-structure errors are appended to it
+            and parsing recovers instead of raising (see ``_parse_lines``).
 
     Returns:
         A :class:`Script` tree representing the parsed file.
     """
     text = Path(filename).read_text(encoding=encoding)
-    return _parse_lines(text.splitlines(), filename)
+    return _parse_lines(text.splitlines(), filename, errors)
 
 
-def parse_string(content: str, source_name: str = "<inline>") -> Script:
+def parse_string(content: str, source_name: str = "<inline>", *, errors: list[ErrInfo] | None = None) -> Script:
     """Parse an inline script string and return a :class:`Script` AST.
 
     Args:
         content: The script content as a string.
         source_name: Name to use in source spans (default ``"<inline>"``).
+        errors: When a list, block-structure errors are appended to it
+            and parsing recovers instead of raising (see ``_parse_lines``).
 
     Returns:
         A :class:`Script` tree representing the parsed content.
     """
-    return _parse_lines(content.splitlines(), source_name)
+    return _parse_lines(content.splitlines(), source_name, errors)

execsql/state.py

@@ -101,6 +101,8 @@ if TYPE_CHECKING:
         SubVarSet,
     )
     from execsql.script.executor import ExecutingStatement
+    from execsql.exceptions import ErrInfo
+    from execsql.manifest import RunManifest
     from execsql.utils.fileio import FileWriter, Logger, TempFileMgr
     from execsql.utils.mail import MailSpec
     from execsql.utils.timer import Timer
@@ -225,6 +227,9 @@ _CONTEXT_ATTRS: frozenset[str] = frozenset(
         "output",
         "filewriter",
         "tier_notices_shown",
+        "manifest",
+        "halt_error",
+        "halt_output_error",
         # Lazy singletons
         "counters",
         "timer",
@@ -280,6 +285,9 @@ class RuntimeContext:
         "output",
         "filewriter",
         "tier_notices_shown",
+        "manifest",
+        "halt_error",
+        "halt_output_error",
         # Lazy singletons
         "counters",
         "timer",
@@ -330,6 +338,12 @@ class RuntimeContext:
         # DBMS names whose best-effort support notice has already been shown,
         # so repeated connections to the same backend announce it only once.
         self.tier_notices_shown: set[str] = set()
+        # ``--manifest`` recorder for this run, or None.
+        self.manifest: RunManifest | None = None
+        # The error that halted this run (set by ``exit_now``), or None.
+        self.halt_error: ErrInfo | None = None
+        # File output lost when the run halted (set by ``exit_now``), or None.
+        self.halt_output_error: ErrInfo | None = None
 
         # Lazy singletons
         self.counters: CounterVars | None = None
@@ -364,9 +378,7 @@ class RuntimeContext:
         # nesting construct: top-level script, EXECUTE SCRIPT calls, INCLUDE'd
         # files, IF/ELSEIF/ELSE branches, LOOP iterations, BATCH blocks. See
         # :class:`ExecFrame` for frame structure. Read by the debug REPL's
-        # ``.stack`` command and ``DEBUG WRITE COMMANDLISTSTACK`` for genuine
-        # execution context — the legacy ``commandliststack`` only records
-        # SCRIPT call frames and is therefore insufficient for the debugger.
+        # ``.stack`` command and ``DEBUG WRITE COMMANDLISTSTACK``.
         self.ast_exec_stack: list[ExecFrame] = []
 
     # -----------------------------------------------------------------
@@ -552,7 +564,7 @@ def reset() -> None:
     """Reset all mutable state to initial values.
 
     Intended for use in tests.  Creates a fresh :class:`RuntimeContext`,
-    preserving only the ``filewriter`` subprocess (which is ``atexit``-managed
+    preserving only the ``filewriter`` thread (which is ``atexit``-managed
     and must not be discarded while alive).
     """
     ctx = _get_ctx()
@@ -594,8 +606,9 @@ def initialize(
     Note:
         ``subvars``, ``status``, ``output``, ``filewriter``, and ``exec_log``
         are **not** set here because they require CLI-specific arguments
-        (script path, subprocess queues, local class definitions).  Those are
-        assigned directly in ``_run()`` before and after this call.
+        (script path, output settings, local class definitions).  Those are
+        assigned directly in ``_run()`` (or :func:`execsql.api.run`) before
+        and after this call.
     """
     import execsql.db.base as _db_base
     import execsql.exporters.base as _exporters_base
@@ -614,10 +627,11 @@ def initialize(
     ctx.conditionallist = conditional_table
 
     # Discover and register metacommand plugins via entry points.
-    # Runs here (not at import time) to avoid I/O side effects during import.
-    from execsql.plugins import discover_metacommand_plugins
+    # Runs here (not at import time) to avoid I/O side effects during import,
+    # and only once per dispatch table: every run shares the table.
+    from execsql.plugins import register_metacommand_plugins_once
 
-    discover_metacommand_plugins(dispatch_table)
+    register_metacommand_plugins_once(dispatch_table)
 
 
 # ---------------------------------------------------------------------------

execsql/state.pyi

@@ -11,6 +11,8 @@ from execsql.config import ConfigData, StatObj
 from execsql.db.base import DatabasePool
 from execsql.exporters.base import ExportMetadata, WriteSpec
 from execsql.script import CounterVars, MetaCommandList, ScriptExecSpec, SubVarSet
+from execsql.exceptions import ErrInfo
+from execsql.manifest import RunManifest
 from execsql.utils.fileio import FileWriter, Logger, TempFileMgr
 from execsql.utils.mail import MailSpec
 from execsql.utils.timer import Timer
@@ -54,6 +56,9 @@ status: StatObj
 output: Any
 tier_notices_shown: set[str]
 filewriter: FileWriter | None
+manifest: RunManifest | None
+halt_error: ErrInfo | None
+halt_output_error: ErrInfo | None
 counters: CounterVars
 timer: Timer
 dbs: DatabasePool
@@ -89,6 +94,9 @@ class RuntimeContext:
     output: Any
     tier_notices_shown: set[str]
     filewriter: FileWriter | None
+    manifest: RunManifest | None
+    halt_error: ErrInfo | None
+    halt_output_error: ErrInfo | None
     counters: CounterVars | None
     timer: Timer | None
     dbs: DatabasePool | None

execsql/types.py

@@ -180,6 +180,10 @@ class DT_Timestamp(DataType):
         dt = parse_datetime(data)
         if not dt:
             raise DataTypeError(self.data_type_name, self._CONV_ERR % data)
+        # A written UTC offset makes it a timestamptz: stored in a timestamp
+        # column, the driver would shift it by the client's time zone.
+        if isinstance(data, str) and dt.tzinfo is not None:
+            raise DataTypeError(self.data_type_name, self._CONV_ERR % data)
         return dt
 
 
@@ -675,18 +679,6 @@ class DbType:
         # conv_mod_fn is a function that modifies the result of data_type().from_data(x).
         self.dialect[data_type] = (dbms_name, length_required, casting_name, conv_mod_fn, precision, scale)
 
-    def datatype_name(self, data_type: type[DataType]) -> str:
-        """Return the DBMS-specific SQL type name for the given DataType class."""
-        # A convenience function to simplify access to data type names.
-        try:
-            return self.dialect[data_type][0]
-        except Exception as e:
-            raise DbTypeError(
-                self.dbms_id,
-                data_type,
-                f"{self.dbms_id} DBMS type has no specification for data type {data_type.data_type_name}",
-            ) from e
-
     def quoted(self, dbms_object: str) -> str:
         """Quote a database identifier if it contains non-word characters."""
         if re.search(r"\W", dbms_object):
@@ -799,7 +791,24 @@ dbt_sqlserver.name_datatype(DT_Varchar, "varchar", True)
 dbt_sqlserver.name_datatype(DT_Text, "varchar(max)")
 dbt_sqlserver.name_datatype(DT_Binary, "varbinary(max)")
 
-dbt_access = DbType("Access")
+
+class _AccessDbType(DbType):
+    """Access dialect: decimal data becomes DOUBLE unless ``access_use_numeric`` is set.
+
+    Read from the run's config at use time, not applied to the shared
+    ``dt_xlate``, so one run's setting does not carry over to the next
+    ``execsql.run()`` in the same process.
+    """
+
+    def spec_type(self, data_type: type[DataType]) -> type[DataType]:
+        import execsql.state as _state
+
+        if data_type is DT_Decimal and getattr(_state.conf, "access_use_numeric", False):
+            return DT_Decimal
+        return super().spec_type(data_type)
+
+
+dbt_access = _AccessDbType("Access")
 dbt_access.name_datatype(DT_TimestampTZ, "VARCHAR", True)
 dbt_access.name_datatype(DT_Timestamp, "VARCHAR", True)
 dbt_access.name_datatype(DT_Date, "VARCHAR", True)