execsql2 2.34.0__py3-none-any.whl → 2.37.0__py3-none-any.whl

execsql/script/ast.py

@@ -212,12 +212,15 @@ class ElseIfClause:
         condition_modifiers: ANDIF/ORIF modifiers that compound the ELSEIF
             condition, evaluated left-to-right at runtime.
         body: Nodes executed when this condition is true.
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     condition: str
     span: SourceSpan
     condition_modifiers: list[ConditionModifier] = field(default_factory=list)
     body: list[Node] = field(default_factory=list)
+    command: str = ""
 
 
 @dataclass
@@ -232,6 +235,8 @@ class IfBlock(Node):
         elseif_clauses: Zero or more ELSEIF branches, evaluated in order.
         else_body: Nodes executed when the IF condition (and all ELSEIFs)
             are false.  Empty list means no ELSE branch.
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     condition: str
@@ -240,6 +245,7 @@ class IfBlock(Node):
     elseif_clauses: list[ElseIfClause] = field(default_factory=list)
     else_body: list[Node] = field(default_factory=list)
     else_span: SourceSpan | None = None
+    command: str = ""
 
     def children(self) -> Iterator[Node]:
         yield from self.body
@@ -261,11 +267,14 @@ class LoopBlock(Node):
         loop_type: Either ``"WHILE"`` or ``"UNTIL"``.
         condition: The condition expression text.
         body: Nodes executed on each iteration.
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     loop_type: str  # "WHILE" or "UNTIL"
     condition: str
     body: list[Node] = field(default_factory=list)
+    command: str = ""
 
     def children(self) -> Iterator[Node]:
         yield from self.body
@@ -283,9 +292,12 @@ class BatchBlock(Node):
 
     Attributes:
         body: Nodes within the batch.
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     body: list[Node] = field(default_factory=list)
+    command: str = ""
 
     def children(self) -> Iterator[Node]:
         yield from self.body
@@ -325,12 +337,15 @@ class ScriptBlock(Node):
         doc: Optional docstring extracted from comments immediately following
             the BEGIN SCRIPT line.
         body: Nodes within the script block.
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     name: str
     param_defs: list[ParamDef] | None = None
     doc: str | None = None
     body: list[Node] = field(default_factory=list)
+    command: str = ""
 
     @property
     def param_names(self) -> list[str] | None:
@@ -358,9 +373,12 @@ class SqlBlock(Node):
     Attributes:
         body: Nodes within the SQL block (typically a single
             :class:`SqlStatement`).
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     body: list[Node] = field(default_factory=list)
+    command: str = ""
 
     def children(self) -> Iterator[Node]:
         yield from self.body
@@ -384,6 +402,8 @@ class IncludeDirective(Node):
         arguments: Optional argument expression for EXECUTE SCRIPT.
         loop_type: Optional ``"WHILE"`` or ``"UNTIL"`` for looped execution.
         loop_condition: The loop condition expression, if *loop_type* is set.
+        command: The metacommand as written, without ``-- !x!``, for error
+            reports.
     """
 
     target: str
@@ -392,6 +412,7 @@ class IncludeDirective(Node):
     arguments: str | None = None
     loop_type: str | None = None
     loop_condition: str | None = None
+    command: str = ""
 
     def __repr__(self) -> str:
         kind = "EXECUTE SCRIPT" if self.is_execute_script else "INCLUDE"

execsql/script/control.py

@@ -30,6 +30,8 @@ class BatchLevels:
     class Batch:
         def __init__(self) -> None:
             self.dbs_used: list[Any] = []
+            # Why this batch can no longer commit (an error inside it), or None.
+            self.failed: str | None = None
 
     def __init__(self) -> None:
         self.batchlevels: list[BatchLevels.Batch] = []
@@ -38,6 +40,25 @@ class BatchLevels:
         """Return True if execution is currently inside at least one BATCH block."""
         return len(self.batchlevels) > 0
 
+    def fail_enclosing(self, reason: str) -> None:
+        """Mark every open batch level as failed, so its END BATCH rolls back instead of committing."""
+        for b in self.batchlevels:
+            if b.failed is None:
+                b.failed = reason
+
+    def failure(self) -> str | None:
+        """Why the innermost batch can no longer commit, or None.
+
+        A batch inside a failed one cannot commit either: its commit would
+        commit the failed batch's later statements on a shared connection.
+        Nothing clears the mark, ROLLBACK BATCH included: once anything in a
+        batch has failed, the whole stack of batches rolls back.
+        """
+        for b in reversed(self.batchlevels):
+            if b.failed is not None:
+                return b.failed
+        return None
+
     def new_batch(self) -> None:
         """Push a new empty batch level onto the stack."""
         self.batchlevels.append(self.Batch())
@@ -61,7 +82,46 @@ class BatchLevels:
                 db.rollback()
 
     def end_batch(self) -> None:
-        """Commit all databases in the innermost batch level and pop the stack."""
+        """Commit all databases in the innermost batch level and pop the stack.
+
+        If a commit fails, :meth:`Database.commit` rolls that database back,
+        and the ones not yet committed are rolled back too (except one with
+        autocommit off, whose transaction is the script's) before the error
+        is raised: a commit that already succeeded
+        cannot be undone, but nothing else of the batch is left pending for
+        a later statement to commit.
+        """
+        b = self.batchlevels.pop()
+        for i, db in enumerate(b.dbs_used):
+            try:
+                db.commit()
+            except BaseException:
+                _roll_back(b.dbs_used[i + 1 :])
+                raise
+
+    def abandon_batch(self) -> None:
+        """Pop the innermost batch level without committing it.
+
+        Inside another batch, its databases join the enclosing level, which
+        commits or rolls them back.  Otherwise they are rolled back, except
+        one with autocommit off: :meth:`end_batch` would not have committed
+        it either, so its transaction stays the script's to end.
+        """
         b = self.batchlevels.pop()
-        for db in b.dbs_used:
-            db.commit()
+        if self.batchlevels:
+            for db in b.dbs_used:
+                self.using_db(db)
+            return
+        _roll_back(b.dbs_used)
+
+    def abandon_all(self) -> None:
+        """Abandon every open batch level, innermost first."""
+        while self.batchlevels:
+            self.abandon_batch()
+
+
+def _roll_back(dbs: list[Any]) -> None:
+    """Roll back each of *dbs* except one with autocommit off, whose transaction is the script's."""
+    for db in dbs:
+        if db.autocommit:
+            db.rollback()