velocity-python 0.1.72__tar.gz → 0.1.74__tar.gz

{velocity_python-0.1.72 → velocity_python-0.1.74}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.72
+Version: 0.1.74
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.72 → velocity_python-0.1.74}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.72"
+version = "0.1.74"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.72"
+__version__ = version = "0.1.74"
 
 import importlib as _importlib
 

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity/db/core/async_support.py

@@ -28,6 +28,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import os
+import re
 import time as _time
 from collections import OrderedDict
 from collections.abc import Mapping
@@ -426,6 +427,16 @@ class AsyncTransaction:
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         if exc_type:
             await self.rollback()
+            # Discard the connection on the error path WITHOUT committing.
+            # (The previous code fell through to close(), which committed even
+            # after a rollback.)
+            if self.connection:
+                try:
+                    await self.connection.close()
+                except Exception:
+                    pass
+                self.connection = None
+            return  # do not suppress the original exception
         await self.close()
 
     async def _ensure_connection(self):
@@ -507,21 +518,23 @@ class AsyncTransaction:
                 stack_info=True,
             )
 
-        # R14 — N+1 detection
-        if _N_PLUS_1_THRESHOLD:
-            from velocity.db.core.transaction import _classify_sql, _extract_table_name
-            op = _classify_sql(sql)
-            if op == "SELECT":
-                tbl = _extract_table_name(sql)
-                if tbl:
-                    self._table_select_counts[tbl] = self._table_select_counts.get(tbl, 0) + 1
-                    count = self._table_select_counts[tbl]
-                    if count > _N_PLUS_1_THRESHOLD and tbl not in self._n1_warned:
-                        self._n1_warned.add(tbl)
-                        _logger.warning(
-                            "Possible N+1: table %s queried %d times in async transaction",
-                            tbl, count,
-                        )
+        # R14 — N+1 detection / R33 — raw-write cache invalidation
+        from velocity.db.core.transaction import _classify_sql, _extract_table_name
+        op = _classify_sql(sql)
+        if _N_PLUS_1_THRESHOLD and op == "SELECT":
+            tbl = _extract_table_name(sql)
+            if tbl:
+                self._table_select_counts[tbl] = self._table_select_counts.get(tbl, 0) + 1
+                count = self._table_select_counts[tbl]
+                if count > _N_PLUS_1_THRESHOLD and tbl not in self._n1_warned:
+                    self._n1_warned.add(tbl)
+                    _logger.warning(
+                        "Possible N+1: table %s queried %d times in async transaction",
+                        tbl, count,
+                    )
+        # Keep the query cache correct for raw writes that bypass the table API.
+        if self._query_cache and op in ("INSERT", "UPDATE", "DELETE", "DDL"):
+            self.invalidate_cache(_extract_table_name(sql))
 
         result = AsyncResult(cursor, self, sql, parms)
         await result._init()
@@ -554,7 +567,13 @@ class AsyncTransaction:
     async def commit(self):
         """Commit the async transaction."""
         if self.connection:
