execsql2 2.16.13__tar.gz → 2.16.14__tar.gz

{execsql2-2.16.13 → execsql2-2.16.14}/CHANGELOG.md

@@ -13,6 +13,16 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.16.14] - 2026-05-01
+
+### Fixed
+
+- ELSEIF conditions now support ANDIF/ORIF modifiers. Previously, ANDIF/ORIF after an ELSEIF were silently attached to the parent IF condition instead of the ELSEIF clause, meaning the compound condition was never evaluated correctly. ELSEIF + ANDIF/ORIF now works the same way as IF + ANDIF/ORIF.
+- Unknown AST node types now raise an error instead of being silently ignored during execution.
+- Cursor leak in `select_rowsource()` and `select_rowdict()`: cursor is now closed on query execution failure. High-traffic callers (EXPORT, COPY) now explicitly close the row generator on error instead of relying on garbage collection.
+
+______________________________________________________________________
+
 ## [2.16.13] - 2026-05-01
 
 ### Added

{execsql2-2.16.13 → execsql2-2.16.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.16.13
+Version: 2.16.14
 Summary: Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables.
 Project-URL: Homepage, https://execsql2.readthedocs.io
 Project-URL: Repository, https://github.com/geocoug/execsql

{execsql2-2.16.13 → execsql2-2.16.14}/docs/about/divergence.md

@@ -310,6 +310,8 @@ These are behavioral changes driven by security or correctness issues in the ups
 | Empty script name in error msg                      | `_execute_script_direct()` and `_execute_script_textual_console()` no longer append "in script , line 0" to uncaught-exception messages when `current_script_line()` returns an empty string.                                                                                                                                                                                                                                                                                                                                                              |
 | `PROMPT COMPARE` diff comparison                    | Diff engine uses native Python equality instead of string comparison — numeric types, Decimals, and booleans compare correctly. `None` is distinguished from empty string. Columns are matched by name (not position), key columns are excluded from comparison, and duplicate PKs keep the first row.                                                                                                                                                                                                                                                     |
 | `win_config_file` broken                            | Checked `os.name == "windows"` which Python never returns (correct value is `"nt"`). Fixed to `os.name == "nt"`. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                                                                                                  |
+| ELSEIF + ANDIF/ORIF                                 | ANDIF/ORIF after an ELSEIF were silently attached to the parent IF condition instead of the ELSEIF clause. The compound condition was never evaluated for the ELSEIF branch. Fixed in the AST parser and executor.                                                                                                                                                                                                                                                                                                                                         |
+| Cursor leak in `select_rowsource()`                 | Cursor was not closed on query execution failure. Row generators in EXPORT and COPY paths were not explicitly closed on error, relying on garbage collection for cleanup.                                                                                                                                                                                                                                                                                                                                                                                  |
 | `NumericParser` right-associative                   | Arithmetic operators were parsed right-to-left. `10 - 3 - 2` evaluated as `9` instead of `5`. Fixed to left-associative parsing. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                                                                                  |
 | Empty-column check precedence                       | `DataTable` and `Database.populate_table()` had an operator precedence bug in the extra-column emptiness check — a redundant `and conf.del_empty_cols` caused incorrect short-circuit evaluation. Inherited from upstream.                                                                                                                                                                                                                                                                                                                                 |
 | SQLite import string processing                     | `SQLiteDatabase.populate_table()` applied `trim_strings`, `replace_newlines`, and `empty_strings` after copying row data, so processing never reached the INSERT. Fixed to process before extraction. Inherited from upstream.                                                                                                                                                                                                                                                                                                                             |

{execsql2-2.16.13 → execsql2-2.16.14}/docs/reference/metacommands.md

@@ -1372,7 +1372,7 @@ ENDIF
 
 Multiple ELSEIF clauses can be used within a single multi-line IF metacommand. An ELSE clause can be used in combination with ELSEIF clauses, but this is not recommended because the results are not likely to be what you expect---the ELSE keyword only inverts the current truth state, it does not provide an alternative to all preceding ELSEIF clauses. To achieve the effect of a case or switch statement, use only ELSEIF clauses without a final ELSE clause.
 
-The ANDIF metacommand allows you to test for the conjunction of two conditional expressions using two separate metacommands instead of one. This may be beneficial for clarity. The simplest form of usage of the ANDIF clause is:
+The ANDIF metacommand allows you to test for the conjunction of two conditional expressions using two separate metacommands instead of one. This may be beneficial for clarity. ANDIF and ORIF can follow either an IF or an ELSEIF metacommand. The simplest form of usage of the ANDIF clause is:
 
 ```
 IF(<conditional expression>)
@@ -1381,7 +1381,7 @@ ANDIF(<conditional expression>)
 ENDIF
 ```
 
-The ANDIF metacommand does not have to immediately follow the IF metacommand. It could instead follow an ELSE statement, or appear anywhere at all within a multi-line IF metacommand. Usage patterns other than that illustrated above may be difficult to interpret, however, and nested IF metacommands may be preferable to complex uses of the ANDIF clause.
+The ANDIF metacommand does not have to immediately follow the IF metacommand. It could instead follow an ELSEIF statement. Usage patterns other than those illustrated here may be difficult to interpret, however, and nested IF metacommands may be preferable to complex uses of the ANDIF clause.
 
 The ORIF metacommand is similar to the ANDIF clause, but allows you to test for the disjunction of two conditional expressions using two different metacommands. The simplest form of usage of the ORIF clause is:
 
@@ -1392,6 +1392,17 @@ ORIF(<conditional expression>)
 ENDIF
 ```
 
+ANDIF and ORIF can also compound an ELSEIF condition:
+
+```
+IF(<conditional expression>)
+    <SQL statements and metacommands>
+ELSEIF(<conditional expression>)
+ANDIF(<conditional expression>)
+    <SQL statements and metacommands>
+ENDIF
+```
+
 The IF metacommands can be used not only to control a single stream of script commands, but also to loop over sets of SQL statements and metacommands, as shown in [Example 6](../guides/examples.md#example6).
 
 The IF metacommands cannot be used within a SQL statement (nor can any other metacommands). This restriction prohibits constructions such as:

{execsql2-2.16.13 → execsql2-2.16.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.16.13"
+version = "2.16.14"
 description = "Runs a SQL script against a PostgreSQL, SQLite, MariaDB/MySQL, DuckDB, Firebird, MS-Access, MS-SQL-Server, or Oracle database, or an ODBC DSN. Provides metacommands to import and export data, copy data between databases, conditionally execute SQL and metacommands, and dynamically alter SQL and metacommands with substitution variables."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = { file = "LICENSE.txt" }
@@ -165,7 +165,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.16.13"
+current_version = "2.16.14"
 commit = true
 tag = true
 tag_name = "v{new_version}"

{execsql2-2.16.13 → execsql2-2.16.14}/src/execsql/db/base.py

@@ -226,6 +226,7 @@ class Database(ABC):
         try:
             curs.execute(sql)
         except Exception:
+            curs.close()
             self.rollback()
             raise
         try:
@@ -264,6 +265,7 @@ class Database(ABC):
         try:
             curs.execute(sql)
         except Exception:
+            curs.close()
             self.rollback()
             raise
         try:

{execsql2-2.16.13 → execsql2-2.16.14}/src/execsql/metacommands/io_export.py

@@ -136,16 +136,20 @@ def _dispatch_format(
             raise
         except Exception as e:
             raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
-        if filefmt == "raw":
-            write_query_raw(outfile, rows, db.encoding, append, zipfile=zipfilename)
-        elif filefmt == "b64":
-            write_query_b64(outfile, rows, append, zipfile=zipfilename)
-        elif filefmt == "feather":
-            write_query_to_feather(outfile, hdrs, rows)
-        elif filefmt == "parquet":
-            write_query_to_parquet(outfile, hdrs, rows)
-        else:
-            write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
+        try:
+            if filefmt == "raw":
+                write_query_raw(outfile, rows, db.encoding, append, zipfile=zipfilename)
+            elif filefmt == "b64":
+                write_query_b64(outfile, rows, append, zipfile=zipfilename)
+            elif filefmt == "feather":
+                write_query_to_feather(outfile, hdrs, rows)
+            elif filefmt == "parquet":
+                write_query_to_parquet(outfile, hdrs, rows)
+            else:
+                write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
+        except BaseException:
+            rows.close()
+            raise
 
 
 # ---------------------------------------------------------------------------

{execsql2-2.16.13 → execsql2-2.16.14}/src/execsql/metacommands/io_fileops.py

@@ -106,10 +106,9 @@ def x_copy(**kwargs: Any) -> None:
     try:
         db2.populate_table(schema2, table2, rows, hdrs, get_ts)
         db2.commit()
-    except ErrInfo:
+    except BaseException:
+        rows.close()
         raise
-    except Exception as e:
-        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
 
 
 def x_copy_query(**kwargs: Any) -> None:
@@ -181,10 +180,9 @@ def x_copy_query(**kwargs: Any) -> None:
     try:
         db2.populate_table(schema2, table2, rows, hdrs, get_ts)
         db2.commit()
-    except ErrInfo:
+    except BaseException:
+        rows.close()
         raise
-    except Exception as e:
-        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
 
 
 def x_zip(**kwargs: Any) -> None:

{execsql2-2.16.13 → execsql2-2.16.14}/src/execsql/script/ast.py

@@ -209,11 +209,14 @@ class ElseIfClause:
     Attributes:
         condition: The condition expression text (e.g. ``"HAS_ROWS"``).
         span: Source location of the ELSEIF line itself.
+        condition_modifiers: ANDIF/ORIF modifiers that compound the ELSEIF
+            condition, evaluated left-to-right at runtime.
         body: Nodes executed when this condition is true.
     """
 
     condition: str
     span: SourceSpan
+    condition_modifiers: list[ConditionModifier] = field(default_factory=list)
     body: list[Node] = field(default_factory=list)
 
 

{execsql2-2.16.13 → execsql2-2.16.14}/src/execsql/script/executor.py

@@ -384,6 +384,12 @@ def _execute_node(
         ctx.last_command = _FakeScriptCmd(node)
         _execute_include(ctx, node, localvars)
 
+    else:
+        raise ErrInfo(
+            type="error",
+            other_msg=f"Unhandled AST node type: {type(node).__name__} at {node.span}",
+        )
+
 
 # ---------------------------------------------------------------------------
 # Block executors
@@ -404,9 +410,7 @@ def _execute_if(
 
     # Try ELSEIF clauses
     for clause in node.elseif_clauses:
-        effective_locals = _stack_localvars(ctx)
-        expanded = substitute_vars(clause.condition, effective_locals, ctx=ctx)
-        if xcmd_test(expanded):
+        if _eval_condition(ctx, clause.condition, clause.condition_modifiers):
             _execute_nodes(ctx, clause.body, node.span.file, localvars, in_loop=in_loop)
             return
 

{execsql2-2.16.13 → execsql2-2.16.14}/src/execsql/script/parser.py

@@ -580,14 +580,17 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                         command_text=line,
                         other_msg=f"ANDIF without matching IF on line {file_lineno} of {source_name}.",
                     )
-                if_node = block_stack[-1].node
-                if_node.condition_modifiers.append(  # type: ignore[union-attr]
-                    ConditionModifier(
-                        kind="AND",
-                        condition=m.group("cond").strip(),
-                        span=SourceSpan(source_name, file_lineno),
-                    ),
+                modifier = ConditionModifier(
+                    kind="AND",
+                    condition=m.group("cond").strip(),
+                    span=SourceSpan(source_name, file_lineno),
                 )
+                frame = block_stack[-1]
+                if_node = frame.node
+                if frame._in_elseif and if_node.elseif_clauses:  # type: ignore[union-attr]
+                    if_node.elseif_clauses[-1].condition_modifiers.append(modifier)  # type: ignore[union-attr]
+                else:
+                    if_node.condition_modifiers.append(modifier)  # type: ignore[union-attr]
                 continue
 
             # -- ORIF --
@@ -599,14 +602,17 @@ def _parse_lines(lines: Iterable[str], source_name: str) -> Script:
                         command_text=line,
                         other_msg=f"ORIF without matching IF on line {file_lineno} of {source_name}.",
                     )
-                if_node = block_stack[-1].node
-                if_node.condition_modifiers.append(  # type: ignore[union-attr]
-                    ConditionModifier(
-                        kind="OR",
-                        condition=m.group("cond").strip(),
-                        span=SourceSpan(source_name, file_lineno),
-                    ),
+                modifier = ConditionModifier(
+                    kind="OR",
+                    condition=m.group("cond").strip(),
+                    span=SourceSpan(source_name, file_lineno),
                 )
+                frame = block_stack[-1]
+                if_node = frame.node
+                if frame._in_elseif and if_node.elseif_clauses:  # type: ignore[union-attr]
+                    if_node.elseif_clauses[-1].condition_modifiers.append(modifier)  # type: ignore[union-attr]
+                else:
+                    if_node.condition_modifiers.append(modifier)  # type: ignore[union-attr]
                 continue
 
             # -- ELSE --

{execsql2-2.16.13 → execsql2-2.16.14}/tests/test_ast_parser.py

@@ -295,6 +295,62 @@ class TestIfBlock:
         assert node.condition_modifiers[1].kind == "OR"
         assert len(node.body) == 1
 
+    def test_elseif_andif_modifier(self):
+        """ANDIF after ELSEIF is stored on the ElseIfClause, not the IfBlock."""
+        script = "-- !x! IF (COND_A)\nSELECT 1;\n-- !x! ELSEIF (COND_B)\n-- !x! ANDIF (COND_C)\nSELECT 2;\n-- !x! ENDIF"
+        node = _first(script)
+        assert isinstance(node, IfBlock)
+        assert len(node.condition_modifiers) == 0
+        assert len(node.elseif_clauses) == 1
+        clause = node.elseif_clauses[0]
+        assert clause.condition == "COND_B"
+        assert len(clause.condition_modifiers) == 1
+        assert clause.condition_modifiers[0].kind == "AND"
+        assert clause.condition_modifiers[0].condition == "COND_C"
+        assert len(clause.body) == 1
+
+    def test_elseif_orif_modifier(self):
+        """ORIF after ELSEIF is stored on the ElseIfClause."""
+        script = "-- !x! IF (COND_A)\nSELECT 1;\n-- !x! ELSEIF (COND_B)\n-- !x! ORIF (COND_C)\nSELECT 2;\n-- !x! ENDIF"
+        node = _first(script)
+        assert isinstance(node, IfBlock)
+        assert len(node.condition_modifiers) == 0
+        clause = node.elseif_clauses[0]
+        assert len(clause.condition_modifiers) == 1
+        assert clause.condition_modifiers[0].kind == "OR"
+        assert clause.condition_modifiers[0].condition == "COND_C"
+
+    def test_elseif_multiple_modifiers(self):
+        """Multiple ANDIF/ORIF after ELSEIF."""
+        script = (
+            "-- !x! IF (COND_A)\nSELECT 1;\n"
+            "-- !x! ELSEIF (COND_B)\n-- !x! ANDIF (COND_C)\n-- !x! ORIF (COND_D)\nSELECT 2;\n"
+            "-- !x! ENDIF"
+        )
+        node = _first(script)
+        clause = node.elseif_clauses[0]
+        assert len(clause.condition_modifiers) == 2
+        assert clause.condition_modifiers[0].kind == "AND"
+        assert clause.condition_modifiers[0].condition == "COND_C"
+        assert clause.condition_modifiers[1].kind == "OR"
+        assert clause.condition_modifiers[1].condition == "COND_D"
+
+    def test_if_andif_then_elseif_andif(self):
+        """ANDIF on IF stays on IF; ANDIF on ELSEIF stays on ELSEIF."""
+        script = (
+            "-- !x! IF (COND_A)\n-- !x! ANDIF (COND_B)\nSELECT 1;\n"
+            "-- !x! ELSEIF (COND_C)\n-- !x! ANDIF (COND_D)\nSELECT 2;\n"
+            "-- !x! ENDIF"
+        )
+        node = _first(script)
+        assert isinstance(node, IfBlock)
+        assert len(node.condition_modifiers) == 1
+        assert node.condition_modifiers[0].condition == "COND_B"
+        assert len(node.elseif_clauses) == 1
+        clause = node.elseif_clauses[0]
+        assert len(clause.condition_modifiers) == 1
+        assert clause.condition_modifiers[0].condition == "COND_D"
+
     def test_andif_without_if_raises(self):
         with pytest.raises(ErrInfo, match="ANDIF without matching IF"):
             parse_string("-- !x! ANDIF (COND)")

{execsql2-2.16.13 → execsql2-2.16.14}/tests/test_executor.py

@@ -238,6 +238,81 @@ class TestIfBlock:
         assert result.returncode == 0
         assert _query_db(tmp_path, "SELECT x FROM t") == [(1,)]
 
+    def test_elseif_andif(self, tmp_path):
+        """ELSEIF with ANDIF modifier — both conditions must be true."""
+        result = _run_ast(
+            "-- !x! SUB a 1\n"
+            "-- !x! SUB b 2\n"
+            "CREATE TABLE t (x INT);\n"
+            "-- !x! IF (EQUALS(!!a!!, 99))\n"
+            "INSERT INTO t VALUES (1);\n"
+            "-- !x! ELSEIF (EQUALS(!!a!!, 1))\n"
+            "-- !x! ANDIF (EQUALS(!!b!!, 2))\n"
+            "INSERT INTO t VALUES (2);\n"
+            "-- !x! ELSE\n"
+            "INSERT INTO t VALUES (3);\n"
+            "-- !x! ENDIF",
+            tmp_path,
+        )
+        assert result.returncode == 0
+        assert _query_db(tmp_path, "SELECT x FROM t") == [(2,)]
+
+    def test_elseif_andif_false(self, tmp_path):
+        """ELSEIF with ANDIF where the ANDIF is false — should fall to ELSE."""
+        result = _run_ast(
+            "-- !x! SUB a 1\n"
+            "-- !x! SUB b 2\n"
+            "CREATE TABLE t (x INT);\n"
+            "-- !x! IF (EQUALS(!!a!!, 99))\n"
+            "INSERT INTO t VALUES (1);\n"
+            "-- !x! ELSEIF (EQUALS(!!a!!, 1))\n"
+            "-- !x! ANDIF (EQUALS(!!b!!, 99))\n"
+            "INSERT INTO t VALUES (2);\n"
+            "-- !x! ELSE\n"
+            "INSERT INTO t VALUES (3);\n"
+            "-- !x! ENDIF",
+            tmp_path,
+        )
+        assert result.returncode == 0
+        assert _query_db(tmp_path, "SELECT x FROM t") == [(3,)]
+
+    def test_elseif_orif(self, tmp_path):
+        """ELSEIF with ORIF modifier — either condition true enters the branch."""
+        result = _run_ast(
+            "-- !x! SUB a 1\n"
+            "-- !x! SUB b 2\n"
+            "CREATE TABLE t (x INT);\n"
+            "-- !x! IF (EQUALS(!!a!!, 99))\n"
+            "INSERT INTO t VALUES (1);\n"
+            "-- !x! ELSEIF (EQUALS(!!a!!, 99))\n"
+            "-- !x! ORIF (EQUALS(!!b!!, 2))\n"
+            "INSERT INTO t VALUES (2);\n"
+            "-- !x! ELSE\n"
+            "INSERT INTO t VALUES (3);\n"
+            "-- !x! ENDIF",
+            tmp_path,
+        )
+        assert result.returncode == 0
+        assert _query_db(tmp_path, "SELECT x FROM t") == [(2,)]
+
+    def test_elseif_orif_both_false(self, tmp_path):
+        """ELSEIF with ORIF where both are false — should fall to ELSE."""
+        result = _run_ast(
+            "-- !x! SUB a 1\n"
+            "CREATE TABLE t (x INT);\n"
+            "-- !x! IF (EQUALS(!!a!!, 99))\n"
+            "INSERT INTO t VALUES (1);\n"
+            "-- !x! ELSEIF (EQUALS(!!a!!, 88))\n"
+            "-- !x! ORIF (EQUALS(!!a!!, 77))\n"
+            "INSERT INTO t VALUES (2);\n"
+            "-- !x! ELSE\n"
+            "INSERT INTO t VALUES (3);\n"
+            "-- !x! ENDIF",
+            tmp_path,
+        )
+        assert result.returncode == 0
+        assert _query_db(tmp_path, "SELECT x FROM t") == [(3,)]
+
     def test_inline_if(self, tmp_path):
         result = _run_ast(
             "-- !x! SUB found no\n"

{execsql2-2.16.13 → execsql2-2.16.14}/uv.lock

@@ -648,7 +648,7 @@ wheels = [
 
 [[package]]
 name = "execsql2"
-version = "2.16.13"
+version = "2.16.14"
 source = { editable = "." }
 dependencies = [
     { name = "python-dateutil" },