execsql2 2.12.0__tar.gz → 2.12.1__tar.gz

{execsql2-2.12.0 → execsql2-2.12.1}/CHANGELOG.md

@@ -13,6 +13,22 @@ ______________________________________________________________________
 
 ______________________________________________________________________
 
+## [2.12.1] - 2026-04-02
+
+### Changed
+
+- Performance: removed dead `_compiled_patterns` dict from `SubVarSet` — eliminated 3 unused regex compilations per `add_substitution` call (~20 calls per statement in typical scripts).
+- Performance: cached `source_dir` and `source_name` on `ScriptCmd` at construction time — eliminated per-statement `Path.resolve()` filesystem calls.
+- Performance: `select_rowdict()` now uses batched `fetchmany()` instead of row-at-a-time `fetchone()`, matching `select_rowsource()` behavior for template exports.
+- Performance: removed redundant `$CURRENT_TIME` set in `set_system_vars()` — now set once per statement in `run_and_increment()`.
+- Performance: removed no-op `copy.copy()` on immutable string in `substitute_vars()`.
+
+### Fixed
+
+- Fixed cursor leak in `select_rowsource()` — generator now closes the cursor in a `finally` block when exhausted or abandoned.
+
+______________________________________________________________________
+
 ## [2.12.0] - 2026-04-01
 
 ### Added

{execsql2-2.12.0 → execsql2-2.12.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: execsql2
-Version: 2.12.0
+Version: 2.12.1
 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: Repository, https://github.com/geocoug/execsql
 Project-URL: Issues, https://github.com/geocoug/execsql/issues

{execsql2-2.12.0 → execsql2-2.12.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "execsql2"
-version = "2.12.0"
+version = "2.12.1"
 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" }
@@ -158,7 +158,7 @@ skip-magic-trailing-comma = false
 line-ending = "auto"
 
 [tool.bumpversion]
-current_version = "2.12.0"
+current_version = "2.12.1"
 commit = true
 commit_args = "--no-verify"
 tag = true

{execsql2-2.12.0 → execsql2-2.12.1}/src/execsql/db/base.py

@@ -234,18 +234,22 @@ class Database(ABC):
             pass  # Non-critical: some drivers lack rowcount support.
 
         def decode_row() -> Generator:
-            while True:
-                rows = curs.fetchmany()
-                if not rows:
-                    break
-                else:
-                    for row in rows:
-                        if self.encoding:
-                            yield [
-                                c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row
-                            ]
-                        else:
-                            yield row
+            try:
+                while True:
+                    rows = curs.fetchmany()
+                    if not rows:
+                        break
+                    else:
+                        for row in rows:
+                            if self.encoding:
+                                yield [
+                                    c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c
+                                    for c in row
+                                ]
+                            else:
+                                yield row
+            finally:
+                curs.close()
 
         return [d[0] for d in curs.description], decode_row()
 
@@ -253,6 +257,10 @@ class Database(ABC):
         """Execute *sql* and return ``(column_names, row_iterator)`` where each row is a ``dict``."""
         # Return an iterable that yields dictionaries of row data
         curs = self.cursor()
+        try:
+            curs.arraysize = _state.conf.export_row_buffer
+        except Exception:
+            pass  # Non-critical: not all drivers support arraysize.
         try:
             curs.execute(sql)
         except Exception:
@@ -264,18 +272,24 @@ class Database(ABC):
             pass  # Non-critical: some drivers lack rowcount support.
         hdrs = [d[0] for d in curs.description]
 
-        def dict_row() -> dict | None:
-            row = curs.fetchone()
-            if row:
-                if self.encoding:
-                    r = [c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row]
-                else:
-                    r = row
-                return dict(zip(hdrs, r))
-            else:
-                return None
+        def dict_rows() -> Generator:
+            try:
+                while True:
+                    rows = curs.fetchmany()
+                    if not rows:
+                        break
+                    for row in rows:
+                        if self.encoding:
+                            r = [
+                                c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c for c in row
+                            ]
+                        else:
+                            r = row
+                        yield dict(zip(hdrs, r))
+            finally:
+                curs.close()
 
-        return hdrs, iter(dict_row, None)
+        return hdrs, dict_rows()
 
     def schema_exists(self, schema_name: str) -> bool:
         """Return ``True`` if *schema_name* exists in this database."""

{execsql2-2.12.0 → execsql2-2.12.1}/src/execsql/script/engine.py

@@ -397,6 +397,15 @@ class ScriptCmd:
         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})"