-            await self.connection.commit()
+            try:
+                await self.connection.commit()
+            except Exception as e:
+                # Classify commit-time failures (serialization failure, deadlock,
+                # deferred-constraint violation) like the sync path does, instead
+                # of letting a raw driver error escape.
+                raise self.engine.process_error(e)
             if self._query_count:
                 _logger.debug(
                     "Async transaction commit: %d queries in %.1f ms",
@@ -570,12 +589,17 @@ class AsyncTransaction:
                 pass
 
     async def close(self):
-        """Commit (if needed) and close the async connection."""
-        if self.connection:
-            try:
-                await self.commit()
-            except Exception:
-                pass
+        """Commit (if needed) and close the async connection.
+
+        A commit failure is **re-raised** (after the connection is closed)
+        rather than swallowed — otherwise a failed COMMIT would look successful
+        and the caller's writes would be silently lost.
+        """
+        if not self.connection:
+            return
+        try:
+            await self.commit()
+        finally:
             try:
                 await self.connection.close()
             except Exception:
@@ -647,7 +671,9 @@ class AsyncTransaction:
         if table_name is None:
             self._query_cache.clear()
             return
-        tbl_lower = table_name.lower()
-        to_remove = [k for k in self._query_cache if tbl_lower in k[0].lower()]
+        # R33 — whole-word match (see sync Transaction.invalidate_cache): a
+        # substring match would wrongly evict "users" when invalidating "user".
+        pattern = re.compile(r"\b" + re.escape(table_name.lower()) + r"\b")
+        to_remove = [k for k in self._query_cache if pattern.search(k[0].lower())]
         for k in to_remove:
             del self._query_cache[k]

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity/db/core/engine.py

@@ -61,6 +61,27 @@ def _build_error_code_map(sql_dialect) -> dict:
 _ENGINE_FILE = os.path.normpath(__file__)
 
 
+# R34 — Optional wall-clock ceiling on the retry envelope. The count caps
+# (MAX_RETRIES=100 for deadlock/serialization) combined with up to 2s of backoff
+# per attempt can spin for minutes on a *deterministic* conflict, burning a whole
+# Lambda/request timeout. A budget lets a caller bound total retry wall time.
+# 0 (default) = disabled, preserving the historical count-only behaviour.
+_RETRY_BUDGET_SECONDS = float(os.environ.get("VELOCITY_RETRY_BUDGET_SECONDS", "0"))
+
+
+def _retry_budget_exhausted(loop_start):
+    """R34 — True (and log) once the cumulative retry wall time exceeds the
+    configured budget, so the envelope re-raises instead of retrying forever."""
+    if _RETRY_BUDGET_SECONDS and (time.perf_counter() - loop_start) > _RETRY_BUDGET_SECONDS:
+        logger.error(
+            "Retry wall-clock budget of %.1fs exhausted; re-raising instead of "
+            "continuing to retry (VELOCITY_RETRY_BUDGET_SECONDS).",
+            _RETRY_BUDGET_SECONDS,
+        )
+        return True
+    return False
+
+
 def _retry_blocked_by_side_effect(tx):
     """R21 — return True (and log) when *tx* has performed an irreversible
     external side effect, so the auto-retry envelope must re-raise instead of
@@ -530,12 +551,18 @@ class Engine:
                             tx = args[pos]
 
                 if tx:
+                    # Joined a caller-owned transaction: the caller drives
+                    # commit/rollback/retry. _owns_tx stays False.
                     return self.exec_function(func_or_cls, tx, *args, **kwds)
 
                 with Transaction(self) as local_tx:
                     pos = names.index("tx")
                     new_args = args[:pos] + (local_tx,) + args[pos:]
-                    return self.exec_function(func_or_cls, local_tx, *new_args, **kwds)
+                    # We created this transaction, so we own it: commit it and
+                    # act as the retry boundary.
+                    return self.exec_function(
+                        func_or_cls, local_tx, *new_args, _owns_tx=True, **kwds
+                    )
 
             return new_function
 
@@ -579,28 +606,62 @@ class Engine:
 
         return Transaction(self)
 
-    def exec_function(self, function, _tx, *args, **kwds):
+    def exec_function(self, function, _tx, *args, _owns_tx=False, **kwds):
         """
         Executes the given function inside the transaction `_tx`.
-        Retries if it raises DbRetryTransaction or DbLockTimeoutError, up to MAX_RETRIES times.
+
+        Retry / commit semantics:
+
+        * When this invocation **owns** the transaction (``_owns_tx=True`` — the
+          decorator created it for an omitted-``tx`` call) and is the outermost
+          such invocation (``depth == 0``), it is the *retry boundary*. It
+          commits the transaction **inside** the retry envelope, so commit-time
+          serialization failures / deadlocks / deferred-constraint violations
+          are classified and retried too — not just statement-time errors. It
+          retries on ``DbRetryTransaction`` / ``DbLockTimeoutError`` (up to
+          ``MAX_RETRIES``) and on transient ``DbConnectionError`` (up to 6).
+
+        * When the transaction was **passed in** (``_owns_tx=False``), the caller
+          owns it. This invocation must NOT commit, roll back, or retry — a
+          rollback would silently discard the caller's other uncommitted work on
+          the same transaction, and a retry would re-run only this function
+          against state the caller no longer has. It simply runs the function;
+          the owner drives commit/rollback/retry. Nested calls (``depth > 0``)
+          are likewise pass-through.
+
+        Note: a manually created ``with engine.transaction() as tx:`` that is
+        passed to a decorated function therefore gets no auto-retry — that is
+        intentional. Wrap the outer scope in ``@engine.transaction`` (so the
+        framework owns the transaction) if you want commit-and-retry semantics.
         """
         depth = getattr(_tx, "_exec_function_depth", 0)
         setattr(_tx, "_exec_function_depth", depth + 1)
 
         try:
-            if depth > 0:
-                # Not top-level. Just call the function.
+            if not (_owns_tx and depth == 0):
+                # Joined a caller-owned transaction, or a nested call. Just run
+                # the function; the transaction's owner handles commit, rollback
+                # and retry. Retrying here would roll back work we don't own.
                 return function(*args, **kwds)
             else:
                 retry_count = 0
                 lock_timeout_count = 0
                 connection_retry_count = 0
+                loop_start = time.perf_counter()
                 while True:
                     try:
-                        return function(*args, **kwds)
+                        result = function(*args, **kwds)
+                        # Commit INSIDE the retry envelope so a commit-time
+                        # serialization failure / deadlock / deferred-constraint
+                        # violation is classified and retried, instead of
+                        # escaping as a raw driver error after the loop exits.
+                        _tx.commit()
+                        return result
                     except exceptions.DbRetryTransaction:
                         if _retry_blocked_by_side_effect(_tx):
                             raise
+                        if _retry_budget_exhausted(loop_start):
+                            raise
                         retry_count += 1
                         if retry_count > self.MAX_RETRIES:
                             raise
@@ -610,6 +671,8 @@ class Engine:
                     except exceptions.DbLockTimeoutError:
                         if _retry_blocked_by_side_effect(_tx):
                             raise
+                        if _retry_budget_exhausted(loop_start):
+                            raise
                         lock_timeout_count += 1
                         if lock_timeout_count > self.MAX_RETRIES:
                             raise
@@ -624,6 +687,8 @@ class Engine:
                         # double-charge a customer.
                         if _retry_blocked_by_side_effect(_tx):
                             raise
+                        if _retry_budget_exhausted(loop_start):
+                            raise
                         msg = str(e).strip().lower()
                         if not getattr(
                             self.sql, "is_transient_connection_error_message", lambda _m: False

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity/db/core/result.py

@@ -1,5 +1,6 @@
 from velocity.misc.format import to_json
 from velocity.db.core.row import Row
+from velocity.db import exceptions
 
 
 class Result:
@@ -52,6 +53,26 @@ class Result:
         # Pre-fetch the first row to enable immediate boolean evaluation
         self._fetch_first_row()
 
+    def _outlived_transaction(self):
+        """True when a fetch failed because this Result outlived its transaction.
+
+        Once the owning transaction commits/closes it releases its connection
+        (``tx.connection`` becomes ``None``) — and, when pooled, that connection
+        may already be serving another transaction. Continuing to read this
+        Result's cursor then returns nothing (or another transaction's data).
+        Silently reporting "no more rows" in that case hides real data, so the
+        caller is told to materialize inside the transaction instead.
+        """
+        tx = self.__tx
+        return tx is not None and getattr(tx, "connection", None) is None
+
+    _OUTLIVED_TX_MESSAGE = (
+        "Result was iterated after its transaction was committed/closed — the "
+        "rows are no longer available (and a pooled connection may now belong to "
+        "another transaction). Materialize the result inside the transaction "
+        "(.all()/.one()/.scalar()/list(...)) before returning it."
+    )
+
     def _fetch_first_row(self):
         """
         Pre-fetch the first row from the cursor to enable immediate boolean evaluation.
