dbos 1.13.0a3__py3-none-any.whl → 1.13.0a5__py3-none-any.whl

dbos/_app_db.py

@@ -1,11 +1,14 @@
+from abc import ABC, abstractmethod
 from typing import Any, Dict, List, Optional, TypedDict
 
+import psycopg
 import sqlalchemy as sa
-import sqlalchemy.dialects.postgresql as pg
 from sqlalchemy import inspect, text
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session, sessionmaker
 
+from dbos._migration import get_sqlite_timestamp_expr
+
 from . import _serialization
 from ._error import DBOSUnexpectedStepError, DBOSWorkflowConflictIDError
 from ._logger import dbos_logger
@@ -29,7 +32,7 @@ class RecordedResult(TypedDict):
     error: Optional[str]  # JSON (jsonpickle)
 
 
-class ApplicationDatabase:
+class ApplicationDatabase(ABC):
 
     def __init__(
         self,
@@ -38,95 +41,37 @@ class ApplicationDatabase:
         engine_kwargs: Dict[str, Any],
         debug_mode: bool = False,
     ):
-        app_db_url = sa.make_url(database_url).set(drivername="postgresql+psycopg")
-
-        if engine_kwargs is None:
-            engine_kwargs = {}
-
-        self.engine = sa.create_engine(
-            app_db_url,
-            **engine_kwargs,
-        )
+        self.engine = self._create_engine(database_url, engine_kwargs)
         self._engine_kwargs = engine_kwargs
         self.sessionmaker = sessionmaker(bind=self.engine)
         self.debug_mode = debug_mode
 
-    def run_migrations(self) -> None:
-        if self.debug_mode:
-            dbos_logger.warning(
-                "Application database migrations are skipped in debug mode."
-            )
-            return
-        # Check if the database exists
-        app_db_url = self.engine.url
-        postgres_db_engine = sa.create_engine(
-            app_db_url.set(database="postgres"),
-            **self._engine_kwargs,
-        )
-        with postgres_db_engine.connect() as conn:
-            conn.execution_options(isolation_level="AUTOCOMMIT")
-            if not conn.execute(
-                sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
-                parameters={"db_name": app_db_url.database},
-            ).scalar():
-                conn.execute(sa.text(f"CREATE DATABASE {app_db_url.database}"))
-        postgres_db_engine.dispose()
-
-        # Create the dbos schema and transaction_outputs table in the application database
-        with self.engine.begin() as conn:
-            # Check if schema exists first
-            schema_exists = conn.execute(
-                sa.text(
-                    "SELECT 1 FROM information_schema.schemata WHERE schema_name = :schema_name"
-                ),
-                parameters={"schema_name": ApplicationSchema.schema},
-            ).scalar()
-
-            if not schema_exists:
-                schema_creation_query = sa.text(
-                    f"CREATE SCHEMA {ApplicationSchema.schema}"
-                )
-                conn.execute(schema_creation_query)
-
-        inspector = inspect(self.engine)
-        if not inspector.has_table(
-            "transaction_outputs", schema=ApplicationSchema.schema
-        ):
-            ApplicationSchema.metadata_obj.create_all(self.engine)
-        else:
-            columns = inspector.get_columns(
-                "transaction_outputs", schema=ApplicationSchema.schema
-            )
-            column_names = [col["name"] for col in columns]
+    @abstractmethod
+    def _create_engine(
+        self, database_url: str, engine_kwargs: Dict[str, Any]
+    ) -> sa.Engine:
+        """Create a database engine specific to the database type."""
+        pass
 
-            if "function_name" not in column_names:
-                # Column missing, alter table to add it
-                with self.engine.connect() as conn:
-                    conn.execute(
-                        text(
-                            f"""
-                        ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
-                        ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
-                        """
-                        )
-                    )
-                    conn.commit()
+    @abstractmethod
+    def run_migrations(self) -> None:
+        """Run database migrations specific to the database type."""
+        pass
 
     def destroy(self) -> None:
         self.engine.dispose()
 
