dbos 1.15.0a2__py3-none-any.whl → 1.15.0a3__py3-none-any.whl

dbos/_app_db.py

@@ -241,6 +241,7 @@ class ApplicationDatabase(ABC):
     def create(
         database_url: str,
         engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
         debug_mode: bool = False,
     ) -> "ApplicationDatabase":
         """Factory method to create the appropriate ApplicationDatabase implementation based on URL."""
@@ -256,12 +257,32 @@ class ApplicationDatabase(ABC):
                 database_url=database_url,
                 engine_kwargs=engine_kwargs,
                 debug_mode=debug_mode,
+                schema=schema,
             )
 
 
 class PostgresApplicationDatabase(ApplicationDatabase):
     """PostgreSQL-specific implementation of ApplicationDatabase."""
 
+    def __init__(
+        self,
+        *,
+        database_url: str,
+        engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
+        debug_mode: bool = False,
+    ):
+        super().__init__(
+            database_url=database_url,
+            engine_kwargs=engine_kwargs,
+            debug_mode=debug_mode,
+        )
+        if schema is None:
+            self.schema = "dbos"
+        else:
+            self.schema = schema
+        ApplicationSchema.transaction_outputs.schema = schema
+
     def _create_engine(
         self, database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
@@ -271,9 +292,6 @@ class PostgresApplicationDatabase(ApplicationDatabase):
         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,
@@ -307,24 +325,18 @@ class PostgresApplicationDatabase(ApplicationDatabase):
                 sa.text(
                     "SELECT 1 FROM information_schema.schemata WHERE schema_name = :schema_name"
                 ),
-                parameters={"schema_name": ApplicationSchema.schema},
+                parameters={"schema_name": self.schema},
             ).scalar()
 
             if not schema_exists:
-                schema_creation_query = sa.text(
-                    f"CREATE SCHEMA {ApplicationSchema.schema}"
-                )
+                schema_creation_query = sa.text(f'CREATE SCHEMA "{self.schema}"')
                 conn.execute(schema_creation_query)
 
         inspector = inspect(self.engine)
-        if not inspector.has_table(
-            "transaction_outputs", schema=ApplicationSchema.schema
-        ):
+        if not inspector.has_table("transaction_outputs", schema=self.schema):
             ApplicationSchema.metadata_obj.create_all(self.engine)
         else:
-            columns = inspector.get_columns(
-                "transaction_outputs", schema=ApplicationSchema.schema
-            )
+            columns = inspector.get_columns("transaction_outputs", schema=self.schema)
             column_names = [col["name"] for col in columns]
 
             if "function_name" not in column_names:
@@ -333,7 +345,7 @@ class PostgresApplicationDatabase(ApplicationDatabase):
                     conn.execute(
                         text(
                             f"""
-                        ALTER TABLE {ApplicationSchema.schema}.transaction_outputs
+                        ALTER TABLE \"{self.schema}\".transaction_outputs
                         ADD COLUMN function_name TEXT NOT NULL DEFAULT '';
                         """
                         )

dbos/_client.py

@@ -123,6 +123,7 @@ class DBOSClient:
         *,
         system_database_url: Optional[str] = None,
         application_database_url: Optional[str] = None,
+        dbos_system_schema: Optional[str] = "dbos",
         system_database: Optional[str] = None,  # DEPRECATED
     ):
         application_database_url = (
@@ -146,6 +147,7 @@ class DBOSClient:
                 "max_overflow": 0,
                 "pool_size": 2,
             },
+            schema=dbos_system_schema,
         )
         self._sys_db.check_connection()
         if application_database_url:
@@ -156,6 +158,7 @@ class DBOSClient:
                     "max_overflow": 0,
                     "pool_size": 2,
                 },
+                schema=dbos_system_schema,
             )
 
     def destroy(self) -> None:

dbos/_dbos.py

@@ -444,10 +444,13 @@ class DBOS:
             self._executor_field = ThreadPoolExecutor(max_workers=sys.maxsize)
             self._background_event_loop.start()
             assert self._config["database"]["sys_db_engine_kwargs"] is not None
+            # Get the schema configuration, use "dbos" as default
+            schema = self._config.get("dbos_system_schema", "dbos")
             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,
+                schema=schema,
             )
             assert self._config["database"]["db_engine_kwargs"] is not None
             if self._config["database_url"]:
@@ -455,6 +458,7 @@ class DBOS:
                     database_url=self._config["database_url"],
                     engine_kwargs=self._config["database"]["db_engine_kwargs"],
                     debug_mode=debug_mode,
+                    schema=schema,
                 )
 
             if debug_mode:

dbos/_dbos_config.py

