Files
openidea/src/features/database/DatabaseView.tsx
T
Budi Santosoandboenkkk 8ddf979cfe feat(db): separate procedures and functions into their own schema folders (#2270)
The database tree lists routines in one `routines` folder. A Separate Procedures and Functions option in the Database tool window's menu (off by default, remembered across sessions) lists `procedures` and `functions` folders instead, each holding only routines of that kind, with the same overload-aware keys and object filter. Expanded folders carry over when the option is switched either way.

Co-authored-by: boenkkk <17746937+boenkkk@users.noreply.github.com>
2026-11-09 18:05:59 +08:00

608 lines
22 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` (optionally `procedures` / `functions`) / `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 { executeAction } from "@/platform/actions";
import { shortcutLabel } from "@/platform/keymap";
import {
Button,
EmptyState,
Icon,
IconButton,
Menu,
SearchField,
Tree,
showContextMenu,
tooltipAttrs,
type TreeHandle,
T,
} from "@/ui";
import {
colorVar,
databaseKey,
passesObjectFilter,
passesTreeFilter,
shownNames,
sourceIcon,
splitTarget,
targetOf,
} from "./model";
import {
nodeTarget,
routineFolder,
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";
import { tx } from "@/platform/i18n";
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",
procedures: "procedures",
functions: "functions",
sequences: "sequences",
};
const FOLDERS: readonly Folder[] = ["tables", "views", "materializedViews", "routines", "sequences"];
const SEPARATE_FOLDERS: readonly Folder[] = [
"tables",
"views",
"materializedViews",
"procedures",
"functions",
"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 folders = st.separateProceduresAndFunctions ? SEPARATE_FOLDERS : FOLDERS;
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],
);
// While a quick filter is on, the schemas of expanded sources load their objects, so
// tables / routines matching the filter show up without expanding every schema node.
useEffect(() => {
if (!st.treeFilter.trim()) return;
const s = useDatabase.getState();
for (const [target, list] of Object.entries(s.schemas)) {
if (list.status !== "ok") continue;
const { id, database } = splitTarget(target);
if (!s.treeExpanded.has(database ? databaseKey(id, database) : id)) continue;
for (const schema of list.value) {
if (!s.tables[tablesKey(target, schema)]) void loadTables(target, schema);
}
}
}, [st.treeFilter, st.treeExpanded, st.schemas]);
/** Schemas tab › Object filter, plus the toolbar's quick 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) && passesTreeFilter(o.name, st.treeFilter);
};
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, after object and quick filtering. */
const folderSize = (id: string, schema: string, folder: Folder): number => {
if (folder === "routines" || folder === "procedures" || folder === "functions")
return routinesOf(id, schema).filter(
(routine) => routineFolder(routine.kind, st.separateProceduresAndFunctions) === folder,
).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);
};
/** Under a quick filter a schema shows when its name matches, or its loaded objects do. */
const schemaVisible = (id: string, schema: string) =>
passesTreeFilter(schema, st.treeFilter) ||
!!tablesOf(id, schema)?.length ||
routinesOf(id, schema).length > 0 ||
sequencesOf(id, schema).length > 0;
const schemasOf = (key: string, id: string) =>
status(key, st.schemas[id], (v) =>
shownSchemas(id, v)
.filter((schema) => schemaVisible(id, schema))
.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" || n.folder === "procedures" || n.folder === "functions")
// Overloads share a name: the key tells them apart by their arguments.
return routinesOf(n.id, n.schema)
.filter((routine) => routineFolder(routine.kind, st.separateProceduresAndFunctions) === n.folder)
.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.pluginOwner ? `${n.source.name} (${n.source.pluginOwner})` : (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}>
<Tree<Node>
aria-label="Data sources"
focusContext={DB_VIEW_FOCUS}
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={tx("Connected")} />}
</span>
)}
<span className={labelClass}>{label(n)}</span>
{n.kind === "source" && n.source.global && (
<span className={styles.treeDetail} title={tx("Available in all projects")}>
{tx("global")}
</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 treeFilter = useDatabase((s) => s.treeFilter);
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={tx("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={tx("Go to DDL")}
disabled={!table}
onClick={() => void executeAction("db.goToDdl")}
{...tooltipAttrs("Go to DDL", shortcutLabel("db.goToDdl"))}
>
<T>DDL</T>
</button>
<SearchField
className={styles.treeFilter}
value={treeFilter}
onChange={(treeFilter) => useDatabase.setState({ treeFilter })}
placeholder={tx("Filter objects")}
aria-label={tx("Filter objects")}
/>
</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} />;
}