Files
openidea/src/features/database/DatabaseView.tsx
T
l0ng-ai 575749f2ac feat(database): Add query plans, history, data tools and schema objects (#63)
New query, data and schema tools for the Database feature (SQLite, PostgreSQL, MySQL).

## Query console
- **Explain Plan** tab: SQLite `EXPLAIN QUERY PLAN`, PostgreSQL `EXPLAIN (FORMAT JSON)`, MySQL `EXPLAIN`, parsed in `ide-db::plan` into an operation tree (Full Scan / Index Scan / Group By / Order By …) under a statement root, with a properties panel.
- **Query history**: `ide-db::history` keeps executed statements per project and source in `db-history.json` (deduplicated, newest first, 500 max). The Browse Query History dialog has search, a highlighted preview, Paste and Delete.
- Output reports `(execution: X ms, fetching: Y ms)`.

## Results and table editor
- Local column filter (value list with counts) and local sort.
- Record / Value / Aggregates side panel.
- Chart view (bar / line) with X / Y / aggregation settings.
- Export Data dialog: extractor, Transpose, headers, preview, file or clipboard. An extractor drop-down sits on the data toolbars.
- Import Data from a CSV / TSV file.
- Table editor gets a WHERE | ORDER BY row. Column headers fit their names, with filter and sort indicators. Whole SQLite REALs display as `3108`, not `3108.0`.

## Database tree
- Triggers under tables. Routines, sequences and materialized views under schemas, with DDL, Quick Documentation and Drop.
- Data source options: object filter, show template databases, single database mode (PostgreSQL).
- New ▸ Import from Clipboard (connection URLs).

## IPC
New commands: `db_schema_objects`, `db_object_ddl`, `db_explain`, `db_history`, `db_remove_history`. Bindings are regenerated.

## Testing
- `cargo test -p ide-db`: plan parsing, history store, trigger listing and DDL, explain without executing.
- `cargo clippy -p ide-db -p openidea --all-targets -- -D warnings` is clean.
- `pnpm typecheck` and eslint pass. `pnpm vitest run src/features/database src/ui`: 226 passed.
- Checked in the running app against a SQLite database:
  - tree with triggers
  - result grid, local filter, side panel
  - chart
  - Explain Plan
  - history dialog
  - Export Data dialog
  - table editor ORDER BY
  - CSV import




Merge follow-up: grouped the new `--chart-series` token under a section comment and added it to the theme plugin template (theme.test.ts on main), regenerated docs/plugins/themes.md. Re-verified after merging main on macOS with a SQLite source: query + result grid with filter/sort headers, Explain Plan tab (Full Scan / Index Scan / Group By / Order By), Query History dialog; `cargo nextest run -p ide-db` 45 passed, bindings unchanged after regeneration.

https://claude.ai/code/session_01VUYsdXA2nkF5v6zsC93dpn
2026-10-27 13:31:29 +08:00

538 lines
20 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/**
* Database tool window (IDEA's layout): data source → database (PostgreSQL) → schema → `tables` /
* `views` / `materialized views` / `routines` / `sequences` folders → table → `columns` / `keys` /
* `foreign keys` / `indexes` / `triggers`,
* with counts and column types, loaded lazily. Double-click a table to open its data, a data
* source to open its query console.
*/
import { useEffect, useMemo, useRef, type CSSProperties } from "react";
import type { DbDatabases, DbTableDetails } from "@/platform/ipc";
import { setContext } from "@/platform/context";
import { executeAction } from "@/platform/actions";
import { shortcutLabel } from "@/platform/keymap";
import {
Button,
EmptyState,
Icon,
IconButton,
Menu,
Tree,
showContextMenu,
tooltipAttrs,
type TreeHandle,
T,
} from "@/ui";
import { colorVar, databaseKey, passesObjectFilter, shownNames, sourceIcon, splitTarget, targetOf } from "./model";
import { nodeTarget, schemaObjectOf, tableFolder, type DbNode as Node, type Folder, type Group } from "./nodes";
import {
connect,
detailsKey,
listsDatabases,
loadDatabases,
loadDetails,
loadSchemas,
loadSources,
loadTables,
openConsole,
openObjectDdl,
tablesKey,
useDatabase,
type Loaded,
} from "./store";
import { DB_VIEW_FOCUS, openTableData } from "./treeActions";
import { newMenu, nodeMenu } from "./treeMenu";
import styles from "./Database.module.css";
const GROUP_LABELS: Record<Group, string> = {
columns: "columns",
keys: "keys",
foreignKeys: "foreign keys",
indexes: "indexes",
triggers: "triggers",
};
const FOLDER_LABELS: Record<Folder, string> = {
tables: "tables",
views: "views",
materializedViews: "materialized views",
routines: "routines",
sequences: "sequences",
};
const FOLDERS: readonly Folder[] = ["tables", "views", "materializedViews", "routines", "sequences"];
function status<T>(key: string, l: Loaded<T> | undefined, map: (v: T) => Node[]): Node[] | undefined {
if (!l) return undefined;
if (l.status === "loading") return undefined;
if (l.status === "error") return [{ kind: "message", key: `${key}/err`, text: l.message, error: true }];
const nodes = map(l.value);
return nodes.length ? nodes : [{ kind: "message", key: `${key}/empty`, text: "Empty" }];
}
const primaryKey = (d: DbTableDetails) => d.columns.filter((c) => c.primaryKey).map((c) => c.name);
/** Rows under a table: IDEA's columns / keys / foreign keys / indexes folders (empty ones left out). */
function groupsOf(d: DbTableDetails): Group[] {
const g: Group[] = ["columns"];
if (primaryKey(d).length) g.push("keys");
if (d.foreignKeys.length) g.push("foreignKeys");
if (d.indexes.length) g.push("indexes");
if (d.triggers.length) g.push("triggers");
return g;
}
function groupSize(d: DbTableDetails, g: Group): number {
if (g === "columns") return d.columns.length;
if (g === "keys") return primaryKey(d).length ? 1 : 0;
if (g === "foreignKeys") return d.foreignKeys.length;
if (g === "triggers") return d.triggers.length;
return d.indexes.length;
}
export function DatabaseView() {
const st = useDatabase();
const tree = useRef<TreeHandle>(null);
useEffect(() => {
if (!st.loaded) void loadSources();
}, [st.loaded]);
// Go to Declaration from a console: the rows exist once the expanded nodes render.
useEffect(() => {
if (!st.treeReveal) return;
const key = st.treeReveal.key;
const frame = requestAnimationFrame(() => {
tree.current?.reveal(key);
tree.current?.focus();
});
return () => cancelAnimationFrame(frame);
}, [st.treeReveal]);
const roots = useMemo<Node[]>(
() => st.sources.map((source) => ({ kind: "source", key: source.id ?? "", source })),
[st.sources],
);
/** Schemas tab › Object filter of the data source of target `id`. */
const shown = (id: string) => {
const filter = sourceOf(id)?.introspection?.objectFilter;
return (o: { name: string }) => passesObjectFilter(o.name, filter);
};
const tablesOf = (id: string, schema: string) => {
const t = st.tables[tablesKey(id, schema)];
return t?.status === "ok" ? t.value.filter(shown(id)) : null;
};
const routinesOf = (id: string, schema: string) =>
(st.objects[tablesKey(id, schema)]?.routines ?? []).filter(shown(id));
const sequencesOf = (id: string, schema: string) =>
(st.objects[tablesKey(id, schema)]?.sequences ?? []).filter(shown(id));
/** Members of a schema folder: tables / views / materialized views, routines or sequences. */
const folderSize = (id: string, schema: string, folder: Folder): number => {
if (folder === "routines") return routinesOf(id, schema).length;
if (folder === "sequences") return sequencesOf(id, schema).length;
return (tablesOf(id, schema) ?? []).filter((t) => tableFolder(t.kind) === folder).length;
};
const detailsOf = (id: string, schema: string, table: string) => {
const d = st.details[detailsKey(id, schema, table)];
return d?.status === "ok" ? d.value : null;
};
const sourceOf = (target: string) => st.sources.find((s) => s.id === splitTarget(target).id);
/** The Schemas tab's choice. */
const shownSchemas = (target: string, names: string[]) => {
const i = sourceOf(target)?.introspection;
return shownNames(names, i?.allSchemas, i?.schemas);
};
const shownDatabases = (id: string, v: DbDatabases) => {
const i = sourceOf(id)?.introspection;
return shownNames(v.names, i?.allDatabases, i?.databases, v.current);
};
const schemasOf = (key: string, id: string) =>
status(key, st.schemas[id], (v) =>
shownSchemas(id, v).map((schema) => ({ kind: "schema", key: `${id}/${schema}`, id, schema }) as Node),
);
const children = (n: Node): readonly Node[] | undefined => {
switch (n.kind) {
case "source": {
const id = n.source.id ?? "";
if (listsDatabases(n.source))
return status(n.key, st.databases[id], (v) =>
shownDatabases(id, v).map((name) => ({
kind: "database",
key: databaseKey(id, name),
id: targetOf(id, name, v.current),
name,
current: name === v.current,
})),
);
return schemasOf(n.key, id);
}
case "database":
return schemasOf(n.key, n.id);
case "schema":
return status(n.key, st.tables[tablesKey(n.id, n.schema)], () =>
FOLDERS.filter((f) => folderSize(n.id, n.schema, f) > 0).map((folder): Node => ({
kind: "folder",
key: `${n.key}/${folder}`,
id: n.id,
schema: n.schema,
folder,
})),
);
case "folder": {
const at = { id: n.id, schema: n.schema };
if (n.folder === "routines")
// Overloads share a name: the key tells them apart by their arguments.
return routinesOf(n.id, n.schema).map((routine) => ({
kind: "routine",
key: `${n.key}/${routine.name}(${routine.arguments})`,
routine,
...at,
}));
if (n.folder === "sequences")
return sequencesOf(n.id, n.schema).map((sequence) => ({
kind: "sequence",
key: `${n.key}/${sequence.name}`,
sequence,
...at,
}));
return (tablesOf(n.id, n.schema) ?? [])
.filter((t) => tableFolder(t.kind) === n.folder)
.map((table) => ({ kind: "table", key: `${n.key}/${table.name}`, table, ...at }));
}
case "table": {
const d = st.details[detailsKey(n.id, n.schema, n.table.name)];
if (!d || d.status === "loading") return undefined;
if (d.status === "error") return [{ kind: "message", key: `${n.key}/err`, text: d.message, error: true }];
return groupsOf(d.value).map((group) => ({
kind: "group",
key: `${n.key}/${group}`,
id: n.id,
schema: n.schema,
table: n.table.name,
group,
}));
}
case "group": {
const d = detailsOf(n.id, n.schema, n.table);
if (!d) return undefined;
const fkCols = new Set(d.foreignKeys.flatMap((k) => k.columns));
const at = { id: n.id, schema: n.schema, table: n.table };
switch (n.group) {
case "columns":
return d.columns.map((column) => ({
kind: "column",
key: `${n.key}/${column.name}`,
column,
foreignKey: fkCols.has(column.name),
...at,
}));
case "keys":
return [{ kind: "key", key: `${n.key}/pk`, columns: primaryKey(d), ...at }];
case "foreignKeys":
return d.foreignKeys.map((fk, i) => ({ kind: "foreignKey", key: `${n.key}/${i}`, fk, ...at }));
case "indexes":
return d.indexes.map((index) => ({ kind: "index", key: `${n.key}/${index.name}`, index, ...at }));
case "triggers":
return d.triggers.map((trigger) => ({ kind: "trigger", key: `${n.key}/${trigger.name}`, trigger, ...at }));
}
return undefined;
}
default:
return undefined;
}
};
const load = async (n: Node) => {
if (n.kind === "source") {
const id = n.source.id ?? "";
if (!(await connect(id))) return;
if (listsDatabases(n.source)) await loadDatabases(id);
else await loadSchemas(id);
} else if (n.kind === "database") {
if (await connect(n.id)) await loadSchemas(n.id);
} else if (n.kind === "schema") await loadTables(n.id, n.schema);
else if (n.kind === "table") await loadDetails(n.id, n.schema, n.table.name);
};
const label = (n: Node): string => {
switch (n.kind) {
case "source":
return n.source.name ?? "";
case "database":
return n.name;
case "schema":
return n.schema;
case "folder":
return FOLDER_LABELS[n.folder];
case "routine":
return n.routine.name;
case "sequence":
return n.sequence.name;
case "trigger":
return n.trigger.name;
case "table":
return n.table.name;
case "group":
return GROUP_LABELS[n.group];
case "column":
return n.column.name;
// Unnamed (SQLite) keys are numbered like IDEA's `key #1` / `foreign-key #1`.
case "key":
return "key #1";
case "foreignKey":
return `foreign-key #${Number(n.key.slice(n.key.lastIndexOf("/") + 1)) + 1}`;
case "index":
return n.index.name;
case "message":
return n.text;
}
};
/** Grey text after the label: counts, column types, key columns. */
const detail = (n: Node): string | undefined => {
switch (n.kind) {
case "source": {
const id = n.source.id ?? "";
if (listsDatabases(n.source)) {
const d = st.databases[id];
return d?.status === "ok" ? String(shownDatabases(id, d.value).length) : undefined;
}
const s = st.schemas[id];
return s?.status === "ok" ? String(shownSchemas(id, s.value).length) : undefined;
}
case "database": {
const s = st.schemas[n.id];
return s?.status === "ok" ? String(shownSchemas(n.id, s.value).length) : undefined;
}
case "folder":
return String(folderSize(n.id, n.schema, n.folder));
case "routine":
return `(${n.routine.arguments})${n.routine.returns ? `: ${n.routine.returns}` : ""}`;
case "sequence":
return n.sequence.dataType;
case "trigger":
return `${n.trigger.timing} ${n.trigger.events}`.trim();
case "group": {
const d = detailsOf(n.id, n.schema, n.table);
return d ? String(groupSize(d, n.group)) : undefined;
}
case "column":
return n.column.dataType;
case "key":
return `(${n.columns.join(", ")})`;
case "foreignKey":
return `(${n.fk.columns.join(", ")}) → ${n.fk.refTable} (${n.fk.refColumns.join(", ")})`;
case "index":
return `${n.index.unique ? "unique " : ""}(${n.index.columns.join(", ")})`;
default:
return undefined;
}
};
const icon = (n: Node): string | undefined => {
switch (n.kind) {
case "source":
return sourceIcon(n.source);
case "database":
return "database";
case "schema":
return "db-schema";
case "folder":
case "group":
return "db-folder";
case "table":
return n.table.kind === "view" ? "db-view" : n.table.kind === "materializedView" ? "db-matview" : "db-table";
case "routine":
return "db-routine";
case "sequence":
return "db-sequence";
case "trigger":
return "db-trigger";
case "column":
return n.column.primaryKey ? "db-column-key" : n.foreignKey ? "db-column-fk" : "db-column";
case "key":
return "db-key";
case "foreignKey":
return "db-foreign-key";
case "index":
return "db-index";
case "message":
return n.error ? "error" : undefined;
}
};
if (st.loaded && !st.sources.length)
return (
<div className={styles.dbView}>
<DatabaseToolbar />
<EmptyState title="No data sources">
<Button variant="ghost" onClick={() => void executeAction("db.newDataSource")}>
<T>New Data Source…</T>
</Button>
</EmptyState>
</div>
);
return (
<div className={styles.dbView}>
<DatabaseToolbar />
<div
className={styles.treeHost}
onFocus={(e) => setContext(DB_VIEW_FOCUS, (e.target as HTMLElement).getAttribute("role") === "tree")}
onBlur={() => setContext(DB_VIEW_FOCUS, false)}
>
<Tree<Node>
aria-label="Data sources"
roots={roots}
handleRef={tree}
expanded={st.treeExpanded}
onExpandedChange={(treeExpanded) => useDatabase.setState({ treeExpanded })}
getKey={(n) => n.key}
getLabel={label}
getChildren={children}
isExpandable={(n) =>
n.kind === "source" ||
n.kind === "database" ||
n.kind === "schema" ||
n.kind === "folder" ||
n.kind === "table" ||
n.kind === "group"
}
loadChildren={load}
getIcon={(n) => icon(n)}
getDetail={detail}
getColor={(n) => (n.kind === "message" && n.error ? "var(--danger)" : undefined)}
renderNode={(n: Node) => {
const i = icon(n);
const d = detail(n);
const counted = n.kind === "source" || n.kind === "database" || n.kind === "folder" || n.kind === "group";
const labelClass =
n.kind === "message" && n.error
? styles.treeError
: n.kind === "key" || n.kind === "foreignKey"
? styles.keyLabel
: styles.nodeLabel;
const live = n.kind === "source" && [...st.connected].some((t) => splitTarget(t).id === n.source.id);
const target = nodeTarget(n);
// IDEA tints every row of a coloured data source.
const tint = colorVar(target ? sourceOf(target)?.color : null);
return (
<span
className={tint ? `${styles.nodeRow} ${styles.tinted}` : styles.nodeRow}
style={tint ? ({ "--db-tint": tint } as CSSProperties) : undefined}
title={n.kind === "source" && n.source.comment ? n.source.comment : undefined}
>
{i && (
<span className={styles.nodeIcon}>
<Icon name={i} size={16} />
{/* IDEA: a green dot on the data source icon while connected. */}
{live && <span className={styles.connectedDot} title="Connected" />}
</span>
)}
<span className={labelClass}>{label(n)}</span>
{d && (
<span
className={
n.kind === "source"
? styles.treeBadge
: counted
? styles.treeCount
: n.kind === "column"
? styles.treeType
: styles.treeDetail
}
>
{d}
</span>
)}
</span>
);
}}
onSelectionChange={(_, lead) =>
useDatabase.setState({ selectedSource: lead ? nodeTarget(lead) : null, selectedNode: lead })
}
onActivate={(n) => {
if (n.kind === "table") openTableData(n.id, n.schema, n.table.name);
else if (n.kind === "source") void openConsole(n.source.id ?? "");
else if (n.kind === "database") void openConsole(n.id);
else {
const o = schemaObjectOf(n);
if (o) void openObjectDdl(o.id, o.schema, o.kind, o.name);
}
}}
activateExpandable={(n) => n.kind === "table"}
onContextMenu={(n, _sel, e) => {
const items = nodeMenu(n);
if (items.length) showContextMenu(e, items);
}}
speedSearch
/>
</div>
</div>
);
}
/**
* The toolbar row of IDEA's Database tool window, always shown under the
* title: New ▸, Properties | Refresh, Deactivate | Jump to Query Console,
* Edit Data, DDL.
*/
function DatabaseToolbar() {
const node = useDatabase((s) => s.selectedNode);
const connected = useDatabase((s) => s.connected);
const sources = useDatabase((s) => s.sources);
const plus = useRef<HTMLButtonElement>(null);
const newOpen = useDatabase((s) => s.newMenuOpen);
const setNewOpen = (v: boolean) => useDatabase.setState({ newMenuOpen: v });
const table = node?.kind === "table" || node?.kind === "column" || node?.kind === "group";
const target = node ? nodeTarget(node) : sources.length === 1 ? (sources[0]!.id ?? null) : null;
const active = !!target && [...connected].some((t) => splitTarget(t).id === splitTarget(target).id);
const button = { size: "small", iconSize: 16 } as const;
return (
<div className={styles.dbToolbar} role="toolbar" aria-label="Database actions">
<IconButton
ref={plus}
{...button}
icon="db-add"
title="New"
shortcut={shortcutLabel("db.new")}
aria-haspopup="menu"
aria-expanded={newOpen}
onClick={() => setNewOpen(!newOpen)}
/>
<Menu
open={newOpen}
anchor={plus}
items={newMenu()}
placement="bottom-start"
onClose={() => setNewOpen(false)}
aria-label="New"
/>
<IconButton {...button} icon="db-properties" action="db.properties" disabled={!sources.length} />
<span className={styles.dbToolbarSep} />
<IconButton {...button} icon="refresh" action="db.refresh" disabled={!sources.length} />
<IconButton {...button} icon="db-disconnect" action="db.disconnect" disabled={node ? !active : !connected.size} />
<span className={styles.dbToolbarSep} />
<IconButton {...button} icon="db-console" action="db.jumpToConsole" disabled={!target} />
<IconButton {...button} icon="db-table" action="db.editData" disabled={!table} />
{/* IDEA labels this one with text. */}
<button
type="button"
className={styles.textTool}
aria-label="Go to DDL"
disabled={!table}
onClick={() => void executeAction("db.goToDdl")}
{...tooltipAttrs("Go to DDL", shortcutLabel("db.goToDdl"))}
>
<T>DDL</T>
</button>
</div>
);
}
/** Header controls (shown on hover, like IDEA's): Collapse All. */
export function DatabaseHeaderActions() {
return <IconButton icon="collapse-all" action="db.collapseAll" size="small" iconSize={16} />;
}