@@ -1,4 +1,3 @@
-import json
 import os
 import re
 from importlib import resources
@@ -34,6 +33,7 @@ class DBOSConfig(TypedDict, total=False):
         otlp_attributes (dict[str, str]): A set of custom attributes to apply OTLP-exported logs and traces
         application_version (str): Application version
         executor_id (str): Executor ID, used to identify the application instance in distributed environments
+        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
         enable_otlp (bool): If True, enable built-in DBOS OTLP tracing and logging.
     """
 
@@ -52,6 +52,7 @@ class DBOSConfig(TypedDict, total=False):
     otlp_attributes: Optional[dict[str, str]]
     application_version: Optional[str]
     executor_id: Optional[str]
+    dbos_system_schema: Optional[str]
     enable_otlp: Optional[bool]
 
 
@@ -70,6 +71,7 @@ class DatabaseConfig(TypedDict, total=False):
         sys_db_pool_size (int): System database pool size
         db_engine_kwargs (Dict[str, Any]): SQLAlchemy engine kwargs
         migrate (List[str]): Migration commands to run on startup
+        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
     """
 
     sys_db_name: Optional[str]
@@ -113,6 +115,7 @@ class ConfigFile(TypedDict, total=False):
         system_database_url (str): System database URL
         telemetry (TelemetryConfig): Configuration for tracing / logging
         env (Dict[str,str]): Environment variables
+        dbos_system_schema (str): Schema name for DBOS system tables. Defaults to "dbos".
 
     """
 
@@ -123,6 +126,7 @@ class ConfigFile(TypedDict, total=False):
     system_database_url: Optional[str]
     telemetry: Optional[TelemetryConfig]
     env: Dict[str, str]
+    dbos_system_schema: Optional[str]
 
 
 def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
@@ -153,6 +157,9 @@ def translate_dbos_config_to_config_file(config: DBOSConfig) -> ConfigFile:
     if "system_database_url" in config:
         translated_config["system_database_url"] = config.get("system_database_url")
 
+    if "dbos_system_schema" in config:
+        translated_config["dbos_system_schema"] = config.get("dbos_system_schema")
+
     # Runtime config
     translated_config["runtimeConfig"] = {"run_admin_server": True}
     if "admin_port" in config:
@@ -546,6 +553,8 @@ def overwrite_config(provided_config: ConfigFile) -> ConfigFile:
             "DBOS_SYSTEM_DATABASE_URL environment variable is not set. This is required to connect to the database."
         )
     provided_config["system_database_url"] = system_db_url
+    # Always use the "dbos" schema when deploying to DBOS Cloud
+    provided_config["dbos_system_schema"] = "dbos"
 
     # Telemetry config
     if "telemetry" not in provided_config or provided_config["telemetry"] is None:

dbos/_migration.py

@@ -5,7 +5,7 @@ import sqlalchemy as sa
 from ._logger import dbos_logger
 
 
-def ensure_dbos_schema(engine: sa.Engine) -> None:
+def ensure_dbos_schema(engine: sa.Engine, schema: str) -> None:
     """
     True if using DBOS migrations (DBOS schema and migrations table already exist or were created)
     False if using Alembic migrations (DBOS schema exists, but dbos_migrations table doesn't)
@@ -14,41 +14,46 @@ def ensure_dbos_schema(engine: sa.Engine) -> None:
         # Check if dbos schema exists
         schema_result = conn.execute(
             sa.text(
-                "SELECT schema_name FROM information_schema.schemata WHERE schema_name = 'dbos'"
-            )
+                "SELECT schema_name FROM information_schema.schemata WHERE schema_name = :schema"
+            ),
+            {"schema": schema},
         )
         schema_exists = schema_result.fetchone() is not None
 
         # Create schema if it doesn't exist
         if not schema_exists:
-            conn.execute(sa.text("CREATE SCHEMA dbos"))
+            conn.execute(sa.text(f'CREATE SCHEMA "{schema}"'))
 
         # Check if dbos_migrations table exists
         table_result = conn.execute(
             sa.text(
-                "SELECT table_name FROM information_schema.tables WHERE table_schema = 'dbos' AND table_name = 'dbos_migrations'"
-            )
+                "SELECT table_name FROM information_schema.tables WHERE table_schema = :schema AND table_name = 'dbos_migrations'"
+            ),
+            {"schema": schema},
         )
         table_exists = table_result.fetchone() is not None
 
         if not table_exists:
             conn.execute(
                 sa.text(
-                    "CREATE TABLE dbos.dbos_migrations (version BIGINT NOT NULL PRIMARY KEY)"
+                    f'CREATE TABLE "{schema}".dbos_migrations (version BIGINT NOT NULL PRIMARY KEY)'
                 )
             )
 
 