@@ -138,6 +159,8 @@ class Result:
                 self._cursor = None
                 if isinstance(e, StopIteration):
                     raise
+                if self._outlived_transaction():
+                    raise exceptions.DbException(self._OUTLIVED_TX_MESSAGE)
                 raise StopIteration
         else:
             raise StopIteration
@@ -168,6 +191,8 @@ class Result:
             # If cursor is closed or has error, mark as exhausted
             self._exhausted = True
             self._cursor = None
+            if self._outlived_transaction():
+                raise exceptions.DbException(self._OUTLIVED_TX_MESSAGE)
 
     def batch(self, qty=1):
         """
@@ -355,6 +380,8 @@ class Result:
                 # If cursor error, return default
                 self._exhausted = True
                 self._cursor = None
+                if self._outlived_transaction():
+                    raise exceptions.DbException(self._OUTLIVED_TX_MESSAGE)
                 return default
         return default
 

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity/db/core/transaction.py

@@ -1,10 +1,13 @@
 import logging
 import os
+import re
 import time as _time
 import traceback
 import uuid
 from collections import OrderedDict
+from contextlib import contextmanager
 
+from velocity.db import exceptions
 from velocity.db.core.row import Row
 from velocity.db.core.table import Table
 from velocity.db.core.view import View
@@ -185,6 +188,12 @@ class Transaction:
         # auto-retry envelope must NOT re-run a function after this, or a
         # transient DB error post-charge would charge the customer again.
         self._external_side_effect = False
+        # R31 — True once a statement has executed on the current connection and
+        # has not yet been committed/rolled back. Used to detect a connection
+        # that died *mid-transaction*: silently reconnecting there would start a
+        # fresh transaction and lose the prior uncommitted statements without
+        # any error. Reset on connect/commit/rollback.
+        self._in_progress = False
 
     def __str__(self):
         config = mask_config_for_display(self.engine.config)
@@ -204,15 +213,54 @@ class Transaction:
             if debug:
                 print("Transaction.__exit__ - an exception occurred.")
                 traceback.print_exc()
-            self.rollback()
-            # After an error + rollback, discard the connection from the pool
-            # rather than returning it in a potentially dirty state.
-            if self.__pooled and self.connection:
-                self.engine.return_pooled_connection(self.connection, discard=True)
+            # Roll back, but never let a secondary failure here (e.g. rolling
+            # back an already-dead connection) mask the original exception that
+            # triggered the unwind.
+            try:
+                self.rollback()
+            except Exception:
+                pass
+            # After an error, discard the connection rather than returning or
+            # reusing it in a potentially dirty state. Release the pool slot
+            # in either mode so an error can't leak it.
+            if self.connection:
+                if self.__pooled:
+                    self.engine.return_pooled_connection(self.connection, discard=True)
+                else:
+                    try:
+                        self.connection.close()
+                    except Exception:
+                        pass
                 self.connection = None
                 self.__pooled = False
+            return  # do not suppress the exception
         self.close()
 
+    def _discard_dead_connection(self):
+        """Drop the current connection because it's dead/unusable.
+
+        If it was a pooled connection, return it to the pool with ``discard=True``
+        so the pool **releases its semaphore slot** (and decrements its count) —
+        otherwise a connection that died while checked out leaks a slot forever,
+        and enough such leaks exhaust the pool. Non-pooled connections are just
+        closed. Always clears ``_in_progress`` since any open work is gone.
+        """
+        dead = self.connection
+        self.connection = None
+        self._in_progress = False
+        if dead is None:
+            return
+        if self.__pooled:
+            try:
+                self.engine.return_pooled_connection(dead, discard=True)
+            except Exception:
+                pass
+        else:
+            try:
+                dead.close()
+            except Exception:
+                pass
+
     def cursor(self):
         """
         Retrieves a database cursor, opening a connection if necessary.
