@kazurolabs/psql-explorer 0.1.0 → 0.3.1

package/dist/explorer/schema-diff.js

@@ -0,0 +1,360 @@
+const relationKinds = {
+    r: 'table',
+    p: 'table',
+    v: 'view',
+    m: 'materialized view',
+    f: 'foreign table',
+};
+// The order kinds are listed in: what holds other things first.
+const kindOrder = [
+    'extension',
+    'schema',
+    'type',
+    'sequence',
+    'table',
+    'foreign table',
+    'view',
+    'materialized view',
+    'function',
+];
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+/**
+ * The text without its own schema's name in front of the names in it, so that "app.users" and
+ * "app_copy.users" read the same when one schema is compared with another. Names in other schemas
+ * keep theirs.
+ */
+export function unqualify(text, schema) {
+    const quoted = `"${schema.replaceAll('"', '""')}".`;
+    let out = text.split(quoted).join('');
+    if (/^[a-z_][a-z0-9_$]*$/.test(schema)) {
+        out = out.replace(new RegExp(`(?<![\\w$".])${escapeRegExp(schema)}\\.(?=[\\w"])`, 'g'), '');
+    }
+    return out;
+}
+// Excludes what an extension created, which its own version already accounts for.
+const notInExtension = (catalog, oid) => `NOT EXISTS (SELECT 1 FROM pg_catalog.pg_depend e
+		WHERE e.classid = '${catalog}'::regclass AND e.objid = ${oid} AND e.deptype = 'e')`;
+const userSchema = (column) => `${column} !~ '^pg_' AND ${column} <> 'information_schema' AND ($1::text IS NULL OR ${column} = $1)`;
+/** The structure of a database (or one schema of it) as text, for comparing with another. */
+export async function snapshotSchema(session, options = {}) {
+    const filter = [options.schema ?? null];
+    // With an empty search path Postgres writes every name with its schema, the same way on both
+    // sides, whatever each environment's search path is. Put back afterwards for the next statement.
+    const [saved] = await session.rows(`SELECT current_setting('search_path') AS path, pg_catalog.set_config('search_path', '', false)`);
+    try {
+        return { objects: await readObjects(session, filter) };
+    }
+    finally {
+        await session.rows(`SELECT pg_catalog.set_config('search_path', $1, false)`, [
+            saved?.path ?? '',
+        ]);
+    }
+}
+async function readObjects(session, filter) {
+    const objects = new Map();
+    const add = (kind, schema, name) => {
+        const key = objectKey({ kind, schema, name });
+        let object = objects.get(key);
+        if (!object) {
+            object = { kind, schema, name, parts: {} };
+            objects.set(key, object);
+        }
+        return object;
+    };
+    // Parts of a table, view, ... by its schema and name, whose kind is already known.
+    const relations = new Map();
+    const partsOf = (schema, name) => relations.get(`${schema}\0${name}`);
+    const set = (parts, part, value, schema) => {
+        if (parts)
+            parts[part] = unqualify(value, schema ?? '');
+    };
+    for (const row of await session.rows(`SELECT n.nspname AS name FROM pg_catalog.pg_namespace n
+		WHERE ${userSchema('n.nspname')} AND ${notInExtension('pg_catalog.pg_namespace', 'n.oid')}`, filter)) {
+        add('schema', row.name ?? '', row.name ?? '');
+    }
+    for (const row of await session.rows(`SELECT x.extname AS name, x.extversion AS version, n.nspname AS schema
+		FROM pg_catalog.pg_extension x JOIN pg_catalog.pg_namespace n ON n.oid = x.extnamespace`)) {
+        const parts = add('extension', '', row.name ?? '').parts;
+        parts.version = row.version ?? '';
+        parts.schema = row.schema ?? '';
+    }
+    for (const row of await session.rows(`SELECT n.nspname AS schema, c.relname AS name, c.relkind AS kind,
+			CASE WHEN c.relkind IN ('v', 'm') THEN pg_catalog.pg_get_viewdef(c.oid, true) END AS definition,
+			CASE WHEN c.relkind = 'p' THEN pg_catalog.pg_get_partkeydef(c.oid) END AS partition_key,
+			(SELECT pg_catalog.format('%I.%I', pn.nspname, pc.relname)
+				FROM pg_catalog.pg_inherits i
+				JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent
+				JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace
+				WHERE i.inhrelid = c.oid AND c.relispartition) AS parent,
+			CASE WHEN c.relispartition THEN pg_catalog.pg_get_expr(c.relpartbound, c.oid) END AS bound,
+			c.relrowsecurity AS rls
+		FROM pg_catalog.pg_class c
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE c.relkind IN ('r', 'p', 'v', 'm', 'f') AND ${userSchema('n.nspname')}
+			AND ${notInExtension('pg_catalog.pg_class', 'c.oid')}`, filter)) {
+        const parts = add(relationKinds[row.kind ?? ''] ?? 'table', row.schema ?? '', row.name ?? '').parts;
+        relations.set(`${row.schema}\0${row.name}`, parts);
+        if (row.definition !== null)
+            set(parts, 'definition', row.definition.trim(), row.schema);
+        if (row.partition_key !== null)
+            set(parts, 'partitioned by', row.partition_key, row.schema);
+        if (row.parent !== null)
+            set(parts, 'partition of', `${row.parent} ${row.bound ?? ''}`.trim(), row.schema);
+        if (row.rls === 't')
+            parts['row level security'] = 'enabled';
+    }
+    // Columns of tables and foreign tables; a view's follow from its definition.
+    for (const row of await session.rows(`SELECT n.nspname AS schema, c.relname AS table, a.attname AS name,
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS type, a.attnotnull AS not_null,
+			pg_catalog.pg_get_expr(d.adbin, d.adrelid) AS default, a.attidentity AS identity,
+			a.attgenerated AS generated,
+			CASE WHEN a.attcollation <> t.typcollation THEN
+				(SELECT pg_catalog.format('%I.%I', cn.nspname, co.collname) FROM pg_catalog.pg_collation co
+					JOIN pg_catalog.pg_namespace cn ON cn.oid = co.collnamespace WHERE co.oid = a.attcollation)
+			END AS collation
+		FROM pg_catalog.pg_attribute a
+		JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+		LEFT JOIN pg_catalog.pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+		WHERE c.relkind IN ('r', 'p', 'f') AND a.attnum > 0 AND NOT a.attisdropped
+			AND ${userSchema('n.nspname')}
+		ORDER BY a.attnum`, filter)) {
+        const words = [row.type ?? ''];
+        if (row.collation)
+            words.push(`COLLATE ${row.collation}`);
+        if (row.not_null === 't')
+            words.push('NOT NULL');
+        if (row.identity === 'a')
+            words.push('GENERATED ALWAYS AS IDENTITY');
+        else if (row.identity === 'd')
+            words.push('GENERATED BY DEFAULT AS IDENTITY');
+        else if (row.generated === 's')
+            words.push(`GENERATED ALWAYS AS (${row.default}) STORED`);
+        else if (row.generated === 'v')
+            words.push(`GENERATED ALWAYS AS (${row.default}) VIRTUAL`);
+        else if (row.default !== null)
+            words.push(`DEFAULT ${row.default}`);
+        set(partsOf(row.schema, row.table), `column ${row.name}`, words.join(' '), row.schema);
+    }
+    for (const row of await session.rows(`SELECT n.nspname AS schema, c.relname AS table, i.relname AS name,
+			pg_catalog.pg_get_indexdef(x.indexrelid) AS definition
+		FROM pg_catalog.pg_index x
+		JOIN pg_catalog.pg_class i ON i.oid = x.indexrelid
+		JOIN pg_catalog.pg_class c ON c.oid = x.indrelid
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE ${userSchema('n.nspname')}
+		ORDER BY x.indisprimary DESC, i.relname`, filter)) {
+        set(partsOf(row.schema, row.table), `index ${row.name}`, row.definition ?? '', row.schema);
+    }
+    // Not-null constraints (Postgres 18) are left out: the column already says NOT NULL.
+    for (const row of await session.rows(`SELECT n.nspname AS schema, c.relname AS table, k.conname AS name,
+			pg_catalog.pg_get_constraintdef(k.oid, true) AS definition
+		FROM pg_catalog.pg_constraint k
+		JOIN pg_catalog.pg_class c ON c.oid = k.conrelid
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE k.contype <> 'n' AND ${userSchema('n.nspname')}
+		ORDER BY array_position(ARRAY['p', 'u', 'f', 'c', 'x', 't']::"char"[], k.contype), k.conname`, filter)) {
+        set(partsOf(row.schema, row.table), `constraint ${row.name}`, row.definition ?? '', row.schema);
+    }
+    for (const row of await session.rows(`SELECT n.nspname AS schema, c.relname AS table, t.tgname AS name,
+			pg_catalog.pg_get_triggerdef(t.oid, true) AS definition, t.tgenabled AS enabled
+		FROM pg_catalog.pg_trigger t
+		JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE NOT t.tgisinternal AND ${userSchema('n.nspname')}
+		ORDER BY t.tgname`, filter)) {
+        const disabled = row.enabled === 'D' ? ' (disabled)' : '';
+        set(partsOf(row.schema, row.table), `trigger ${row.name}`, `${row.definition}${disabled}`, row.schema);
+    }
+    for (const row of await session.rows(`SELECT schemaname AS schema, tablename AS table, policyname AS name, permissive,
+			array_to_string(roles, ', ') AS roles, cmd AS command, qual, with_check
+		FROM pg_catalog.pg_policies
+		WHERE ${userSchema('schemaname')}
+		ORDER BY policyname`, filter)) {
+        const words = [`AS ${row.permissive} FOR ${row.command} TO ${row.roles}`];
+        if (row.qual !== null)
+            words.push(`USING (${row.qual})`);
+        if (row.with_check !== null)
+            words.push(`WITH CHECK (${row.with_check})`);
+        set(partsOf(row.schema, row.table), `policy ${row.name}`, words.join(' '), row.schema);
+    }
+    for (const row of await session.rows(`SELECT n.nspname AS schema, p.proname AS name, pg_catalog.oidvectortypes(p.proargtypes) AS args,
+			p.prokind AS kind,
+			CASE WHEN p.prokind <> 'a' THEN pg_catalog.pg_get_functiondef(p.oid) END AS definition,
+			pg_catalog.pg_get_function_result(p.oid) AS returns
+		FROM pg_catalog.pg_proc p
+		JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+		WHERE ${userSchema('n.nspname')} AND ${notInExtension('pg_catalog.pg_proc', 'p.oid')}`, filter)) {
+        const schema = row.schema ?? '';
+        const name = `${row.name}(${unqualify(row.args ?? '', schema)})`;
+        const parts = add('function', schema, name).parts;
+        if (row.definition !== null)
+            set(parts, 'definition', row.definition.trim(), schema);
+        else
+            set(parts, 'aggregate returning', row.returns ?? '', schema);
+    }
+    for (const row of await session.rows(`SELECT s.schemaname AS schema, s.sequencename AS name, s.data_type::text AS type,
+			s.start_value::text AS start, s.increment_by::text AS increment, s.min_value::text AS min,
+			s.max_value::text AS max, s.cache_size::text AS cache, s.cycle,
+			(SELECT pg_catalog.format('%I.%I.%I', rn.nspname, r.relname, a.attname)
+				FROM pg_catalog.pg_depend d
+				JOIN pg_catalog.pg_class r ON r.oid = d.refobjid
+				JOIN pg_catalog.pg_namespace rn ON rn.oid = r.relnamespace
+				JOIN pg_catalog.pg_attribute a ON a.attrelid = d.refobjid AND a.attnum = d.refobjsubid
+				WHERE d.objid = c.oid AND d.classid = 'pg_catalog.pg_class'::regclass
+					AND d.refclassid = 'pg_catalog.pg_class'::regclass AND d.deptype IN ('a', 'i')
+				LIMIT 1) AS owned_by
+		FROM pg_catalog.pg_sequences s
+		JOIN pg_catalog.pg_namespace n ON n.nspname = s.schemaname
+		JOIN pg_catalog.pg_class c ON c.relname = s.sequencename AND c.relnamespace = n.oid
+		WHERE ${userSchema('s.schemaname')} AND ${notInExtension('pg_catalog.pg_class', 'c.oid')}`, filter)) {
+        const schema = row.schema ?? '';
+        const parts = add('sequence', schema, row.name ?? '').parts;
+        for (const field of ['type', 'start', 'increment', 'min', 'max', 'cache']) {
+            parts[field] = row[field] ?? '';
+        }
+        parts.cycle = row.cycle === 't' ? 'yes' : 'no';
+        if (row.owned_by !== null)
+            set(parts, 'owned by', row.owned_by ?? '', schema);
+    }
+    for (const row of await session.rows(`SELECT n.nspname AS schema, t.typname AS name, t.typtype AS kind,
+			(SELECT string_agg(pg_catalog.quote_literal(e.enumlabel), ', ' ORDER BY e.enumsortorder)
+				FROM pg_catalog.pg_enum e WHERE e.enumtypid = t.oid) AS labels,
+			CASE t.typtype
+				WHEN 'd' THEN pg_catalog.format_type(t.typbasetype, t.typtypmod)
+				WHEN 'r' THEN (SELECT pg_catalog.format_type(r.rngsubtype, NULL)
+					FROM pg_catalog.pg_range r WHERE r.rngtypid = t.oid)
+			END AS base,
+			t.typdefault AS default, t.typnotnull AS not_null
+		FROM pg_catalog.pg_type t
+		JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+		WHERE t.typtype IN ('e', 'c', 'd', 'r') AND ${userSchema('n.nspname')}
+			AND (t.typtype <> 'c' OR EXISTS (
+				SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c'))
+			AND ${notInExtension('pg_catalog.pg_type', 't.oid')}`, filter)) {
+        const schema = row.schema ?? '';
+        const parts = add('type', schema, row.name ?? '').parts;
+        if (row.kind === 'e')
+            parts['enum labels'] = row.labels ?? '';
+        if (row.kind === 'd') {
+            set(parts, 'domain of', row.base ?? '', schema);
+            if (row.default !== null)
+                set(parts, 'default', row.default, schema);
+            if (row.not_null === 't')
+                parts['not null'] = 'yes';
+        }
+        if (row.kind === 'r')
+            set(parts, 'range of', row.base ?? '', schema);
+    }
+    // The attributes of composite types and the constraints of domains.
+    for (const row of await session.rows(`SELECT n.nspname AS schema, t.typname AS type, a.attname AS name,
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS type_of
+		FROM pg_catalog.pg_type t
+		JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+		JOIN pg_catalog.pg_class c ON c.oid = t.typrelid AND c.relkind = 'c'
+		JOIN pg_catalog.pg_attribute a ON a.attrelid = c.oid AND a.attnum > 0 AND NOT a.attisdropped
+		WHERE ${userSchema('n.nspname')}
+		ORDER BY a.attnum`, filter)) {
+        const object = objects.get(objectKey({ kind: 'type', schema: row.schema ?? '', name: row.type ?? '' }));
+        if (object)
+            set(object.parts, `attribute ${row.name}`, row.type_of ?? '', row.schema);
+    }
+    for (const row of await session.rows(`SELECT n.nspname AS schema, t.typname AS type, k.conname AS name,
+			pg_catalog.pg_get_constraintdef(k.oid, true) AS definition
+		FROM pg_catalog.pg_constraint k
+		JOIN pg_catalog.pg_type t ON t.oid = k.contypid
+		JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+		WHERE ${userSchema('n.nspname')}
+		ORDER BY k.conname`, filter)) {
+        const object = objects.get(objectKey({ kind: 'type', schema: row.schema ?? '', name: row.type ?? '' }));
+        if (object)
+            set(object.parts, `constraint ${row.name}`, row.definition ?? '', row.schema);
+    }
+    return [...objects.values()];
+}
+const objectKey = (object) => `${object.kind}\0${object.schema}\0${object.name}`;
+// Beyond this many lines a side the comparison is not worth its time: all of a, then all of b.
+const MAX_DIFF_LINES = 3000;
+/** The lines of a and b in order, those they share once, by the longest common subsequence. */
+export function diffLines(a, b) {
+    const left = a.split('\n');
+    const right = b.split('\n');
+    if (left.length > MAX_DIFF_LINES || right.length > MAX_DIFF_LINES) {
+        return [
+            ...left.map((text) => ({ side: 'a', text })),
+            ...right.map((text) => ({ side: 'b', text })),
+        ];
+    }
+    // common[i][j]: how many lines left[i..] and right[j..] have in common.
+    const common = Array.from({ length: left.length + 1 }, () => new Uint32Array(right.length + 1));
+    for (let i = left.length - 1; i >= 0; i--) {
+        for (let j = right.length - 1; j >= 0; j--) {
+            common[i][j] =
+                left[i] === right[j]
+                    ? common[i + 1][j + 1] + 1
+                    : Math.max(common[i + 1][j], common[i][j + 1]);
+        }
+    }
+    const lines = [];
+    let i = 0;
+    let j = 0;
+    while (i < left.length || j < right.length) {
+        if (i < left.length && j < right.length && left[i] === right[j]) {
+            lines.push({ side: 'both', text: left[i] });
+            i++;
+            j++;
+        }
+        else if (j >= right.length || (i < left.length && common[i + 1][j] >= common[i][j + 1])) {
+            lines.push({ side: 'a', text: left[i++] });
+        }
+        else {
+            lines.push({ side: 'b', text: right[j++] });
+        }
+    }
+    return lines;
+}
+const partChange = (part, a, b) => a !== null && b !== null && (a.includes('\n') || b.includes('\n'))
+    ? { part, a, b, lines: diffLines(a, b) }
+    : { part, a, b };
+const sortKey = (object) => `${object.schema}\0${String(kindOrder.indexOf(object.kind)).padStart(2, '0')}\0${object.name}`;
+/** The objects and parts that differ between two snapshots, by schema, kind and name. */
+export function diffSnapshots(a, b, options = {}) {
+    const { schemas } = options;
+    // Side b's objects named as though in side a's schema, so the two line up.
+    const rename = (object) => schemas && object.schema === schemas.b
+        ? { ...object, schema: schemas.a, name: object.kind === 'schema' ? schemas.a : object.name }
+        : object;
+    const left = new Map(a.objects.map((object) => [objectKey(object), object]));
+    const right = new Map(b.objects.map(rename).map((object) => [objectKey(object), object]));
+    const changes = [];
+    let same = 0;
+    for (const key of new Set([...left.keys(), ...right.keys()])) {
+        const one = left.get(key);
+        const other = right.get(key);
+        const object = (one ?? other);
+        const names = [
+            ...new Set([...Object.keys(one?.parts ?? {}), ...Object.keys(other?.parts ?? {})]),
+        ];
+        const parts = names
+            .filter((part) => !one || !other || one.parts[part] !== other.parts[part])
+            .map((part) => partChange(part, one?.parts[part] ?? null, other?.parts[part] ?? null));
+        const status = !other ? 'only-a' : !one ? 'only-b' : parts.length > 0 ? 'changed' : null;
+        if (status)
+            changes.push({ kind: object.kind, schema: object.schema, name: object.name, status, parts });
+        else
+            same++;
+    }
+    changes.sort((x, y) => sortKey(x).localeCompare(sortKey(y)));
+    return { changes, same };
+}
+/** Reads both sides at once (one after the other on the same session) and compares them. */
+export async function compareSchemas(a, b, options = {}) {
+    const { schema } = options;
+    const withSchema = options.withSchema ?? schema;
+    const readA = () => snapshotSchema(a, schema ? { schema } : {});
+    const readB = () => snapshotSchema(b, withSchema ? { schema: withSchema } : {});
+    // One connection runs one statement at a time, and each read changes its search path meanwhile.
+    const [left, right] = a === b ? [await readA(), await readB()] : await Promise.all([readA(), readB()]);
+    return diffSnapshots(left, right, schema && withSchema && schema !== withSchema ? { schemas: { a: schema, b: withSchema } } : {});
+}