@@ -498,9 +507,9 @@ class CommandList:
             _state.subvars.add_substitution("$CURRENT_SCRIPT", cmditem.source)
             _state.subvars.add_substitution(
                 "$CURRENT_SCRIPT_PATH",
-                str(Path(cmditem.source).resolve().parent) + os.sep,
+                cmditem.source_dir,
             )
-            _state.subvars.add_substitution("$CURRENT_SCRIPT_NAME", Path(cmditem.source).name)
+            _state.subvars.add_substitution("$CURRENT_SCRIPT_NAME", cmditem.source_name)
             _state.subvars.add_substitution("$CURRENT_SCRIPT_LINE", str(cmditem.line_no))
             _state.subvars.add_substitution("$SCRIPT_LINE", str(cmditem.line_no))
             if _state.step_mode:
@@ -709,7 +718,7 @@ def set_system_vars() -> None:
         "ON" if _state.conf.gui_wait_on_error_halt else "OFF",
     )
     _state.subvars.add_substitution("$CONSOLE_WAIT_WHEN_DONE_STATE", "ON" if _state.conf.gui_wait_on_exit else "OFF")
-    _state.subvars.add_substitution("$CURRENT_TIME", datetime.datetime.now().strftime("%Y-%m-%d %H:%M"))
+    # $CURRENT_TIME is set per-statement in run_and_increment() for accuracy.
     _state.subvars.add_substitution("$CURRENT_DIR", str(Path(".").resolve()))
     _state.subvars.add_substitution("$CURRENT_PATH", str(Path(".").resolve()) + os.sep)
     _state.subvars.add_substitution("$CURRENT_ALIAS", _state.dbs.current_alias())
@@ -742,7 +751,7 @@ def substitute_vars(command_str: str, localvars: SubVarSet | None = None) -> str
         subs = _state.subvars.merge(localvars)
     else:
         subs = _state.subvars
-    cmdstr = copy.copy(command_str)
+    cmdstr = command_str
     subs_made = True
     iterations = 0
     while subs_made:

{execsql2-2.12.0 → execsql2-2.12.1}/src/execsql/script/variables.py

@@ -89,7 +89,6 @@ class SubVarSet:
     # compatibility with external code.
     def __init__(self) -> None:
         self._subs_dict: dict[str, Any] = {}
-        self._compiled_patterns: dict[str, tuple] = {}
         self.prefix_list: list[str] = ["$", "&", "@"]
         # Don't construct/compile on init because deepcopy() can't handle compiled regexes.
         self.var_rx = None
@@ -106,21 +105,6 @@ class SubVarSet:
             self._subs_dict = dict(value)
         else:
             self._subs_dict = dict(value)
-        self._rebuild_all_patterns()
-
-    def _compile_patterns_for(self, varname: str) -> tuple:
-        """Compile and return the three regex patterns (plain, single-quoted, double-quoted) for *varname*."""
-        match_escaped = "\\" + varname if varname[0] == "$" else varname
-        pat = re.compile(f"!!{match_escaped}!!", re.I)
-        patq = re.compile(f"!'!{match_escaped}!'!", re.I)
-        patdq = re.compile(f'!"!{match_escaped}!"!', re.I)
-        return (pat, patq, patdq)
-
-    def _rebuild_all_patterns(self) -> None:
-        """Rebuild compiled patterns for every variable currently stored."""
-        self._compiled_patterns = {}
-        for varname in self._subs_dict:
-            self._compiled_patterns[varname] = self._compile_patterns_for(varname)
 
     def compile_var_rx(self) -> None:
         """Compile the variable-name validation regex from the current prefix list."""