-def run_dbos_migrations(engine: sa.Engine) -> None:
+def run_dbos_migrations(engine: sa.Engine, schema: str) -> None:
     """Run DBOS-managed migrations by executing each SQL command in dbos_migrations."""
     with engine.begin() as conn:
         # Get current migration version
-        result = conn.execute(sa.text("SELECT version FROM dbos.dbos_migrations"))
+        result = conn.execute(
+            sa.text(f'SELECT version FROM "{schema}".dbos_migrations')
+        )
         current_version = result.fetchone()
         last_applied = current_version[0] if current_version else 0
 
         # Apply migrations starting from the next version
-        for i, migration_sql in enumerate(dbos_migrations, 1):
+        migrations = get_dbos_migrations(schema)
+        for i, migration_sql in enumerate(migrations, 1):
             if i <= last_applied:
                 continue
 
@@ -60,23 +65,26 @@ def run_dbos_migrations(engine: sa.Engine) -> None:
             if last_applied == 0:
                 conn.execute(
                     sa.text(
-                        "INSERT INTO dbos.dbos_migrations (version) VALUES (:version)"
+                        f'INSERT INTO "{schema}".dbos_migrations (version) VALUES (:version)'
                     ),
                     {"version": i},
                 )
             else:
                 conn.execute(
-                    sa.text("UPDATE dbos.dbos_migrations SET version = :version"),
+                    sa.text(
+                        f'UPDATE "{schema}".dbos_migrations SET version = :version'
+                    ),
                     {"version": i},
                 )
             last_applied = i
 
 
-dbos_migration_one = """
+def get_dbos_migration_one(schema: str) -> str:
+    return f"""
 -- Enable uuid extension for generating UUIDs
 CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
 