@@ -221,14 +269,32 @@ class Transaction:
         # (psycopg v3 uses `connection.closed` returning bool; v2 used int != 0.)
         if self.connection is not None:
             try:
-                if getattr(self.connection, "closed", 0):
-                    self.connection = None
+                is_closed = bool(getattr(self.connection, "closed", 0))
             except Exception:
                 # If the driver object is in a bad state, force a reconnect.
-                self.connection = None
+                is_closed = True
+            if is_closed:
+                # R31 — If statements already ran in this transaction, silently
+                # reconnecting would open a NEW connection (a fresh transaction)
+                # and discard that uncommitted work with no error. Surface it as
+                # a transient connection error instead, so the @engine.transaction
+                # retry envelope re-runs the whole unit of work from the start
+                # rather than committing a partial/empty transaction.
+                in_progress = self._in_progress
+                # Discard the dead connection properly (releases the pool slot;
+                # the previous code nulled it and leaked the slot).
+                self._discard_dead_connection()
+                if in_progress:
+                    raise exceptions.DbConnectionError(
+                        "Database connection already closed mid-transaction; "
+                        "uncommitted work in this transaction was lost and cannot "
+                        "be recovered in place. (A function wrapped by "
+                        "@engine.transaction will be retried from the start.)"
+                    )
 
         if not self.connection:
             self.connection = self.engine.connect()
