@adecore/database 0.17.0 → 0.18.1

package/src/table/TableView.tsx

@@ -1,6 +1,7 @@
 import { useEffect, useMemo, useRef, useState, type KeyboardEvent, type ReactNode, type Ref } from 'react';
 import clsx from 'clsx';
 import { ArrowDownWideNarrow, ArrowUpRight, Check, CircleAlert, CopyPlus, Download, Filter, FilterX, RefreshCw, Trash2, Undo2 } from 'lucide-react';
+import type { TFunction } from 'i18next';
 import { useTranslation } from 'react-i18next';
 import {
     Banner,
@@ -19,18 +20,17 @@ import {
 } from '@adecore/ui';
 import { formatNumber } from '@adecore/ui/format';
 import { DatabaseRequestError, type Connection } from '../client/types.ts';
-import { useDatabaseAction, useDatabaseClient, useDatabaseFiles, useDatabaseStorage } from '../client-context.ts';
+import { useDatabaseAction, useDatabaseClient, useDatabaseFiles, useDatabaseNotice, useDatabaseStorage } from '../client-context.ts';
 import { aggregateBlock, blockSize, type RangeBlock } from '../grid/aggregates.ts';
 import { DataGrid } from '../grid/DataGrid.tsx';
-import { wholeValueOf } from '../grid/focused-value.ts';
 import type { GridSort } from '../grid/sort.ts';
-import type { ColumnRequest, FocusedCell, GridMenuContext } from '../grid/types.ts';
+import type { ColumnRequest, FocusedCell, FocusRequest, GridMenuContext } from '../grid/types.ts';
 import { RecordView } from '../grid/RecordView.tsx';
 import { ValueDock } from '../grid/ValueDock.tsx';
 import { valueOfCell, type EditValue, type RowChange, type Value } from '../protocol/index.ts';
 import type { SqlTarget } from '../sql.ts';
 import { useSchemaChange } from '../use-schema-change.ts';
-import { ValuePanel } from '../value/ValuePanel.tsx';
+import { useStableCallback } from '../use-stable-callback.ts';
 import {
     addChip,
     cellChip,
@@ -72,12 +72,27 @@ import { TableStatusBar } from './TableStatusBar.tsx';
 import { TableToolbar } from './TableToolbar.tsx';
 import { useLoaded } from './useLoaded.ts';
 import { useStoredLayout } from './useStoredLayout.ts';
-import { useTableTransfer } from './useTableTransfer.ts';
+import { useTableTransfer, type TransferNotice } from './useTableTransfer.ts';
+
+/* Where the width of the record view is kept, in pixels, for every table. */
+export const RECORD_WIDTH_KEY = 'database:record-view';
+const RECORD_WIDTH = 360;
+
+const parseRecordWidth = (raw: string | null | undefined): number | null => {
+    try {
+        const value: unknown = JSON.parse(raw ?? 'null');
+        return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.round(value) : null;
+    } catch {
+        return null;
+    }
+};
 
 export interface TableViewProps {
     connection: Connection;
     schema: string;
     table: string;
+    /* The app's own content at the start of the toolbar, such as where the table is; the view draws the separators around the command field. */
+    toolbarStart?: ReactNode;
     /* The filters the view starts with, such as the condition of a jump along a foreign key. They win over the ones remembered. */
     defaultWhere?: string;
     defaultOrderBy?: string;
@@ -94,6 +109,20 @@ interface Filters {
 
 const NO_KEYS: ReadonlySet<string> = new Set();
 
+/* What the strip over the table, or the app's notice, says of an export or an import. */
+const transferText = (found: TransferNotice, t: TFunction<'database'>): string => {
+    switch (found.kind) {
+        case 'exporting':
+            return t('table.export.running', { format: found.format.toUpperCase() });
+        case 'exported':
+            return t('table.export.done', { count: found.rows, rows: formatNumber(found.rows) });
+        case 'imported':
+            return t('table.import.done', { count: found.rows, rows: formatNumber(found.rows) });
+        case 'failed':
+            return found.message;
+    }
+};
+
 /* How much of a value a menu item spells out before it cuts it. */
 const MENU_VALUE_LENGTH = 40;
 
@@ -104,7 +133,7 @@ const DUPLICATE_ROWS = shortcut('Mod+D');
  * The rows of one table: read a page at a time, filtered and sorted with SQL a person types, and
  * editable in place. Changes pile up as pending and go to the server together on Submit.
  */
-export function TableView({ connection, schema, table, defaultWhere, defaultOrderBy, onDirtyChange, className, ref }: TableViewProps) {
+export function TableView({ connection, schema, table, toolbarStart, defaultWhere, defaultOrderBy, onDirtyChange, className, ref }: TableViewProps) {
     // A new table, or the same one asked for with other filters, starts from nothing: no page, no pending change.
     return (
         <TableBody
@@ -112,6 +141,7 @@ export function TableView({ connection, schema, table, defaultWhere, defaultOrde
             connection={connection}
             schema={schema}
             table={table}
+            toolbarStart={toolbarStart}
             defaultWhere={defaultWhere}
             defaultOrderBy={defaultOrderBy}
             onDirtyChange={onDirtyChange}
@@ -121,12 +151,14 @@ export function TableView({ connection, schema, table, defaultWhere, defaultOrde
     );
 }
 
-function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, onDirtyChange, className, ref }: TableViewProps) {
+function TableBody({ connection, schema, table, toolbarStart, defaultWhere, defaultOrderBy, onDirtyChange, className, ref }: TableViewProps) {
     const { t } = useTranslation('database');
     const client = useDatabaseClient();
     const onAction = useDatabaseAction();
+    const onNotice = useDatabaseNotice();
     const files = useDatabaseFiles();
-    const { stored, remember } = useStoredLayout(useDatabaseStorage(), layoutStorageKey(connection.id, schema, table));
+    const storage = useDatabaseStorage();
+    const { stored, remember } = useStoredLayout(storage, layoutStorageKey(connection.id, schema, table));
     const session = useMemo(() => client.session(connection), [client, connection]);
     const grid = useRef<HTMLDivElement>(null);
     const command = useRef<HTMLInputElement>(null);
@@ -151,14 +183,12 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
     const [failure, setFailure] = useState<string | null>(null);
     const [shapeChanged, setShapeChanged] = useState(false);
     const [discard, setDiscard] = useState<{ run(): void } | null>(null);
-    const [panelOpen, setPanelOpen] = useState(false);
     const [focus, setFocus] = useState<FocusedCell | null>(null);
     const [recordOpen, setRecordOpen] = useState(false);
-    const [recordKey, setRecordKey] = useState<string | null>(null);
-    const [focusRequest, setFocusRequest] = useState<FocusedCell | null>(null);
+    const [recordWidth, setRecordWidth] = useState(() => parseRecordWidth(storage?.get(RECORD_WIDTH_KEY)));
+    const [focusRequest, setFocusRequest] = useState<FocusRequest | null>(null);
     const [columnRequest, setColumnRequest] = useState<ColumnRequest | null>(null);
     const [range, setRange] = useState<RangeBlock | null>(null);
-    const [fetched, setFetched] = useState<{ id: string; rows: unknown; value: Value | undefined } | null>(null);
 
     const applied = useMemo((): Filters => ({ where: chipsToWhere(chips), orderBy: chipsToOrderBy(engine, chips) }), [chips, engine]);
     const target = `${connection.id}|${schema}|${table}`;
@@ -209,7 +239,20 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
         onImported: () => {
             setCounted(null);
             rowsLoad.reload();
-        }
+        },
+        report:
+            onNotice === undefined
+                ? undefined
+                : (found) =>
+                      onNotice(
+                          found.kind === 'failed'
+                              ? {
+                                    tone: 'error',
+                                    title: t(found.during === 'export' ? 'table.export.failed' : 'table.import.readFailed'),
+                                    description: found.message
+                                }
+                              : { tone: 'success', title: transferText(found, t) }
+                      )
     });
     const changeCount = pendingCount(pending);
     const dirty = changeCount > 0;
@@ -218,13 +261,12 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
     const sorts = useMemo(() => sortsOf(chips), [chips]);
     const commandColumns = useMemo((): CommandColumn[] => columns.map((column) => ({ name: column.name, type: column.type })), [columns]);
     const rowByKey = useMemo(() => new Map(rows.map((row) => [row.key, row])), [rows]);
-    const recordIndex = Math.max(
-        0,
-        rows.findIndex((row) => row.key === recordKey)
-    );
+    // The record view shows the row of the focused cell, or the first row before a cell has the focus.
+    const focusedIndex = focus === null ? -1 : rows.findIndex((row) => row.key === focus.rowKey);
+    const recordIndex = focusedIndex >= 0 ? focusedIndex : rows.length > 0 ? 0 : -1;
     const selectionFigures = useMemo(
         () =>
-            recordOpen || range === null || blockSize(range) < 2
+            range === null || blockSize(range) < 2
                 ? null
                 : {
                       columns: range.columns.map((index) => columns[index]?.name ?? ''),
@@ -234,19 +276,9 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
                           range
                       )
                   },
-        [recordOpen, range, rows, columns]
+        [range, rows, columns]
     );
     const sqlTarget = useMemo((): SqlTarget => ({ engine, schema, table }), [engine, schema, table]);
-    const focusedRow = panelOpen && focus !== null ? rows.find((row) => row.key === focus.rowKey) : undefined;
-    const focusedCell = focus === null ? undefined : focusedRow?.cells[focus.column];
-    const needsFetch =
-        focusedCell !== undefined &&
-        focus !== null &&
-        wholeValueOf(focusedCell) === undefined &&
-        !(focusedCell !== null && typeof focusedCell === 'object' && focusedCell.kind === 'default');
-    const focusedRef = focus === null ? null : parseRowKey(focus.rowKey);
-    const canFetch = focusedRef?.kind === 'loaded' && structure !== null && loaded !== null && rowKeyOf(structure, loaded, focusedRef.index) !== null;
-    const fetchId = needsFetch && canFetch ? `${focus.rowKey}:${focus.column}` : null;
 
     useSchemaChange(connection.id, schema, () => {
         if (isPendingEmpty(pending)) {
@@ -286,31 +318,10 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
     }, [pending.inserts.length]);
 
     useEffect(() => {
-        if (fetchId === null || focus === null || structure === null || loaded === null) {
-            return;
-        }
-        const row = parseRowKey(focus.rowKey);
-        const key = row.kind === 'loaded' ? rowKeyOf(structure, loaded, row.index) : null;
-        const name = loaded.columns[focus.column]?.name;
-        if (key === null || name === undefined) {
-            return;
+        if (recordWidth !== null) {
+            storage?.set(RECORD_WIDTH_KEY, JSON.stringify(recordWidth));
         }
-        const controller = new AbortController();
-        session.cell(schema, table, key, name, { signal: controller.signal }).then(
-            (value) => {
-                if (!controller.signal.aborted) {
-                    setFetched({ id: fetchId, rows: loaded, value });
-                }
-            },
-            (error: unknown) => {
-                if (!controller.signal.aborted) {
-                    setFetched({ id: fetchId, rows: loaded, value: undefined });
-                    setFailure(messageOf(error));
-                }
-            }
-        );
-        return () => controller.abort();
-    }, [fetchId, focus, structure, loaded, session, schema, table]);
+    }, [storage, recordWidth]);
 
     const discardPending = (): void => {
         setPending(emptyPending);
@@ -447,7 +458,7 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
         }
     };
 
-    const loadValue = async (rowKey: string, column: number): Promise<Value | undefined> => {
+    const loadValue = useStableCallback(async (rowKey: string, column: number): Promise<Value | undefined> => {
         const row = parseRowKey(rowKey);
         const name = loaded?.columns[column]?.name;
         const key = row.kind === 'loaded' && structure !== null && loaded !== null ? rowKeyOf(structure, loaded, row.index) : null;
@@ -460,7 +471,7 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
             setFailure(messageOf(error));
             return undefined;
         }
-    };
+    });
 
     const refsOf = (keys: Iterable<string>): RowSelectionRefs => {
         const loadedRows: number[] = [];
@@ -527,24 +538,19 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
     };
 
     const toggleRecordView = (): void => {
-        if (recordOpen) {
-            const row = rows[recordIndex];
-            setRecordOpen(false);
-            if (row !== undefined) {
-                setFocusRequest({ rowKey: row.key, column: focus?.column ?? 0 });
-            }
-            return;
-        }
-        const focused = focus === null ? undefined : rows.find((row) => row.key === focus.rowKey);
-        setRecordKey((focused ?? rows[0])?.key ?? null);
-        setRecordOpen(true);
+        setRecordOpen((now) => !now);
+    };
+
+    /* The record view moves the grid's focus along with it, without taking the keyboard from its field. */
+    const followInGrid = (cell: FocusedCell): void => {
+        setFocus(cell);
+        setFocusRequest({ ...cell, quiet: true });
     };
 
     const changeRecordIndex = (index: number): void => {
         const row = rows[index];
         if (row !== undefined) {
-            setRecordKey(row.key);
-            setFocus((now) => (now === null ? now : { rowKey: row.key, column: now.column }));
+            followInGrid({ rowKey: row.key, column: focus?.column ?? 0 });
         }
     };
 
@@ -645,47 +651,16 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
     };
 
     const bounds = pageBounds(loadedOffset, loaded?.rows.length ?? 0, loaded?.hasMore ?? false, counted);
-    const focusedColumn = focus === null ? null : (columns[focus.column] ?? null);
-    const panelEditable =
-        editable && focusedRow !== undefined && focusedRow.locked !== true && focusedRow.state !== 'deleted' && focusedColumn?.readOnly !== true;
-    const fetchedNow = fetched !== null && fetched.id === fetchId && fetched.rows === loaded;
-    const panelValue = ((): Value | undefined => {
-        if (focusedCell === undefined || focusedRow === undefined || focus === null) {
-            return undefined;
-        }
-        const whole = wholeValueOf(focusedCell);
-        if (whole !== undefined) {
-            return whole;
-        }
-        if (focusedCell !== null && typeof focusedCell === 'object' && focusedCell.kind === 'default') {
-            // A pending DEFAULT holds no value of its own, so the panel keeps showing what the row had.
-            const row = parseRowKey(focusedRow.key);
-            return row.kind === 'loaded' && loaded !== null ? wholeValueOf(loaded.rows[row.index]?.[focus.column] ?? null) : null;
-        }
-        return fetchedNow ? fetched.value : undefined;
-    })();
     const notice = failure ?? rowsLoad.error ?? structureLoad.error;
-    const noticeText = (found: NonNullable<typeof transfer.notice>): string => {
-        switch (found.kind) {
-            case 'exporting':
-                return t('table.export.running', { format: found.format.toUpperCase() });
-            case 'exported':
-                return t('table.export.done', { count: found.rows, rows: formatNumber(found.rows) });
-            case 'imported':
-                return t('table.import.done', { count: found.rows, rows: formatNumber(found.rows) });
-            case 'failed':
-                return found.message;
-        }
-    };
 
     return (
         <div ref={ref} className={clsx('flex min-h-0 flex-col bg-surface text-text', className)} onKeyDown={handleKeyDown}>
             <TableToolbar
+                start={toolbarStart}
                 refreshing={rowsLoad.loading}
                 readOnlyReason={readOnlyReason}
                 hasSelection={selected.size > 0}
                 canRevertSelection={selected.size > 0 && canRevert(selected)}
-                valuePanelOpen={panelOpen}
                 recordViewOpen={recordOpen}
                 transfer={
                     files === undefined
@@ -711,7 +686,6 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
                 onDeleteRows={deleteSelected}
                 onCloneRows={() => cloneRows([...selected])}
                 onRevertRows={() => revertRowKeys(selected)}
-                onToggleValuePanel={() => setPanelOpen((now) => !now)}
                 onToggleRecordView={toggleRecordView}
                 onPageSizeChange={changePageSize}
                 onFirstPage={() => goToPage(0)}
@@ -743,7 +717,7 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
                 <Banner
                     icon={transfer.notice.kind === 'failed' ? CircleAlert : transfer.notice.kind === 'exporting' ? Download : Check}
                     tone={transfer.notice.kind === 'failed' ? 'error' : 'neutral'}
-                    message={noticeText(transfer.notice)}
+                    message={transferText(transfer.notice, t)}
                     className="shrink-0 pt-2"
                 >
                     {transfer.notice.kind === 'exporting' ? (
@@ -765,26 +739,31 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
             ) : (
                 <>
                     <ValueDock
-                        open={panelOpen}
+                        open={recordOpen}
+                        width={recordWidth ?? RECORD_WIDTH}
+                        onWidthChange={setRecordWidth}
                         panel={
-                            <ValuePanel
-                                column={focusedColumn}
-                                value={panelValue}
-                                loading={fetchId !== null && !fetchedNow}
-                                editable={panelEditable}
-                                onCommit={(value) => focus !== null && commit(focus.rowKey, focus.column, value)}
-                                onClose={() => setPanelOpen(false)}
-                                className="min-w-0 flex-1"
+                            <RecordView
+                                label={t('table.recordFields', { table })}
+                                columns={columns}
+                                rows={rows}
+                                index={recordIndex}
+                                onIndexChange={changeRecordIndex}
+                                focusedColumn={focus !== null && focusedIndex === recordIndex ? focus.column : null}
+                                editable={editable}
+                                onCommit={commit}
+                                loadValue={loadValue}
+                                onFocusedCellChange={followInGrid}
+                                onFollow={onAction === undefined ? undefined : follow}
+                                canFollow={(cell) => referenceAt(cell) !== null}
+                                onClose={() => setRecordOpen(false)}
+                                empty={t('table.empty')}
                             />
                         }
                     >
                         <div
                             aria-busy={rowsLoad.loading}
-                            className={clsx(
-                                'relative min-h-0 flex-1 flex-col',
-                                recordOpen ? 'hidden' : 'flex',
-                                rowsLoad.loading && 'pointer-events-none opacity-60'
-                            )}
+                            className={clsx('relative flex min-h-0 flex-1 flex-col', rowsLoad.loading && 'pointer-events-none opacity-60')}
                         >
                             <DataGrid
                                 ref={grid}
@@ -814,22 +793,6 @@ function TableBody({ connection, schema, table, defaultWhere, defaultOrderBy, on
                                 columnRequest={columnRequest}
                             />
                         </div>
-                        {recordOpen && (
-                            <RecordView
-                                label={t('table.recordFields', { table })}
-                                columns={columns}
-                                rows={rows}
-                                index={recordIndex}
-                                onIndexChange={changeRecordIndex}
-                                editable={editable}
-                                onCommit={commit}
-                                loadValue={loadValue}
-                                onFocusedCellChange={setFocus}
-                                onFollow={onAction === undefined ? undefined : follow}
-                                canFollow={(cell) => referenceAt(cell) !== null}
-                                empty={t('table.empty')}
-                            />
-                        )}
                     </ValueDock>
                     <TableStatusBar
                         elapsedMs={loaded.elapsedMs}

package/src/table/grid-rows.ts

@@ -13,14 +13,16 @@ export const insertedRowKey = (id: number): string => `new:${id}`;
 export const parseRowKey = (key: string): RowRef =>
     key.startsWith('new:') ? { kind: 'inserted', id: Number(key.slice(4)) } : { kind: 'loaded', index: Number(key.slice(4)) };
 
-export const buildGridColumns = (loaded: Pick<RowsResult, 'columns'>, structure: TableStructure | null): GridColumn[] =>
-    loaded.columns.map((column) =>
+export const buildGridColumns = (loaded: Pick<RowsResult, 'columns'>, structure: TableStructure | null): GridColumn[] => {
+    const keys = { primaryKey: structure?.primaryKey ?? [], foreignKey: structure?.foreignKeys.flatMap((key) => key.columns) ?? [] };
+    return loaded.columns.map((column) =>
         gridColumnOf(
             column,
             structure?.columns.find((info) => info.name === column.name),
-            structure?.primaryKey ?? []
+            keys
         )
     );
+};
 
 export interface GridRowsInput {
     readonly structure: TableStructure | null;

package/src/table/useTableTransfer.ts

@@ -11,7 +11,7 @@ export type TransferNotice =
     | { readonly kind: 'exporting'; readonly format: FileFormat }
     | { readonly kind: 'exported'; readonly rows: number }
     | { readonly kind: 'imported'; readonly rows: number }
-    | { readonly kind: 'failed'; readonly message: string };
+    | { readonly kind: 'failed'; readonly during: 'export' | 'import'; readonly message: string };
 
 /* The import a person is setting up. */
 export interface ImportDraft {
@@ -38,6 +38,8 @@ export interface TableTransferInput {
     readonly orderBy: string;
     /* Rows were added; the table reloads. */
     readonly onImported: () => void;
+    /* Takes what finished or failed off the strip, for the app to show; the strip keeps only a running export. */
+    readonly report?: (notice: TransferNotice) => void;
 }
 
 export interface TableTransfer {
@@ -55,7 +57,7 @@ export interface TableTransfer {
 }
 
 /* Export of the table as filtered, and import of a file into it, with the state both need between the dialogs and the strip. */
-export function useTableTransfer({ client, session, files, schema, table, structure, where, orderBy, onImported }: TableTransferInput): TableTransfer {
+export function useTableTransfer({ client, session, files, schema, table, structure, where, orderBy, onImported, report }: TableTransferInput): TableTransfer {
     const [notice, setNotice] = useState<TransferNotice | null>(null);
     const [importDraft, setImportDraft] = useState<ImportDraft | null>(null);
     const exporting = useRef<AbortController | null>(null);
@@ -72,6 +74,15 @@ export function useTableTransfer({ client, session, files, schema, table, struct
 
     useEffect(() => () => sampling.current?.abort(), []);
 
+    const show = (next: TransferNotice): void => {
+        if (report === undefined) {
+            setNotice(next);
+        } else {
+            setNotice(null);
+            report(next);
+        }
+    };
+
     const exportAs = (format: FileFormat): void => {
         if (files === undefined || exporting.current !== null) {
             return;
@@ -89,10 +100,14 @@ export function useTableTransfer({ client, session, files, schema, table, struct
                     { source: { kind: 'table', schema, table, where: where || undefined, orderBy: orderBy || undefined }, format, path },
                     { signal: controller.signal }
                 );
-                setNotice({ kind: 'exported', rows: result.rows });
+                show({ kind: 'exported', rows: result.rows });
             } catch (error) {
                 const cancelled = controller.signal.aborted || (error instanceof DatabaseRequestError && error.code === 'cancelled');
-                setNotice(cancelled ? null : { kind: 'failed', message: messageOf(error) });
+                if (cancelled) {
+                    setNotice(null);
+                } else {
+                    show({ kind: 'failed', during: 'export', message: messageOf(error) });
+                }
             } finally {
                 exporting.current = null;
             }
@@ -120,7 +135,7 @@ export function useTableTransfer({ client, session, files, schema, table, struct
                 const read = await sample(path, format, true);
                 setImportDraft({ path, format, header: true, sample: read, mapping: matchColumns(read.columns, tableColumns, true), busy: false, error: null });
             } catch (error) {
-                setNotice({ kind: 'failed', message: messageOf(error) });
+                show({ kind: 'failed', during: 'import', message: messageOf(error) });
             }
         })();
     };
@@ -159,7 +174,7 @@ export function useTableTransfer({ client, session, files, schema, table, struct
             try {
                 const rows = await session.import(schema, table, { path, format, header, columns: mapping });
                 setImportDraft(null);
-                setNotice({ kind: 'imported', rows });
+                show({ kind: 'imported', rows });
                 onImported();
             } catch (error) {
                 setImportDraft((now) => (now === null ? now : { ...now, busy: false, error: messageOf(error) }));

package/src/testing/fake.ts

@@ -1,5 +1,6 @@
 import type {
     Cell,
+    CheckInfo,
     ColumnInfo,
     DatabaseErrorCode,
     DatabaseMethod,
@@ -16,6 +17,7 @@ import type {
     ServerInfo,
     StatementResult,
     TableKind,
+    TriggerInfo,
     Value
 } from '../protocol/index.ts';
 import type { DatabaseTransport } from '../client/types.ts';
@@ -30,6 +32,9 @@ export interface FakeTable {
     readonly rows: readonly (readonly Value[])[];
     readonly indexes?: readonly IndexInfo[];
     readonly foreignKeys?: readonly ForeignKeyInfo[];
+    /* Left out, `structure` leaves them out too, as SQLite does for its checks. */
+    readonly checks?: readonly CheckInfo[];
+    readonly triggers?: readonly TriggerInfo[];
     readonly ddl?: string;
 }
 
@@ -50,12 +55,17 @@ export interface FakeDatabaseTransportOptions {
 }
 
 interface Table {
+    /* Where the table is, which the columns of a result read from it name as their source. */
+    schema: string;
+    name: string;
     kind: TableKind;
     columns: ColumnInfo[];
     primaryKey: string[];
     rows: Value[][];
     indexes: IndexInfo[];
     foreignKeys: ForeignKeyInfo[];
+    checks: CheckInfo[] | undefined;
+    triggers: TriggerInfo[] | undefined;
     ddl: string | null;
 }
 
@@ -92,12 +102,16 @@ const toTables = (database: FakeDatabase): Map<string, Map<string, Table>> =>
                 Object.entries(tables).map(([name, table]) => [
                     name,
                     {
+                        schema,
+                        name,
                         kind: table.kind ?? 'table',
                         columns: structuredClone([...table.columns]),
                         primaryKey: [...(table.primaryKey ?? [])],
                         rows: structuredClone(table.rows.map((row) => [...row])),
                         indexes: structuredClone([...(table.indexes ?? [])]),
                         foreignKeys: structuredClone([...(table.foreignKeys ?? [])]),
+                        checks: table.checks === undefined ? undefined : structuredClone([...table.checks]),
+                        triggers: table.triggers === undefined ? undefined : structuredClone([...table.triggers]),
                         ddl: table.ddl ?? null
                     } satisfies Table
                 ])
@@ -167,7 +181,8 @@ const toCell = (value: Value, cellLimit: number): Cell => {
     return value;
 };
 
-const toResultColumns = (table: Table): ResultColumn[] => table.columns.map(({ name, type, kind }) => ({ name, type, kind }));
+const toResultColumns = (table: Table): ResultColumn[] =>
+    table.columns.map(({ name, type, kind }) => ({ name, type, kind, source: { schema: table.schema, table: table.name, column: name } }));
 
 const toRowsResult = (table: Table, rows: readonly (readonly Value[])[], offset: number, limit: number, cellLimit: number): RowsResult => ({
     columns: toResultColumns(table),
@@ -406,6 +421,8 @@ export const fakeDatabaseTransport = (options: FakeDatabaseTransportOptions): Da
                 rowKey: rowKeyOf(table),
                 indexes: table.indexes,
                 foreignKeys: table.foreignKeys,
+                ...(table.checks === undefined ? {} : { checks: table.checks }),
+                ...(table.triggers === undefined ? {} : { triggers: table.triggers }),
                 ddl: table.ddl
             };
         },