-    @staticmethod
     def record_transaction_output(
-        session: Session, output: TransactionResultInternal
+        self, session: Session, output: TransactionResultInternal
     ) -> None:
         try:
             session.execute(
-                pg.insert(ApplicationSchema.transaction_outputs).values(
+                sa.insert(ApplicationSchema.transaction_outputs).values(
                     workflow_uuid=output["workflow_uuid"],
                     function_id=output["function_id"],
                     output=output["output"],
                     error=None,
-                    txn_id=sa.text("(select pg_current_xact_id_if_assigned()::text)"),
+                    txn_id="",
                     txn_snapshot=output["txn_snapshot"],
                     executor_id=(
                         output["executor_id"] if output["executor_id"] else None
@@ -135,7 +80,7 @@ class ApplicationDatabase:
                 )
             )
         except DBAPIError as dbapi_error:
-            if dbapi_error.orig.sqlstate == "23505":  # type: ignore
+            if self._is_unique_constraint_violation(dbapi_error):
                 raise DBOSWorkflowConflictIDError(output["workflow_uuid"])
             raise
 
@@ -145,14 +90,12 @@ class ApplicationDatabase:
         try:
             with self.engine.begin() as conn:
                 conn.execute(
-                    pg.insert(ApplicationSchema.transaction_outputs).values(
+                    sa.insert(ApplicationSchema.transaction_outputs).values(
                         workflow_uuid=output["workflow_uuid"],
                         function_id=output["function_id"],
                         output=None,
                         error=output["error"],
-                        txn_id=sa.text(
-                            "(select pg_current_xact_id_if_assigned()::text)"
-                        ),
+                        txn_id="",
                         txn_snapshot=output["txn_snapshot"],
                         executor_id=(
                             output["executor_id"] if output["executor_id"] else None
@@ -161,7 +104,7 @@ class ApplicationDatabase:
                     )
                 )
         except DBAPIError as dbapi_error:
-            if dbapi_error.orig.sqlstate == "23505":  # type: ignore
+            if self._is_unique_constraint_violation(dbapi_error):
                 raise DBOSWorkflowConflictIDError(output["workflow_uuid"])
             raise
 
@@ -283,3 +226,197 @@ class ApplicationDatabase:
                 )
 
             c.execute(delete_query)
+
+    @abstractmethod
+    def _is_unique_constraint_violation(self, dbapi_error: DBAPIError) -> bool:
+        """Check if the error is a unique constraint violation."""
+        pass
+
+    @abstractmethod
+    def _is_serialization_error(self, dbapi_error: DBAPIError) -> bool:
+        """Check if the error is a serialization/concurrency error."""
+        pass
+
+    @staticmethod
+    def create(
+        database_url: str,
+        engine_kwargs: Dict[str, Any],
+        debug_mode: bool = False,
+    ) -> "ApplicationDatabase":
+        """Factory method to create the appropriate ApplicationDatabase implementation based on URL."""
+        if database_url.startswith("sqlite"):
+            return SQLiteApplicationDatabase(
+                database_url=database_url,
+                engine_kwargs=engine_kwargs,
+                debug_mode=debug_mode,
+            )
+        else:
+            # Default to PostgreSQL for postgresql://, postgres://, or other URLs
+            return PostgresApplicationDatabase(
+                database_url=database_url,
+                engine_kwargs=engine_kwargs,
+                debug_mode=debug_mode,
+            )
+
+
+class PostgresApplicationDatabase(ApplicationDatabase):
+    """PostgreSQL-specific implementation of ApplicationDatabase."""
+
+    def _create_engine(
+        self, database_url: str, engine_kwargs: Dict[str, Any]
+    ) -> sa.Engine:
+        """Create a PostgreSQL engine."""
+        app_db_url = sa.make_url(database_url).set(drivername="postgresql+psycopg")
+
+        if engine_kwargs is None:
+            engine_kwargs = {}
+
+        # TODO: Make the schema dynamic so this isn't needed
+        ApplicationSchema.transaction_outputs.schema = "dbos"
+
+        return sa.create_engine(
+            app_db_url,
+            **engine_kwargs,
+        )
+
+    def run_migrations(self) -> None:
+        if self.debug_mode:
+            dbos_logger.warning(
+                "Application database migrations are skipped in debug mode."
+            )
+            return
+        # Check if the database exists
+        app_db_url = self.engine.url
+        postgres_db_engine = sa.create_engine(
+            app_db_url.set(database="postgres"),
+            **self._engine_kwargs,
+        )
+        with postgres_db_engine.connect() as conn:
+            conn.execution_options(isolation_level="AUTOCOMMIT")
+            if not conn.execute(
+                sa.text("SELECT 1 FROM pg_database WHERE datname=:db_name"),
+                parameters={"db_name": app_db_url.database},
+            ).scalar():
+                conn.execute(sa.text(f"CREATE DATABASE {app_db_url.database}"))
+        postgres_db_engine.dispose()
+
+        # Create the dbos schema and transaction_outputs table in the application database
+        with self.engine.begin() as conn:
+            # Check if schema exists first
+            schema_exists = conn.execute(
+                sa.text(
+                    "SELECT 1 FROM information_schema.schemata WHERE schema_name = :schema_name"
+                ),
+                parameters={"schema_name": ApplicationSchema.schema},
+            ).scalar()
+
+            if not schema_exists:
+                schema_creation_query = sa.text(
+                    f"CREATE SCHEMA {ApplicationSchema.schema}"
+                )
+                conn.execute(schema_creation_query)
+
+        inspector = inspect(self.engine)
+        if not inspector.has_table(
+            "transaction_outputs", schema=ApplicationSchema.schema
+        ):
+            ApplicationSchema.metadata_obj.create_all(self.engine)
+        else:
+            columns = inspector.get_columns(
+                "transaction_outputs", schema=ApplicationSchema.schema
+            )
+            column_names = [col["name"] for col in columns]
+
+            if "function_name" not in column_names:
+                # Column missing, alter table to add it
+                with self.engine.connect() as conn:
+                    conn.execute(
+                        text(
+                            f"""
+                        ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
+                        ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
+                        """
+                        )
+                    )
+                    conn.commit()
+
+    def _is_unique_constraint_violation(self, dbapi_error: DBAPIError) -> bool:
+        """Check if the error is a unique constraint violation in PostgreSQL."""
+        return dbapi_error.orig.sqlstate == "23505"  # type: ignore
+
+    def _is_serialization_error(self, dbapi_error: DBAPIError) -> bool:
+        """Check if the error is a serialization/concurrency error in PostgreSQL."""
+        # 40001: serialization_failure (MVCC conflict)
+        # 40P01: deadlock_detected
+        driver_error = dbapi_error.orig
+        return (
+            driver_error is not None
+            and isinstance(driver_error, psycopg.OperationalError)
+            and driver_error.sqlstate in ("40001", "40P01")
+        )
+
+
+class SQLiteApplicationDatabase(ApplicationDatabase):
+    """SQLite-specific implementation of ApplicationDatabase."""
+
+    def _create_engine(
+        self, database_url: str, engine_kwargs: Dict[str, Any]
+    ) -> sa.Engine:
+        """Create a SQLite engine."""
+        # TODO: Make the schema dynamic so this isn't needed
+        ApplicationSchema.transaction_outputs.schema = None
+        return sa.create_engine(database_url)
+
+    def run_migrations(self) -> None:
+        if self.debug_mode:
+            dbos_logger.warning(
+                "Application database migrations are skipped in debug mode."
+            )
+            return
+
+        with self.engine.begin() as conn:
+            # Check if table exists
+            result = conn.execute(
+                sa.text(
+                    "SELECT name FROM sqlite_master WHERE type='table' AND name='transaction_outputs'"
+                )
+            ).fetchone()
+
+            if result is None:
+                # Create the table with proper SQLite syntax
+                conn.execute(
+                    sa.text(
+                        f"""
+                        CREATE TABLE transaction_outputs (
+                            workflow_uuid TEXT NOT NULL,
+                            function_id INTEGER NOT NULL,
+                            output TEXT,
+                            error TEXT,
+                            txn_id TEXT,
+                            txn_snapshot TEXT NOT NULL,
+                            executor_id TEXT,
+                            function_name TEXT NOT NULL DEFAULT '',
+                            created_at BIGINT NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+                            PRIMARY KEY (workflow_uuid, function_id)
+                        )
+                        """
+                    )
+                )
+                # Create the index
+                conn.execute(
+                    sa.text(
+                        "CREATE INDEX transaction_outputs_created_at_index ON transaction_outputs (created_at)"
+                    )
+                )
+
+    def _is_unique_constraint_violation(self, dbapi_error: DBAPIError) -> bool:
+        """Check if the error is a unique constraint violation in SQLite."""
+        return "UNIQUE constraint failed" in str(dbapi_error.orig)
+
+    def _is_serialization_error(self, dbapi_error: DBAPIError) -> bool:
+        """Check if the error is a serialization/concurrency error in SQLite."""
+        # SQLite database is locked or busy errors
+        error_msg = str(dbapi_error.orig).lower()
+        return (
+            "database is locked" in error_msg or "database table is locked" in error_msg
+        )

dbos/_client.py

@@ -16,6 +16,7 @@ from typing import (
 
 from dbos._app_db import ApplicationDatabase
 from dbos._context import MaxPriority, MinPriority
+from dbos._sys_db import SystemDatabase
 
 if sys.version_info < (3, 11):
     from typing_extensions import NotRequired
@@ -119,7 +120,7 @@ class DBOSClient:
     ):
         assert is_valid_database_url(database_url)
         # We only create database connections but do not run migrations
-        self._sys_db = SystemDatabase(
+        self._sys_db = SystemDatabase.create(
             system_database_url=get_system_database_url(
                 {
                     "system_database_url": system_database_url,
@@ -134,7 +135,7 @@ class DBOSClient:
             },
         )
         self._sys_db.check_connection()
-        self._app_db = ApplicationDatabase(
+        self._app_db = ApplicationDatabase.create(
             database_url=database_url,
             engine_kwargs={
                 "pool_timeout": 30,

dbos/_core.py

@@ -950,18 +950,14 @@ def decorate_transaction(
                                 assert (
                                     ctx.sql_session is not None
                                 ), "Cannot find a database connection"
-                                ApplicationDatabase.record_transaction_output(
+                                dbos._app_db.record_transaction_output(
                                     ctx.sql_session, txn_output
                                 )
                                 break
                         except DBAPIError as dbapi_error:
-                            driver_error = cast(
-                                Optional[psycopg.OperationalError], dbapi_error.orig
-                            )
-                            if retriable_postgres_exception(dbapi_error) or (
-                                driver_error is not None
-                                and driver_error.sqlstate == "40001"
-                            ):
+                            if retriable_postgres_exception(
+                                dbapi_error
+                            ) or dbos._app_db._is_serialization_error(dbapi_error):
                                 # Retry on serialization failure
                                 span = ctx.get_current_span()
                                 if span:

dbos/_dbos.py

@@ -32,7 +32,7 @@ from opentelemetry.trace import Span
 from rich import print
 
 from dbos._conductor.conductor import ConductorWebsocket
-from dbos._sys_db import WorkflowStatus
+from dbos._sys_db import SystemDatabase, WorkflowStatus
 from dbos._utils import INTERNAL_QUEUE_NAME, GlobalParams
 from dbos._workflow_commands import fork_workflow, list_queued_workflows, list_workflows
 
@@ -70,7 +70,6 @@ from ._sys_db import (
     SystemDatabase,
     WorkflowStatus,
     _dbos_stream_closed_sentinel,
-    reset_system_database,
     workflow_is_active,
 )
 from ._tracer import DBOSTracer, dbos_tracer
@@ -80,7 +79,6 @@ if TYPE_CHECKING:
     from ._kafka import _KafkaConsumerWorkflow
     from flask import Flask
 
-from sqlalchemy import make_url
 from sqlalchemy.orm import Session
 
 if sys.version_info < (3, 10):
@@ -457,13 +455,13 @@ class DBOS:
             self._background_event_loop.start()
             assert self._config["database_url"] is not None
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
-            self._sys_db_field = SystemDatabase(
+            self._sys_db_field = SystemDatabase.create(
                 system_database_url=get_system_database_url(self._config),
                 engine_kwargs=self._config["database"]["sys_db_engine_kwargs"],
                 debug_mode=debug_mode,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
-            self._app_db_field = ApplicationDatabase(
+            self._app_db_field = ApplicationDatabase.create(
                 database_url=self._config["database_url"],
                 engine_kwargs=self._config["database"]["db_engine_kwargs"],
                 debug_mode=debug_mode,
@@ -589,13 +587,7 @@ class DBOS:
             not self._launched
         ), "The system database cannot be reset after DBOS is launched. Resetting the system database is a destructive operation that should only be used in a test environment."
 
-        sysdb_name = self._config["database"]["sys_db_name"]
-        assert sysdb_name is not None
-
-        assert self._config["database_url"] is not None
-        pg_db_url = make_url(self._config["database_url"]).set(database="postgres")
-
-        reset_system_database(pg_db_url, sysdb_name)
+        SystemDatabase.reset_system_database(get_system_database_url(self._config))
 
     def _destroy(self, *, workflow_completion_timeout_sec: int) -> None:
         self._initialized = False

dbos/_dbos_config.py

@@ -296,19 +296,12 @@ def process_config(
     """
     If a database_url is provided, pass it as is in the config.
 
-    Else, build a database_url from defaults.
+    Else, default to SQLite.
 
     Also build SQL Alchemy "kwargs" base on user input + defaults.
     Specifically, db_engine_kwargs takes precedence over app_db_pool_size
 
     In debug mode, apply overrides from DBOS_DBHOST, DBOS_DBPORT, DBOS_DBUSER, and DBOS_DBPASSWORD.
-
-    Default configuration:
-        - Hostname: localhost
-        - Port: 5432
-        - Username: postgres
-        - Password: $PGPASSWORD
-        - Database name: transformed application name.
     """
 
     if "name" not in data:
@@ -350,9 +343,14 @@ def process_config(
 
         url = make_url(data["database_url"])
 
-        if not data["database"].get("sys_db_name"):
+        if data["database_url"].startswith("sqlite"):
+            data["system_database_url"] = data["database_url"]
+        else:
             assert url.database is not None
-            data["database"]["sys_db_name"] = url.database + SystemSchema.sysdb_suffix
+            if not data["database"].get("sys_db_name"):
+                data["database"]["sys_db_name"] = (
+                    url.database + SystemSchema.sysdb_suffix
+                )
 
         # Gather connect_timeout from the URL if provided. It should be used in engine kwargs if not provided there (instead of our default)
         connect_timeout_str = url.query.get("connect_timeout")
@@ -380,23 +378,24 @@ def process_config(
             ).render_as_string(hide_password=False)
     else:
         _app_db_name = _app_name_to_db_name(data["name"])
-        _password = os.environ.get("PGPASSWORD", "dbos")
-        data["database_url"] = (
-            f"postgres://postgres:{_password}@localhost:5432/{_app_db_name}?connect_timeout=10&sslmode=prefer"
-        )
-        if not data["database"].get("sys_db_name"):
-            data["database"]["sys_db_name"] = _app_db_name + SystemSchema.sysdb_suffix
-        assert data["database_url"] is not None
+        data["database_url"] = f"sqlite:///{_app_db_name}.sqlite"
+        data["system_database_url"] = data["database_url"]
 
     configure_db_engine_parameters(data["database"], connect_timeout=connect_timeout)
 
     # Pretty-print where we've loaded database connection information from, respecting the log level
+    assert data["database_url"] is not None
     if not silent and logs["logLevel"] == "INFO" or logs["logLevel"] == "DEBUG":
         log_url = make_url(data["database_url"]).render_as_string(hide_password=True)
         print(f"[bold blue]Using database connection string: {log_url}[/bold blue]")
-        print(
-            f"[bold blue]Database engine parameters: {data['database']['db_engine_kwargs']}[/bold blue]"
-        )
+        if data["database_url"].startswith("sqlite"):
+            print(
+                f"[bold blue]Using SQLite as a system database. The SQLite system database is for development and testing. PostgreSQL is recommended for production use.[/bold blue]"
+            )
+        else:
+            print(
+                f"[bold blue]Database engine parameters: {data['database']['db_engine_kwargs']}[/bold blue]"
+            )
 
     # Return data as ConfigFile type
     return data
@@ -445,6 +444,8 @@ def configure_db_engine_parameters(
 
 
 def is_valid_database_url(database_url: str) -> bool:
+    if database_url.startswith("sqlite"):
+        return True
     url = make_url(database_url)
     required_fields = [
         ("username", "Username must be specified in the connection URL"),
@@ -559,6 +560,8 @@ def get_system_database_url(config: ConfigFile) -> str:
         return config["system_database_url"]
     else:
         assert config["database_url"] is not None
+        if config["database_url"].startswith("sqlite"):
+            return config["database_url"]
         app_db_url = make_url(config["database_url"])
         if config["database"].get("sys_db_name") is not None:
             sys_db_name = config["database"]["sys_db_name"]

dbos/_migration.py

@@ -1,6 +1,7 @@
 import logging
 import os
 import re
+import sys
 
 import sqlalchemy as sa
 from alembic import command
@@ -230,4 +231,92 @@ CREATE TABLE dbos.event_dispatch_kv (
 );
 """
 
+
+def get_sqlite_timestamp_expr() -> str:
+    """Get SQLite timestamp expression with millisecond precision for Python >= 3.12."""
+    if sys.version_info >= (3, 12):
+        return "(unixepoch('subsec') * 1000)"
+    else:
+        return "(strftime('%s','now') * 1000)"
+
+
+sqlite_migration_one = f"""
+CREATE TABLE workflow_status (
+    workflow_uuid TEXT PRIMARY KEY,
+    status TEXT,
+    name TEXT,
+    authenticated_user TEXT,
+    assumed_role TEXT,
+    authenticated_roles TEXT,
+    request TEXT,
+    output TEXT,
+    error TEXT,
+    executor_id TEXT,
+    created_at INTEGER NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+    updated_at INTEGER NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+    application_version TEXT,
+    application_id TEXT,
+    class_name TEXT DEFAULT NULL,
+    config_name TEXT DEFAULT NULL,
+    recovery_attempts INTEGER DEFAULT 0,
+    queue_name TEXT,
+    workflow_timeout_ms INTEGER,
+    workflow_deadline_epoch_ms INTEGER,
+    inputs TEXT,
+    started_at_epoch_ms INTEGER,
+    deduplication_id TEXT,
+    priority INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE INDEX workflow_status_created_at_index ON workflow_status (created_at);
+CREATE INDEX workflow_status_executor_id_index ON workflow_status (executor_id);
+CREATE INDEX workflow_status_status_index ON workflow_status (status);
+
+CREATE UNIQUE INDEX uq_workflow_status_queue_name_dedup_id 
+ON workflow_status (queue_name, deduplication_id);
+
+CREATE TABLE operation_outputs (
+    workflow_uuid TEXT NOT NULL,
+    function_id INTEGER NOT NULL,
+    function_name TEXT NOT NULL DEFAULT '',
+    output TEXT,
+    error TEXT,
+    child_workflow_id TEXT,
+    PRIMARY KEY (workflow_uuid, function_id),
+    FOREIGN KEY (workflow_uuid) REFERENCES workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE notifications (
+    destination_uuid TEXT NOT NULL,
+    topic TEXT,
+    message TEXT NOT NULL,
+    created_at_epoch_ms INTEGER NOT NULL DEFAULT {get_sqlite_timestamp_expr()},
+    message_uuid TEXT NOT NULL DEFAULT (hex(randomblob(16))),
+    FOREIGN KEY (destination_uuid) REFERENCES workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+CREATE INDEX idx_workflow_topic ON notifications (destination_uuid, topic);
+
+CREATE TABLE workflow_events (
+    workflow_uuid TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    PRIMARY KEY (workflow_uuid, key),
+    FOREIGN KEY (workflow_uuid) REFERENCES workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+
+CREATE TABLE streams (
+    workflow_uuid TEXT NOT NULL,
+    key TEXT NOT NULL,
+    value TEXT NOT NULL,
+    "offset" INTEGER NOT NULL,
+    PRIMARY KEY (workflow_uuid, key, "offset"),
+    FOREIGN KEY (workflow_uuid) REFERENCES workflow_status(workflow_uuid) 
+        ON UPDATE CASCADE ON DELETE CASCADE
+);
+"""
+
 dbos_migrations = [dbos_migration_one]
+sqlite_migrations = [sqlite_migration_one]