dbos 0.20.0a9__tar.gz → 0.21.0a3__tar.gz

{dbos-0.20.0a9 → dbos-0.21.0a3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dbos
-Version: 0.20.0a9
+Version: 0.21.0a3
 Summary: Ultra-lightweight durable execution in Python
 Author-Email: "DBOS, Inc." <contact@dbos.dev>
 License: MIT

{dbos-0.20.0a9 → dbos-0.21.0a3}/dbos/_context.py

@@ -63,7 +63,6 @@ class DBOSContext:
         self.parent_workflow_fid: int = -1
         self.workflow_id: str = ""
         self.function_id: int = -1
-        self.in_recovery: bool = False
 
         self.curr_step_function_id: int = -1
         self.curr_tx_function_id: int = -1
@@ -82,7 +81,6 @@ class DBOSContext:
         rv.is_within_set_workflow_id_block = self.is_within_set_workflow_id_block
         rv.parent_workflow_id = self.workflow_id
         rv.parent_workflow_fid = self.function_id
-        rv.in_recovery = self.in_recovery
         rv.authenticated_user = self.authenticated_user
         rv.authenticated_roles = (
             self.authenticated_roles[:]
@@ -335,34 +333,6 @@ class SetWorkflowID:
         return False  # Did not handle
 
 
-class SetWorkflowRecovery:
-    def __init__(self) -> None:
-        self.created_ctx = False
-
-    def __enter__(self) -> SetWorkflowRecovery:
-        # Code to create a basic context
-        ctx = get_local_dbos_context()
-        if ctx is None:
-            self.created_ctx = True
-            _set_local_dbos_context(DBOSContext())
-        assert_current_dbos_context().in_recovery = True
-
-        return self
-
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_value: Optional[BaseException],
-        traceback: Optional[TracebackType],
-    ) -> Literal[False]:
-        assert assert_current_dbos_context().in_recovery == True
-        assert_current_dbos_context().in_recovery = False
-        # Code to clean up the basic context if we created it
-        if self.created_ctx:
-            _clear_local_dbos_context()
-        return False  # Did not handle
-
-
 class EnterDBOSWorkflow(AbstractContextManager[DBOSContext, Literal[False]]):
     def __init__(self, attributes: TracedAttributes) -> None:
         self.created_ctx = False

{dbos-0.20.0a9 → dbos-0.21.0a3}/dbos/_core.py

@@ -185,8 +185,8 @@ def _init_workflow(
         # Synchronously record the status and inputs for workflows and single-step workflows
         # We also have to do this for single-step workflows because of the foreign key constraint on the operation outputs table
         # TODO: Make this transactional (and with the queue step below)
-        wf_status = dbos._sys_db.update_workflow_status(
-            status, False, ctx.in_recovery, max_recovery_attempts=max_recovery_attempts
+        wf_status = dbos._sys_db.insert_workflow_status(
+            status, max_recovery_attempts=max_recovery_attempts
         )
         # TODO: Modify the inputs if they were changed by `update_workflow_inputs`
         dbos._sys_db.update_workflow_inputs(wfid, _serialization.serialize_args(inputs))

{dbos-0.20.0a9 → dbos-0.21.0a3}/dbos/_dbos.py

@@ -801,7 +801,7 @@ class DBOS:
     def cancel_workflow(cls, workflow_id: str) -> None:
         """Cancel a workflow by ID."""
         _get_dbos_instance()._sys_db.set_workflow_status(
-            workflow_id, WorkflowStatusString.CANCELLED, False
+            workflow_id, WorkflowStatusString.CANCELLED
         )
 
     @classmethod

{dbos-0.20.0a9 → dbos-0.21.0a3}/dbos/_recovery.py

@@ -4,7 +4,6 @@ import time
 import traceback
 from typing import TYPE_CHECKING, Any, List
 
-from ._context import SetWorkflowRecovery
 from ._core import execute_workflow_by_id
 from ._error import DBOSWorkflowFunctionNotFoundError
 
@@ -19,8 +18,7 @@ def startup_recovery_thread(dbos: "DBOS", workflow_ids: List[str]) -> None:
     while not stop_event.is_set() and len(workflow_ids) > 0:
         try:
             for workflowID in list(workflow_ids):
-                with SetWorkflowRecovery():
-                    execute_workflow_by_id(dbos, workflowID)
+                execute_workflow_by_id(dbos, workflowID)
                 workflow_ids.remove(workflowID)
         except DBOSWorkflowFunctionNotFoundError:
             time.sleep(1)
@@ -45,8 +43,7 @@ def recover_pending_workflows(
         dbos.logger.debug(f"Pending workflows: {workflow_ids}")
 
         for workflowID in workflow_ids:
-            with SetWorkflowRecovery():
-                handle = execute_workflow_by_id(dbos, workflowID)
+            handle = execute_workflow_by_id(dbos, workflowID)
             workflow_handles.append(handle)
 
     dbos.logger.info("Recovered pending workflows")

{dbos-0.20.0a9 → dbos-0.21.0a3}/dbos/_sys_db.py

@@ -243,66 +243,50 @@ class SystemDatabase:
             dbos_logger.debug("Waiting for system buffers to be exported")
             time.sleep(1)
 
-    def update_workflow_status(
+    def insert_workflow_status(
         self,
         status: WorkflowStatusInternal,
-        replace: bool = True,
-        in_recovery: bool = False,
         *,
-        conn: Optional[sa.Connection] = None,
         max_recovery_attempts: int = DEFAULT_MAX_RECOVERY_ATTEMPTS,
     ) -> WorkflowStatuses:
         wf_status: WorkflowStatuses = status["status"]
 
-        cmd = pg.insert(SystemSchema.workflow_status).values(
-            workflow_uuid=status["workflow_uuid"],
-            status=status["status"],
-            name=status["name"],
-            class_name=status["class_name"],
-            config_name=status["config_name"],
-            output=status["output"],
-            error=status["error"],
-            executor_id=status["executor_id"],
-            application_version=status["app_version"],
-            application_id=status["app_id"],
-            request=status["request"],
-            authenticated_user=status["authenticated_user"],
-            authenticated_roles=status["authenticated_roles"],
-            assumed_role=status["assumed_role"],
-            queue_name=status["queue_name"],
-        )
-        if replace:
-            cmd = cmd.on_conflict_do_update(
-                index_elements=["workflow_uuid"],
-                set_=dict(
-                    status=status["status"],
-                    output=status["output"],
-                    error=status["error"],
-                ),
-            )
-        elif in_recovery:
-            cmd = cmd.on_conflict_do_update(
-                index_elements=["workflow_uuid"],
-                set_=dict(
-                    recovery_attempts=SystemSchema.workflow_status.c.recovery_attempts
-                    + 1,
+        cmd = (
+            pg.insert(SystemSchema.workflow_status)
+            .values(
+                workflow_uuid=status["workflow_uuid"],
+                status=status["status"],
+                name=status["name"],
+                class_name=status["class_name"],
+                config_name=status["config_name"],
+                output=status["output"],
+                error=status["error"],
+                executor_id=status["executor_id"],
+                application_version=status["app_version"],
+                application_id=status["app_id"],
+                request=status["request"],
+                authenticated_user=status["authenticated_user"],
+                authenticated_roles=status["authenticated_roles"],
+                assumed_role=status["assumed_role"],
+                queue_name=status["queue_name"],
+                recovery_attempts=(
+                    1 if wf_status != WorkflowStatusString.ENQUEUED.value else 0
                 ),
             )
-        else:
-            # A blank update so that we can return the existing status
-            cmd = cmd.on_conflict_do_update(
+            .on_conflict_do_update(
                 index_elements=["workflow_uuid"],
                 set_=dict(
-                    recovery_attempts=SystemSchema.workflow_status.c.recovery_attempts
+                    recovery_attempts=(
+                        SystemSchema.workflow_status.c.recovery_attempts + 1
+                    ),
                 ),
             )
+        )
+
         cmd = cmd.returning(SystemSchema.workflow_status.c.recovery_attempts, SystemSchema.workflow_status.c.status, SystemSchema.workflow_status.c.name, SystemSchema.workflow_status.c.class_name, SystemSchema.workflow_status.c.config_name, SystemSchema.workflow_status.c.queue_name)  # type: ignore
 
-        if conn is not None:
-            results = conn.execute(cmd)
-        else:
-            with self.engine.begin() as c:
-                results = c.execute(cmd)
+        with self.engine.begin() as c:
+            results = c.execute(cmd)
 
         row = results.fetchone()
         if row is not None:
@@ -325,7 +309,9 @@ class SystemDatabase:
             if err_msg is not None:
                 raise DBOSConflictingWorkflowError(status["workflow_uuid"], err_msg)
 
-            if in_recovery and recovery_attempts > max_recovery_attempts:
+            # Every time we start executing a workflow (and thus attempt to insert its status), we increment `recovery_attempts` by 1.
+            # When this number becomes equal to `maxRetries + 1`, we mark the workflow as `RETRIES_EXCEEDED`.
+            if recovery_attempts > max_recovery_attempts + 1:
                 with self.engine.begin() as c:
                     c.execute(
                         sa.delete(SystemSchema.workflow_queue).where(
@@ -352,17 +338,62 @@ class SystemDatabase:
                     status["workflow_uuid"], max_recovery_attempts
                 )
 
-        # Record we have exported status for this single-transaction workflow
+        return wf_status
+
+    def update_workflow_status(
+        self,
+        status: WorkflowStatusInternal,
+        *,
+        conn: Optional[sa.Connection] = None,
+    ) -> None:
+        wf_status: WorkflowStatuses = status["status"]
+
+        cmd = (
+            pg.insert(SystemSchema.workflow_status)
+            .values(
+                workflow_uuid=status["workflow_uuid"],
+                status=status["status"],
+                name=status["name"],
+                class_name=status["class_name"],
+                config_name=status["config_name"],
+                output=status["output"],
+                error=status["error"],
+                executor_id=status["executor_id"],
+                application_version=status["app_version"],
+                application_id=status["app_id"],
+                request=status["request"],
+                authenticated_user=status["authenticated_user"],
+                authenticated_roles=status["authenticated_roles"],
+                assumed_role=status["assumed_role"],
+                queue_name=status["queue_name"],
+                recovery_attempts=(
+                    1 if wf_status != WorkflowStatusString.ENQUEUED.value else 0
+                ),
+            )
+            .on_conflict_do_update(
+                index_elements=["workflow_uuid"],
+                set_=dict(
+                    status=status["status"],
+                    output=status["output"],
+                    error=status["error"],
+                ),
+            )
+        )
+
+        if conn is not None:
+            conn.execute(cmd)
+        else:
+            with self.engine.begin() as c:
+                c.execute(cmd)
+
+        # If this is a single-transaction workflow, record that its status has been exported
         if status["workflow_uuid"] in self._temp_txn_wf_ids:
             self._exported_temp_txn_wf_status.add(status["workflow_uuid"])
 
-        return wf_status
-
     def set_workflow_status(
         self,
         workflow_uuid: str,
         status: WorkflowStatusString,
-        reset_recovery_attempts: bool,
     ) -> None:
         with self.engine.begin() as c:
             stmt = (
@@ -374,17 +405,6 @@ class SystemDatabase:
             )
             c.execute(stmt)
 
-        if reset_recovery_attempts:
-            with self.engine.begin() as c:
-                stmt = (
-                    sa.update(SystemSchema.workflow_status)
-                    .where(
-                        SystemSchema.workflow_status.c.workflow_uuid == workflow_uuid
-                    )
-                    .values(recovery_attempts=reset_recovery_attempts)
-                )
-                c.execute(stmt)
-
     def get_workflow_status(
         self, workflow_uuid: str
     ) -> Optional[WorkflowStatusInternal]:

{dbos-0.20.0a9 → dbos-0.21.0a3}/dbos/_workflow_commands.py

@@ -116,7 +116,7 @@ def _cancel_workflow(config: ConfigFile, uuid: str) -> None:
 
     try:
         sys_db = SystemDatabase(config)
-        sys_db.set_workflow_status(uuid, WorkflowStatusString.CANCELLED, False)
+        sys_db.set_workflow_status(uuid, WorkflowStatusString.CANCELLED)
         return
 
     except Exception as e:

{dbos-0.20.0a9 → dbos-0.21.0a3}/pyproject.toml

@@ -27,7 +27,7 @@ dependencies = [
 ]
 requires-python = ">=3.9"
 readme = "README.md"
-version = "0.20.0a9"
+version = "0.21.0a3"
 
 [project.license]
 text = "MIT"

{dbos-0.20.0a9 → dbos-0.21.0a3}/tests/test_dbos.py

@@ -14,6 +14,7 @@ from dbos import DBOS, ConfigFile, SetWorkflowID, WorkflowHandle, WorkflowStatus
 # Private API because this is a test
 from dbos._context import assert_current_dbos_context, get_local_dbos_context
 from dbos._error import DBOSMaxStepRetriesExceeded
+from dbos._schemas.system_database import SystemSchema
 from dbos._sys_db import GetWorkflowsInput
 
 
@@ -63,6 +64,23 @@ def test_simple_workflow(dbos: DBOS) -> None:
     assert wf_counter == 4
 
 
+def test_simple_workflow_attempts_counter(dbos: DBOS) -> None:
+    @DBOS.workflow()
+    def noop() -> None:
+        pass
+
+    wfuuid = str(uuid.uuid4())
+    with dbos._sys_db.engine.connect() as c:
+        stmt = sa.select(SystemSchema.workflow_status.c.recovery_attempts).where(
+            SystemSchema.workflow_status.c.workflow_uuid == wfuuid
+        )
+        for i in range(10):
+            with SetWorkflowID(wfuuid):
+                noop()
+            result = c.execute(stmt).scalar()
+            assert result == i + 1
+
+
 def test_child_workflow(dbos: DBOS) -> None:
     txn_counter: int = 0
     wf_counter: int = 0
@@ -365,26 +383,12 @@ def test_recovery_workflow(dbos: DBOS) -> None:
 
     dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
-    dbos._sys_db.update_workflow_status(
-        {
-            "workflow_uuid": wfuuid,
-            "status": "PENDING",
-            "name": test_workflow.__qualname__,
-            "class_name": None,
-            "config_name": None,
-            "output": None,
-            "error": None,
-            "executor_id": None,
-            "app_id": None,
-            "app_version": None,
-            "request": None,
-            "recovery_attempts": None,
-            "authenticated_user": None,
-            "authenticated_roles": None,
-            "assumed_role": None,
-            "queue_name": None,
-        }
-    )
+    with dbos._sys_db.engine.begin() as c:
+        c.execute(
+            sa.update(SystemSchema.workflow_status)
+            .values({"status": "PENDING", "name": test_workflow.__qualname__})
+            .where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
+        )
 
     # Recovery should execute the workflow again but skip the transaction
     workflow_handles = DBOS.recover_pending_workflows()
@@ -397,7 +401,7 @@ def test_recovery_workflow(dbos: DBOS) -> None:
     # Test that there was a recovery attempt of this
     stat = workflow_handles[0].get_status()
     assert stat
-    assert stat.recovery_attempts == 1
+    assert stat.recovery_attempts == 2  # original attempt + recovery attempt
 
 
 def test_recovery_workflow_step(dbos: DBOS) -> None:
@@ -425,26 +429,12 @@ def test_recovery_workflow_step(dbos: DBOS) -> None:
 
     dbos._sys_db.wait_for_buffer_flush()
     # Change the workflow status to pending
-    dbos._sys_db.update_workflow_status(
-        {
-            "workflow_uuid": wfuuid,
-            "status": "PENDING",
-            "name": test_workflow.__qualname__,
-            "class_name": None,
-            "config_name": None,
-            "output": None,
-            "error": None,
-            "executor_id": None,
-            "app_id": None,
-            "app_version": None,
-            "request": None,
-            "recovery_attempts": None,
-            "authenticated_user": None,
-            "authenticated_roles": None,
-            "assumed_role": None,
-            "queue_name": None,
-        }
-    )
+    with dbos._sys_db.engine.begin() as c:
+        c.execute(
+            sa.update(SystemSchema.workflow_status)
+            .values({"status": "PENDING", "name": test_workflow.__qualname__})
+            .where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
+        )
 
     # Recovery should execute the workflow again but skip the transaction
     workflow_handles = DBOS.recover_pending_workflows()
@@ -456,7 +446,7 @@ def test_recovery_workflow_step(dbos: DBOS) -> None:
     # Test that there was a recovery attempt of this
     stat = workflow_handles[0].get_status()
     assert stat
-    assert stat.recovery_attempts == 1
+    assert stat.recovery_attempts == 2
 
 
 def test_workflow_returns_none(dbos: DBOS) -> None:
@@ -484,26 +474,12 @@ def test_workflow_returns_none(dbos: DBOS) -> None:
     assert wf_counter == 2
 
     # Change the workflow status to pending
-    dbos._sys_db.update_workflow_status(
-        {
-            "workflow_uuid": wfuuid,
-            "status": "PENDING",
-            "name": test_workflow.__qualname__,
-            "class_name": None,
-            "config_name": None,
-            "output": None,
-            "error": None,
-            "executor_id": None,
-            "app_id": None,
-            "app_version": None,
-            "request": None,
-            "recovery_attempts": None,
-            "authenticated_user": None,
-            "authenticated_roles": None,
-            "assumed_role": None,
-            "queue_name": None,
-        }
-    )
+    with dbos._sys_db.engine.begin() as c:
+        c.execute(
+            sa.update(SystemSchema.workflow_status)
+            .values({"status": "PENDING", "name": test_workflow.__qualname__})
+            .where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
+        )
 
     workflow_handles = DBOS.recover_pending_workflows()
     assert len(workflow_handles) == 1
@@ -513,7 +489,7 @@ def test_workflow_returns_none(dbos: DBOS) -> None:
     # Test that there was a recovery attempt of this
     stat = workflow_handles[0].get_status()
     assert stat
-    assert stat.recovery_attempts == 1
+    assert stat.recovery_attempts == 3  # 2 calls to test_workflow + 1 recovery attempt
 
 
 def test_recovery_temp_workflow(dbos: DBOS) -> None:
@@ -545,26 +521,12 @@ def test_recovery_temp_workflow(dbos: DBOS) -> None:
     assert wfi["name"].startswith("<temp>")
 
     # Change the workflow status to pending
-    dbos._sys_db.update_workflow_status(
-        {
-            "workflow_uuid": wfuuid,
-            "status": "PENDING",
-            "name": wfi["name"],
-            "class_name": None,
-            "config_name": None,
-            "output": None,
-            "error": None,
-            "executor_id": None,
-            "app_id": None,
-            "app_version": None,
-            "request": None,
-            "recovery_attempts": None,
-            "authenticated_user": None,
-            "authenticated_roles": None,
-            "assumed_role": None,
-            "queue_name": None,
-        }
-    )
+    with dbos._sys_db.engine.begin() as c:
+        c.execute(
+            sa.update(SystemSchema.workflow_status)
+            .values({"status": "PENDING", "name": wfi["name"]})
+            .where(SystemSchema.workflow_status.c.workflow_uuid == wfuuid)
+        )
 
     # Recovery should execute the workflow again but skip the transaction
     workflow_handles = DBOS.recover_pending_workflows()
@@ -787,19 +749,19 @@ def test_retrieve_workflow_in_workflow(dbos: DBOS) -> None:
     with SetWorkflowID("parent_b"):
         assert test_workflow_status_b() == "PENDINGrun_this_once_bSUCCESS"
 
-    # Test that there were no recovery attempts of this
+    # Test that the number of attempts matches the number of calls
     stat = dbos.get_workflow_status("parent_a")
     assert stat
-    assert stat.recovery_attempts == 0
+    assert stat.recovery_attempts == 2
     stat = dbos.get_workflow_status("parent_b")
     assert stat
-    assert stat.recovery_attempts == 0
+    assert stat.recovery_attempts == 2
     stat = dbos.get_workflow_status("run_this_once_a")
     assert stat
-    assert stat.recovery_attempts == 0
+    assert stat.recovery_attempts == 2
     stat = dbos.get_workflow_status("run_this_once_b")
     assert stat
-    assert stat.recovery_attempts == 0
+    assert stat.recovery_attempts == 2
 
 
 def test_sleep(dbos: DBOS) -> None:

{dbos-0.20.0a9 → dbos-0.21.0a3}/tests/test_failures.py

@@ -200,10 +200,6 @@ def test_dead_letter_queue(dbos: DBOS) -> None:
     assert exc_info.errisinstance(DBOSDeadLetterQueueError)
     assert handle.get_status().status == WorkflowStatusString.RETRIES_EXCEEDED.value
 
-    with SetWorkflowID(handle.get_workflow_id()):
-        DBOS.start_workflow(dead_letter_workflow)
-    assert recovery_count == max_recovery_attempts + 2
-
     event.set()
     assert handle.get_result() == None
     dbos._sys_db.wait_for_buffer_flush()

dbos-0.21.0a3/tests/test_sqlalchemy.py

@@ -0,0 +1,113 @@
+import uuid
+
+import pytest
+import sqlalchemy as sa
+from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+
+# Public API
+from dbos import DBOS, SetWorkflowID
+
+
+# Declare a SQLAlchemy ORM base class
+class Base(DeclarativeBase):
+    pass
+
+
+# Declare a SQLAlchemy ORM class for accessing the database table.
+class Hello(Base):
+    __tablename__ = "dbos_hello"
+    greet_count: Mapped[int] = mapped_column(primary_key=True, autoincrement=True)
+    name: Mapped[str] = mapped_column(nullable=False)
+
+    def __repr__(self) -> str:
+        return f"Hello(greet_count={self.greet_count!r}, name={self.name!r})"
+
+
+def test_simple_transaction(dbos: DBOS, postgres_db_engine: sa.Engine) -> None:
+    txn_counter: int = 0
+    assert dbos._app_db_field is not None
+    Base.metadata.drop_all(dbos._app_db_field.engine)
+    Base.metadata.create_all(dbos._app_db_field.engine)
+
+    @DBOS.transaction()
+    def test_transaction(name: str) -> str:
+        new_greeting = Hello(name=name)
+        DBOS.sql_session.add(new_greeting)
+        stmt = (
+            sa.select(Hello)
+            .where(Hello.name == name)
+            .order_by(Hello.greet_count.desc())
+            .limit(1)
+        )
+        row = DBOS.sql_session.scalar(stmt)
+        assert row is not None
+        greet_count = row.greet_count
+        nonlocal txn_counter
+        txn_counter += 1
+        return name + str(greet_count)
+
+    assert test_transaction("alice") == "alice1"
+    assert test_transaction("alice") == "alice2"
+    assert txn_counter == 2
+
+    # Test OAOO
+    wfuuid = str(uuid.uuid4())
+    with SetWorkflowID(wfuuid):
+        assert test_transaction("alice") == "alice3"
+    with SetWorkflowID(wfuuid):
+        assert test_transaction("alice") == "alice3"
+    assert txn_counter == 3  # Only increment once
+
+    Base.metadata.drop_all(dbos._app_db_field.engine)
+
+    # Make sure no transactions are left open
+    with postgres_db_engine.begin() as conn:
+        result = conn.execute(
+            sa.text(
+                "select * from pg_stat_activity where state = 'idle in transaction'"
+            )
+        ).fetchall()
+        assert len(result) == 0
+
+
+def test_error_transaction(dbos: DBOS, postgres_db_engine: sa.Engine) -> None:
+    txn_counter: int = 0
+    assert dbos._app_db_field is not None
+    # Drop the database but don't re-create. Should fail.
+    Base.metadata.drop_all(dbos._app_db_field.engine)
+
+    @DBOS.transaction()
+    def test_transaction(name: str) -> str:
+        nonlocal txn_counter
+        txn_counter += 1
+        new_greeting = Hello(name=name)
+        DBOS.sql_session.add(new_greeting)
+        return name
+
+    with pytest.raises(Exception) as exc_info:
+        test_transaction("alice")
+    assert 'relation "dbos_hello" does not exist' in str(exc_info.value)
+    assert txn_counter == 1
+
+    # Test OAOO
+    wfuuid = str(uuid.uuid4())
+    with SetWorkflowID(wfuuid):
+        with pytest.raises(Exception) as exc_info:
+            test_transaction("alice")
+    assert 'relation "dbos_hello" does not exist' in str(exc_info.value)
+    assert txn_counter == 2
+
+    with SetWorkflowID(wfuuid):
+        with pytest.raises(Exception) as exc_info:
+            test_transaction("alice")
+    assert 'relation "dbos_hello" does not exist' in str(exc_info.value)
+    assert txn_counter == 2
+
+    # Make sure no transactions are left open
+    with postgres_db_engine.begin() as conn:
+        result = conn.execute(
+            sa.text(
+                "select * from pg_stat_activity where state = 'idle in transaction'"
+            )
+        ).fetchall()
+        assert len(result) == 0