+            self._in_progress = False
         if debug:
             print(f"*** {id(self)} --> transaction.cursor()")
         return self.connection.cursor()
@@ -239,15 +305,36 @@ class Transaction:
         If the connection was obtained from the pool, it is returned to
         the pool instead of being closed.
         """
-        if self.connection:
+        if not self.connection:
+            return
+        if debug:
+            print(f"<<< {id(self)} close connection.")
+        try:
             self.commit()
-            if debug:
-                print(f"<<< {id(self)} close connection.")
-            if self.__pooled and self.engine.return_pooled_connection(self.connection):
-                self.connection = None
+        except Exception:
+            # A commit-time failure (serialization failure, deadlock, or a
+            # deferred-constraint violation — all of which surface at COMMIT,
+            # not at statement time) leaves the connection in an aborted state.
+            # Discard it rather than returning a dirty connection to the pool,
+            # and ALWAYS release the pool slot so a commit failure can't leak
+            # it. Repeated commit-time failures would otherwise exhaust the
+            # pool, turning a transient error into a hard outage. Then re-raise
+            # so the caller still sees the commit error.
+            if self.__pooled:
+                self.engine.return_pooled_connection(self.connection, discard=True)
             else:
-                self.connection.close()
-                self.connection = None
+                try:
+                    self.connection.close()
+                except Exception:
+                    pass
+            self.connection = None
+            self.__pooled = False
+            raise
+        if self.__pooled and self.engine.return_pooled_connection(self.connection):
+            self.connection = None
+        else:
+            self.connection.close()
+            self.connection = None
 
     def execute(self, sql, parms=None, single=False, cursor=None, prepare=None):
         return self._execute(sql, parms, single, cursor, prepare=prepare)
@@ -259,6 +346,18 @@ class Transaction:
             self.connection = self.engine.connect()
 
         if single:
+            # R32 — single=True needs autocommit mode, which can't have an open
+            # transaction, so it must commit first. If there is uncommitted work
+            # pending, that work is silently committed here — warn, because
+            # single=True is meant for standalone statements (e.g. CREATE
+            # DATABASE) on a clean transaction, not mid-unit-of-work.
+            if self._in_progress:
+                _logger.warning(
+                    "execute(single=True) is committing work already pending in "
+                    "this transaction before switching to autocommit. single=True "
+                    "is for standalone statements on a clean transaction; running "
+                    "it mid-transaction silently commits the prior statements."
+                )
             self.commit()
             self.connection.autocommit = True
 
@@ -309,6 +408,20 @@ class Transaction:
             elapsed_ms = (_time.perf_counter() - t0) * 1000
             self._query_count += 1
             self._query_time_ms += elapsed_ms
+            if not single:
+                # A statement is now pending in an open transaction (single=True
+                # runs in autocommit, so nothing is left pending there).
+                self._in_progress = True
+
+            # R33 — Keep the query cache correct for raw writes that bypass the
+            # Table API (which invalidates on its own). A write run directly via
+            # tx.execute() would otherwise leave stale cached reads for that
+            # table. Cheap when the cache is empty (the common case).
+            if self.__query_cache:
+                op = _classify_sql(sql)
+                if op in ("INSERT", "UPDATE", "DELETE", "DDL"):
+                    tbl = _extract_table_name(sql)
+                    self.invalidate_cache(tbl)  # tbl=None clears the whole cache
 
             # R12 — Slow query logging.
             if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
@@ -395,6 +508,8 @@ class Transaction:
         except Exception as e:
             raise self.engine.process_error(e, sql, args_list)
 
+        # Rows are now pending in an open transaction.
+        self._in_progress = True
         return total
 
     def server_execute(self, sql, parms=None):
@@ -429,7 +544,18 @@ class Transaction:
         if self.connection:
             if debug:
                 print(f"{id(self)} --- connection commit.")
-            self.connection.commit()
+            try:
+                self.connection.commit()
+            except Exception as e:
+                # Serialization failures (40001), deadlocks (40P01) and deferred
+                # constraint violations are reported at COMMIT, not at statement
+                # time. Route them through the engine's classifier so they become
+                # the right velocity exception (e.g. DbRetryTransaction) and can
+                # be retried by exec_function's envelope — instead of escaping as
+                # a raw driver error after the retry loop has already exited.
+                raise self.engine.process_error(e)
+            # Work is durably committed; the transaction is clean again.
+            self._in_progress = False
             if self._query_count:
                 _logger.debug(
                     "Transaction commit: %d queries in %.1f ms",
@@ -448,6 +574,8 @@ class Transaction:
             if debug:
                 print(f"{id(self)} --- connection rollback.")
             self.connection.rollback()
+            # Transaction is clean again — no uncommitted work pending.
+            self._in_progress = False
 
     def create_savepoint(self, sp=None, cursor=None):
         """
