sqlseed-web 0.2.4__py3-none-any.whl

sqlseed_web/workbench_ai_relations.py

@@ -0,0 +1,285 @@
+"""Finite AI relation templates compiled by the server, never by the model."""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+from copy import deepcopy
+from typing import Any, Literal
+
+from pydantic import BaseModel, ConfigDict, Field
+from sqlglot import exp, parse_one
+from sqlglot.errors import SqlglotError
+from sqlseed._utils.type_checks import has_exact_type
+from sqlseed.config.models import ColumnConfig
+from sqlseed.core.check_parser import CheckConstraintParser, ParsedCheck
+from sqlseed.core.column_dag import ColumnDAG
+from sqlseed.core.mapper import GeneratorSpec
+
+
+class RelationSuggestion(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    kind: Literal["relation"]
+    table: str = Field(min_length=1, max_length=300)
+    column: str = Field(min_length=1, max_length=300)
+    template: Literal["copy", "concat", "product", "date_offset"]
+    sources: list[str] = Field(min_length=1, max_length=8)
+    options: dict[str, Any] = Field(default_factory=dict)
+    reason: str = Field(default="请确认同一行字段之间的业务关系。", max_length=2000)
+
+
+def locked_column(
+    table: dict[str, Any], column: dict[str, Any], rule: dict[str, Any] | None, *, source: bool = False
+) -> bool:
+    """Protect managed rules; skipped values cannot supply a relation source."""
+    foreign = {name for key in table["foreign_keys"] for name in key["columns"]}
+    protected: tuple[str, ...] = ("faker_method", "mimesis_method", "native_params")
+    if not source:
+        protected += ("derive_from", "expression")
+    generator = (rule or {}).get("generator") or table.get("mapping", {}).get(column["name"], {}).get("generator_name")
+    # An existing derived rule supplies a value even if the SQL column also
+    # declares DEFAULT. It may feed another relation but remains a locked target.
+    derived = bool(rule and rule.get("derive_from") and rule.get("expression"))
+    uses_default = (
+        not derived
+        and column.get("default") is not None
+        and (not generator or generator == "skip" or str(generator).startswith("__"))
+    )
+    return bool(
+        column["name"] in foreign
+        or column.get("is_primary_key")
+        or column.get("is_computed")
+        or uses_default
+        or (rule and (any(rule.get(key) for key in protected) or (source and rule.get("generator") == "skip")))
+    )
+
+
+def _kind(column: dict[str, Any]) -> str:
+    name = str(column["type"]).upper()
+    if "INT" in name:
+        return "integer"
+    if any(token in name for token in ("REAL", "FLOAT", "DOUBLE", "NUMERIC", "DECIMAL")):
+        return "number"
+    if "DATETIME" in name or "TIMESTAMP" in name:
+        return "datetime"
+    if name == "DATE":
+        return "date"
+    if any(token in name for token in ("TEXT", "CHAR", "STRING")):
+        return "text"
+    return name
+
+
+def _copy_expression(kinds: list[str], target_kind: str, options: dict[str, Any]) -> str:
+    if (
+        options
+        or len(kinds) != 1
+        or not (kinds[0] == target_kind or (kinds[0] == "integer" and target_kind == "number"))
+    ):
+        raise ValueError("复制需要兼容的单个来源")
+    return "value"
+
+
+def _concat_expression(kinds: list[str], target_kind: str, options: dict[str, Any], values: list[str]) -> str:
+    separator = options.get("separator", "")
+    if (
+        set(options) - {"separator"}
+        or not isinstance(separator, str)
+        or len(separator) > 32
+        or target_kind != "text"
+        or any(kind != "text" for kind in kinds)
+    ):
+        raise ValueError("拼接仅支持文本字段与不超过 32 字的分隔符")
+    return (" + " + json.dumps(separator, ensure_ascii=False) + " + ").join(values)
+
+
+def _product_expression(kinds: list[str], target_kind: str, options: dict[str, Any], values: list[str]) -> str:
+    precision = options.get("precision", 2 if target_kind == "number" else 0)
+    if set(options) - {"precision"} or not has_exact_type(precision, int) or not 0 <= precision <= 8:
+        raise ValueError("乘积需要两个数值字段，精度为 0–8")
+    if (
+        len(kinds) != 2
+        or any(kind not in {"integer", "number"} for kind in kinds)
+        or target_kind not in {"integer", "number"}
+    ):
+        raise ValueError("乘积需要两个数值字段，精度为 0–8")
+    if target_kind == "integer" and (precision != 0 or any(kind != "integer" for kind in kinds)):
+        raise ValueError("整数目标需要整数来源")
+    return f"round({values[0]} * {values[1]}, {precision})"
+
+
+def _date_offset_expression(kinds: list[str], target_kind: str, options: dict[str, Any]) -> str:
+    days = options.get("days", 0)
+    if set(options) - {"days"} or not has_exact_type(days, int) or not -36500 <= days <= 36500:
+        raise ValueError("日期偏移需要相同日期类型，天数为 -36500–36500")
+    if len(kinds) != 1 or target_kind not in {"date", "datetime"} or kinds[0] != target_kind:
+        raise ValueError("日期偏移需要相同日期类型，天数为 -36500–36500")
+    return f"value + timedelta(days={days})"
+
+
+def _relation_expression(suggestion: RelationSuggestion, kinds: list[str], target_kind: str, values: list[str]) -> str:
+    if suggestion.template == "copy":
+        return _copy_expression(kinds, target_kind, suggestion.options)
+    if suggestion.template == "concat":
+        return _concat_expression(kinds, target_kind, suggestion.options, values)
+    if suggestion.template == "product":
+        return _product_expression(kinds, target_kind, suggestion.options, values)
+    return _date_offset_expression(kinds, target_kind, suggestion.options)
+
+
+def compile_relation(
+    suggestion: RelationSuggestion, table: dict[str, Any], rules: dict[str, dict[str, Any]]
+) -> dict[str, Any]:
+    """Compile only bounded typed templates, with explicit NULL propagation."""
+    columns = {col["name"]: col for col in table["columns"]}
+    target = columns[suggestion.column]
+    sources = [columns[name] for name in suggestion.sources]
+    if len(set(suggestion.sources)) != len(sources) or suggestion.column in suggestion.sources:
+        raise ValueError("来源不能重复或引用自身")
+    if any(locked_column(table, col, rules.get(col["name"]), source=True) for col in sources):
+        raise ValueError("来源必须是同一行中可生成的普通或派生字段")
+    if not target.get("nullable", True) and any(
+        col.get("nullable", True) or (rules.get(col["name"], {}).get("null_ratio") or 0) > 0 for col in sources
+    ):
+        raise ValueError("可空来源不能派生为不可空目标")
+    kinds, target_kind = [_kind(col) for col in sources], _kind(target)
+    values = ["value"] if len(sources) == 1 else [f"value[{index}]" for index in range(len(sources))]
+    expression = _relation_expression(suggestion, kinds, target_kind, values)
+    if suggestion.template != "copy":
+        expression = f"None if {' or '.join(value + ' == None' for value in values)} else ({expression})"
+    after = deepcopy(rules.get(suggestion.column, {}))
+    for key in ("generator", "params", "provider", "faker_method", "mimesis_method", "native_params"):
+        after.pop(key, None)
+    after.update(
+        name=suggestion.column,
+        derive_from=suggestion.sources[0] if len(sources) == 1 else suggestion.sources,
+        expression=expression,
+    )
+    ColumnConfig.model_validate(after)
+    return after
+
+
+def validate_dags(document: dict[str, Any], schema: dict[str, Any]) -> None:
+    """Use the real core DAG, retaining all old derived rules and row references."""
+    tables = {table["name"]: table for table in schema["tables"]}
+    for table in document["tables"]:
+        columns = {col["name"] for col in tables[table["name"]]["columns"]}
+        configs = [ColumnConfig.model_validate(col) for col in table.get("columns", [])]
+        for config in configs:
+            if isinstance(config.derive_from, list):
+                sources = config.derive_from
+            elif config.derive_from:
+                sources = [config.derive_from]
+            else:
+                sources = []
+            if not set(sources) <= columns:
+                raise ValueError("派生来源不存在")
+        ColumnDAG().build({name: GeneratorSpec(generator_name="string") for name in columns}, configs)
+
+
+def _constraint_columns(table: dict[str, Any]) -> list[list[str]]:
+    constraints = [constraint["columns"] for constraint in table["unique_constraints"]]
+    for check in table["checks"]:
+        try:
+            columns = [column.name for column in parse_one(check["expression"]).find_all(exp.Column)]
+        except SqlglotError:
+            # If a dialect-specific constraint cannot be understood, keep
+            # the table's proposals together rather than guessing independence.
+            columns = [column["name"] for column in table["columns"]]
+        constraints.append(columns)
+    return constraints
+
+
+def _patch_dependencies(
+    document: dict[str, Any], schema: dict[str, Any]
+) -> Iterator[tuple[tuple[str, str], tuple[str, str]]]:
+    for table in document["tables"]:
+        configs = [ColumnConfig.model_validate(col) for col in table.get("columns", [])]
+        specs = {col.name: GeneratorSpec(generator_name="string") for col in configs}
+        for node in ColumnDAG().build(specs, configs):
+            for source in node.depends_on:
+                yield (table["name"], source), (table["name"], node.name)
+    for table in schema["tables"]:
+        for columns in _constraint_columns(table):
+            for name in columns[1:]:
+                yield (table["name"], name), (table["name"], columns[0])
+
+
+def group_patches(patches: list[dict[str, Any]], document: dict[str, Any], schema: dict[str, Any]) -> None:
+    """Connected old/new derivations are a single review and application unit."""
+    parents: dict[tuple[str, str], tuple[str, str]] = {}
+
+    def root(node: tuple[str, str]) -> tuple[str, str]:
+        parents.setdefault(node, node)
+        if parents[node] != node:
+            parents[node] = root(parents[node])
+        return parents[node]
+
+    for source, target in _patch_dependencies(document, schema):
+        parents[root(source)] = root(target)
+    groups: dict[tuple[str, str], str] = {}
+    for patch in patches:
+        group_root = root((patch["table"], patch["column"]))
+        patch["group_id"] = groups.setdefault(group_root, f"ai-group-{len(groups) + 1}")
+
+
+class SampleCheckError(ValueError):
+    """Expose the failed schema constraint, never the generated value."""
+
+    def __init__(self, table: str, column: str, message: str) -> None:
+        super().__init__(f"{table}.{column}: {message}")
+        self.issue = {
+            "code": "sample_check_failed",
+            "severity": "error",
+            "table": table,
+            "column": column,
+            "message": message,
+        }
+
+
+def _validate_sample_range(table: str, column: str, parsed: ParsedCheck, value: Any) -> None:
+    if parsed.min_value is not None and (
+        value < parsed.min_value or (parsed.min_exclusive and value == parsed.min_value)
+    ):
+        raise SampleCheckError(
+            table,
+            column,
+            f"生成值不满足 CHECK 下界（{'>' if parsed.min_exclusive else '>='} {parsed.min_value}）",
+        )
+    if parsed.max_value is not None and (
+        value > parsed.max_value or (parsed.max_exclusive and value == parsed.max_value)
+    ):
+        raise SampleCheckError(
+            table,
+            column,
+            f"生成值不满足 CHECK 上界（{'<' if parsed.max_exclusive else '<='} {parsed.max_value}）",
+        )
+
+
+def _validate_sample_value(table: str, column: str, parsed: ParsedCheck, value: Any) -> None:
+    if value is None:
+        return  # SQL CHECK accepts UNKNOWN; NOT NULL is checked separately.
+    if parsed.kind == "choice" and value not in parsed.choices:
+        raise SampleCheckError(table, column, "生成值不满足 CHECK 候选范围")
+    if parsed.kind == "range":
+        _validate_sample_range(table, column, parsed, value)
+    if parsed.kind == "length_range" and (
+        (parsed.min_length is not None and len(value) < parsed.min_length)
+        or (parsed.max_length is not None and len(value) > parsed.max_length)
+    ):
+        raise SampleCheckError(
+            table,
+            column,
+            f"生成值长度不满足 CHECK（最少 {parsed.min_length if parsed.min_length is not None else 0}，"
+            f"最多 {parsed.max_length if parsed.max_length is not None else '不限'}）",
+        )
+
+
+def validate_sample_checks(schema: dict[str, Any], samples: dict[str, Any]) -> None:
+    """Check finite single-column constraints against actual generated values."""
+    for table in schema["tables"]:
+        for column in table["columns"]:
+            for check in table["checks"]:
+                if (parsed := CheckConstraintParser.parse(column["name"], check["expression"])) is None:
+                    continue
+                for row in samples.get(table["name"], []):
+                    _validate_sample_value(table["name"], column["name"], parsed, row.get(column["name"]))

sqlseed_web/workbench_ai_stream.py

@@ -0,0 +1,172 @@
+"""Bounded, cancellable delivery of synchronous AI work without a database lease."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from collections.abc import AsyncIterator, Callable
+from concurrent.futures import Future
+from queue import Empty, Full, Queue
+from threading import Event, Lock
+from time import monotonic
+from typing import Any
+
+from fastapi import HTTPException, Request
+from fastapi.responses import Response, StreamingResponse
+from sqlseed._utils.daemon_task import DaemonTask
+
+from sqlseed_web import runtime_lifecycle
+
+ANALYSIS_TIMEOUT = 180.0
+_active: set[str] = set()
+_active_lock = Lock()
+Analysis = Callable[[Callable[[str, str], None], Callable[[], None]], dict[str, Any]]
+
+
+def _error(exc: HTTPException) -> dict[str, Any]:
+    detail = exc.detail
+    return {
+        "type": "error",
+        "code": detail.get("code", "ai_analysis_failed") if isinstance(detail, dict) else "ai_analysis_failed",
+        "message": detail.get("message", "AI 分析失败，请重试。") if isinstance(detail, dict) else str(detail),
+        "status": exc.status_code,
+    }
+
+
+class AnalysisOperation:
+    """Own the in-flight gate until the worker actually exits, even after disconnect."""
+
+    def __init__(self, conn_id: str, run: Analysis) -> None:
+        self.cancelled = Event()
+        self.deadline = monotonic() + ANALYSIS_TIMEOUT
+        self.queue: Queue[dict[str, Any]] = Queue(maxsize=16)
+        with _active_lock:
+            if conn_id in _active:
+                raise HTTPException(
+                    409, detail={"code": "ai_busy", "message": "此连接的 AI 分析尚未结束，请稍后重试。"}
+                )
+            _active.add(conn_id)
+
+        gate = runtime_lifecycle.runtime_gate
+        try:
+            gate.acquire("ai_analyses")
+        except BaseException:
+            with _active_lock:
+                _active.discard(conn_id)
+            raise
+
+        def worker() -> dict[str, Any]:
+            self.check_cancelled()
+            result = run(self.progress, self.check_cancelled)
+            self.check_cancelled()
+            return result
+
+        def finished(task: Future[dict[str, Any]]) -> None:
+            try:
+                if (failure := task.exception()) is None:
+                    self.publish({"type": "result", "result": task.result()})
+                elif isinstance(failure, HTTPException):
+                    self.publish(_error(failure))
+                else:
+                    self.publish(
+                        _error(
+                            HTTPException(
+                                500,
+                                detail={
+                                    "code": "ai_analysis_failed",
+                                    "message": "AI 分析未完成，请重试；当前规则未改变。",
+                                },
+                            )
+                        )
+                    )
+            finally:
+                with _active_lock:
+                    _active.discard(conn_id)
+                gate.release("ai_analyses")
+
+        try:
+            self.task = DaemonTask(worker, name="sqlseed-ai-analysis", on_done=finished)
+        except BaseException:
+            gate.release("ai_analyses")
+            with _active_lock:
+                _active.discard(conn_id)
+            raise
+
+    def publish(self, event: dict[str, Any]) -> None:
+        # There are four phase events and one terminal event. Keep the queue
+        # bounded even if a future caller reports more frequently.
+        try:
+            self.queue.put_nowait(event)
+        except Full:
+            try:
+                self.queue.get_nowait()
+            except Empty:
+                pass
+            self.queue.put_nowait(event)
+
+    def check_cancelled(self) -> None:
+        if self.cancelled.is_set():
+            raise HTTPException(499, detail={"code": "ai_cancelled", "message": "分析已取消。"})
+        if monotonic() >= self.deadline:
+            raise HTTPException(504, detail={"code": "ai_timeout", "message": "分析超过时间限制，请缩小范围后重试。"})
+
+    def progress(self, stage: str, message: str) -> None:
+        self.check_cancelled()
+        self.publish({"type": "progress", "stage": stage, "message": message})
+
+    async def events(self, request: Request | None = None) -> AsyncIterator[dict[str, Any]]:
+        try:
+            while True:
+                if request is not None and await request.is_disconnected():
+                    return
+                if monotonic() >= self.deadline:
+                    yield _error(
+                        HTTPException(
+                            504, detail={"code": "ai_timeout", "message": "分析超过时间限制，请缩小范围后重试。"}
+                        )
+                    )
+                    return
+                try:
+                    event = self.queue.get_nowait()
+                except Empty:
+                    await asyncio.sleep(0.025)
+                    continue
+                yield event
+                if event["type"] in {"result", "error"}:
+                    return
+        finally:
+            # This does not pretend to interrupt an SDK network call. The worker
+            # checks the flag when that call returns, before any further DB work.
+            self.cancelled.set()
+
+    async def ndjson(self, request: Request | None = None) -> AsyncIterator[str]:
+        try:
+            async for event in self.events(request):
+                yield (
+                    json.dumps(
+                        {key: value for key, value in event.items() if key != "status"}, ensure_ascii=False, default=str
+                    )
+                    + "\n"
+                )
+        finally:
+            self.cancelled.set()
+
+
+async def analysis_response(conn_id: str, run: Analysis, request: Request) -> dict[str, Any] | Response:
+    operation = AnalysisOperation(conn_id, run)
+    if "application/x-ndjson" in request.headers.get("accept", ""):
+        # ASGI < 2.4 is watched by StreamingResponse itself. Newer ASGI
+        # relies on send errors, so poll disconnect while the model is silent.
+        spec = tuple(int(part) for part in request.scope.get("asgi", {}).get("spec_version", "2.0").split("."))
+        watched_request = request if spec >= (2, 4) else None
+        return StreamingResponse(
+            operation.ndjson(watched_request),
+            media_type="application/x-ndjson",
+            headers={"Cache-Control": "no-store", "X-Accel-Buffering": "no"},
+        )
+    async for event in operation.events(request):
+        if event["type"] == "result":
+            return dict(event["result"])
+        if event["type"] == "error":
+            raise HTTPException(event["status"], detail={"code": event["code"], "message": event["message"]})
+    raise HTTPException(499, detail={"code": "ai_cancelled", "message": "分析已取消。"})

sqlseed_web/workbench_data.py

@@ -0,0 +1,163 @@
+"""Bounded reads of current database records, independent of generation state."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterator
+from contextlib import closing, contextmanager
+from dataclasses import asdict
+from datetime import datetime, timezone
+from decimal import Decimal
+from http import HTTPStatus
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Query
+from fastapi.encoders import jsonable_encoder
+from sqlseed._utils.paths import validate_table_name
+from sqlseed._utils.sql_safe import quote_identifier
+from sqlseed.database.sqlalchemy_adapter import SQLAlchemyAdapter
+
+from sqlseed_web.state import ConnectionBusyError, UnknownConnectionError, state
+from sqlseed_web.workbench_schema import _refresh_inspector, _target_identity
+from sqlseed_web.workbench_store import get_store
+
+router = APIRouter(prefix="/api/workbench", tags=["workbench-data"])
+
+
+@contextmanager
+def _read_errors() -> Iterator[None]:
+    """Keep driver exceptions, connection credentials and record values private."""
+    try:
+        yield
+    except HTTPException:
+        raise
+    except ConnectionBusyError as exc:
+        raise HTTPException(
+            409, detail={"code": "connection_busy", "message": "当前连接正在处理请求，请稍后重试。"}
+        ) from exc
+    except KeyError as exc:
+        raise HTTPException(
+            404, detail={"code": "not_found", "message": "连接或运行记录已不存在，请刷新后重试。"}
+        ) from exc
+    except Exception as exc:
+        raise HTTPException(
+            422,
+            detail={"code": "data_read_failed", "message": "读取数据失败，请检查连接、表结构和读取权限后重试。"},
+        ) from exc
+
+
+def _read_rows(
+    adapter: SQLAlchemyAdapter, table: str, order_by: list[str], limit: int, offset: int
+) -> list[dict[str, Any]]:
+    """Use the adapter's native parameter contract and release the pooled cursor."""
+    dialect = adapter.dialect.name
+    placeholder = {"sqlite": "?", "postgresql": "%s"}[dialect]
+    sql = f"SELECT * FROM {quote_identifier(table)}"
+    if order_by:
+        sql += " ORDER BY " + ", ".join(quote_identifier(column) for column in order_by)
+    # PostgreSQL DBAPI format/pyformat drivers parse percent signs even inside
+    # quoted names when parameters are supplied; literal percent signs double.
+    if dialect == "postgresql":
+        sql = sql.replace("%", "%%")
+    sql += f" LIMIT {placeholder} OFFSET {placeholder}"
+    with closing(adapter.execute(sql, (limit, offset))) as cursor:
+        names = [description[0] for description in cursor.description]
+        return [dict(zip(names, row, strict=True)) for row in cursor.fetchall()]
+
+
+@router.get(
+    "/connections/{conn_id}/tables/{table:path}/data",
+    responses={
+        403: {"description": HTTPStatus(403).phrase},
+        404: {"description": HTTPStatus(404).phrase},
+        409: {"description": HTTPStatus(409).phrase},
+        422: {"description": HTTPStatus(422).phrase},
+    },
+)
+def table_data(
+    conn_id: str,
+    table: str,
+    limit: int = Query(default=50, ge=1, le=100),
+    offset: int = Query(default=0, ge=0),
+    run_id: str | None = Query(default=None, min_length=1, max_length=128),
+) -> dict[str, Any]:
+    """Read a current page; a run links the target and scope, never an insert delta."""
+    with _read_errors(), state.connection_operation(conn_id) as conn:
+        target_key, target_label = _target_identity(conn)
+        if run_id is not None:
+            run = get_store().get_run(run_id)
+            if run["target_key"] != target_key:
+                raise HTTPException(
+                    409,
+                    detail={"code": "target_mismatch", "message": "当前连接与运行记录的数据库不一致，请重新选择连接。"},
+                )
+            if table not in {item["name"] for item in run["tables"]}:
+                raise HTTPException(
+                    403, detail={"code": "table_outside_run", "message": "该表不属于这条运行记录的生成范围。"}
+                )
+        conn.orchestrator.get_table_names()  # Ensure the existing adapter is connected.
+        adapter = conn.orchestrator.database_adapter
+        if not isinstance(adapter, SQLAlchemyAdapter):
+            # An unsupported runtime adapter follows the existing RuntimeError API contract.
+            raise RuntimeError("Data browsing requires a SQLAlchemyAdapter connection")  # noqa: TRY004
+        _refresh_inspector(conn, adapter)
+        names = adapter.get_table_names()
+        if table not in names:
+            raise HTTPException(
+                404, detail={"code": "table_not_found", "message": "该表已不存在，请重新读取数据库结构。"}
+            )
+        validate_table_name(table, names)
+        columns = [asdict(column) for column in adapter.get_column_info(table)]
+        order_by = adapter.get_primary_keys(table)
+        rows = _read_rows(adapter, table, order_by, limit, offset)
+        total = adapter.get_row_count(table)
+        result: dict[str, Any] = jsonable_encoder(
+            {
+                "table": table,
+                "target_key": target_key,
+                "target_label": target_label,
+                "dialect": adapter.dialect.name,
+                "columns": columns,
+                "rows": rows,
+                "total": total,
+                "limit": limit,
+                "offset": offset,
+                "order_by": order_by,
+                "read_at": datetime.now(timezone.utc).isoformat(),
+            },
+            custom_encoder={
+                bytes: lambda value: "0x" + value.hex(),
+                memoryview: lambda value: "0x" + value.hex(),
+                Decimal: str,
+                # JSON/browser numbers cannot represent these values faithfully.
+                int: lambda value: str(value) if abs(value) > 2**53 - 1 else value,
+                float: lambda value: str(value) if not math.isfinite(value) else value,
+            },
+        )
+        return result
+
+
+@router.get(
+    "/runs/{run_id}/data-connections",
+    responses={
+        404: {"description": HTTPStatus(404).phrase},
+        409: {"description": HTTPStatus(409).phrase},
+        422: {"description": HTTPStatus(422).phrase},
+    },
+)
+def run_data_connections(run_id: str) -> dict[str, Any]:
+    """Match registered target identities without connecting or reflecting any DB."""
+    with _read_errors():
+        run = get_store().get_run(run_id)
+        connections = []
+        for item in state.list_connections():
+            try:
+                # Registry access takes its short lock. Identity uses immutable
+                # target metadata, so a busy database remains a valid candidate.
+                conn = state.get_connection(item["conn_id"])
+            except UnknownConnectionError:
+                continue
+            target_key, target_label = _target_identity(conn)
+            if target_key == run["target_key"]:
+                connections.append({"conn_id": conn.conn_id, "target_label": target_label})
+        return {"connections": connections, "target_key": run["target_key"], "target_label": run["target_label"]}