package/dist/explorer/search.js

@@ -0,0 +1,309 @@
+// Finding things in a database: a flat index of its object names for a search box, and a search for
+// a value through the text, uuid and integer columns of its tables.
+import { quoteIdentifier } from '../db/identifiers.js';
+import { qualified } from './catalog.js';
+export const MAX_INDEXED_COLUMNS = 50_000;
+const relationKinds = {
+    r: 'table',
+    p: 'partitioned',
+    v: 'view',
+    m: 'materialized',
+    f: 'foreign',
+};
+// The schemas a person works with, as in listSchemas.
+const userSchema = `n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'`;
+/**
+ * Every table, view, column, function, sequence, type and enum value of the schemas a person works
+ * with, with comments, for matching against what is typed in a search box.
+ */
+export async function buildSearchIndex(session) {
+    const entries = [];
+    const relations = await session.rows(`SELECT n.nspname AS schema, c.relname AS name, c.relkind AS kind,
+			pg_catalog.obj_description(c.oid, 'pg_class') AS comment
+		FROM pg_catalog.pg_class c
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE ${userSchema} AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
+		ORDER BY n.nspname, c.relname`);
+    for (const row of relations) {
+        entries.push({
+            kind: relationKinds[row.kind ?? ''] ?? 'table',
+            schema: row.schema ?? '',
+            name: row.name ?? '',
+            parent: null,
+            detail: null,
+            comment: row.comment,
+        });
+    }
+    const columns = await session.rows(`SELECT n.nspname AS schema, c.relname AS table, a.attname AS name,
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS type,
+			pg_catalog.col_description(a.attrelid, a.attnum) AS comment
+		FROM pg_catalog.pg_attribute a
+		JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		WHERE ${userSchema} AND c.relkind IN ('r', 'p', 'v', 'm', 'f')
+			AND a.attnum > 0 AND NOT a.attisdropped
+		ORDER BY n.nspname, c.relname, a.attnum
+		LIMIT $1`, [MAX_INDEXED_COLUMNS + 1]);
+    const truncated = columns.length > MAX_INDEXED_COLUMNS;
+    for (const row of columns.slice(0, MAX_INDEXED_COLUMNS)) {
+        entries.push({
+            kind: 'column',
+            schema: row.schema ?? '',
+            name: row.name ?? '',
+            parent: row.table,
+            detail: row.type,
+            comment: row.comment,
+        });
+    }
+    const labels = await session.rows(`SELECT n.nspname AS schema, t.typname AS type, e.enumlabel AS label
+		FROM pg_catalog.pg_enum e
+		JOIN pg_catalog.pg_type t ON t.oid = e.enumtypid
+		JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+		WHERE ${userSchema}
+		ORDER BY n.nspname, t.typname, e.enumsortorder`);
+    for (const row of labels) {
+        entries.push({
+            kind: 'enum value',
+            schema: row.schema ?? '',
+            name: row.label ?? '',
+            parent: row.type,
+            detail: null,
+            comment: null,
+        });
+    }
+    const functions = await session.rows(`SELECT n.nspname AS schema, p.proname AS name,
+			pg_catalog.pg_get_function_identity_arguments(p.oid) AS args,
+			pg_catalog.obj_description(p.oid, 'pg_proc') AS comment
+		FROM pg_catalog.pg_proc p
+		JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+		WHERE ${userSchema}
+		ORDER BY n.nspname, p.proname, args`);
+    for (const row of functions) {
+        entries.push({
+            kind: 'function',
+            schema: row.schema ?? '',
+            name: row.name ?? '',
+            parent: null,
+            detail: row.args ?? '',
+            comment: row.comment,
+        });
+    }
+    const sequences = await session.rows(`SELECT schemaname AS schema, sequencename AS name FROM pg_catalog.pg_sequences
+		WHERE schemaname !~ '^pg_' AND schemaname <> 'information_schema'
+		ORDER BY schemaname, sequencename`);
+    for (const row of sequences) {
+        entries.push({
+            kind: 'sequence',
+            schema: row.schema ?? '',
+            name: row.name ?? '',
+            parent: null,
+            detail: null,
+            comment: null,
+        });
+    }
+    const types = await session.rows(`SELECT n.nspname AS schema, t.typname AS name, t.typtype AS kind,
+			pg_catalog.obj_description(t.oid, 'pg_type') AS comment
+		FROM pg_catalog.pg_type t
+		JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+		WHERE ${userSchema} AND t.typtype IN ('e', 'c', 'd', 'r', 'm')
+			AND (t.typtype <> 'c' OR EXISTS (
+				SELECT 1 FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid AND c.relkind = 'c'))
+		ORDER BY n.nspname, t.typname`);
+    const typeKinds = {
+        e: 'enum',
+        c: 'composite',
+        d: 'domain',
+        r: 'range',
+        m: 'multirange',
+    };
+    for (const row of types) {
+        entries.push({
+            kind: 'type',
+            schema: row.schema ?? '',
+            name: row.name ?? '',
+            parent: null,
+            detail: typeKinds[row.kind ?? ''] ?? null,
+            comment: row.comment,
+        });
+    }
+    return { entries, truncated };
+}
+export const DEFAULT_TABLE_TIMEOUT_MS = 5_000;
+export const DEFAULT_DEADLINE_MS = 30_000;
+export const DEFAULT_MAX_TABLES = 200;
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const integerPattern = /^[+-]?\d{1,18}$/;
+const valueKinds = {
+    text: 'text',
+    varchar: 'text',
+    bpchar: 'text',
+    name: 'text',
+    citext: 'text',
+    uuid: 'uuid',
+    int2: 'integer',
+    int4: 'integer',
+    int8: 'integer',
+};
+/** The column kinds a text can be compared with, e.g. a uuid is only compared with uuid columns. */
+export function comparableKinds(text) {
+    const kinds = new Set(['text']);
+    if (uuidPattern.test(text))
+        kinds.add('uuid');
+    if (integerPattern.test(text))
+        kinds.add('integer');
+    return kinds;
+}
+/** Escapes the characters that mean something to LIKE. */
+export const escapeLike = (text) => text.replace(/[\\%_]/g, (char) => `\\${char}`);
+const likePattern = (text) => `%${escapeLike(text)}%`;
+const quoteLiteral = (text) => `'${text.replaceAll("'", "''")}'`;
+/**
+ * The condition that finds `text` in a column of the given kind. A text is compared by `$1`, which
+ * holds a LIKE pattern for it; a uuid and an integer are written out, which is safe because
+ * `comparableKinds` only lets through text of exactly their shape.
+ */
+const conditionFor = (column, kind, text) => kind === 'text'
+    ? `${column} ILIKE $1`
+    : kind === 'uuid'
+        ? `${column} = ${quoteLiteral(text)}::uuid`
+        : `${column} = ${text.replace(/^\+/, '')}`;
+/** A statement that lists the rows of a table holding the text in one column. */
+export function valueSql(table, column, kind, text) {
+    const name = quoteIdentifier(column);
+    const where = kind === 'text'
+        ? `${name} ILIKE ${quoteLiteral(likePattern(text))}`
+        : conditionFor(name, kind, text);
+    return `SELECT * FROM ${qualified(table)} WHERE ${where} LIMIT 100`;
+}
+const timedOut = (error) => error?.code === '57014';
+/**
+ * Looks for `text` in every text, uuid and integer column of the tables of a schema (or of all),
+ * reading each table once. Given several sessions, the tables are shared out over them, one table at a time on
+ * each, so more sessions read more tables side by side. The work is bounded: a table that takes
+ * longer than `tableTimeoutMs` is skipped, and so is everything left once `deadlineMs` has passed
+ * or `maxTables` are done, each with the reason in the result. Views are not read. Only SELECT
+ * statements are run.
+ */
+export async function searchValues(sessionOrSessions, { text, schema }, { tableTimeoutMs = DEFAULT_TABLE_TIMEOUT_MS, deadlineMs = DEFAULT_DEADLINE_MS, maxTables = DEFAULT_MAX_TABLES, } = {}) {
+    const sessions = Array.isArray(sessionOrSessions)
+        ? sessionOrSessions
+        : [sessionOrSessions];
+    const [first] = sessions;
+    if (!first)
+        throw new Error('searchValues needs a session');
+    const kinds = comparableKinds(text);
+    const found = await first.rows(`SELECT n.nspname AS schema, c.relname AS table, a.attname AS column,
+			pg_catalog.format_type(a.atttypid, a.atttypmod) AS type, t.typname AS udt
+		FROM pg_catalog.pg_attribute a
+		JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
+		JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+		JOIN pg_catalog.pg_type t ON t.oid = a.atttypid
+		WHERE ${userSchema} AND c.relkind IN ('r', 'p')
+			AND ($1::text IS NULL OR n.nspname = $1)
+			AND a.attnum > 0 AND NOT a.attisdropped
+			AND t.typname = ANY($2::text[])
+			AND pg_catalog.has_column_privilege(a.attrelid, a.attnum, 'SELECT')
+		ORDER BY n.nspname, c.relname, a.attnum`, [schema ?? null, Object.keys(valueKinds)]);
+    // Group the columns that can be compared with the text by table.
+    const tables = new Map();
+    for (const row of found) {
+        const kind = valueKinds[row.udt ?? ''];
+        if (!kind || !kinds.has(kind))
+            continue;
+        const table = { schema: row.schema ?? '', name: row.table ?? '' };
+        const key = `${table.schema}\0${table.name}`;
+        const entry = tables.get(key) ?? { table, columns: [] };
+        entry.columns.push({ name: row.column ?? '', type: row.type ?? '', kind });
+        tables.set(key, entry);
+    }
+    const started = Date.now();
+    const queue = [...tables.values()];
+    // One slot per table, so the result reads the same however the sessions interleave.
+    const outcomes = [];
+    let next = 0;
+    // Tables being read or read successfully, against maxTables.
+    let used = 0;
+    // The timeout belongs to the session, so put the old one back when done.
+    const worker = async (session) => {
+        const [before] = await session.rows("SELECT current_setting('statement_timeout') AS timeout");
+        await session.rows("SELECT pg_catalog.set_config('statement_timeout', $1, false)", [
+            String(tableTimeoutMs),
+        ]);
+        try {
+            for (;;) {
+                const index = next++;
+                const item = queue[index];
+                if (!item)
+                    return;
+                const { table, columns } = item;
+                if (used >= maxTables) {
+                    outcomes[index] = { skipped: `only ${maxTables} tables are searched at a time` };
+                    continue;
+                }
+                if (Date.now() - started > deadlineMs) {
+                    outcomes[index] = { skipped: 'ran out of time' };
+                    continue;
+                }
+                used++;
+                // One pass over the table counts the rows for every column at once.
+                const counts = columns
+                    .map((column, i) => {
+                    const condition = conditionFor(quoteIdentifier(column.name), column.kind, text);
+                    return `count(*) FILTER (WHERE ${condition}) AS c${i}`;
+                })
+                    .join(', ');
+                // A parameter nobody uses has no type, so it is only sent along with a text column.
+                const values = columns.some((column) => column.kind === 'text') ? [likePattern(text)] : [];
+                try {
+                    const [row] = await session.rows(`SELECT ${counts} FROM ${qualified(table)}`, values);
+                    outcomes[index] = {
+                        matches: columns.flatMap((column, i) => {
+                            const count = Number(row?.[`c${i}`] ?? 0);
+                            return count > 0
+                                ? [
+                                    {
+                                        ...table,
+                                        column: column.name,
+                                        type: column.type,
+                                        matches: count,
+                                        sql: valueSql(table, column.name, column.kind, text),
+                                    },
+                                ]
+                                : [];
+                        }),
+                    };
+                }
+                catch (error) {
+                    used--;
+                    outcomes[index] = {
+                        skipped: timedOut(error)
+                            ? `took longer than ${Math.round(tableTimeoutMs / 1000)}s`
+                            : error instanceof Error
+                                ? error.message
+                                : String(error),
+                    };
+                }
+            }
+        }
+        finally {
+            await session.rows("SELECT pg_catalog.set_config('statement_timeout', $1, false)", [
+                before?.timeout ?? '0',
+            ]);
+        }
+    };
+    await Promise.all(sessions.map(worker));
+    const matches = [];
+    const skipped = [];
+    let searched = 0;
+    outcomes.forEach((outcome, index) => {
+        if ('skipped' in outcome)
+            skipped.push({ table: queue[index].table, reason: outcome.skipped });
+        else {
+            searched++;
+            matches.push(...outcome.matches);
+        }
+    });
+    // Most matches first.
+    matches.sort((a, b) => b.matches - a.matches);
+    return { matches, searched, skipped };
+}