@@ -476,6 +604,49 @@ class Transaction:
         if sql:
             self._execute(sql, vals, cursor=cursor)
 
+    @contextmanager
+    def savepoint(self, name=None):
+        """Context manager for a nested savepoint (attempt-and-recover).
+
+        On a clean exit the savepoint is released. If the body raises, the
+        transaction is rolled back **to the savepoint** — undoing only the work
+        inside the block — and the exception is re-raised, leaving the outer
+        transaction usable.
+
+        This is the safe way to try a fallible operation inside a transaction on
+        PostgreSQL. Without a savepoint, the first error aborts the *whole*
+        transaction and every later statement fails with "current transaction is
+        aborted, commands ignored until end of transaction block"; a plain
+        ``try/except`` around a bare ``execute`` does **not** recover from that.
+        ::
+
+            with engine.transaction() as tx:
+                try:
+                    with tx.savepoint():
+                        tx.table("x").insert(maybe_dup)
+                except exceptions.DbDuplicateKeyError:
+                    pass                         # tx is still usable here
+                tx.table("y").insert(...)        # succeeds
+
+        Args:
+            name: Optional savepoint name; a random one is generated if omitted.
+        """
+        sp = self.create_savepoint(name)
+        try:
+            yield sp
+        except Exception:
+            # Roll back only the inner work and clear the aborted state so the
+            # outer transaction can continue. Guard cleanup so a dead connection
+            # can't mask the original error.
+            try:
+                self.rollback_savepoint(sp)
+                self.release_savepoint(sp)
+            except Exception:
+                pass
+            raise
+        else:
+            self.release_savepoint(sp)
+
     def mark_external_side_effect(self):
         """Record that this transaction performed an irreversible external side
         effect (a payment charge/capture, an email send, an external API write).
@@ -559,10 +730,14 @@ class Transaction:
             self._json_columns_cache.clear()
             return
         self._json_columns_cache.pop(table_name, None)
-        # Simple substring match on the SQL text (first element of the key).
-        tbl_lower = table_name.lower()
+        # R33 — Whole-word match on the SQL text (first element of the key), not
+        # a substring: a substring match would wrongly evict "users" when asked
+        # to invalidate "user" (and vice-versa). \b boundaries treat quotes /
+        # dots / whitespace around an identifier as delimiters while keeping
+        # "order" from matching "order_items" (underscore is a word char).
+        pattern = re.compile(r"\b" + re.escape(table_name.lower()) + r"\b")
         to_remove = [
-            k for k in self.__query_cache if tbl_lower in k[0].lower()
+            k for k in self.__query_cache if pattern.search(k[0].lower())
         ]
         for k in to_remove:
             del self.__query_cache[k]

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.72
+Version: 0.1.74
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.72 → velocity_python-0.1.74}/src/velocity_python.egg-info/SOURCES.txt

@@ -204,5 +204,7 @@ tests/test_store_user_data.py
 tests/test_sys_modified_count_postgres_demo.py
 tests/test_table_alter.py
 tests/test_transaction_class_wrapping.py
+tests/test_transaction_commit_and_ownership.py
+tests/test_transaction_edge_cases.py
 tests/test_where_clause_validation.py
 tests/test_write_hook_create_flow.py