@@ -141,14 +125,12 @@ class SubVarSet:
         self.check_var_name(template_str)
         old_sub = template_str.lower()
         self._subs_dict.pop(old_sub, None)
-        self._compiled_patterns.pop(old_sub, None)
 
     def add_substitution(self, varname: str, repl_str: Any) -> None:
-        """Add or overwrite a substitution variable, compiling its match patterns."""
+        """Add or overwrite a substitution variable."""
         self.check_var_name(varname)
         varname = varname.lower()
         self._subs_dict[varname] = repl_str
-        self._compiled_patterns[varname] = self._compile_patterns_for(varname)
 
     def append_substitution(self, varname: str, repl_str: str) -> None:
         self.check_var_name(varname)
@@ -186,15 +168,10 @@ class SubVarSet:
         return template_str.lower() in self._subs_dict
 
     def merge(self, other_subvars: SubVarSet | None) -> SubVarSet:
-        """Return a new SubVarSet with this object's variables merged with other_subvars.
-
-        Copies dictionaries and pre-compiled patterns directly instead of
-        re-adding variables one at a time, avoiding O(V) regex recompilation.
-        """
+        """Return a new SubVarSet with this object's variables merged with other_subvars."""
         if other_subvars is not None:
             newsubs = SubVarSet()
             newsubs._subs_dict = {**self._subs_dict, **other_subvars._subs_dict}
-            newsubs._compiled_patterns = {**self._compiled_patterns, **other_subvars._compiled_patterns}
             newsubs.prefix_list = list(set(self.prefix_list + other_subvars.prefix_list))
             newsubs.compile_var_rx()
             return newsubs

{execsql2-2.12.0 → execsql2-2.12.1}/tests/db/test_base.py

@@ -628,9 +628,9 @@ class TestSelectRowdictEncoding:
         mock_curs = MagicMock()
         mock_curs.description = [("name",)]
         mock_curs.rowcount = 1