-CREATE TABLE dbos.workflow_status (
+CREATE TABLE \"{schema}\".workflow_status (
     workflow_uuid TEXT PRIMARY KEY,
     status TEXT,
     name TEXT,
@@ -103,15 +111,15 @@ CREATE TABLE dbos.workflow_status (
     priority INTEGER NOT NULL DEFAULT 0
 );
 
-CREATE INDEX workflow_status_created_at_index ON dbos.workflow_status (created_at);
-CREATE INDEX workflow_status_executor_id_index ON dbos.workflow_status (executor_id);
-CREATE INDEX workflow_status_status_index ON dbos.workflow_status (status);
+CREATE INDEX workflow_status_created_at_index ON \"{schema}\".workflow_status (created_at);
+CREATE INDEX workflow_status_executor_id_index ON \"{schema}\".workflow_status (executor_id);
+CREATE INDEX workflow_status_status_index ON \"{schema}\".workflow_status (status);
 
-ALTER TABLE dbos.workflow_status 
+ALTER TABLE \"{schema}\".workflow_status 
 ADD CONSTRAINT uq_workflow_status_queue_name_dedup_id 
 UNIQUE (queue_name, deduplication_id);
 
-CREATE TABLE dbos.operation_outputs (
+CREATE TABLE \"{schema}\".operation_outputs (
     workflow_uuid TEXT NOT NULL,
     function_id INTEGER NOT NULL,
     function_name TEXT NOT NULL DEFAULT '',
@@ -119,23 +127,23 @@ CREATE TABLE dbos.operation_outputs (
     error TEXT,
     child_workflow_id TEXT,
     PRIMARY KEY (workflow_uuid, function_id),
-    FOREIGN KEY (workflow_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
 
-CREATE TABLE dbos.notifications (
+CREATE TABLE \"{schema}\".notifications (
     destination_uuid TEXT NOT NULL,
     topic TEXT,
     message TEXT NOT NULL,
     created_at_epoch_ms BIGINT NOT NULL DEFAULT (EXTRACT(epoch FROM now()) * 1000::numeric)::bigint,
     message_uuid TEXT NOT NULL DEFAULT gen_random_uuid(), -- Built-in function
-    FOREIGN KEY (destination_uuid) REFERENCES dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (destination_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
-CREATE INDEX idx_workflow_topic ON dbos.notifications (destination_uuid, topic);
+CREATE INDEX idx_workflow_topic ON \"{schema}\".notifications (destination_uuid, topic);
 
 -- Create notification function
-CREATE OR REPLACE FUNCTION dbos.notifications_function() RETURNS TRIGGER AS $$
+CREATE OR REPLACE FUNCTION \"{schema}\".notifications_function() RETURNS TRIGGER AS $$
 DECLARE
     payload text := NEW.destination_uuid || '::' || NEW.topic;
 BEGIN
@@ -146,20 +154,20 @@ $$ LANGUAGE plpgsql;
 
 -- Create notification trigger
 CREATE TRIGGER dbos_notifications_trigger
-AFTER INSERT ON dbos.notifications
-FOR EACH ROW EXECUTE FUNCTION dbos.notifications_function();
+AFTER INSERT ON \"{schema}\".notifications
+FOR EACH ROW EXECUTE FUNCTION \"{schema}\".notifications_function();
 
-CREATE TABLE dbos.workflow_events (
+CREATE TABLE \"{schema}\".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 dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
 
 -- Create events function
-CREATE OR REPLACE FUNCTION dbos.workflow_events_function() RETURNS TRIGGER AS $$
+CREATE OR REPLACE FUNCTION \"{schema}\".workflow_events_function() RETURNS TRIGGER AS $$
 DECLARE
     payload text := NEW.workflow_uuid || '::' || NEW.key;
 BEGIN
@@ -170,20 +178,20 @@ $$ LANGUAGE plpgsql;
 
 -- Create events trigger
 CREATE TRIGGER dbos_workflow_events_trigger
-AFTER INSERT ON dbos.workflow_events
-FOR EACH ROW EXECUTE FUNCTION dbos.workflow_events_function();
+AFTER INSERT ON \"{schema}\".workflow_events
+FOR EACH ROW EXECUTE FUNCTION \"{schema}\".workflow_events_function();
 
-CREATE TABLE dbos.streams (
+CREATE TABLE \"{schema}\".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 dbos.workflow_status(workflow_uuid) 
+    FOREIGN KEY (workflow_uuid) REFERENCES \"{schema}\".workflow_status(workflow_uuid) 
         ON UPDATE CASCADE ON DELETE CASCADE
 );
 
-CREATE TABLE dbos.event_dispatch_kv (
+CREATE TABLE \"{schema}\".event_dispatch_kv (
     service_name TEXT NOT NULL,
     workflow_fn_name TEXT NOT NULL,
     key TEXT NOT NULL,
@@ -195,6 +203,10 @@ CREATE TABLE dbos.event_dispatch_kv (
 """
 
 
+def get_dbos_migrations(schema: str) -> list[str]:
+    return [get_dbos_migration_one(schema)]
+
+
 def get_sqlite_timestamp_expr() -> str:
     """Get SQLite timestamp expression with millisecond precision for Python >= 3.12."""
     if sys.version_info >= (3, 12):
@@ -281,5 +293,4 @@ CREATE TABLE streams (
 );
 """
 
-dbos_migrations = [dbos_migration_one]
 sqlite_migrations = [sqlite_migration_one]

dbos/_schemas/system_database.py

@@ -1,3 +1,5 @@
+from typing import Optional
+
 from sqlalchemy import (
     BigInteger,
     Column,
@@ -19,6 +21,21 @@ class SystemSchema:
     metadata_obj = MetaData(schema="dbos")
     sysdb_suffix = "_dbos_sys"
 
+    @classmethod
+    def set_schema(cls, schema_name: Optional[str]) -> None:
+        """
+        Set the schema for all DBOS system tables.
+
+        Args:
+            schema_name: The name of the schema to use for system tables
+        """
+        cls.metadata_obj.schema = schema_name
+        cls.workflow_status.schema = schema_name
+        cls.operation_outputs.schema = schema_name
+        cls.notifications.schema = schema_name
+        cls.workflow_events.schema = schema_name
+        cls.streams.schema = schema_name
+
     workflow_status = Table(
         "workflow_status",
         metadata_obj,

dbos/_sys_db.py

@@ -1443,6 +1443,7 @@ class SystemDatabase(ABC):
     def create(
         system_database_url: str,
         engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
         debug_mode: bool = False,
     ) -> "SystemDatabase":
         """Factory method to create the appropriate SystemDatabase implementation based on URL."""
@@ -1461,6 +1462,7 @@ class SystemDatabase(ABC):
                 system_database_url=system_database_url,
                 engine_kwargs=engine_kwargs,
                 debug_mode=debug_mode,
+                schema=schema,
             )
 
     @db_retry()

dbos/_sys_db_postgres.py

@@ -20,6 +20,7 @@ class PostgresSystemDatabase(SystemDatabase):
         *,
         system_database_url: str,
         engine_kwargs: Dict[str, Any],
+        schema: Optional[str],
         debug_mode: bool = False,
     ):
         super().__init__(
@@ -27,17 +28,16 @@ class PostgresSystemDatabase(SystemDatabase):
             engine_kwargs=engine_kwargs,
             debug_mode=debug_mode,
         )
+        if schema is None:
+            self.schema = "dbos"
+        else:
+            self.schema = schema
+        SystemSchema.set_schema(self.schema)
         self.notification_conn: Optional[psycopg.connection.Connection] = None
 
     def _create_engine(
         self, system_database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
-        # TODO: Make the schema dynamic so this isn't needed
-        SystemSchema.workflow_status.schema = "dbos"
-        SystemSchema.operation_outputs.schema = "dbos"
-        SystemSchema.notifications.schema = "dbos"
-        SystemSchema.workflow_events.schema = "dbos"
-        SystemSchema.streams.schema = "dbos"
         url = sa.make_url(system_database_url).set(drivername="postgresql+psycopg")
         return sa.create_engine(url, **engine_kwargs)
 
@@ -62,8 +62,8 @@ class PostgresSystemDatabase(SystemDatabase):
                 conn.execute(sa.text(f"CREATE DATABASE {sysdb_name}"))
         engine.dispose()
 
-        ensure_dbos_schema(self.engine)
-        run_dbos_migrations(self.engine)
+        ensure_dbos_schema(self.engine, self.schema)
+        run_dbos_migrations(self.engine, self.schema)
 
     def _cleanup_connections(self) -> None:
         """Clean up PostgreSQL-specific connections."""

dbos/_sys_db_sqlite.py

@@ -19,12 +19,7 @@ class SQLiteSystemDatabase(SystemDatabase):
         self, system_database_url: str, engine_kwargs: Dict[str, Any]
     ) -> sa.Engine:
         """Create a SQLite engine."""
-        # TODO: Make the schema dynamic so this isn't needed
-        SystemSchema.workflow_status.schema = None
-        SystemSchema.operation_outputs.schema = None
-        SystemSchema.notifications.schema = None
-        SystemSchema.workflow_events.schema = None
-        SystemSchema.streams.schema = None
+        SystemSchema.set_schema(None)
         return sa.create_engine(system_database_url)
 
     def run_migrations(self) -> None:

dbos/cli/cli.py

@@ -287,6 +287,13 @@ def migrate(
             help="The role with which you will run your DBOS application",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -297,21 +304,27 @@ def migrate(
     if application_database_url:
         typer.echo(f"Application database: {sa.make_url(application_database_url)}")
     typer.echo(f"System database: {sa.make_url(system_database_url)}")
+    if schema is None:
+        schema = "dbos"
+    typer.echo(f"DBOS system schema: {schema}")
 
     # First, run DBOS migrations on the system database and the application database
     migrate_dbos_databases(
         app_database_url=application_database_url,
         system_database_url=system_database_url,
+        schema=schema,
     )
 
     # Next, assign permissions on the DBOS schema to the application role, if any
     if application_role:
         if application_database_url:
             grant_dbos_schema_permissions(
-                database_url=application_database_url, role_name=application_role
+                database_url=application_database_url,
+                role_name=application_role,
+                schema=schema,
             )
         grant_dbos_schema_permissions(
-            database_url=system_database_url, role_name=application_role
+            database_url=system_database_url, role_name=application_role, schema=schema
         )
 
     # Next, run any custom migration commands specified in the configuration
@@ -477,6 +490,13 @@ def list(
             help="Offset for pagination",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -485,6 +505,7 @@ def list(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     workflows = client.list_workflows(
         limit=limit,
@@ -519,6 +540,13 @@ def get(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -527,6 +555,7 @@ def get(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     status = client.retrieve_workflow(workflow_id=workflow_id).get_status()
     print(json.dumps(status.__dict__, cls=DefaultEncoder))
@@ -551,6 +580,13 @@ def steps(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -559,6 +595,7 @@ def steps(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     steps = client.list_workflow_steps(workflow_id=workflow_id)
     print(json.dumps(steps, cls=DefaultEncoder))
@@ -585,6 +622,13 @@ def cancel(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -593,6 +637,7 @@ def cancel(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     client.cancel_workflow(workflow_id=workflow_id)
 
@@ -616,6 +661,13 @@ def resume(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -624,6 +676,7 @@ def resume(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     client.resume_workflow(workflow_id=workflow_id)
 
@@ -649,6 +702,13 @@ def restart(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -657,6 +717,7 @@ def restart(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     status = client.fork_workflow(workflow_id=workflow_id, start_step=1).get_status()
     print(json.dumps(status.__dict__, cls=DefaultEncoder))
@@ -707,6 +768,13 @@ def fork(
             help="Your DBOS system database URL",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -715,6 +783,7 @@ def fork(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
 
     if forked_workflow_id is not None:
@@ -811,6 +880,13 @@ def list_queue(
             help="Offset for pagination",
         ),
     ] = None,
+    schema: Annotated[
+        typing.Optional[str],
+        typer.Option(
+            "--schema",
+            help='Schema name for DBOS system tables. Defaults to "dbos".',
+        ),
+    ] = "dbos",
 ) -> None:
     system_database_url, application_database_url = _get_db_url(
         system_database_url=system_database_url,
@@ -819,6 +895,7 @@ def list_queue(
     client = DBOSClient(
         application_database_url=application_database_url,
         system_database_url=system_database_url,
+        dbos_system_schema=schema,
     )
     workflows = client.list_queued_workflows(
         limit=limit,

dbos/cli/migration.py

@@ -8,7 +8,7 @@ from dbos._sys_db import SystemDatabase
 
 
 def migrate_dbos_databases(
-    app_database_url: Optional[str], system_database_url: str
+    app_database_url: Optional[str], system_database_url: str, schema: str
 ) -> None:
     app_db = None
     sys_db = None
@@ -20,6 +20,7 @@ def migrate_dbos_databases(
                 "max_overflow": 0,
                 "pool_size": 2,
             },
+            schema=schema,
         )
         sys_db.run_migrations()
         if app_database_url:
@@ -30,6 +31,7 @@ def migrate_dbos_databases(
                     "max_overflow": 0,
                     "pool_size": 2,
                 },
+                schema=schema,
             )
             app_db.run_migrations()
     except Exception as e:
@@ -42,12 +44,14 @@ def migrate_dbos_databases(
             app_db.destroy()
 
 
-def grant_dbos_schema_permissions(database_url: str, role_name: str) -> None:
+def grant_dbos_schema_permissions(
+    database_url: str, role_name: str, schema: str
+) -> None:
     """
-    Grant all permissions on all entities in the dbos schema to the specified role.
+    Grant all permissions on all entities in the system schema to the specified role.
     """
     typer.echo(
-        f"Granting permissions for DBOS schema to {role_name} in database {sa.make_url(database_url)}"
+        f"Granting permissions for the {schema} schema to {role_name} in database {sa.make_url(database_url)}"
     )
     engine = None
     try:
@@ -57,38 +61,38 @@ def grant_dbos_schema_permissions(database_url: str, role_name: str) -> None:
         with engine.connect() as connection:
             connection.execution_options(isolation_level="AUTOCOMMIT")
 
-            # Grant usage on the dbos schema
-            sql = f'GRANT USAGE ON SCHEMA dbos TO "{role_name}"'
+            # Grant usage on the system schema
+            sql = f'GRANT USAGE ON SCHEMA "{schema}" TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant all privileges on all existing tables in dbos schema (includes views)
-            sql = f'GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA dbos TO "{role_name}"'
+            # Grant all privileges on all existing tables in the system schema (includes views)
+            sql = f'GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA "{schema}" TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant all privileges on all sequences in dbos schema
-            sql = (
-                f'GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA dbos TO "{role_name}"'
-            )
+            # Grant all privileges on all sequences in the system schema
+            sql = f'GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA "{schema}" TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant execute on all functions and procedures in dbos schema
-            sql = f'GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA dbos TO "{role_name}"'
+            # Grant execute on all functions and procedures in the system schema
+            sql = (
+                f'GRANT EXECUTE ON ALL FUNCTIONS IN SCHEMA "{schema}" TO "{role_name}"'
+            )
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            # Grant default privileges for future objects in dbos schema
-            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT ALL ON TABLES TO "{role_name}"'
+            # Grant default privileges for future objects in the system schema
+            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema}" GRANT ALL ON TABLES TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT ALL ON SEQUENCES TO "{role_name}"'
+            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema}" GRANT ALL ON SEQUENCES TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 
-            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA dbos GRANT EXECUTE ON FUNCTIONS TO "{role_name}"'
+            sql = f'ALTER DEFAULT PRIVILEGES IN SCHEMA "{schema}" GRANT EXECUTE ON FUNCTIONS TO "{role_name}"'
             typer.echo(sql)
             connection.execute(sa.text(sql))
 

{dbos-1.15.0a2.dist-info → dbos-1.15.0a3.dist-info}/METADATA

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

{dbos-1.15.0a2.dist-info → dbos-1.15.0a3.dist-info}/RECORD

@@ -1,20 +1,20 @@
-dbos-1.15.0a2.dist-info/METADATA,sha256=STEFFiAPM8uZbNbNRPz81v65hcKlFKT1hiL52v7yjo8,13021
-dbos-1.15.0a2.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
-dbos-1.15.0a2.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
-dbos-1.15.0a2.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
+dbos-1.15.0a3.dist-info/METADATA,sha256=Ft-tggTIl0dxVo3Byd4BKytIRVdvegchZIKPnrcnq0w,13021
+dbos-1.15.0a3.dist-info/WHEEL,sha256=9P2ygRxDrTJz3gsagc0Z96ukrxjr-LFBGOgv3AuKlCA,90
+dbos-1.15.0a3.dist-info/entry_points.txt,sha256=_QOQ3tVfEjtjBlr1jS4sHqHya9lI2aIEIWkz8dqYp14,58
+dbos-1.15.0a3.dist-info/licenses/LICENSE,sha256=VGZit_a5-kdw9WT6fY5jxAWVwGQzgLFyPWrcVVUhVNU,1067
 dbos/__init__.py,sha256=pT4BuNLDCrIQX27vQG8NlfxX6PZRU7r9miq4thJTszU,982
 dbos/__main__.py,sha256=G7Exn-MhGrVJVDbgNlpzhfh8WMX_72t3_oJaFT9Lmt8,653
 dbos/_admin_server.py,sha256=e8ELhcDWqR3_PNobnNgUvLGh5lzZq0yFSF6dvtzoQRI,16267
-dbos/_app_db.py,sha256=GsV-uYU0QsChWwQDxnrh8_iiZ_zMQB-bsP2jPGIe2aM,16094
+dbos/_app_db.py,sha256=WJwUdKsTpSZPCIWVeSF5FQNf5y1PF_lJ96tiaCjvck8,16385
 dbos/_classproperty.py,sha256=f0X-_BySzn3yFDRKB2JpCbLYQ9tLwt1XftfshvY7CBs,626
-dbos/_client.py,sha256=zfFQhj_mf4NS85Nlf1xbXwMQVX_mu3UaU7sb8uE5peM,18794
+dbos/_client.py,sha256=Rp1OiT5523QosHB8Qy0xe9eWNx9osZGhfQknO122hj8,18928
 dbos/_conductor/conductor.py,sha256=3E_hL3c9g9yWqKZkvI6KA0-ZzPMPRo06TOzT1esMiek,24114
 dbos/_conductor/protocol.py,sha256=q3rgLxINFtWFigdOONc-4gX4vn66UmMlJQD6Kj8LnL4,7420
 dbos/_context.py,sha256=cJDxVbswTLXKE5MV4Hmg6gpIX3Dd5mBTG-4lmofWP9E,27668
 dbos/_core.py,sha256=13DNN_fpSIs42NquV80XsHV7yKwY_adKP03h_xhXok4,50493
 dbos/_croniter.py,sha256=XHAyUyibs_59sJQfSNWkP7rqQY6_XrlfuuCxk4jYqek,47559
-dbos/_dbos.py,sha256=ZrNrFUoND2t8UorqPLjeDvfOP73AasOXqpeuSS6Rz7E,57836
-dbos/_dbos_config.py,sha256=sWXd9RuWGmhkd7j2SraxDWQir_-F2p0SIqGO61ILeyk,25391
+dbos/_dbos.py,sha256=ReujpyRseUNL_9FQN-uIhSFh6HJnAA2IAcVy6qDdEco,58036
+dbos/_dbos_config.py,sha256=pnFeWZFDsk_94DWDCqm3e-ppTrqBFKQQdD5TvQGZ8-Y,25963
 dbos/_debouncer.py,sha256=VmGq1_ZIQ79fnH14LEhdoqxKWp6rlEwzsUwumwAMgTQ,15095
 dbos/_debug.py,sha256=0MfgNqutCUhI4PEmmra9x7f3DiFE_0nscfUCHdLimEY,1415
 dbos/_docker_pg_helper.py,sha256=xySum4hTA8TVMBODoG19u4cXQAB1vCock-jwM2pnmSI,7791
@@ -25,7 +25,7 @@ dbos/_flask.py,sha256=Npnakt-a3W5OykONFRkDRnumaDhTQmA0NPdUCGRYKXE,1652
 dbos/_kafka.py,sha256=Gm4fHWl7gYb-i5BMvwNwm5Km3z8zQpseqdMgqgFjlGI,4252
 dbos/_kafka_message.py,sha256=NYvOXNG3Qn7bghn1pv3fg4Pbs86ILZGcK4IB-MLUNu0,409
 dbos/_logger.py,sha256=djnCp147QoQ1iG9Bt3Uz8RyGaXGmi6gebccXsrA6Cps,4660
-dbos/_migration.py,sha256=LgxWPtXqRRwjvS5CrSvQ81B_UzLvRNWd4fnQ_Wo-gek,9507
+dbos/_migration.py,sha256=VAQxZXWQISifW0JpIG78lowV1MTBJ5ZC4P0YIwqxQhM,10013
 dbos/_outcome.py,sha256=7HvosMfEHTh1U5P6xok7kFTGLwa2lPaul0YApb3UnN4,8191
 dbos/_queue.py,sha256=0kJTPwXy3nZ4Epzt-lHky9M9S4L31645drPGFR8fIJY,4854
 dbos/_recovery.py,sha256=K-wlFhdf4yGRm6cUzyhcTjQUS0xp2T5rdNMLiiBErYg,2882
@@ -34,11 +34,11 @@ dbos/_roles.py,sha256=kCuhhg8XLtrHCgKgm44I0abIRTGHltf88OwjEKAUggk,2317
 dbos/_scheduler.py,sha256=CWeGVfl9h51VXfxt80y5Da_5pE8SPty_AYkfpJkkMxQ,2117
 dbos/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_schemas/application_database.py,sha256=SypAS9l9EsaBHFn9FR8jmnqt01M74d9AF1AMa4m2hhI,1040
-dbos/_schemas/system_database.py,sha256=-dAKk-_Y3vzbpLT4ei-sIrBQgFyQiwPj1enZb1TYc8I,4943
+dbos/_schemas/system_database.py,sha256=aEkjRQDh9xjdke0d9uFx_20-c9UjQtvuLtHZ24aOypA,5497
 dbos/_serialization.py,sha256=GLgWLtHpvk7nSHyXukVQLE1ASNA3CJBtfF8w6iflBDw,3590
-dbos/_sys_db.py,sha256=SspVk-wYmE6xZLuyYQUclwh_AMjnkDXcog5g5WmYn7c,83036
-dbos/_sys_db_postgres.py,sha256=CcvxWzoByEvCZ2P_P-KNBRcyJ_8vSpCjtHBRmc7l5hI,7324
-dbos/_sys_db_sqlite.py,sha256=xT9l-czMhLmfuu5UcnBzAyUxSFgzt3XtEWx9t_D8mZs,7361
+dbos/_sys_db.py,sha256=Trlbf99KvH8YRthQ3diJQMSi0eDmky7X8dPG1wuv5VI,83098
+dbos/_sys_db_postgres.py,sha256=V3RGj2cXdCZ8xNxiMO-ECfKuHXtGZLVVNtOXtFSVHBw,7215
+dbos/_sys_db_sqlite.py,sha256=lEmJjyUHXo09q1sMpNpasurh4JyrH6DsmYzLjDC5k6Y,7091
 dbos/_templates/dbos-db-starter/README.md,sha256=GhxhBj42wjTt1fWEtwNriHbJuKb66Vzu89G4pxNHw2g,930
 dbos/_templates/dbos-db-starter/__package/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dbos/_templates/dbos-db-starter/__package/main.py.dbos,sha256=aQnBPSSQpkB8ERfhf7gB7P9tsU6OPKhZscfeh0yiaD8,2702
@@ -51,9 +51,9 @@ dbos/_utils.py,sha256=ZdoM1MDbHnlJrh31zfhp3iX62bAxK1kyvMwXnltC_84,1779
 dbos/_workflow_commands.py,sha256=k-i1bCfNrux43BHLT8wQ-l-MVZX3D6LGZLH7-uuiDRo,4951
 dbos/cli/_github_init.py,sha256=R_94Fnn40CAmPy-zM00lwHi0ndyfv57TmIooADjmag4,3378
 dbos/cli/_template_init.py,sha256=AltKk256VocgvxLpuTxpjJyACrdHFjbGoqYhHzeLae4,2649
-dbos/cli/cli.py,sha256=8fn8hseZWWseJiJMo21_mWYfMqgM2y7l_3UbMP0YNMI,26724
-dbos/cli/migration.py,sha256=vaYxHy0k5KgEuoOQUl6R9oxKv4V5nKKpaVhRbkLDXpo,3440
+dbos/cli/cli.py,sha256=K8Fz05qach61EMuv5reUMRgT-UltysGZ4XerOTR4KEg,29003
+dbos/cli/migration.py,sha256=1Y52EMc2rX7PJgJa3_KXV7oiQEO569k7aHXRofwYipo,3608
 dbos/dbos-config.schema.json,sha256=LyUT1DOTaAwOP6suxQGS5KemVIqXGPyu_q7Hbo0neA8,6192
 dbos/py.typed,sha256=QfzXT1Ktfk3Rj84akygc7_42z0lRpCq0Ilh8OXI6Zas,44
 version/__init__.py,sha256=L4sNxecRuqdtSFdpUGX3TtBi9KL3k7YsZVIvv-fv9-A,1678
-dbos-1.15.0a2.dist-info/RECORD,,
+dbos-1.15.0a3.dist-info/RECORD,,