queryview 0.0.2__py3-none-any.whl

queryview/mcp_server.py

@@ -0,0 +1,294 @@
+"""The MCP layer: a FastMCP server (mounted by main.py at /mcp) whose tools push
+queries/dashboards to a live QueryView browser session, delegating to the
+in-process remote.py hub."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from . import gitsync, remote
+from .dashboards import _push_dashboard
+from .queries import list_predefined_queries_view
+
+mcp = FastMCP("queryview", stateless_http=True)
+mcp.settings.streamable_http_path = "/"
+
+
+@mcp.tool()
+async def push_query(
+    session_id: str,
+    query: str,
+    limit: int = 100,
+    offset: int = 0,
+    order_by: list[dict[str, Any]] | None = None,
+    fields: list[str] | None = None,
+    cell_view: str | None = None,
+    name: str | None = None,
+) -> dict[str, Any]:
+    """Push a SQL query to a live QueryView browser session.
+
+    The targeted browser fills its query panel and auto-runs the query. Get the
+    `session_id` from the QueryView UI: the agent icon next to the connection
+    status pill, after enabling "Allow remote control".
+
+    Args:
+        session_id: The session id shown in the QueryView popover.
+        query: The SQL to run.
+        limit: Page size (default 100).
+        offset: Row offset (default 0).
+        order_by: Optional sort, e.g. [{"name": "id", "dir": "DESC"}].
+        fields: Optional column names to display; omit to show all columns.
+        cell_view: Optional raw cell-view YAML (column -> {type, value}) applied
+            to this pushed result only, e.g. to render a column as a custom
+            HTML token. Same format as the "Cell view" modal; see docs/query.md.
+            Unlike the modal it isn't persisted — it rides with this one push and
+            overrides any selected predefined query's saved cell_view.
+        name: Optional predefined-query name to select in the dropdown (e.g.
+            "findings sources"). Selection only — nothing is persisted. When the
+            name matches a saved query and no `cell_view` is given, the pushed
+            result renders with that query's saved cell_view.
+    """
+    payload = {
+        "type": "query",
+        "query": query,
+        "limit": limit,
+        "offset": offset,
+        "order_by": order_by,
+        "fields": fields,
+        "cell_view": cell_view,
+        "name": name,
+    }
+    ok, message = remote.push(session_id, payload)
+    return {"ok": ok, "message": message, "database": remote.session_database(session_id)}
+
+
+def _columns_to_rows(cols: dict[str, list]) -> dict[str, Any]:
+    """Turn a column-oriented map {col: [values, ...]} into
+    {"columns": [...], "rows": [[...], ...]} for agent-friendly row output."""
+    names = list(cols.keys())
+    n = len(next(iter(cols.values()), []))
+    return {"columns": names, "rows": [[cols[c][i] for c in names] for i in range(n)]}
+
+
+@mcp.tool()
+async def run_query(
+    query: str,
+    connection: str = "clickhouse",
+    limit: int = 1000,
+    offset: int = 0,
+) -> dict[str, Any]:
+    """Run a read-only SQL query against a saved connection and return the rows
+    to the agent (unlike push_query, which only fills a browser panel).
+
+    Use this to explore schema (system.tables / system.columns) and inspect data
+    before building a dashboard or a push_query. `limit`/`offset` page the result
+    (default 1000 / 0; limit is capped at 10000). Returns
+    {"ok": True, "connection": ..., "database": ..., "columns": [...],
+    "rows": [[...], ...]}, or {"ok": False, "message": ...}.
+    `database` is the connection's currently-selected database (the user can
+    change it from the connection pill), so check it before deciding whether to
+    fully-qualify tables as db.table.
+    """
+    from .connect import _connection_by_name
+    from .dashboard_queries import run_queries_for_connection
+    from .validation import MAX_LIMIT
+
+    limit = max(0, min(limit, MAX_LIMIT))
+    offset = max(0, offset)
+    r = await run_queries_for_connection(connection, {"q": query}, limit=limit, offset=offset)
+    if not r["ok"]:
+        return {"ok": False, "message": r["message"]}
+    stored = await _connection_by_name(connection)
+    return {
+        "ok": True,
+        "connection": connection,
+        "database": stored.database if stored else None,
+        **_columns_to_rows(r["results"]["q"]),
+    }
+
+
+async def _session_workspace_rec(session_id: str | None):
+    """The workspace the given armed session is on (reported by the browser),
+    else the default workspace. MCP is deliberately workspace-unaware: the
+    human picks the workspace in the UI; the agent works in session scope."""
+    from . import workspaces
+
+    name = remote.session_workspace(session_id) if session_id else None
+    return await workspaces.resolve(name or workspaces.DEFAULT_WORKSPACE)
+
+
+@mcp.tool()
+async def list_queries(conn_type: str = "clickhouse", session_id: str | None = None) -> dict[str, Any]:
+    """List the saved (predefined) queries for a connection type.
+
+    These are reusable queries a human has saved, shared per connection type
+    (default "clickhouse") within a workspace. Returns
+    {"queries": [{query_name, query, cell_view, order_by, fields}]}, where
+    order_by is [{"name","dir"}] or null, fields is ["col", ...] or null, and
+    cell_view is raw YAML or null. Pass a query_name back as push_query's `name`
+    to select that query in the browser (its saved presentation then applies).
+
+    Args:
+        conn_type: Connection type to list queries for.
+        session_id: Optional armed-session id; scopes the list to that
+            session's workspace (default workspace otherwise).
+    """
+    ws = await _session_workspace_rec(session_id)
+    return {"queries": await list_predefined_queries_view(conn_type, ws.id)}
+
+
+@mcp.tool()
+async def list_dashboards(session_id: str | None = None) -> dict[str, Any]:
+    """List the saved dashboards (names + metadata, no HTML/queries payload).
+
+    Use this to discover dashboard names — e.g. to pick a `name` for
+    git_store/git_history/git_restore with kind="dashboard", or to avoid
+    overwriting an existing dashboard when pushing a new one.
+
+    Args:
+        session_id: Optional armed-session id; scopes the list to that
+            session's workspace (default workspace otherwise).
+
+    Returns {"dashboards": [{name, connection, updated_at}]}; updated_at is
+    unix ms.
+    """
+    from .dashboards import list_dashboards as _list_dashboards
+
+    ws = await _session_workspace_rec(session_id)
+    return {"dashboards": await _list_dashboards(ws.id)}
+
+
+@mcp.tool()
+async def push_dashboard(
+    session_id: str,
+    name: str,
+    connection: str,
+    html: str,
+    queries: dict[str, str],
+) -> dict[str, Any]:
+    """Push a dashboard DRAFT to a live QueryView session (does not persist).
+
+    The dashboard renders immediately in the browser, but nothing is written to
+    the store — only the user's **Save** button in the dashboard view persists
+    it, mirroring how push_query drafts a query for the user to Save. Re-push to
+    update the live draft. The dashboard's queries run against the named
+    connection.
+
+    The browser consumes the results, not the agent: the HTML reads them from a
+    `window.queries` global, a column-oriented map
+    `{query_name: {column_name: [values, …]}}` — e.g.
+    `window.queries.sales.revenue`. Load chart libraries from a CDN if needed.
+
+    Args:
+        session_id: The session id shown in the QueryView popover.
+        name: Dashboard name (the name the user's Save will persist under).
+        connection: Saved connection name the queries run against.
+        html: The dashboard HTML document (renders in a sandboxed iframe).
+        queries: Map of query name to SQL.
+
+    Returns {ok, pushed, message}.
+    """
+    pushed, message = await _push_dashboard(name, connection, html, queries, session_id or None)
+    return {
+        "ok": pushed,
+        "pushed": pushed,
+        "message": message,
+        "database": remote.session_database(session_id),
+    }
+
+
+async def _git_tool(coro) -> dict[str, Any]:
+    """Await a gitsync operation, mapping its result (or GitSyncError) to the
+    tool result — the one place the git-tool error contract lives."""
+    try:
+        return {"ok": True, **(await coro)}
+    except gitsync.GitSyncError as e:
+        return {"ok": False, "message": str(e)}
+
+
+@mcp.tool()
+async def git_store(
+    kind: str,
+    name: str,
+    conn_type: str | None = None,
+    message: str | None = None,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """Back up one predefined query or dashboard to its workspace's git remote.
+
+    Exports the entity's saved DB state as files, makes one commit, and pushes.
+    Requires the target workspace to have a git remote configured. Versions are
+    git commits — use git_history to list them and git_restore to roll back.
+
+    Args:
+        kind: "query" or "dashboard".
+        name: The entity's name.
+        conn_type: The query's connection type (e.g. "clickhouse"); required
+            for kind="query", ignored for dashboards.
+        message: Optional commit message (default: "store query {conn_type}/{name}"
+            for queries, "store dashboard {name}" for dashboards).
+        session_id: Optional armed-session id; the operation runs in that
+            session's workspace (default workspace otherwise).
+
+    Returns {ok, committed, sha, message}; committed=False with "no changes"
+    when the repo already matches the DB.
+    """
+    ws = await _session_workspace_rec(session_id)
+    return await _git_tool(gitsync.store(ws, kind, name, conn_type, message))
+
+
+@mcp.tool()
+async def git_history(
+    kind: str,
+    name: str,
+    conn_type: str | None = None,
+    before: str | None = None,
+    limit: int = 10,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """List an entity's backup revisions (commits touching it), newest first.
+
+    Args:
+        kind: "query" or "dashboard".
+        name: The entity's name.
+        conn_type: The query's connection type; required for kind="query".
+        before: A sha from a previous page; returns strictly older revisions.
+        limit: Page size (default 10).
+        session_id: Optional armed-session id; the operation runs in that
+            session's workspace (default workspace otherwise).
+
+    Returns {ok, revisions: [{sha, date, message}], has_more}; date is unix ms.
+    Pass a sha to git_restore's `ref` to restore that revision.
+    """
+    ws = await _session_workspace_rec(session_id)
+    return await _git_tool(gitsync.history(ws, kind, name, conn_type, before, limit))
+
+
+@mcp.tool()
+async def git_restore(
+    kind: str,
+    name: str,
+    conn_type: str | None = None,
+    ref: str | None = None,
+    session_id: str | None = None,
+) -> dict[str, Any]:
+    """Overwrite the local DB copy of one query/dashboard with a git revision.
+
+    Reads the entity's files at `ref` (default: the remote branch head) and
+    upserts them into the store. Git history is untouched — HEAD never moves;
+    a later git_store simply commits on top.
+
+    Args:
+        kind: "query" or "dashboard".
+        name: The entity's name.
+        conn_type: The query's connection type; required for kind="query".
+        ref: A sha from git_history (default: latest backup).
+        session_id: Optional armed-session id; the operation runs in that
+            session's workspace (default workspace otherwise).
+
+    Returns {ok, restored, sha} or {ok: False, message}.
+    """
+    ws = await _session_workspace_rec(session_id)
+    return await _git_tool(gitsync.restore(ws, kind, name, conn_type, ref))

queryview/migrations/env.py

@@ -0,0 +1,39 @@
+"""Alembic environment. Uses a *sync* SQLite engine (separate from the app's
+async aiosqlite runtime, to avoid async-greenlet complexity). Importing the model
+modules populates SQLModel.metadata so autogenerate sees every table;
+render_as_batch=True is required for SQLite's limited ALTER TABLE.
+
+Online migrations only — the app and dev CLI both run `alembic upgrade` against a
+real connection; offline (`--sql`) mode isn't used."""
+
+from __future__ import annotations
+
+# Import for side effects: register all tables on SQLModel.metadata.
+import queryview.connect  # noqa: F401
+import queryview.dashboards  # noqa: F401
+import queryview.queries  # noqa: F401
+from alembic import context
+from sqlalchemy import create_engine, pool
+from sqlmodel import SQLModel
+
+config = context.config
+target_metadata = SQLModel.metadata
+
+
+def _url() -> str:
+    """Prefer the URL the app injects; fall back to DB_PATH so the dev CLI
+    (`alembic ...`) targets the same SQLite file the app would."""
+    from queryview.connect import _db_path
+
+    return config.get_main_option("sqlalchemy.url") or f"sqlite:///{_db_path()}"
+
+
+connectable = create_engine(_url(), poolclass=pool.NullPool)
+with connectable.connect() as connection:
+    context.configure(
+        connection=connection,
+        target_metadata=target_metadata,
+        render_as_batch=True,
+    )
+    with context.begin_transaction():
+        context.run_migrations()

queryview/migrations/script.py.mako

@@ -0,0 +1,29 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from __future__ import annotations
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+import sqlmodel
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    ${downgrades if downgrades else "pass"}

queryview/migrations/versions/9a536b7c0328_initial_schema.py

@@ -0,0 +1,89 @@
+"""initial schema
+
+Revision ID: 9a536b7c0328
+Revises:
+Create Date: 2026-06-03 15:30:03.750791
+
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "9a536b7c0328"
+down_revision: str | None = None
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table(
+        "connections",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("type", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("host", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("port", sa.Integer(), nullable=False),
+        sa.Column("username", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("password", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("database", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("last_active_at", sa.Integer(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("connections", schema=None) as batch_op:
+        batch_op.create_index(batch_op.f("ix_connections_name"), ["name"], unique=True)
+        batch_op.create_index(batch_op.f("ix_connections_type"), ["type"], unique=False)
+
+    op.create_table(
+        "dashboards",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("connection", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("html", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("queries", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("updated_at", sa.Integer(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    with op.batch_alter_table("dashboards", schema=None) as batch_op:
+        batch_op.create_index(batch_op.f("ix_dashboards_name"), ["name"], unique=True)
+
+    op.create_table(
+        "predefined_queries",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("query_name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("type", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("query", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("cell_view", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.PrimaryKeyConstraint("id"),
+        sa.UniqueConstraint("type", "query_name", name="uq_predefined_type_name"),
+    )
+    with op.batch_alter_table("predefined_queries", schema=None) as batch_op:
+        batch_op.create_index(batch_op.f("ix_predefined_queries_query_name"), ["query_name"], unique=False)
+        batch_op.create_index(batch_op.f("ix_predefined_queries_type"), ["type"], unique=False)
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("predefined_queries", schema=None) as batch_op:
+        batch_op.drop_index(batch_op.f("ix_predefined_queries_type"))
+        batch_op.drop_index(batch_op.f("ix_predefined_queries_query_name"))
+
+    op.drop_table("predefined_queries")
+    with op.batch_alter_table("dashboards", schema=None) as batch_op:
+        batch_op.drop_index(batch_op.f("ix_dashboards_name"))
+
+    op.drop_table("dashboards")
+    with op.batch_alter_table("connections", schema=None) as batch_op:
+        batch_op.drop_index(batch_op.f("ix_connections_type"))
+        batch_op.drop_index(batch_op.f("ix_connections_name"))
+
+    op.drop_table("connections")
+    # ### end Alembic commands ###

queryview/migrations/versions/a1b2c3d4e5f6_connection_config_blob.py

@@ -0,0 +1,59 @@
+"""connections: per-driver columns -> one encrypted JSON config blob
+
+Revision ID: a1b2c3d4e5f6
+Revises: 9a536b7c0328
+Create Date: 2026-06-20
+
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision: str = "a1b2c3d4e5f6"
+down_revision: str | None = "9a536b7c0328"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # 1. Add the new blob column (nullable while we backfill).
+    with op.batch_alter_table("connections", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("config", sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+
+    # 2. Backfill each existing row: decrypt the old password, build the config
+    #    dict, re-encrypt the whole JSON. The app's key loader is imported here.
+    from queryview.connect import _decrypt_str, _encrypt_str
+
+    conn = op.get_bind()
+    rows = conn.execute(sa.text("SELECT id, host, port, username, password FROM connections")).fetchall()
+    for rid, host, port, username, password in rows:
+        plain = _decrypt_str(password) if password else ""
+        blob = _encrypt_str(json.dumps({"host": host, "port": port, "username": username, "password": plain}))
+        conn.execute(
+            sa.text("UPDATE connections SET config = :c WHERE id = :i"),
+            {"c": blob, "i": rid},
+        )
+
+    # 3. Enforce NOT NULL and drop the per-driver columns.
+    with op.batch_alter_table("connections", schema=None) as batch_op:
+        batch_op.alter_column("config", existing_type=sqlmodel.sql.sqltypes.AutoString(), nullable=False)
+        batch_op.drop_column("host")
+        batch_op.drop_column("port")
+        batch_op.drop_column("username")
+        batch_op.drop_column("password")
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("connections", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("host", sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+        batch_op.add_column(sa.Column("port", sa.Integer(), nullable=True))
+        batch_op.add_column(sa.Column("username", sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+        batch_op.add_column(sa.Column("password", sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+        batch_op.drop_column("config")

queryview/migrations/versions/b2c3d4e5f6a7_predefined_presentation.py

@@ -0,0 +1,32 @@
+"""predefined_queries: add order_by + fields presentation columns
+
+Revision ID: b2c3d4e5f6a7
+Revises: a1b2c3d4e5f6
+Create Date: 2026-07-05
+
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+revision: str = "b2c3d4e5f6a7"
+down_revision: str | None = "a1b2c3d4e5f6"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    with op.batch_alter_table("predefined_queries", schema=None) as batch_op:
+        batch_op.add_column(sa.Column("order_by", sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+        batch_op.add_column(sa.Column("fields", sqlmodel.sql.sqltypes.AutoString(), nullable=True))
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("predefined_queries", schema=None) as batch_op:
+        batch_op.drop_column("fields")
+        batch_op.drop_column("order_by")

queryview/migrations/versions/c7d8e9f0a1b2_workspaces.py

@@ -0,0 +1,98 @@
+"""workspaces: per-workspace git sync — workspaces table, entity workspace_id
+
+Seeds a 'default' workspace from GIT_SYNC_REMOTE/GIT_SYNC_BRANCH (read once
+here; runtime config lives in the table from now on) and backfills all
+existing predefined queries and dashboards into it. Name uniqueness becomes
+per-workspace.
+
+Revision ID: c7d8e9f0a1b2
+Revises: b2c3d4e5f6a7
+Create Date: 2026-07-10
+
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+revision: str = "c7d8e9f0a1b2"
+down_revision: str | None = "b2c3d4e5f6a7"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "workspaces",
+        sa.Column("id", sa.Integer(), nullable=False),
+        sa.Column("name", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.Column("remote", sqlmodel.sql.sqltypes.AutoString(), nullable=True),
+        sa.Column("branch", sqlmodel.sql.sqltypes.AutoString(), nullable=False),
+        sa.PrimaryKeyConstraint("id"),
+    )
+    op.create_index(op.f("ix_workspaces_name"), "workspaces", ["name"], unique=True)
+
+    # Seed 'default' from the legacy env config. The app's key loader is
+    # imported here, mirroring the connection-config-blob migration.
+    from queryview.connect import _encrypt_str
+
+    env_remote = os.environ.get("GIT_SYNC_REMOTE")
+    remote = _encrypt_str(env_remote) if env_remote else None
+    branch = os.environ.get("GIT_SYNC_BRANCH") or "main"
+    conn = op.get_bind()
+    conn.execute(
+        sa.text("INSERT INTO workspaces (name, remote, branch) VALUES (:n, :r, :b)"),
+        {"n": "default", "r": remote, "b": branch},
+    )
+    default_id = conn.execute(sa.text("SELECT id FROM workspaces WHERE name = 'default'")).scalar()
+
+    # server_default backfills existing rows during the batch table rewrite and
+    # keeps pre-workspace INSERT paths working mid-upgrade; application code
+    # always passes workspace_id explicitly.
+    with op.batch_alter_table("predefined_queries", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "workspace_id",
+                sa.Integer(),
+                nullable=False,
+                server_default=str(default_id),
+            )
+        )
+        batch_op.drop_constraint("uq_predefined_type_name", type_="unique")
+        batch_op.create_unique_constraint("uq_predefined_ws_type_name", ["workspace_id", "type", "query_name"])
+
+    with op.batch_alter_table("dashboards", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "workspace_id",
+                sa.Integer(),
+                nullable=False,
+                server_default=str(default_id),
+            )
+        )
+        batch_op.create_unique_constraint("uq_dashboards_ws_name", ["workspace_id", "name"])
+
+    # Dashboard names are now unique per workspace, not globally.
+    op.drop_index("ix_dashboards_name", table_name="dashboards")
+    op.create_index("ix_dashboards_name", "dashboards", ["name"], unique=False)
+
+
+def downgrade() -> None:
+    with op.batch_alter_table("dashboards", schema=None) as batch_op:
+        batch_op.drop_constraint("uq_dashboards_ws_name", type_="unique")
+        batch_op.drop_column("workspace_id")
+    op.drop_index("ix_dashboards_name", table_name="dashboards")
+    op.create_index("ix_dashboards_name", "dashboards", ["name"], unique=True)
+
+    with op.batch_alter_table("predefined_queries", schema=None) as batch_op:
+        batch_op.drop_constraint("uq_predefined_ws_type_name", type_="unique")
+        batch_op.create_unique_constraint("uq_predefined_type_name", ["type", "query_name"])
+        batch_op.drop_column("workspace_id")
+
+    op.drop_index(op.f("ix_workspaces_name"), table_name="workspaces")
+    op.drop_table("workspaces")