-        mock_curs.fetchone.side_effect = [
-            (b"encoded value",),
-            None,
+        mock_curs.fetchmany.side_effect = [
+            [(b"encoded value",)],
+            [],
         ]
 
         with patch.object(db, "cursor", return_value=mock_curs):
@@ -648,7 +648,7 @@ class TestSelectRowdictEncoding:
         mock_curs = MagicMock()
         mock_curs.description = [("score",)]
         mock_curs.rowcount = 1
-        mock_curs.fetchone.side_effect = [(99,), None]
+        mock_curs.fetchmany.side_effect = [[(99,)], []]
 
         with patch.object(db, "cursor", return_value=mock_curs):
             _, it = db.select_rowdict("SELECT score FROM fake;")
@@ -664,7 +664,7 @@ class TestSelectRowdictEncoding:
         mock_curs = MagicMock()
         mock_curs.description = [("x",)]
         mock_curs.rowcount = 1
-        mock_curs.fetchone.side_effect = [("plain",), None]
+        mock_curs.fetchmany.side_effect = [[("plain",)], []]
 
         with patch.object(db, "cursor", return_value=mock_curs):
             _, it = db.select_rowdict("SELECT x FROM fake;")

{execsql2-2.12.0 → execsql2-2.12.1}/tests/test_engine.py

@@ -706,7 +706,8 @@ class TestSetSystemVars:
         set_system_vars()
         assert _state.subvars.varvalue("$DB_USER") == "testuser"
 
-    def test_populates_current_time(self, engine_state):
+    def test_current_time_not_set_by_set_system_vars(self, engine_state):
+        """$CURRENT_TIME is set per-statement in run_and_increment, not in set_system_vars."""
         pool = MagicMock()
         pool.current.return_value = self._make_db()
         pool.current_alias.return_value = "main"
@@ -715,9 +716,7 @@ class TestSetSystemVars:
         mock_timer.elapsed.return_value = 0
         _state.timer = mock_timer
         set_system_vars()
-        t = _state.subvars.varvalue("$CURRENT_TIME")
-        assert t is not None
-        assert len(t) == 16  # "YYYY-MM-DD HH:MM"
+        assert _state.subvars.varvalue("$CURRENT_TIME") is None
 
     def test_populates_version_numbers(self, engine_state):
         pool = MagicMock()

{execsql2-2.12.0 → execsql2-2.12.1}/tests/test_script.py

@@ -471,59 +471,55 @@ class TestSubVarSet:
         sv.remove_substitution("$x")
         assert sv.sub_exists("$x") is False
 
-    # -- compiled regex patterns ---------------------------------------------
+    # -- substitution ---------------------------------------------------------
 
-    def test_compiled_patterns_created_on_add(self):
+    def test_add_stores_in_subs_dict(self):
         sv = SubVarSet()
         sv.add_substitution("$foo", "bar")
-        assert "$foo" in sv._compiled_patterns
-        pat, patq, patdq = sv._compiled_patterns["$foo"]
-        assert pat.search("!!$foo!!") is not None
-        assert patq.search("!'!$foo!'!") is not None
-        assert patdq.search('!"!$foo!"!') is not None
+        assert "$foo" in sv._subs_dict
 
-    def test_compiled_patterns_removed_on_remove(self):
+    def test_remove_clears_from_subs_dict(self):
         sv = SubVarSet()
         sv.add_substitution("$foo", "bar")
         sv.remove_substitution("$foo")
-        assert "$foo" not in sv._compiled_patterns
+        assert "$foo" not in sv._subs_dict
 
-    def test_substitute_uses_compiled_patterns(self):
+    def test_substitute_expands_token(self):
         sv = SubVarSet()
         sv.add_substitution("$x", "replaced")
         result, changed = sv.substitute("value is !!$x!!")
         assert changed is True
         assert result == "value is replaced"
 
-    def test_substitute_case_insensitive_with_compiled(self):
+    def test_substitute_case_insensitive(self):
         sv = SubVarSet()
         sv.add_substitution("$myvar", "val")
         result, changed = sv.substitute("!!$MYVAR!!")
         assert changed is True
         assert result == "val"
 
-    def test_substitute_single_quoted_with_compiled(self):
+    def test_substitute_single_quoted(self):
         sv = SubVarSet()
         sv.add_substitution("$v", "it's")
         result, changed = sv.substitute("!'!$v!'!")
         assert changed is True
         assert "it''s" in result
 
-    def test_substitute_double_quoted_with_compiled(self):
+    def test_substitute_double_quoted(self):
         sv = SubVarSet()
         sv.add_substitution("$v", "hello")
         result, changed = sv.substitute('!"!$v!"!')
         assert changed is True
         assert '"hello"' in result
 
-    def test_merge_preserves_compiled_patterns(self):
+    def test_merge_preserves_variables(self):
         sv1 = SubVarSet()
         sv1.add_substitution("$a", "1")
         sv2 = SubVarSet()
         sv2.add_substitution("$b", "2")
         merged = sv1.merge(sv2)
-        assert "$a" in merged._compiled_patterns
-        assert "$b" in merged._compiled_patterns
+        assert "$a" in merged._subs_dict
+        assert "$b" in merged._subs_dict
         result, changed = merged.substitute_all("!!$a!! !!$b!!")
         assert result == "1 2"
 

{execsql2-2.12.0 → execsql2-2.12.1}/uv.lock

@@ -657,7 +657,7 @@ wheels = [
 
 [[package]]
 name = "execsql2"
-version = "2.12.0"
+version = "2.12.1"
 source = { editable = "." }
 dependencies = [
     { name = "rich" },