The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
/**
* Database Console service view (IDEA's): an Output tab logging every
* executed statement with its outcome, and a `Result N` tab per result set —
* a toolbar (re-run, export / copy as CSV, JSON, SQL…), the grid and a floating row count.
*/
import { copySelectionOnKeyDown } from "@/ui/selectableText";
import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
import clsx from "clsx";
import { call, commands, type DbPlanNode, type DbQueryResult } from "@/platform/ipc";
import { shortcutLabel } from "@/platform/keymap";
import {
Button,
EmptyState,
Icon,
IconButton,
Select,
Spinner,
Tabs,
Tree,
showContextMenu,
T,
tooltipAttrs,
} from "@/ui";
import { notifications } from "@/workbench/contributions";
import { ChartView } from "./ChartView";
import { ColumnsPopup } from "./ColumnsPopup";
import { DataView, ExtractorSelect, PanelToggle, copyFormatOf, exportMenu, type DataPanel } from "./DataView";
import type { ExportData, ExportFormat } from "./export";
import { buildRowEdits, emptyEdits, hasEdits, splitTarget, type Cell, type PendingEdits } from "./model";
import {
editStatements,
pkResultColumns,
resultColumnSources,
resultEditability,
resolveTarget,
type EditBlockReason,
} from "./resultEditing";
import { pageWindow } from "./resultView";
import { analyze } from "./sql/analyze";
import { nameMatcher } from "./sql/dialect";
import {
OUTPUT_TAB,
clearOutput,
closeResult,
countResult,
countable,
detailsKey,
loadDetails,
loadResultPage,
log,
outcomeSummary,
pageable,
rerunResult,
targetLabel,
useDatabase,
withConnection,
type OutputLine,
type ResultTab,
} from "./store";
import styles from "./Database.module.css";
import { registerTableEditor, tableEditorChanged, type TableEditorHandle } from "./tableEditorFocus";
import { tx } from "@/platform/i18n";
function time(t: number): string {
const d = new Date(t);
const p = (n: number, w = 2) => String(n).padStart(w, "0");
return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}:${p(d.getSeconds())}`;
}
function Output() {
const lines = useDatabase((s) => s.output);
const ref = useRef<HTMLDivElement>(null);
useEffect(() => {
const el = ref.current;
if (el) el.scrollTop = el.scrollHeight;
}, [lines.length]);
return (
<div className={styles.view}>
<div className={styles.toolbar}>
<span className={styles.spacer} />
<IconButton icon="trash" title="Clear All" disabled={!lines.length} onClick={clearOutput} />
</div>
<div
ref={ref}
className={styles.output}
tabIndex={0}
onKeyDown={copySelectionOnKeyDown}
role="log"
aria-label={tx("Database output")}
>
{lines.map((l: OutputLine) => (
<div key={l.id} className={clsx(styles.outputLine, l.kind === "error" && styles.outputError)}>
<span className={styles.outputTime}>[{time(l.time)}]</span>{" "}
{l.prompt && <span className={styles.outputPrompt}>{l.prompt} </span>}
<span className={l.kind === "statement" ? styles.outputStatement : undefined}>{l.text}</span>
</div>
))}
</div>
</div>
);
}
/** The table a query reads (target of exported SQL inserts), else IDEA's placeholder. */
function queryTable(text: string, data: Pick<ExportData, "driver">): string {
const a = analyze(text, text.length, data.driver);
return a.refs.find((r) => r.depth === 0 && r.kind === "table")?.name ?? "MY_TABLE";
}
const PAGE_SIZES = [10, 100, 500, 1000];
/** Why a result's grid is read-only, as the issue's examples put it. */
function readonlyNotice(reason: EditBlockReason): string {
switch (reason) {
case "joined":
return tx("Read-only: the query joins several tables.");
case "aggregated":
return tx("Read-only: the result is aggregated (DISTINCT, GROUP BY or an aggregate function).");
case "setOp":
return tx("Read-only: the result combines several queries (UNION / INTERSECT / EXCEPT).");
case "plain":
return tx("Read-only: the result is not a plain select from a single table.");
}
}
/** IDEA's pager at the bottom of a result: |< < 1-500 of 501+ > >| and the page size; paging runs the query again. */
function Pager({ tab }: { tab: ResultTab }) {
const r = tab.outcome.result!;
const page = tab.page ?? 0;
const pageSize = tab.pageSize ?? Math.max(r.rows.length, 1);
const state = { page, pageSize, rows: r.rows.length, hasMore: r.hasMore, total: tab.total ?? null };
const w = pageWindow(state);
const canPage = pageable(tab) && !tab.busy;
const go = (p: number, size = pageSize) => void loadResultPage(tab.id, p, size);
const goLast = async () => {
let lastPage = w.lastPage;
if (lastPage === null) {
const total = await countResult(tab.id);
if (total === null) return;
lastPage = pageWindow({ ...state, total }).lastPage;
}
if (lastPage !== null && lastPage !== page) go(lastPage);
};
const { first, last } = w;
const total = w.total === null ? `${w.last + 1}+` : String(w.total);
const sizes = PAGE_SIZES.includes(pageSize) ? PAGE_SIZES : [...PAGE_SIZES, pageSize].sort((a, b) => a - b);
return (
<div
className={styles.resultPager}
role="toolbar"
aria-label={tx("Result pages")}
title={outcomeSummary(tab.outcome)}
>
<IconButton
icon="page-first"
title="First Page"
size="small"
disabled={!canPage || page === 0}
onClick={() => go(0)}
/>
<IconButton
icon="chevron-left"
title="Previous Page"
size="small"
disabled={!canPage || page === 0}
onClick={() => go(page - 1)}
/>
<button
type="button"
className={clsx(styles.resultPagerRange, styles.resultPagerCount)}
disabled={w.total !== null || !canPage || !countable(tab)}
title={w.total === null ? tx("Count rows") : undefined}
onClick={() => void countResult(tab.id)}
>
{tx`${first}-${last} of ${total}`}
</button>
<IconButton
icon="chevron-right"
title="Next Page"
size="small"
disabled={!canPage || !r.hasMore}
onClick={() => go(page + 1)}
/>
<IconButton
icon="page-last"
title="Last Page"
size="small"
disabled={!canPage || (!r.hasMore && w.total !== null) || (w.total === null && !countable(tab))}
onClick={() => void goLast()}
/>
<Select
aria-label="Page size"
value={String(pageSize)}
options={sizes.map((v) => ({ value: String(v), label: String(v) }))}
onChange={(v) => go(0, Number(v))}
disabled={!canPage}
/>
</div>
);
}
function Result({ tab }: { tab: ResultTab }) {
const [view, setView] = useState<"table" | "chart">("table");
const [panel, setPanel] = useState<DataPanel | null>(null);
const [searchOpen, setSearchOpen] = useState(false);
const [extractor, setExtractor] = useState<ExportFormat>("csv");
const r = tab.outcome.result;
const columns = useMemo(() => (r ? r.columns.map((c) => ({ name: c.name, type: c.typeName })) : []), [r]);
const source = useDatabase((s) => s.sources.find((source) => source.id === splitTarget(tab.sourceId).id));
const driver = source?.driver ?? "sqlite";
// Editing a result in place (like DataGrip): only a plain select of one base
// table, carrying the table's primary key, on a writable data source.
const text = tab.outcome.statement.text;
const editability = useMemo(() => resultEditability(text, driver), [text, driver]);
const model = useDatabase((s) => s.completion[tab.sourceId]) ?? null;
const target = useMemo(
() => (editability.kind === "editable" ? resolveTarget(editability, model, tab.schema, driver) : null),
[editability, model, tab.schema, driver],
);
const detailsId = target ? detailsKey(tab.sourceId, target.schema ?? "", target.table) : null;
const details = useDatabase((s) => (detailsId ? s.details[detailsId] : undefined));
const detailsValue = details?.status === "ok" ? details.value : null;
useEffect(() => {
// Only when never loaded: a failed fetch must not retry on every state change.
if (target && !details) void loadDetails(tab.sourceId, target.schema ?? "", target.table);
}, [target, details, tab.sourceId]);
const resultNames = useMemo(() => r?.columns.map((c) => c.name) ?? [], [r]);
const eq = useMemo(
() =>
driver === "postgres" || driver === "oracle" || driver === "sqlServer"
? (a: string | null | undefined, b: string | null | undefined) => !!a && a === b
: nameMatcher(driver),
[driver],
);
const sources = useMemo(
() =>
editability.kind === "editable"
? resultColumnSources(editability.items, resultNames, detailsValue?.columns.map((c) => c.name) ?? null, eq)
: [],
[editability, resultNames, detailsValue, eq],
);
const pk = useMemo(() => {
if (!detailsValue) return null;
return pkResultColumns(
detailsValue.columns.filter((c) => c.primaryKey).map((c) => c.name),
sources,
resultNames,
eq,
);
}, [detailsValue, sources, resultNames, eq]);
// Nullability and defaults follow the table's details once they load (they gate Set NULL / Set DEFAULT).
const gridColumns = useMemo(
() =>
columns.map((c) => {
const d = detailsValue?.columns.find((x) => eq(x.name, c.name));
return {
...c,
type: d?.dataType ?? c.type,
primaryKey: !!pk?.includes(c.name),
nullable: d?.nullable,
default: d?.default ?? null,
};
}),
[columns, pk, detailsValue, eq],
);
const readOnlySource = source?.readOnly ?? false;
const editable =
editability.kind === "editable" &&
!!target &&
!!pk &&
!readOnlySource &&
driver !== "clickhouse" &&
sources.some((s) => s !== null);
// The pending edits belong to the result they were made on: fresh rows (a
// re-run, another page) start over, without an effect.
const [pending, setPending] = useState<{ outcome: DbQueryResult | null; edits: PendingEdits }>({
outcome: null,
edits: emptyEdits(),
});
const edits = pending.outcome === r ? pending.edits : emptyEdits();
const setEdits = (f: (e: PendingEdits) => PendingEdits) =>
setPending((previous) => ({ outcome: r, edits: f(previous.outcome === r ? previous.edits : emptyEdits()) }));
const loaded = r?.rows.length ?? 0;
const rowCount = loaded + edits.inserts.length;
const value = useCallback(
(row: number, col: number): Cell => {
const name = resultNames[col]!;
if (row >= loaded) return edits.inserts[row - loaded]?.get(name) ?? null;
const upd = edits.updates.get(row);
if (upd?.has(name)) return upd.get(name)!;
return r?.rows[row]?.[col] ?? null;
},
[r, resultNames, loaded, edits],
);
const onEdit = (row: number, col: number, v: Cell) => {
if (!editable || busy || !sources[col]) return; // an aliased or computed column
const name = resultNames[col]!;
setEdits((e) => {
const next: PendingEdits = { updates: new Map(e.updates), deletes: new Set(e.deletes), inserts: [...e.inserts] };
if (row >= loaded) {
const ins = new Map(next.inserts[row - loaded]);
ins.set(name, v);
next.inserts[row - loaded] = ins;
} else {
const upd = new Map(next.updates.get(row));
if ((r?.rows[row]?.[col] ?? null) === v) upd.delete(name);
else upd.set(name, v);
if (upd.size) next.updates.set(row, upd);
else next.updates.delete(row);
}
return next;
});
};
const onResetCell = (row: number, col: number) => {
setEdits((e) => {
const inserts = [...e.inserts];
const ins = new Map(inserts[row - loaded]);
ins.delete(resultNames[col]!);
inserts[row - loaded] = ins;
return { ...e, inserts };
});
};
const deleteRows = (rows: number[]) =>
setEdits((e) => {
const deletes = new Set(e.deletes);
const insertsGone = new Set(rows.filter((row) => row >= loaded).map((row) => row - loaded));
for (const row of rows) if (row < loaded) deletes.add(row);
return { ...e, deletes, inserts: e.inserts.filter((_, i) => !insertsGone.has(i)) };
});
const dirty = hasEdits(edits);
const [submitting, setSubmitting] = useState(false);
const submitGuard = useRef(false);
const busy = submitting || !!tab.busy;
const submit = async () => {
if (!r || !target || !pk || !editable || busy || submitGuard.current) return;
submitGuard.current = true;
setSubmitting(true);
const list = buildRowEdits(resultNames, r.rows, pk, edits);
try {
// The Output log shows what the submit is about to change.
for (const s of editStatements(driver, target.schema ?? "", target.table, list)) log("statement", s);
const n = await withConnection(tab.sourceId, () =>
call(commands.dbApplyEdits(tab.sourceId, target.schema ?? "", target.table, list)),
);
log("result", `${target.table}: ${n} row(s) changed`);
notifications().notify({ level: "info", title: `${target.table}: ${n} row(s) changed`, key: "db-submit" });
setEdits(() => emptyEdits());
await rerunResult(tab.id);
} catch (e) {
log("error", e instanceof Error ? e.message : String(e));
notifications().notify({
level: "error",
title: "Changes were not submitted",
body: e instanceof Error ? e.message : String(e),
key: "db-submit",
});
} finally {
submitGuard.current = false;
setSubmitting(false);
}
};
// Submit / Revert / Go to Column (⌘↩ / ⌥⌘Z / ⌘F12) reach the latest state through the handle, as in the table editor.
const canSubmit = editable && dirty && !busy;
const viewRef = useRef<HTMLDivElement>(null);
const handleRef = useRef<TableEditorHandle>({
dirty: false,
submit: () => {},
revert: () => {},
showColumns: () => {},
});
const [columnsAt, setColumnsAt] = useState<{ x: number; y: number } | null>(null);
const [revealColumn, setRevealColumn] = useState<{ col: number } | null>(null);
useLayoutEffect(() => {
const handle = handleRef.current;
handle.dirty = canSubmit;
handle.submit = () => {
if (canSubmit) void submit();
};
handle.revert = () => {
if (!busy) setEdits(() => emptyEdits());
};
handle.showColumns = () => {
const rect = viewRef.current?.getBoundingClientRect();
if (view === "table" && rect) setColumnsAt({ x: rect.left + rect.width / 2, y: rect.top + 48 });
};
tableEditorChanged(handle);
});
const hasResult = !!r;
useEffect(
() => (hasResult && viewRef.current ? registerTableEditor(viewRef.current, handleRef.current) : undefined),
[hasResult],
);
if (!r) return null;
const data = (): ExportData => ({
columns,
rows: r.rows,
driver,
table: queryTable(text, { driver }),
});
const tableLabel = target ? `${target.schema ? `${target.schema}.` : ""}${target.table}` : "";
const tablePkCount = detailsValue?.columns.filter((c) => c.primaryKey).length ?? 0;
let notice: string | null = null;
if (!editable) {
if (driver === "clickhouse") notice = tx("Use the query console to change ClickHouse data.");
else if (readOnlySource) notice = tx("Read-only data source.");
else if (editability.kind === "readonly") notice = readonlyNotice(editability.reason);
else if (!target) notice = tx("Read-only: the table schema could not be identified in the result database.");
else if (details?.status === "error" || (detailsValue && tablePkCount > 0))
// The result exists but doesn't carry every key column (or the keys are unknown).
notice = tx`Read-only: the result has no primary key of ${tableLabel}.`;
else if (detailsValue) notice = tx("Read-only: the table has no primary key to identify rows.");
// else: the table's details are still loading.
}
return (
<div className={styles.view} ref={viewRef} data-db-table-editor="">
<div className={styles.toolbar}>
<IconButton icon="db-table" title="Table" aria-pressed={view === "table"} onClick={() => setView("table")} />
<IconButton icon="db-chart" title="Chart" aria-pressed={view === "chart"} onClick={() => setView("chart")} />
<span className={styles.toolbarSeparator} />
<IconButton icon="refresh" title="Rerun Query" disabled={busy} onClick={() => void rerunResult(tab.id)} />
{view === "table" && (
<IconButton
icon="search"
title="Search"
shortcut={shortcutLabel("find.inFile")}
aria-pressed={searchOpen}
onClick={() => setSearchOpen(!searchOpen)}
/>
)}
{editable && (
<>
<IconButton
icon="plus"
title="Add Row"
disabled={busy}
onClick={() => setEdits((e) => ({ ...e, inserts: [...e.inserts, new Map()] }))}
/>
<Button
size="small"
variant="primary"
disabled={!dirty || busy}
onClick={() => void submit()}
{...tooltipAttrs("Submit", shortcutLabel("db.submitChanges"))}
>
<T>Submit</T>
</Button>
<Button
size="small"
disabled={!dirty || busy}
onClick={() => setEdits(() => emptyEdits())}
{...tooltipAttrs("Revert", shortcutLabel("db.revertChanges"))}
>
<T>Revert</T>
</Button>
</>
)}
{tab.busy && <Spinner size={12} />}
<span className={styles.spacer} />
<span className={styles.resultSource} title={tab.outcome.statement.text}>
{targetLabel(tab.sourceId)}
</span>
<ExtractorSelect value={extractor} onChange={setExtractor} />
<IconButton
icon="export"
title="Export Data"
onClick={(e) => showContextMenu(e, exportMenu(data(), queryTable(text, { driver }), extractor))}
/>
{view === "table" && <PanelToggle panel={panel} onChange={setPanel} />}
</div>
{view === "chart" ? (
<div className={styles.fill}>
<ChartView columns={columns} rows={r.rows} />
</div>
) : (
<>
{notice && (
<div className={styles.notice} role="note">
{notice}
</div>
)}
<div className={clsx(styles.fill, styles.gridHost)}>
<DataView
columns={gridColumns}
rowCount={rowCount}
fixedRows={loaded}
driver={driver}
value={value}
panel={panel}
onPanelChange={setPanel}
copyFormat={copyFormatOf(extractor)}
searchOpen={searchOpen}
onSearchOpenChange={setSearchOpen}
firstRowNumber={(tab.page ?? 0) * (tab.pageSize ?? 0) + 1}
aria-label={tab.title}
rowState={(row) => (row >= loaded ? "inserted" : edits.deletes.has(row) ? "deleted" : null)}
isModified={(row, col) => !!edits.updates.get(row)?.has(resultNames[col]!)}
editable={editable && !busy}
onEdit={onEdit}
onResetCell={onResetCell}
revealColumn={revealColumn}
rowMenu={(rows) =>
editable && !busy
? [
{ label: "Delete Rows", icon: "trash", run: () => deleteRows(rows) },
{
label: "Restore Rows",
run: () =>
setEdits((e) => ({
...e,
deletes: new Set([...e.deletes].filter((d) => !rows.includes(d))),
})),
},
]
: []
}
/>
<Pager tab={busy ? { ...tab, busy: true } : tab} />
</div>
</>
)}
{columnsAt && (
<ColumnsPopup
anchor={columnsAt}
table={tableLabel || tab.title}
columns={columns}
onPick={(col) => {
setColumnsAt(null);
setRevealColumn({ col });
}}
onClose={() => setColumnsAt(null)}
/>
)}
</div>
);
}
interface PlanRow {
node: DbPlanNode;
index: number;
key: string;
}
/** IDEA's operation icons: a table for scans of one, a key for index lookups, an arrow for the statement. */
function planIcon(r: PlanRow): string | null {
if (r.index < 0) return "arrow-left";
if (/index/i.test(r.node.operation)) return "db-key";
if (/scan/i.test(r.node.operation)) return "db-table";
return null;
}
/** IDEA's Query Plan tab: the operation tree with its parameters, the selected operation's properties beside it. */
function PlanResult({ tab }: { tab: ResultTab }) {
const plan = useMemo(() => tab.plan ?? [], [tab.plan]);
const rows = useMemo(() => plan.map((node, index): PlanRow => ({ node, index, key: String(index) })), [plan]);
// IDEA roots the operations in the statement itself ("Select").
const statement = useMemo((): PlanRow => {
const kind = /^\s*(\w+)/.exec(tab.outcome.statement.text)?.[1]?.toLowerCase() ?? "statement";
const operation = kind[0]!.toUpperCase() + kind.slice(1);
return {
node: { parent: null, operation, params: "", properties: [{ name: "Operation", value: kind }] },
index: -1,
key: "statement",
};
}, [tab.outcome.statement.text]);
const [selected, setSelected] = useState(-1);
// Everything starts expanded, a re-explained plan too.
const [collapsed, setCollapsed] = useState<ReadonlySet<string>>(new Set());
const keys = useMemo(() => [statement.key, ...rows.map((r) => r.key)], [statement, rows]);
const expanded = useMemo(() => new Set(keys.filter((k) => !collapsed.has(k))), [keys, collapsed]);
const setExpanded = (next: ReadonlySet<string>) => setCollapsed(new Set(keys.filter((k) => !next.has(k))));
const children = (r: PlanRow) =>
r === statement ? rows.filter((c) => c.node.parent === null) : rows.filter((c) => c.node.parent === r.index);
const props = (selected < 0 ? statement : rows[selected])?.node.properties ?? [];
const selectedKey = selected < 0 ? statement.key : String(selected);
return (
<div className={styles.view}>
<div className={styles.toolbar}>
<IconButton icon="refresh" title="Explain Again" disabled={tab.busy} onClick={() => void rerunResult(tab.id)} />
{tab.busy && <Spinner size={12} />}
<span className={styles.spacer} />
<span className={styles.resultSource} title={tab.outcome.statement.text}>
{targetLabel(tab.sourceId)}
</span>
</div>
<div className={clsx(styles.fill, styles.planView)}>
<div className={styles.planTree}>
<div className={styles.planHeader}>
<span>
<T>Operation</T>
</span>
<span>
<T>Params</T>
</span>
</div>
{plan.length ? (
<Tree<PlanRow>
aria-label="Query plan"
roots={[statement]}
selected={new Set([selectedKey])}
expanded={expanded}
onExpandedChange={setExpanded}
getKey={(r) => r.key}
getLabel={(r) => r.node.operation}
getChildren={(r) => children(r)}
isExpandable={(r) => children(r).length > 0}
onSelectionChange={(_, lead) => lead && setSelected(lead.index)}
renderNode={(r) => (
<span className={styles.planRow}>
<span className={styles.planOperation}>
{planIcon(r) && <Icon name={planIcon(r)!} size={16} />}
{r.node.operation}
</span>
<span className={styles.planParams}>{r.node.params}</span>
</span>
)}
/>
) : (
<EmptyState title="Empty plan" />
)}
</div>
<table className={styles.planProperties} aria-label={tx("Plan node properties")}>
<thead>
<tr>
<th>
<T>Property</T>
</th>
<th>
<T>Value</T>
</th>
</tr>
</thead>
<tbody>
{props.map((p) => (
<tr key={p.name}>
<td>{p.name}</td>
<td>{p.value}</td>
</tr>
))}
</tbody>
</table>
</div>
</div>
);
}
export function ResultsView() {
const results = useDatabase((s) => s.results);
const active = useDatabase((s) => s.activeResult);
const hasOutput = useDatabase((s) => s.output.length > 0);
if (!results.length && !hasOutput)
return (
<EmptyState title="No results">
<T>Execute a statement in a query console with ⌘↩.</T>
</EmptyState>
);
const tab = results.find((r) => r.id === active);
return (
<div className={styles.view}>
<Tabs
variant="compact"
aria-label="Results"
activeId={tab ? String(tab.id) : String(OUTPUT_TAB)}
onSelect={(id) => useDatabase.setState({ activeResult: Number(id) })}
onClose={(id) => closeResult(Number(id))}
items={[
{ id: String(OUTPUT_TAB), label: "Output", icon: "db-console", closable: false },
...results.map((r) => ({
id: String(r.id),
label: r.title,
icon: r.plan ? "db-plan" : "db-table",
closable: true,
tooltip: r.outcome.statement.text,
})),
]}
/>
<div className={styles.fill}>
{!tab ? <Output /> : tab.plan ? <PlanResult key={tab.id} tab={tab} /> : <Result key={tab.id} tab={tab} />}
</div>
</div>
);
}