neonctl 2.22.2 → 2.23.1

package/psql/describe/queries.js

@@ -0,0 +1,2373 @@
+/**
+ * SQL builders for psql's `\d*` describe commands.
+ *
+ * Each exported function returns a {@link DescribeQuery} carrying the SQL the
+ * upstream C `describe.c` would have produced for the same `\d*` invocation,
+ * adapted for the active `serverVersion`. The header text (column aliases)
+ * matches upstream literally so that WP-20's formatter can rely on stable
+ * output column names.
+ *
+ * Pattern matching (the `processSQLNamePattern` flex routine in upstream) is
+ * NOT yet implemented; we accept a `pattern` option and emit a placeholder
+ * `(<col> ~ $1 OR $1 IS NULL)` clause where needed. WP-20 wires the real
+ * pattern parser. See TODO comments throughout.
+ *
+ * Translation policy: SQL whitespace is normalized but column aliases and
+ * catalog table/column names are byte-identical to upstream. Conditional
+ * branches in the C source collapse into TS conditional concatenation gated
+ * on `serverVersion`.
+ */
+import { serverAtLeast, serverLess, PG_9_5, PG_9_6, PG_10, PG_11, PG_12, PG_13, PG_14, PG_15, PG_16, PG_17, PG_18, } from './versionGate.js';
+/* ------------------------------------------------------------------ */
+/* Shared helpers                                                     */
+/* ------------------------------------------------------------------ */
+/**
+ * Reproduces upstream `printACLColumn(buf, colname)`: emits the standard
+ * ACL pretty-printing expression with column alias "Access privileges".
+ */
+const aclColumn = (colname) => `CASE WHEN pg_catalog.array_length(${colname}, 1) = 0 THEN '(none)'` +
+    ` ELSE pg_catalog.array_to_string(${colname}, E'\\n') END AS "Access privileges"`;
+/**
+ * Placeholder pattern clause. WP-20 will replace these stubs with the real
+ * `processSQLNamePattern` port. For now the clause is a tautology so the
+ * query runs unfiltered; the pattern parameter is still threaded through
+ * `params` so callers do not need to change call sites later.
+ *
+ * @param hasWhere whether a WHERE clause already exists in the SQL
+ * @param schemaCol column expression for the schema name, or undefined
+ * @param nameCol column expression for the object name
+ */
+const patternStub = (hasWhere, schemaCol, nameCol) => {
+    // TODO(WP-20): real pattern matching via processSQLNamePattern port.
+    void schemaCol;
+    void nameCol;
+    const join = hasWhere ? '  AND ' : 'WHERE ';
+    return `${join}true /* TODO(WP-20): pattern matching */\n`;
+};
+/**
+ * Per-argument pattern slot for `\df name argtype1 argtype2 …` and
+ * `\do name argtype1 argtype2`. Each slot emits a uniquely tagged
+ * placeholder so the dispatcher can substitute the i-th processed
+ * type-name pattern (matched against `t<i>.typname`, `nt<i>.nspname`,
+ * and `format_type(t<i>.oid, NULL)` like upstream).
+ */
+const argPatternStub = (slot) => `true /* ARG_PATTERN_${slot} */`;
+const orderBy = (cols) => `ORDER BY ${cols};`;
+// Returns the base params for a describe query. Always empty: the pattern
+// itself is threaded through `processSQLNamePattern` + `applyPattern` in
+// cmd_describe.ts, which renders the conditions with their own `$N` slots
+// and pushes the right values into params at runtime. Returning [pattern]
+// here would leave $1 unreferenced in the final SQL (applyPattern shifts
+// the conditions' $N by baseParams.length), causing the server to reject
+// the Parse with "could not determine data type of parameter $1".
+const params = () => [];
+/* ------------------------------------------------------------------ */
+/* \da — describeAggregates                                           */
+/* ------------------------------------------------------------------ */
+export const describeAggregates = (opts) => {
+    const { showSystem, pattern, serverVersion } = opts;
+    let sql = '';
+    sql +=
+        'SELECT n.nspname as "Schema",\n' +
+            '  p.proname AS "Name",\n' +
+            '  pg_catalog.format_type(p.prorettype, NULL) AS "Result data type",\n' +
+            '  CASE WHEN p.pronargs = 0\n' +
+            "    THEN CAST('*' AS pg_catalog.text)\n" +
+            '    ELSE pg_catalog.pg_get_function_arguments(p.oid)\n' +
+            '  END AS "Argument data types",\n' +
+            '  pg_catalog.obj_description(p.oid, \'pg_proc\') as "Description"\n' +
+            'FROM pg_catalog.pg_proc p\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n';
+    sql += serverAtLeast(serverVersion, PG_11)
+        ? "WHERE p.prokind = 'a'\n"
+        : 'WHERE p.proisagg\n';
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n" +
+                "      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 'p.proname');
+    sql += orderBy('1, 2, 4');
+    return {
+        sql,
+        params: params(),
+        description: 'List of aggregate functions',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dA — describeAccessMethods                                        */
+/* ------------------------------------------------------------------ */
+export const describeAccessMethods = (opts) => {
+    const { verbose, serverVersion } = opts;
+    if (serverLess(serverVersion, 9, 6)) {
+        return {
+            sql: '/* server < 9.6 does not support access methods */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'List of access methods',
+        };
+    }
+    let sql = 'SELECT amname AS "Name",\n' +
+        "  CASE amtype WHEN 'i' THEN 'Index' WHEN 't' THEN 'Table' END AS \"Type\"";
+    if (verbose) {
+        sql +=
+            ',\n  amhandler AS "Handler",\n' +
+                '  pg_catalog.obj_description(oid, \'pg_am\') AS "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_am\n';
+    sql += patternStub(false, undefined, 'amname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of access methods' };
+};
+/* ------------------------------------------------------------------ */
+/* \db — describeTablespaces                                          */
+/* ------------------------------------------------------------------ */
+export const describeTablespaces = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT spcname AS "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(spcowner) AS "Owner",\n' +
+        '  pg_catalog.pg_tablespace_location(oid) AS "Location"';
+    if (verbose) {
+        sql += ',\n  ' + aclColumn('spcacl');
+        sql +=
+            ',\n  spcoptions AS "Options",\n' +
+                '  pg_catalog.pg_size_pretty(pg_catalog.pg_tablespace_size(oid)) AS "Size",\n' +
+                '  pg_catalog.shobj_description(oid, \'pg_tablespace\') AS "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_tablespace\n';
+    sql += patternStub(false, undefined, 'spcname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of tablespaces' };
+};
+export const describeFunctions = (opts) => {
+    const { verbose, showSystem, pattern, serverVersion } = opts;
+    const functypes = opts.functypes ?? '';
+    const argPatterns = opts.argPatterns ?? [];
+    let showAgg = functypes.includes('a');
+    let showNorm = functypes.includes('n');
+    let showProc = functypes.includes('p');
+    let showTrig = functypes.includes('t');
+    let showWin = functypes.includes('w');
+    if (!showAgg && !showNorm && !showProc && !showTrig && !showWin) {
+        showAgg = showNorm = showTrig = showWin = true;
+        if (serverAtLeast(serverVersion, PG_11))
+            showProc = true;
+    }
+    let sql = 'SELECT n.nspname as "Schema",\n  p.proname as "Name",\n';
+    if (serverAtLeast(serverVersion, PG_11)) {
+        sql +=
+            '  pg_catalog.pg_get_function_result(p.oid) as "Result data type",\n' +
+                '  pg_catalog.pg_get_function_arguments(p.oid) as "Argument data types",\n' +
+                ' CASE p.prokind\n' +
+                "  WHEN 'a' THEN 'agg'\n" +
+                "  WHEN 'w' THEN 'window'\n" +
+                "  WHEN 'p' THEN 'proc'\n" +
+                "  ELSE 'func'\n" +
+                ' END as "Type"';
+    }
+    else {
+        sql +=
+            '  pg_catalog.pg_get_function_result(p.oid) as "Result data type",\n' +
+                '  pg_catalog.pg_get_function_arguments(p.oid) as "Argument data types",\n' +
+                ' CASE\n' +
+                "  WHEN p.proisagg THEN 'agg'\n" +
+                "  WHEN p.proiswindow THEN 'window'\n" +
+                "  WHEN p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype THEN 'trigger'\n" +
+                "  ELSE 'func'\n" +
+                ' END as "Type"';
+    }
+    if (verbose) {
+        sql +=
+            ',\n CASE\n' +
+                "  WHEN p.provolatile = 'i' THEN 'immutable'\n" +
+                "  WHEN p.provolatile = 's' THEN 'stable'\n" +
+                "  WHEN p.provolatile = 'v' THEN 'volatile'\n" +
+                ' END as "Volatility"';
+        if (serverAtLeast(serverVersion, PG_9_6)) {
+            sql +=
+                ',\n CASE\n' +
+                    "  WHEN p.proparallel = 'r' THEN 'restricted'\n" +
+                    "  WHEN p.proparallel = 's' THEN 'safe'\n" +
+                    "  WHEN p.proparallel = 'u' THEN 'unsafe'\n" +
+                    ' END as "Parallel"';
+        }
+        sql +=
+            ',\n pg_catalog.pg_get_userbyid(p.proowner) as "Owner"' +
+                ",\n CASE WHEN prosecdef THEN 'definer' ELSE 'invoker' END AS \"Security\"";
+        // PG 18 added a "Leakproof?" column to verbose `\df+`. The pg_proc
+        // catalog has carried `proleakproof` since 9.2, but upstream's psql
+        // only began surfacing it in 18.
+        if (serverAtLeast(serverVersion, PG_18)) {
+            sql +=
+                ",\n CASE WHEN p.proleakproof THEN 'yes' ELSE 'no' END as \"Leakproof?\"";
+        }
+        sql += ',\n ' + aclColumn('p.proacl');
+        sql +=
+            ',\n l.lanname as "Language"' +
+                ",\n CASE WHEN l.lanname IN ('internal', 'c') THEN p.prosrc END as \"Internal name\"" +
+                ',\n pg_catalog.obj_description(p.oid, \'pg_proc\') as "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_proc p' +
+            '\n     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace\n';
+    // Upstream emits the per-argument joins *before* the verbose-language
+    // join so that all `t<i>`/`nt<i>` tables exist by the time the WHERE
+    // pulls in per-arg conditions. See describe.c::describeFunctions.
+    for (let i = 0; i < argPatterns.length; i++) {
+        sql +=
+            `     LEFT JOIN pg_catalog.pg_type t${i} ON t${i}.oid = p.proargtypes[${i}]\n` +
+                `     LEFT JOIN pg_catalog.pg_namespace nt${i} ON nt${i}.oid = t${i}.typnamespace\n`;
+    }
+    if (verbose) {
+        sql += '     LEFT JOIN pg_catalog.pg_language l ON l.oid = p.prolang\n';
+    }
+    let hasWhere = false;
+    const allTypes = showAgg && showNorm && showProc && showTrig && showWin;
+    if (!allTypes && showNorm) {
+        if (!showAgg) {
+            sql += hasWhere ? '      AND ' : 'WHERE ';
+            hasWhere = true;
+            sql += serverAtLeast(serverVersion, PG_11)
+                ? "p.prokind <> 'a'\n"
+                : 'NOT p.proisagg\n';
+        }
+        if (!showProc && serverAtLeast(serverVersion, PG_11)) {
+            sql += hasWhere ? '      AND ' : 'WHERE ';
+            hasWhere = true;
+            sql += "p.prokind <> 'p'\n";
+        }
+        if (!showTrig) {
+            sql += hasWhere ? '      AND ' : 'WHERE ';
+            hasWhere = true;
+            sql += "p.prorettype <> 'pg_catalog.trigger'::pg_catalog.regtype\n";
+        }
+        if (!showWin) {
+            sql += hasWhere ? '      AND ' : 'WHERE ';
+            hasWhere = true;
+            sql += serverAtLeast(serverVersion, PG_11)
+                ? "p.prokind <> 'w'\n"
+                : 'NOT p.proiswindow\n';
+        }
+    }
+    else if (!allTypes) {
+        sql += 'WHERE (\n       ';
+        hasWhere = true;
+        const parts = [];
+        if (showAgg) {
+            parts.push(serverAtLeast(serverVersion, PG_11) ? "p.prokind = 'a'" : 'p.proisagg');
+        }
+        if (showTrig) {
+            parts.push("p.prorettype = 'pg_catalog.trigger'::pg_catalog.regtype");
+        }
+        if (showProc)
+            parts.push("p.prokind = 'p'");
+        if (showWin) {
+            parts.push(serverAtLeast(serverVersion, PG_11)
+                ? "p.prokind = 'w'"
+                : 'p.proiswindow');
+        }
+        sql += parts.join('\n       OR ') + '\n      )\n';
+    }
+    sql += patternStub(hasWhere, 'n.nspname', 'p.proname');
+    // Upstream's per-argument filter loop. `-` means "no type in this
+    // slot" (function has fewer args); anything else is a type-name
+    // pattern matched against typname/format_type — same shape as `\dT`.
+    // Each slot emits a uniquely tagged placeholder so cmd_describe.ts
+    // can splice in the appropriate per-arg conditions.
+    for (let i = 0; i < argPatterns.length; i++) {
+        if (argPatterns[i] === '-') {
+            sql += `      AND t${i}.typname IS NULL\n`;
+        }
+        else {
+            sql += `      AND ${argPatternStub(i)}\n`;
+        }
+    }
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n" +
+                "      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += orderBy('1, 2, 4');
+    return { sql, params: params(), description: 'List of functions' };
+};
+/* ------------------------------------------------------------------ */
+/* \dT — describeTypes                                                */
+/* ------------------------------------------------------------------ */
+export const describeTypes = (opts) => {
+    const { verbose, showSystem, pattern } = opts;
+    let sql = 'SELECT n.nspname as "Schema",\n  pg_catalog.format_type(t.oid, NULL) AS "Name",\n';
+    if (verbose) {
+        sql +=
+            '  t.typname AS "Internal name",\n' +
+                '  CASE WHEN t.typrelid != 0\n' +
+                "      THEN CAST('tuple' AS pg_catalog.text)\n" +
+                '    WHEN t.typlen < 0\n' +
+                "      THEN CAST('var' AS pg_catalog.text)\n" +
+                '    ELSE CAST(t.typlen AS pg_catalog.text)\n' +
+                '  END AS "Size",\n' +
+                '  pg_catalog.array_to_string(\n' +
+                '      ARRAY(\n' +
+                '          SELECT e.enumlabel\n' +
+                '          FROM pg_catalog.pg_enum e\n' +
+                '          WHERE e.enumtypid = t.oid\n' +
+                '          ORDER BY e.enumsortorder\n' +
+                '      ),\n' +
+                "      E'\\n'\n" +
+                '  ) AS "Elements",\n' +
+                '  pg_catalog.pg_get_userbyid(t.typowner) AS "Owner",\n  ' +
+                aclColumn('t.typacl') +
+                ',\n  ';
+    }
+    sql += '  pg_catalog.obj_description(t.oid, \'pg_type\') as "Description"\n';
+    sql +=
+        'FROM pg_catalog.pg_type t\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n';
+    sql += 'WHERE (t.typrelid = 0 ';
+    sql +=
+        "OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid))\n";
+    if (!pattern?.includes('[]')) {
+        sql +=
+            '  AND NOT EXISTS(SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)\n';
+    }
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n" +
+                "      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 't.typname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of data types' };
+};
+export const describeOperators = (opts) => {
+    const { verbose, showSystem, pattern, serverVersion } = opts;
+    let argPatterns = opts.argPatterns ?? [];
+    // Upstream caps at 2 — extra args past two are silently dropped.
+    if (argPatterns.length > 2)
+        argPatterns = argPatterns.slice(0, 2);
+    let sql = 'SELECT n.nspname as "Schema",\n' +
+        '  o.oprname AS "Name",\n' +
+        '  CASE WHEN o.oprkind=\'l\' THEN NULL ELSE pg_catalog.format_type(o.oprleft, NULL) END AS "Left arg type",\n' +
+        '  CASE WHEN o.oprkind=\'r\' THEN NULL ELSE pg_catalog.format_type(o.oprright, NULL) END AS "Right arg type",\n' +
+        '  pg_catalog.format_type(o.oprresult, NULL) AS "Result type",\n';
+    if (verbose) {
+        sql += '  o.oprcode AS "Function",\n';
+        // PG 18 added "Leakproof?" to verbose `\do+`. Earlier servers only
+        // emitted Function and Description.
+        if (serverAtLeast(serverVersion, PG_18)) {
+            sql +=
+                "  CASE WHEN p.proleakproof THEN 'yes' ELSE 'no' END AS \"Leakproof?\",\n";
+        }
+    }
+    sql +=
+        "  coalesce(pg_catalog.obj_description(o.oid, 'pg_operator'),\n" +
+            '           pg_catalog.obj_description(o.oprcode, \'pg_proc\')) AS "Description"\n' +
+            'FROM pg_catalog.pg_operator o\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = o.oprnamespace\n';
+    // Upstream emits arg-type joins before the verbose `pg_proc` join.
+    // With one arg pattern: only join the right-hand side (oprright);
+    // with two: both oprleft/oprright. Tag indices match the join name
+    // so `t0/nt0` correspond to the first arg pattern slot.
+    if (argPatterns.length === 1) {
+        sql +=
+            '     LEFT JOIN pg_catalog.pg_type t0 ON t0.oid = o.oprright\n' +
+                '     LEFT JOIN pg_catalog.pg_namespace nt0 ON nt0.oid = t0.typnamespace\n';
+    }
+    else if (argPatterns.length >= 2) {
+        sql +=
+            '     LEFT JOIN pg_catalog.pg_type t0 ON t0.oid = o.oprleft\n' +
+                '     LEFT JOIN pg_catalog.pg_namespace nt0 ON nt0.oid = t0.typnamespace\n' +
+                '     LEFT JOIN pg_catalog.pg_type t1 ON t1.oid = o.oprright\n' +
+                '     LEFT JOIN pg_catalog.pg_namespace nt1 ON nt1.oid = t1.typnamespace\n';
+    }
+    if (verbose && serverAtLeast(serverVersion, PG_18)) {
+        // Only joined when we need proleakproof from pg_proc (PG 18+).
+        sql += '     LEFT JOIN pg_catalog.pg_proc p ON p.oid = o.oprcode\n';
+    }
+    let hasWhere = false;
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "WHERE n.nspname <> 'pg_catalog'\n      AND n.nspname <> 'information_schema'\n";
+        hasWhere = true;
+    }
+    sql += patternStub(hasWhere, 'n.nspname', 'o.oprname');
+    // With a single arg pattern, upstream additionally constrains the
+    // operator to be unary-right (oprleft = 0) so unrelated binary
+    // operators don't leak through the `t0` join.
+    if (argPatterns.length === 1) {
+        sql += '      AND o.oprleft = 0\n';
+    }
+    for (let i = 0; i < argPatterns.length; i++) {
+        if (argPatterns[i] === '-') {
+            sql += `      AND t${i}.typname IS NULL\n`;
+        }
+        else {
+            sql += `      AND ${argPatternStub(i)}\n`;
+        }
+    }
+    sql += orderBy('1, 2, 3, 4');
+    return { sql, params: params(), description: 'List of operators' };
+};
+/* ------------------------------------------------------------------ */
+/* \l / \list — listAllDbs                                            */
+/* ------------------------------------------------------------------ */
+export const listAllDbs = (opts) => {
+    const { verbose, serverVersion } = opts;
+    let sql = 'SELECT\n' +
+        '  d.datname as "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(d.datdba) as "Owner",\n' +
+        '  pg_catalog.pg_encoding_to_char(d.encoding) as "Encoding",\n';
+    if (serverAtLeast(serverVersion, PG_15)) {
+        sql +=
+            '  CASE d.datlocprovider' +
+                " WHEN 'b' THEN 'builtin'" +
+                " WHEN 'c' THEN 'libc'" +
+                " WHEN 'i' THEN 'icu'" +
+                ' END AS "Locale Provider",\n';
+    }
+    else {
+        sql += '  \'libc\' AS "Locale Provider",\n';
+    }
+    sql += '  d.datcollate as "Collate",\n  d.datctype as "Ctype",\n';
+    if (serverAtLeast(serverVersion, PG_17)) {
+        sql += '  d.datlocale as "Locale",\n';
+    }
+    else if (serverAtLeast(serverVersion, PG_15)) {
+        sql += '  d.daticulocale as "Locale",\n';
+    }
+    else {
+        sql += '  NULL as "Locale",\n';
+    }
+    if (serverAtLeast(serverVersion, PG_16)) {
+        sql += '  d.daticurules as "ICU Rules",\n';
+    }
+    else {
+        sql += '  NULL as "ICU Rules",\n';
+    }
+    sql += '  ' + aclColumn('d.datacl');
+    if (verbose) {
+        sql +=
+            ",\n  CASE WHEN pg_catalog.has_database_privilege(d.datname, 'CONNECT')\n" +
+                '       THEN pg_catalog.pg_size_pretty(pg_catalog.pg_database_size(d.datname))\n' +
+                "       ELSE 'No Access'\n" +
+                '  END as "Size"' +
+                ',\n  t.spcname as "Tablespace"' +
+                ',\n  pg_catalog.shobj_description(d.oid, \'pg_database\') as "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_database d\n';
+    if (verbose) {
+        sql += '  JOIN pg_catalog.pg_tablespace t on d.dattablespace = t.oid\n';
+    }
+    if (opts.pattern !== undefined) {
+        sql += patternStub(false, undefined, 'd.datname');
+    }
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of databases' };
+};
+/* ------------------------------------------------------------------ */
+/* \dp / \z — permissionsList                                         */
+/* ------------------------------------------------------------------ */
+export const permissionsList = (opts) => {
+    const { showSystem, pattern, serverVersion } = opts;
+    let sql = 'SELECT n.nspname as "Schema",\n' +
+        '  c.relname as "Name",\n' +
+        '  CASE c.relkind' +
+        " WHEN 'r' THEN 'table'" +
+        " WHEN 'v' THEN 'view'" +
+        " WHEN 'm' THEN 'materialized view'" +
+        " WHEN 'S' THEN 'sequence'" +
+        " WHEN 'f' THEN 'foreign table'" +
+        " WHEN 'p' THEN 'partitioned table'" +
+        ' END as "Type",\n  ';
+    sql += aclColumn('c.relacl');
+    sql +=
+        ',\n  pg_catalog.array_to_string(ARRAY(\n' +
+            "    SELECT attname || E':\\n  ' || pg_catalog.array_to_string(attacl, E'\\n  ')\n" +
+            '    FROM pg_catalog.pg_attribute a\n' +
+            '    WHERE attrelid = c.oid AND NOT attisdropped AND attacl IS NOT NULL\n' +
+            '  ), E\'\\n\') AS "Column privileges"';
+    if (serverAtLeast(serverVersion, PG_10)) {
+        sql +=
+            ',\n  pg_catalog.array_to_string(ARRAY(\n' +
+                '    SELECT polname\n' +
+                "    || CASE WHEN NOT polpermissive THEN E' (RESTRICTIVE)' ELSE '' END\n" +
+                "    || CASE WHEN polcmd != '*' THEN E' (' || polcmd::pg_catalog.text || E'):' ELSE E':' END\n" +
+                "    || CASE WHEN polqual IS NOT NULL THEN E'\\n  (u): ' || pg_catalog.pg_get_expr(polqual, polrelid) ELSE E'' END\n" +
+                "    || CASE WHEN polwithcheck IS NOT NULL THEN E'\\n  (c): ' || pg_catalog.pg_get_expr(polwithcheck, polrelid) ELSE E'' END\n" +
+                "    || CASE WHEN polroles <> '{0}' THEN E'\\n  to: ' || pg_catalog.array_to_string(\n" +
+                '             ARRAY(SELECT rolname FROM pg_catalog.pg_roles WHERE oid = ANY (polroles) ORDER BY 1)\n' +
+                "             , E', ') ELSE E'' END\n" +
+                '    FROM pg_catalog.pg_policy pol\n' +
+                '    WHERE polrelid = c.oid), E\'\\n\') AS "Policies"';
+    }
+    else if (serverAtLeast(serverVersion, PG_9_5)) {
+        sql +=
+            ',\n  pg_catalog.array_to_string(ARRAY(\n' +
+                '    SELECT polname\n' +
+                "    || CASE WHEN polcmd != '*' THEN E' (' || polcmd::pg_catalog.text || E'):' ELSE E':' END\n" +
+                "    || CASE WHEN polqual IS NOT NULL THEN E'\\n  (u): ' || pg_catalog.pg_get_expr(polqual, polrelid) ELSE E'' END\n" +
+                "    || CASE WHEN polwithcheck IS NOT NULL THEN E'\\n  (c): ' || pg_catalog.pg_get_expr(polwithcheck, polrelid) ELSE E'' END\n" +
+                "    || CASE WHEN polroles <> '{0}' THEN E'\\n  to: ' || pg_catalog.array_to_string(\n" +
+                '             ARRAY(SELECT rolname FROM pg_catalog.pg_roles WHERE oid = ANY (polroles) ORDER BY 1)\n' +
+                "             , E', ') ELSE E'' END\n" +
+                '    FROM pg_catalog.pg_policy pol\n' +
+                '    WHERE polrelid = c.oid), E\'\\n\') AS "Policies"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_class c\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n' +
+            "WHERE c.relkind IN ('r','v','m','S','f','p')\n";
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 'c.relname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'Access privileges' };
+};
+/* ------------------------------------------------------------------ */
+/* \ddp — listDefaultACLs                                             */
+/* ------------------------------------------------------------------ */
+export const listDefaultACLs = (opts) => {
+    const { serverVersion } = opts;
+    // PG 18 added DEFACLOBJ_LARGEOBJECT ('L'); pre-18 servers can never
+    // produce that defaclobjtype value, so emitting the WHEN is harmless
+    // there — but to mirror upstream `\ddp` output, we gate it.
+    let sql = 'SELECT pg_catalog.pg_get_userbyid(d.defaclrole) AS "Owner",\n' +
+        '  n.nspname AS "Schema",\n' +
+        '  CASE d.defaclobjtype' +
+        " WHEN 'r' THEN 'table'" +
+        " WHEN 'S' THEN 'sequence'" +
+        " WHEN 'f' THEN 'function'" +
+        " WHEN 'T' THEN 'type'" +
+        " WHEN 'n' THEN 'schema'";
+    if (serverAtLeast(serverVersion, PG_18)) {
+        sql += " WHEN 'L' THEN 'large object'";
+    }
+    sql += ' END AS "Type",\n  ';
+    sql += aclColumn('d.defaclacl');
+    sql +=
+        '\nFROM pg_catalog.pg_default_acl d\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = d.defaclnamespace\n';
+    sql += patternStub(false, 'n.nspname', 'pg_catalog.pg_get_userbyid(d.defaclrole)');
+    sql += orderBy('1, 2, 3');
+    return {
+        sql,
+        params: params(),
+        description: 'Default access privileges',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dd — objectDescription                                            */
+/* ------------------------------------------------------------------ */
+export const objectDescription = (opts) => {
+    const sysPart = (objLabel) => !opts.showSystem && opts.pattern === undefined
+        ? `WHERE n.nspname <> 'pg_catalog' AND n.nspname <> 'information_schema'` +
+            ` /* ${objLabel} */ `
+        : `WHERE true /* ${objLabel} */ `;
+    let sql = 'SELECT DISTINCT tt.nspname AS "Schema", tt.name AS "Name", tt.object AS "Object", d.description AS "Description"\n' +
+        'FROM (\n';
+    sql +=
+        '  SELECT pgc.oid as oid, pgc.tableoid AS tableoid, n.nspname as nspname,\n' +
+            '  CAST(pgc.conname AS pg_catalog.text) as name,' +
+            "  CAST('table constraint' AS pg_catalog.text) as object\n" +
+            '  FROM pg_catalog.pg_constraint pgc\n' +
+            '    JOIN pg_catalog.pg_class c ON c.oid = pgc.conrelid\n' +
+            '    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n' +
+            sysPart('table constraint') +
+            '\n';
+    sql +=
+        'UNION ALL\n' +
+            '  SELECT pgc.oid, pgc.tableoid, n.nspname,\n' +
+            '  CAST(pgc.conname AS pg_catalog.text),' +
+            "  CAST('domain constraint' AS pg_catalog.text)\n" +
+            '  FROM pg_catalog.pg_constraint pgc\n' +
+            '    JOIN pg_catalog.pg_type t ON t.oid = pgc.contypid\n' +
+            '    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n' +
+            sysPart('domain constraint') +
+            '\n';
+    sql +=
+        'UNION ALL\n' +
+            '  SELECT o.oid, o.tableoid, n.nspname,\n' +
+            '  CAST(o.opcname AS pg_catalog.text),' +
+            "  CAST('operator class' AS pg_catalog.text)\n" +
+            '  FROM pg_catalog.pg_opclass o\n' +
+            '    JOIN pg_catalog.pg_am am ON o.opcmethod = am.oid\n' +
+            '    JOIN pg_catalog.pg_namespace n ON n.oid = o.opcnamespace\n' +
+            sysPart('operator class') +
+            '\n';
+    sql +=
+        'UNION ALL\n' +
+            '  SELECT opf.oid, opf.tableoid, n.nspname,\n' +
+            '  CAST(opf.opfname AS pg_catalog.text),' +
+            "  CAST('operator family' AS pg_catalog.text)\n" +
+            '  FROM pg_catalog.pg_opfamily opf\n' +
+            '    JOIN pg_catalog.pg_am am ON opf.opfmethod = am.oid\n' +
+            '    JOIN pg_catalog.pg_namespace n ON opf.opfnamespace = n.oid\n' +
+            sysPart('operator family') +
+            '\n';
+    sql +=
+        'UNION ALL\n' +
+            '  SELECT r.oid, r.tableoid, n.nspname,\n' +
+            '  CAST(r.rulename AS pg_catalog.text),' +
+            "  CAST('rule' AS pg_catalog.text)\n" +
+            '  FROM pg_catalog.pg_rewrite r\n' +
+            '       JOIN pg_catalog.pg_class c ON c.oid = r.ev_class\n' +
+            '       LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n' +
+            "  WHERE r.rulename != '_RETURN'\n";
+    sql +=
+        'UNION ALL\n' +
+            '  SELECT t.oid, t.tableoid, n.nspname,\n' +
+            '  CAST(t.tgname AS pg_catalog.text),' +
+            "  CAST('trigger' AS pg_catalog.text)\n" +
+            '  FROM pg_catalog.pg_trigger t\n' +
+            '       JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid\n' +
+            '       LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n' +
+            sysPart('trigger') +
+            '\n';
+    sql +=
+        ') AS tt\n' +
+            '  JOIN pg_catalog.pg_description d ON (tt.oid = d.objoid AND tt.tableoid = d.classoid AND d.objsubid = 0)\n';
+    sql += orderBy('1, 2, 3');
+    return { sql, params: params(), description: 'Object descriptions' };
+};
+/* ------------------------------------------------------------------ */
+/* \d (no args / \d <name>) — describeTableDetails                    */
+/* This WP delivers ONLY the lookup query; the per-relation detail    */
+/* render is WP-20.                                                   */
+/* ------------------------------------------------------------------ */
+export const describeTableDetails = (opts) => {
+    const { verbose, showSystem, pattern, serverVersion } = opts;
+    const hideTableam = opts.hideTableam ?? false;
+    // For bare `\d [pattern]` upstream renders the same relations table as
+    // `\dtvmsiE` does, with the per-relkind type column populated. Include
+    // the verbose-mode columns when caller asks for them so `\d+ [pat]`
+    // matches `\dt+ [pat]` shape.
+    let sql = 'SELECT n.nspname as "Schema",\n' +
+        '  c.relname as "Name",\n' +
+        '  CASE c.relkind' +
+        " WHEN 'r' THEN 'table'" +
+        " WHEN 'v' THEN 'view'" +
+        " WHEN 'm' THEN 'materialized view'" +
+        " WHEN 'i' THEN 'index'" +
+        " WHEN 'S' THEN 'sequence'" +
+        " WHEN 't' THEN 'TOAST table'" +
+        " WHEN 'f' THEN 'foreign table'" +
+        " WHEN 'p' THEN 'partitioned table'" +
+        " WHEN 'I' THEN 'partitioned index'" +
+        ' END as "Type",\n' +
+        '  pg_catalog.pg_get_userbyid(c.relowner) as "Owner"';
+    if (verbose) {
+        sql +=
+            ',\n  CASE c.relpersistence' +
+                " WHEN 'p' THEN 'permanent'" +
+                " WHEN 't' THEN 'temporary'" +
+                " WHEN 'u' THEN 'unlogged'" +
+                ' END as "Persistence"';
+        if (!hideTableam && serverAtLeast(serverVersion, PG_12)) {
+            sql += ',\n  am.amname as "Access method"';
+        }
+        sql +=
+            ',\n  pg_catalog.pg_size_pretty(pg_catalog.pg_total_relation_size(c.oid)) as "Size"' +
+                ',\n  pg_catalog.obj_description(c.oid, \'pg_class\') as "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_class c' +
+            '\n     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace';
+    if (verbose && !hideTableam && serverAtLeast(serverVersion, PG_12)) {
+        sql += '\n     LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam';
+    }
+    sql += "\nWHERE c.relkind IN ('r','p','v','m','S','f','')\n";
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n" +
+                "      AND n.nspname !~ '^pg_toast'\n" +
+                "      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 'c.relname');
+    sql += orderBy('1,2');
+    return {
+        sql,
+        params: params(),
+        description: 'List of relations',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \du / \dg — describeRoles                                          */
+/* ------------------------------------------------------------------ */
+/**
+ * Upstream `describeRoles` (psql/describe.c) fetches the raw boolean
+ * columns then builds the cooked "Attributes" cell client-side from
+ * fixed per-flag strings. We do that aggregation in SQL via a
+ * NULL-skipping array_to_string so the printer sees only the final
+ * two visible columns ("Role name", "Attributes") plus an optional
+ * "Description" column when `+` is used. This matches the column
+ * layout, header banner ("List of roles"), and content ordering of
+ * vanilla psql 18, including the `Cannot login`-only rows produced by
+ * `\du regress_du_role*` in `src/test/regress/expected/psql.out`.
+ */
+export const describeRoles = (opts) => {
+    const { verbose, showSystem, pattern, serverVersion } = opts;
+    // Per-flag attribute strings, in upstream order. Each VALUES row
+    // contributes one string (or NULL when the flag is off) so
+    // array_to_string can join them with ", ".
+    const attrParts = [
+        "CASE WHEN r.rolsuper THEN 'Superuser' END",
+        "CASE WHEN NOT r.rolinherit THEN 'No inheritance' END",
+        "CASE WHEN r.rolcreaterole THEN 'Create role' END",
+        "CASE WHEN r.rolcreatedb THEN 'Create DB' END",
+        "CASE WHEN NOT r.rolcanlogin THEN 'Cannot login' END",
+        "CASE WHEN r.rolreplication THEN 'Replication' END",
+    ];
+    if (serverAtLeast(serverVersion, PG_9_5)) {
+        attrParts.push("CASE WHEN r.rolbypassrls THEN 'Bypass RLS' END");
+    }
+    // `rolconnlimit = -1` means unlimited; only render when >= 0.
+    attrParts.push('CASE WHEN r.rolconnlimit >= 0 THEN' +
+        " pg_catalog.format('%s connection%s', r.rolconnlimit," +
+        " CASE WHEN r.rolconnlimit = 1 THEN '' ELSE 's' END) END");
+    // `rolvaliduntil` rendered with upstream's `Password valid until <ts>`.
+    attrParts.push('CASE WHEN r.rolvaliduntil IS NOT NULL THEN' +
+        " pg_catalog.format('Password valid until %s', r.rolvaliduntil) END");
+    const attrValues = attrParts.map((p) => `(${p})`).join(',\n        ');
+    let sql = 'SELECT r.rolname AS "Role name",\n' +
+        '  pg_catalog.array_to_string(ARRAY(\n' +
+        '    SELECT a FROM (VALUES\n' +
+        `        ${attrValues}\n` +
+        '      ) AS x(a)\n' +
+        '      WHERE a IS NOT NULL\n' +
+        '  ), \', \') AS "Attributes"';
+    if (verbose) {
+        sql +=
+            ',\n  pg_catalog.shobj_description(r.oid, \'pg_authid\') AS "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_roles r\n';
+    let hasWhere = false;
+    if (!showSystem && pattern === undefined) {
+        sql += "WHERE r.rolname !~ '^pg_'\n";
+        hasWhere = true;
+    }
+    sql += patternStub(hasWhere, undefined, 'r.rolname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of roles' };
+};
+export const listDbRoleSettings = (opts) => {
+    let sql = 'SELECT rolname AS "Role", datname AS "Database",\n' +
+        'pg_catalog.array_to_string(setconfig, E\'\\n\') AS "Settings"\n' +
+        'FROM pg_catalog.pg_db_role_setting s\n' +
+        'LEFT JOIN pg_catalog.pg_database d ON d.oid = setdatabase\n' +
+        'LEFT JOIN pg_catalog.pg_roles r ON r.oid = setrole\n';
+    let hasWhere = false;
+    if (opts.pattern !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'r.rolname');
+        hasWhere = true;
+    }
+    if (opts.pattern2 !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'd.datname');
+    }
+    sql += orderBy('1, 2');
+    const ps = [];
+    if (opts.pattern !== undefined)
+        ps.push(opts.pattern);
+    if (opts.pattern2 !== undefined)
+        ps.push(opts.pattern2);
+    return { sql, params: ps, description: 'List of settings' };
+};
+/* ------------------------------------------------------------------ */
+/* \drg — describeRoleGrants                                          */
+/* ------------------------------------------------------------------ */
+export const describeRoleGrants = (opts) => {
+    const { showSystem, pattern, serverVersion } = opts;
+    let sql = 'SELECT m.rolname AS "Role name", r.rolname AS "Member of",\n' +
+        "  pg_catalog.concat_ws(', ',\n";
+    if (serverAtLeast(serverVersion, PG_16)) {
+        sql +=
+            "    CASE WHEN pam.admin_option THEN 'ADMIN' END,\n" +
+                "    CASE WHEN pam.inherit_option THEN 'INHERIT' END,\n" +
+                "    CASE WHEN pam.set_option THEN 'SET' END\n";
+    }
+    else {
+        sql +=
+            "    CASE WHEN pam.admin_option THEN 'ADMIN' END,\n" +
+                "    CASE WHEN m.rolinherit THEN 'INHERIT' END,\n" +
+                "    'SET'\n";
+    }
+    sql += '  ) AS "Options",\n  g.rolname AS "Grantor"\n';
+    sql +=
+        'FROM pg_catalog.pg_roles m\n' +
+            '     JOIN pg_catalog.pg_auth_members pam ON (pam.member = m.oid)\n' +
+            '     LEFT JOIN pg_catalog.pg_roles r ON (pam.roleid = r.oid)\n' +
+            '     LEFT JOIN pg_catalog.pg_roles g ON (pam.grantor = g.oid)\n';
+    let hasWhere = false;
+    if (!showSystem && pattern === undefined) {
+        sql += "WHERE m.rolname !~ '^pg_'\n";
+        hasWhere = true;
+    }
+    sql += patternStub(hasWhere, undefined, 'm.rolname');
+    sql += orderBy('1, 2, 4');
+    return { sql, params: params(), description: 'List of role grants' };
+};
+export const listTables = (opts) => {
+    const { verbose, showSystem, pattern, serverVersion } = opts;
+    const hideTableam = opts.hideTableam ?? false;
+    const tt = opts.tabtypes ?? '';
+    let showTables = tt.includes('t');
+    const showIndexes = tt.includes('i');
+    let showViews = tt.includes('v');
+    let showMatViews = tt.includes('m');
+    let showSeq = tt.includes('s');
+    let showForeign = tt.includes('E');
+    const ntypes = +showTables +
+        +showIndexes +
+        +showViews +
+        +showMatViews +
+        +showSeq +
+        +showForeign;
+    if (ntypes === 0) {
+        showTables = showViews = showMatViews = showSeq = showForeign = true;
+    }
+    let sql = 'SELECT n.nspname as "Schema",\n' +
+        '  c.relname as "Name",\n' +
+        '  CASE c.relkind' +
+        " WHEN 'r' THEN 'table'" +
+        " WHEN 'v' THEN 'view'" +
+        " WHEN 'm' THEN 'materialized view'" +
+        " WHEN 'i' THEN 'index'" +
+        " WHEN 'S' THEN 'sequence'" +
+        " WHEN 't' THEN 'TOAST table'" +
+        " WHEN 'f' THEN 'foreign table'" +
+        " WHEN 'p' THEN 'partitioned table'" +
+        " WHEN 'I' THEN 'partitioned index'" +
+        ' END as "Type",\n' +
+        '  pg_catalog.pg_get_userbyid(c.relowner) as "Owner"';
+    if (showIndexes)
+        sql += ',\n  c2.relname as "Table"';
+    if (verbose) {
+        sql +=
+            ',\n  CASE c.relpersistence' +
+                " WHEN 'p' THEN 'permanent'" +
+                " WHEN 't' THEN 'temporary'" +
+                " WHEN 'u' THEN 'unlogged'" +
+                ' END as "Persistence"';
+        const wantsAm = !hideTableam &&
+            serverAtLeast(serverVersion, PG_12) &&
+            (showTables || showMatViews || showIndexes);
+        if (wantsAm)
+            sql += ',\n  am.amname as "Access method"';
+        // Upstream uses `pg_total_relation_size` (table + indexes + toast)
+        // in verbose mode so the formatting matches `pg_size_pretty` exactly
+        // — including the "8192 bytes" vs "8 kB" threshold the upstream
+        // tests pin to.
+        sql +=
+            ',\n  pg_catalog.pg_size_pretty(pg_catalog.pg_total_relation_size(c.oid)) as "Size"' +
+                ',\n  pg_catalog.obj_description(c.oid, \'pg_class\') as "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_class c' +
+            '\n     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace';
+    if (verbose &&
+        !hideTableam &&
+        serverAtLeast(serverVersion, PG_12) &&
+        (showTables || showMatViews || showIndexes)) {
+        sql += '\n     LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam';
+    }
+    if (showIndexes) {
+        sql +=
+            '\n     LEFT JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid' +
+                '\n     LEFT JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid';
+    }
+    sql += '\nWHERE c.relkind IN (';
+    const kinds = [];
+    if (showTables) {
+        kinds.push("'r'", "'p'");
+        if (showSystem || pattern !== undefined)
+            kinds.push("'t'");
+    }
+    if (showViews)
+        kinds.push("'v'");
+    if (showMatViews)
+        kinds.push("'m'");
+    if (showIndexes)
+        kinds.push("'i'", "'I'");
+    if (showSeq)
+        kinds.push("'S'");
+    if (showSystem || pattern !== undefined)
+        kinds.push("'s'");
+    if (showForeign)
+        kinds.push("'f'");
+    kinds.push("''");
+    sql += kinds.join(',') + ')\n';
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n" +
+                "      AND n.nspname !~ '^pg_toast'\n" +
+                "      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 'c.relname');
+    sql += orderBy('1,2');
+    // Upstream `describe.c::listTables` uses a type-specific title when the
+    // caller filters to a single relkind family, falling back to "relations"
+    // for mixed (or default) selections. Mirror that so `\dt` / `\dv` /
+    // `\dm` / `\di` / `\ds` / `\dE` titles match.
+    let description = 'List of relations';
+    if (ntypes === 1) {
+        if (showTables)
+            description = 'List of tables';
+        else if (showIndexes)
+            description = 'List of indexes';
+        else if (showViews)
+            description = 'List of views';
+        else if (showMatViews)
+            description = 'List of materialized views';
+        else if (showSeq)
+            description = 'List of sequences';
+        else if (showForeign)
+            description = 'List of foreign tables';
+    }
+    return { sql, params: params(), description };
+};
+export const listPartitionedTables = (opts) => {
+    const { verbose, pattern, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support declarative partitioning */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'List of partitioned relations',
+        };
+    }
+    const rt = opts.reltypes ?? '';
+    let showTables = rt.includes('t');
+    let showIndexes = rt.includes('i');
+    const showNested = rt.includes('n');
+    if (!showTables && !showIndexes)
+        showTables = showIndexes = true;
+    const mixed = showTables && showIndexes;
+    let sql = 'SELECT n.nspname as "Schema",\n' +
+        '  c.relname as "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(c.relowner) as "Owner"';
+    if (mixed) {
+        sql +=
+            ',\n  CASE c.relkind' +
+                " WHEN 'p' THEN 'partitioned table'" +
+                " WHEN 'I' THEN 'partitioned index'" +
+                ' END as "Type"';
+    }
+    if (showNested || pattern !== undefined) {
+        sql += ',\n  inh.inhparent::pg_catalog.regclass as "Parent name"';
+    }
+    if (showIndexes) {
+        sql += ',\n c2.oid::pg_catalog.regclass as "Table"';
+    }
+    if (verbose) {
+        sql += ',\n  am.amname as "Access method"';
+        if (showNested) {
+            sql += ',\n  s.dps as "Leaf partition size"';
+            sql += ',\n  s.tps as "Total size"';
+        }
+        else {
+            sql += ',\n  s.tps as "Total size"';
+        }
+        sql +=
+            ',\n  pg_catalog.obj_description(c.oid, \'pg_class\') as "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_class c' +
+            '\n     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace';
+    if (showIndexes) {
+        sql +=
+            '\n     LEFT JOIN pg_catalog.pg_index i ON i.indexrelid = c.oid' +
+                '\n     LEFT JOIN pg_catalog.pg_class c2 ON i.indrelid = c2.oid';
+    }
+    if (showNested || pattern !== undefined) {
+        sql +=
+            '\n     LEFT JOIN pg_catalog.pg_inherits inh ON c.oid = inh.inhrelid';
+    }
+    if (verbose) {
+        sql += '\n     LEFT JOIN pg_catalog.pg_am am ON c.relam = am.oid';
+        if (serverLess(serverVersion, PG_12)) {
+            sql +=
+                ',\n     LATERAL (WITH RECURSIVE d AS (\n' +
+                    '              SELECT inhrelid AS oid, 1 AS level FROM pg_catalog.pg_inherits WHERE inhparent = c.oid\n' +
+                    '              UNION ALL\n' +
+                    '              SELECT inhrelid, level + 1 FROM pg_catalog.pg_inherits i JOIN d ON i.inhparent = d.oid)\n' +
+                    '            SELECT pg_catalog.pg_size_pretty(sum(pg_catalog.pg_table_size(d.oid))) AS tps,\n' +
+                    '                   pg_catalog.pg_size_pretty(sum(CASE WHEN d.level = 1 THEN pg_catalog.pg_table_size(d.oid) ELSE 0 END)) AS dps\n' +
+                    '            FROM d) s';
+        }
+        else {
+            sql +=
+                ',\n     LATERAL (SELECT pg_catalog.pg_size_pretty(sum(\n' +
+                    '              CASE WHEN ppt.isleaf AND ppt.level = 1\n' +
+                    '                   THEN pg_catalog.pg_table_size(ppt.relid) ELSE 0 END)) AS dps,\n' +
+                    '              pg_catalog.pg_size_pretty(sum(pg_catalog.pg_table_size(ppt.relid))) AS tps\n' +
+                    '              FROM pg_catalog.pg_partition_tree(c.oid) ppt) s';
+        }
+    }
+    sql += '\nWHERE c.relkind IN (';
+    const kinds = [];
+    if (showTables)
+        kinds.push("'p'");
+    if (showIndexes)
+        kinds.push("'I'");
+    kinds.push("''");
+    sql += kinds.join(',') + ')\n';
+    if (!showNested && pattern === undefined) {
+        sql += ' AND NOT c.relispartition\n';
+    }
+    if (pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n" +
+                "      AND n.nspname !~ '^pg_toast'\n" +
+                "      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 'c.relname');
+    sql += `ORDER BY "Schema", ${mixed ? '"Type" DESC, ' : ''}${showNested || pattern !== undefined ? '"Parent name" NULLS FIRST, ' : ''}"Name";`;
+    // Mirror upstream's `tabletitle` switch: `\dPi*` lists indexes,
+    // `\dPt*` lists tables, and any mixed/empty form lists relations.
+    const description = showIndexes && !showTables
+        ? 'List of partitioned indexes'
+        : showTables && !showIndexes
+            ? 'List of partitioned tables'
+            : 'List of partitioned relations';
+    return {
+        sql,
+        params: params(),
+        description,
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dL — listLanguages                                                */
+/* ------------------------------------------------------------------ */
+export const listLanguages = (opts) => {
+    const { verbose, showSystem, pattern } = opts;
+    let sql = 'SELECT l.lanname AS "Name",\n' +
+        '       pg_catalog.pg_get_userbyid(l.lanowner) as "Owner",\n' +
+        '       l.lanpltrusted AS "Trusted"';
+    if (verbose) {
+        sql +=
+            ',\n       NOT l.lanispl AS "Internal language",\n' +
+                '       l.lanplcallfoid::pg_catalog.regprocedure AS "Call handler",\n' +
+                '       l.lanvalidator::pg_catalog.regprocedure AS "Validator",\n       ' +
+                'l.laninline::pg_catalog.regprocedure AS "Inline handler",\n       ' +
+                aclColumn('l.lanacl');
+    }
+    sql +=
+        ',\n       d.description AS "Description"\n' +
+            'FROM pg_catalog.pg_language l\n' +
+            'LEFT JOIN pg_catalog.pg_description d\n' +
+            '  ON d.classoid = l.tableoid AND d.objoid = l.oid AND d.objsubid = 0\n';
+    let hasWhere = false;
+    if (pattern !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'l.lanname');
+        hasWhere = true;
+    }
+    if (!showSystem && pattern === undefined) {
+        sql += 'WHERE l.lanplcallfoid != 0\n';
+        hasWhere = true;
+    }
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of languages' };
+};
+/* ------------------------------------------------------------------ */
+/* \dD — listDomains                                                  */
+/* ------------------------------------------------------------------ */
+export const listDomains = (opts) => {
+    const { verbose, showSystem, pattern } = opts;
+    let sql = 'SELECT n.nspname as "Schema",\n' +
+        '       t.typname as "Name",\n' +
+        '       pg_catalog.format_type(t.typbasetype, t.typtypmod) as "Type",\n' +
+        '       (SELECT c.collname FROM pg_catalog.pg_collation c, pg_catalog.pg_type bt\n' +
+        '        WHERE c.oid = t.typcollation AND bt.oid = t.typbasetype AND t.typcollation <> bt.typcollation) as "Collation",\n' +
+        '       CASE WHEN t.typnotnull THEN \'not null\' END as "Nullable",\n' +
+        '       t.typdefault as "Default",\n' +
+        "       pg_catalog.array_to_string(ARRAY(\n         SELECT pg_catalog.pg_get_constraintdef(r.oid, true) FROM pg_catalog.pg_constraint r WHERE t.oid = r.contypid AND r.contype = 'c' ORDER BY r.conname\n       ), ' ') as \"Check\"";
+    if (verbose) {
+        sql += ',\n  ' + aclColumn('t.typacl');
+        sql += ',\n       d.description as "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_type t\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace\n';
+    if (verbose) {
+        sql +=
+            '     LEFT JOIN pg_catalog.pg_description d ON d.classoid = t.tableoid AND d.objoid = t.oid AND d.objsubid = 0\n';
+    }
+    sql += "WHERE t.typtype = 'd'\n";
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n      AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 't.typname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of domains' };
+};
+/* ------------------------------------------------------------------ */
+/* \dc — listConversions                                              */
+/* ------------------------------------------------------------------ */
+export const listConversions = (opts) => {
+    const { verbose, showSystem, pattern } = opts;
+    let sql = 'SELECT n.nspname AS "Schema",\n' +
+        '       c.conname AS "Name",\n' +
+        '       pg_catalog.pg_encoding_to_char(c.conforencoding) AS "Source",\n' +
+        '       pg_catalog.pg_encoding_to_char(c.contoencoding) AS "Destination",\n' +
+        "       CASE WHEN c.condefault THEN 'yes' ELSE 'no' END AS \"Default?\"";
+    if (verbose)
+        sql += ',\n       d.description AS "Description"';
+    sql +=
+        '\nFROM pg_catalog.pg_conversion c\n' +
+            '     JOIN pg_catalog.pg_namespace n ON n.oid = c.connamespace\n';
+    if (verbose) {
+        sql +=
+            'LEFT JOIN pg_catalog.pg_description d ON d.classoid = c.tableoid AND d.objoid = c.oid AND d.objsubid = 0\n';
+    }
+    sql += 'WHERE true\n';
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "  AND n.nspname <> 'pg_catalog'\n  AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(true, 'n.nspname', 'c.conname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of conversions' };
+};
+/* ------------------------------------------------------------------ */
+/* \dconfig — describeConfigurationParameters                         */
+/* ------------------------------------------------------------------ */
+export const describeConfigurationParameters = (opts) => {
+    const { verbose, pattern, serverVersion } = opts;
+    let sql = 'SELECT s.name AS "Parameter", pg_catalog.current_setting(s.name) AS "Value"';
+    if (verbose) {
+        sql += ', s.vartype AS "Type", s.context AS "Context", ';
+        if (serverAtLeast(serverVersion, PG_15)) {
+            sql += aclColumn('p.paracl');
+        }
+        else {
+            sql += 'NULL AS "Access privileges"';
+        }
+    }
+    sql += '\nFROM pg_catalog.pg_settings s\n';
+    if (verbose && serverAtLeast(serverVersion, PG_15)) {
+        sql +=
+            '  LEFT JOIN pg_catalog.pg_parameter_acl p ON pg_catalog.lower(s.name) = p.parname\n';
+    }
+    if (pattern !== undefined) {
+        sql += patternStub(false, undefined, 'pg_catalog.lower(s.name)');
+    }
+    else {
+        sql +=
+            "WHERE s.source <> 'default' AND s.setting IS DISTINCT FROM s.boot_val\n";
+    }
+    sql += orderBy('1');
+    return {
+        sql,
+        params: params(),
+        description: pattern !== undefined
+            ? 'List of configuration parameters'
+            : 'List of non-default configuration parameters',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dy — listEventTriggers                                            */
+/* ------------------------------------------------------------------ */
+export const listEventTriggers = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT evtname as "Name", evtevent as "Event", pg_catalog.pg_get_userbyid(e.evtowner) as "Owner",\n' +
+        " case evtenabled when 'O' then 'enabled' when 'R' then 'replica' when 'A' then 'always' when 'D' then 'disabled' end as \"Enabled\",\n" +
+        ' e.evtfoid::pg_catalog.regproc as "Function", ' +
+        'pg_catalog.array_to_string(array(select x from pg_catalog.unnest(evttags) as t(x)), \', \') as "Tags"';
+    if (verbose) {
+        sql +=
+            ',\npg_catalog.obj_description(e.oid, \'pg_event_trigger\') as "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_event_trigger e\n';
+    sql += patternStub(false, undefined, 'evtname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of event triggers' };
+};
+/* ------------------------------------------------------------------ */
+/* \dX — listExtendedStats                                            */
+/* ------------------------------------------------------------------ */
+export const listExtendedStats = (opts) => {
+    const { verbose, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support extended statistics */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'List of extended statistics',
+        };
+    }
+    let sql = 'SELECT\n' +
+        'es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text AS "Schema",\n' +
+        'es.stxname AS "Name",\n';
+    if (serverAtLeast(serverVersion, PG_14)) {
+        sql +=
+            'pg_catalog.format(\'%s FROM %s\', pg_catalog.pg_get_statisticsobjdef_columns(es.oid), es.stxrelid::pg_catalog.regclass) AS "Definition"';
+    }
+    else {
+        sql +=
+            "pg_catalog.format('%s FROM %s',\n" +
+                "  (SELECT pg_catalog.string_agg(pg_catalog.quote_ident(a.attname),', ')\n" +
+                '   FROM pg_catalog.unnest(es.stxkeys) s(attnum)\n' +
+                '   JOIN pg_catalog.pg_attribute a\n' +
+                '   ON (es.stxrelid = a.attrelid AND a.attnum = s.attnum AND NOT a.attisdropped)),\n' +
+                'es.stxrelid::pg_catalog.regclass) AS "Definition"';
+    }
+    sql +=
+        ",\nCASE WHEN 'd' = any(es.stxkind) THEN 'defined' END AS \"Ndistinct\",\n" +
+            "CASE WHEN 'f' = any(es.stxkind) THEN 'defined' END AS \"Dependencies\"";
+    if (serverAtLeast(serverVersion, PG_12)) {
+        sql += ",\nCASE WHEN 'm' = any(es.stxkind) THEN 'defined' END AS \"MCV\"";
+    }
+    if (verbose) {
+        sql +=
+            ', \npg_catalog.obj_description(oid, \'pg_statistic_ext\') AS "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_statistic_ext es\n';
+    sql += patternStub(false, 'es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text', 'es.stxname');
+    sql += orderBy('1, 2');
+    return {
+        sql,
+        params: params(),
+        description: 'List of extended statistics',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dC — listCasts                                                    */
+/* ------------------------------------------------------------------ */
+export const listCasts = (opts) => {
+    const { verbose, serverVersion } = opts;
+    let sql = 'SELECT pg_catalog.format_type(castsource, NULL) AS "Source type",\n' +
+        '       pg_catalog.format_type(casttarget, NULL) AS "Target type",\n' +
+        "       CASE WHEN c.castmethod = 'b' THEN '(binary coercible)'\n" +
+        "            WHEN c.castmethod = 'i' THEN '(with inout)'\n" +
+        '            ELSE p.proname\n' +
+        '       END AS "Function",\n' +
+        "       CASE WHEN c.castcontext = 'e' THEN 'no'\n" +
+        "            WHEN c.castcontext = 'a' THEN 'in assignment'\n" +
+        "            ELSE 'yes'\n" +
+        '       END AS "Implicit?"';
+    if (verbose) {
+        // PG 18 added "Leakproof?" to verbose `\dC+`. The pg_proc join
+        // already exists for the Function column, so emitting the cast's
+        // function's `proleakproof` is incremental.
+        if (serverAtLeast(serverVersion, PG_18)) {
+            sql +=
+                ",\n       CASE WHEN p.proleakproof THEN 'yes' ELSE 'no' END AS \"Leakproof?\"";
+        }
+        sql += ',\n       d.description AS "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_cast c LEFT JOIN pg_catalog.pg_proc p\n' +
+            '     ON c.castfunc = p.oid\n' +
+            '     LEFT JOIN pg_catalog.pg_type ts ON c.castsource = ts.oid\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace ns ON ns.oid = ts.typnamespace\n' +
+            '     LEFT JOIN pg_catalog.pg_type tt ON c.casttarget = tt.oid\n' +
+            '     LEFT JOIN pg_catalog.pg_namespace nt ON nt.oid = tt.typnamespace\n';
+    if (verbose) {
+        sql +=
+            '     LEFT JOIN pg_catalog.pg_description d ON d.classoid = c.tableoid AND d.objoid = c.oid AND d.objsubid = 0\n';
+    }
+    sql += 'WHERE ( (true';
+    sql += patternStub(true, 'ns.nspname', 'ts.typname');
+    sql += ') OR (true';
+    sql += patternStub(true, 'nt.nspname', 'tt.typname');
+    sql += ') )\n';
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of casts' };
+};
+/* ------------------------------------------------------------------ */
+/* \dO — listCollations                                               */
+/* ------------------------------------------------------------------ */
+export const listCollations = (opts) => {
+    const { verbose, showSystem, pattern, serverVersion } = opts;
+    let sql = 'SELECT\n  n.nspname AS "Schema",\n  c.collname AS "Name",\n';
+    if (serverAtLeast(serverVersion, PG_10)) {
+        sql +=
+            '  CASE c.collprovider' +
+                " WHEN 'd' THEN 'default'" +
+                " WHEN 'b' THEN 'builtin'" +
+                " WHEN 'c' THEN 'libc'" +
+                " WHEN 'i' THEN 'icu'" +
+                ' END AS "Provider",\n';
+    }
+    else {
+        sql += '  \'libc\' AS "Provider",\n';
+    }
+    sql += '  c.collcollate AS "Collate",\n  c.collctype AS "Ctype",\n';
+    if (serverAtLeast(serverVersion, PG_17)) {
+        sql += '  c.colllocale AS "Locale",\n';
+    }
+    else if (serverAtLeast(serverVersion, PG_15)) {
+        sql += '  c.colliculocale AS "Locale",\n';
+    }
+    else {
+        sql += '  c.collcollate AS "Locale",\n';
+    }
+    if (serverAtLeast(serverVersion, PG_16)) {
+        sql += '  c.collicurules AS "ICU Rules",\n';
+    }
+    else {
+        sql += '  NULL AS "ICU Rules",\n';
+    }
+    if (serverAtLeast(serverVersion, PG_12)) {
+        sql +=
+            "  CASE WHEN c.collisdeterministic THEN 'yes' ELSE 'no' END AS \"Deterministic?\"";
+    }
+    else {
+        sql += '  \'yes\' AS "Deterministic?"';
+    }
+    if (verbose) {
+        sql +=
+            ',\n  pg_catalog.obj_description(c.oid, \'pg_collation\') AS "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_collation c, pg_catalog.pg_namespace n\n' +
+            'WHERE n.oid = c.collnamespace\n';
+    if (!showSystem && pattern === undefined) {
+        sql +=
+            "      AND n.nspname <> 'pg_catalog'\n      AND n.nspname <> 'information_schema'\n";
+    }
+    sql +=
+        '      AND c.collencoding IN (-1, pg_catalog.pg_char_to_encoding(pg_catalog.getdatabaseencoding()))\n';
+    sql += patternStub(true, 'n.nspname', 'c.collname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of collations' };
+};
+/* ------------------------------------------------------------------ */
+/* \dn — listSchemas                                                  */
+/* ------------------------------------------------------------------ */
+export const listSchemas = (opts) => {
+    const { verbose, showSystem, pattern } = opts;
+    let sql = 'SELECT n.nspname AS "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(n.nspowner) AS "Owner"';
+    if (verbose) {
+        sql += ',\n  ' + aclColumn('n.nspacl');
+        sql +=
+            ',\n  pg_catalog.obj_description(n.oid, \'pg_namespace\') AS "Description"';
+    }
+    sql += '\nFROM pg_catalog.pg_namespace n\n';
+    if (!showSystem && pattern === undefined) {
+        sql += "WHERE n.nspname !~ '^pg_' AND n.nspname <> 'information_schema'\n";
+    }
+    sql += patternStub(!showSystem && pattern === undefined, undefined, 'n.nspname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of schemas' };
+};
+/* ------------------------------------------------------------------ */
+/* \dFp — listTSParsers                                               */
+/* ------------------------------------------------------------------ */
+export const listTSParsers = (opts) => {
+    const { verbose } = opts;
+    if (verbose) {
+        // Verbose form: fetch (oid, schema, name) so the renderer can issue
+        // per-parser detail queries (see describeOneTSParser below). WP-20 will
+        // wire the iteration.
+        let sql = 'SELECT p.oid,\n  n.nspname,\n  p.prsname\n' +
+            'FROM pg_catalog.pg_ts_parser p\n' +
+            'LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.prsnamespace\n';
+        sql += patternStub(false, 'n.nspname', 'p.prsname');
+        sql += orderBy('1, 2');
+        return {
+            sql,
+            params: params(),
+            description: 'List of text search parsers (verbose)',
+        };
+    }
+    let sql = 'SELECT\n  n.nspname as "Schema",\n  p.prsname as "Name",\n' +
+        '  pg_catalog.obj_description(p.oid, \'pg_ts_parser\') as "Description"\n' +
+        'FROM pg_catalog.pg_ts_parser p\n' +
+        'LEFT JOIN pg_catalog.pg_namespace n ON n.oid = p.prsnamespace\n';
+    sql += patternStub(false, 'n.nspname', 'p.prsname');
+    sql += orderBy('1, 2');
+    return {
+        sql,
+        params: params(),
+        description: 'List of text search parsers',
+    };
+};
+/**
+ * Per-parser detail (one row per phase). Caller binds the parser oid.
+ * Two queries upstream; we emit both as a UNION via a single string.
+ */
+export const describeOneTSParser = (opts) => {
+    const { oid } = opts;
+    const sql = `SELECT 'Start parse' AS "Method",\n` +
+        `   p.prsstart::pg_catalog.regproc AS "Function",\n` +
+        `   pg_catalog.obj_description(p.prsstart, 'pg_proc') as "Description"\n` +
+        ` FROM pg_catalog.pg_ts_parser p WHERE p.oid = '${oid}'\n` +
+        `UNION ALL\n` +
+        `SELECT 'Get next token', p.prstoken::pg_catalog.regproc, pg_catalog.obj_description(p.prstoken, 'pg_proc')\n` +
+        ` FROM pg_catalog.pg_ts_parser p WHERE p.oid = '${oid}'\n` +
+        `UNION ALL\n` +
+        `SELECT 'End parse', p.prsend::pg_catalog.regproc, pg_catalog.obj_description(p.prsend, 'pg_proc')\n` +
+        ` FROM pg_catalog.pg_ts_parser p WHERE p.oid = '${oid}'\n` +
+        `UNION ALL\n` +
+        `SELECT 'Get headline', p.prsheadline::pg_catalog.regproc, pg_catalog.obj_description(p.prsheadline, 'pg_proc')\n` +
+        ` FROM pg_catalog.pg_ts_parser p WHERE p.oid = '${oid}'\n` +
+        `UNION ALL\n` +
+        `SELECT 'Get token types', p.prslextype::pg_catalog.regproc, pg_catalog.obj_description(p.prslextype, 'pg_proc')\n` +
+        ` FROM pg_catalog.pg_ts_parser p WHERE p.oid = '${oid}';`;
+    return { sql, params: [], description: 'Text search parser details' };
+};
+/* ------------------------------------------------------------------ */
+/* \dFd — listTSDictionaries                                          */
+/* ------------------------------------------------------------------ */
+export const listTSDictionaries = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT\n  n.nspname as "Schema",\n  d.dictname as "Name",\n';
+    if (verbose) {
+        sql +=
+            "  ( SELECT COALESCE(nt.nspname, '(null)')::pg_catalog.text || '.' || t.tmplname FROM\n" +
+                '    pg_catalog.pg_ts_template t\n' +
+                '    LEFT JOIN pg_catalog.pg_namespace nt ON nt.oid = t.tmplnamespace\n' +
+                '    WHERE d.dicttemplate = t.oid ) AS "Template",\n' +
+                '  d.dictinitoption as "Init options",\n';
+    }
+    sql +=
+        '  pg_catalog.obj_description(d.oid, \'pg_ts_dict\') as "Description"\n' +
+            'FROM pg_catalog.pg_ts_dict d\n' +
+            'LEFT JOIN pg_catalog.pg_namespace n ON n.oid = d.dictnamespace\n';
+    sql += patternStub(false, 'n.nspname', 'd.dictname');
+    sql += orderBy('1, 2');
+    return {
+        sql,
+        params: params(),
+        description: 'List of text search dictionaries',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dFt — listTSTemplates                                             */
+/* ------------------------------------------------------------------ */
+export const listTSTemplates = (opts) => {
+    const { verbose } = opts;
+    let sql;
+    if (verbose) {
+        sql =
+            'SELECT\n  n.nspname AS "Schema",\n  t.tmplname AS "Name",\n' +
+                '  t.tmplinit::pg_catalog.regproc AS "Init",\n' +
+                '  t.tmpllexize::pg_catalog.regproc AS "Lexize",\n' +
+                '  pg_catalog.obj_description(t.oid, \'pg_ts_template\') AS "Description"\n';
+    }
+    else {
+        sql =
+            'SELECT\n  n.nspname AS "Schema",\n  t.tmplname AS "Name",\n' +
+                '  pg_catalog.obj_description(t.oid, \'pg_ts_template\') AS "Description"\n';
+    }
+    sql +=
+        'FROM pg_catalog.pg_ts_template t\n' +
+            'LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.tmplnamespace\n';
+    sql += patternStub(false, 'n.nspname', 't.tmplname');
+    sql += orderBy('1, 2');
+    return {
+        sql,
+        params: params(),
+        description: 'List of text search templates',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dF — listTSConfigs                                                */
+/* ------------------------------------------------------------------ */
+export const listTSConfigs = (opts) => {
+    const { verbose } = opts;
+    if (verbose) {
+        let sql = 'SELECT c.oid, c.cfgname, n.nspname, p.prsname, np.nspname as pnspname\n' +
+            'FROM pg_catalog.pg_ts_config c\n' +
+            '   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.cfgnamespace,\n' +
+            ' pg_catalog.pg_ts_parser p\n' +
+            '   LEFT JOIN pg_catalog.pg_namespace np ON np.oid = p.prsnamespace\n' +
+            'WHERE p.oid = c.cfgparser\n';
+        sql += patternStub(true, 'n.nspname', 'c.cfgname');
+        sql += orderBy('3, 2');
+        return {
+            sql,
+            params: params(),
+            description: 'List of text search configurations (verbose)',
+        };
+    }
+    let sql = 'SELECT\n   n.nspname as "Schema",\n   c.cfgname as "Name",\n' +
+        '   pg_catalog.obj_description(c.oid, \'pg_ts_config\') as "Description"\n' +
+        'FROM pg_catalog.pg_ts_config c\n' +
+        'LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.cfgnamespace\n';
+    sql += patternStub(false, 'n.nspname', 'c.cfgname');
+    sql += orderBy('1, 2');
+    return {
+        sql,
+        params: params(),
+        description: 'List of text search configurations',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dew — listForeignDataWrappers                                     */
+/* ------------------------------------------------------------------ */
+export const listForeignDataWrappers = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT fdw.fdwname AS "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(fdw.fdwowner) AS "Owner",\n' +
+        '  fdw.fdwhandler::pg_catalog.regproc AS "Handler",\n' +
+        '  fdw.fdwvalidator::pg_catalog.regproc AS "Validator"';
+    if (verbose) {
+        sql += ',\n  ' + aclColumn('fdwacl');
+        sql +=
+            ",\n CASE WHEN fdwoptions IS NULL THEN '' ELSE\n" +
+                "  '(' || pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value) FROM pg_catalog.pg_options_to_table(fdwoptions)), ', ') || ')'\n" +
+                '  END AS "FDW options",\n' +
+                '  d.description AS "Description" ';
+    }
+    sql += '\nFROM pg_catalog.pg_foreign_data_wrapper fdw\n';
+    if (verbose) {
+        sql +=
+            'LEFT JOIN pg_catalog.pg_description d ON d.classoid = fdw.tableoid AND d.objoid = fdw.oid AND d.objsubid = 0\n';
+    }
+    sql += patternStub(false, undefined, 'fdwname');
+    sql += orderBy('1');
+    return {
+        sql,
+        params: params(),
+        description: 'List of foreign-data wrappers',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \des — listForeignServers                                          */
+/* ------------------------------------------------------------------ */
+export const listForeignServers = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT s.srvname AS "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(s.srvowner) AS "Owner",\n' +
+        '  f.fdwname AS "Foreign-data wrapper"';
+    if (verbose) {
+        sql += ',\n  ' + aclColumn('s.srvacl');
+        sql +=
+            ',\n  s.srvtype AS "Type",\n' +
+                '  s.srvversion AS "Version",\n' +
+                "  CASE WHEN srvoptions IS NULL THEN '' ELSE\n" +
+                "  '(' || pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value) FROM pg_catalog.pg_options_to_table(srvoptions)), ', ') || ')'\n" +
+                '  END AS "FDW options",\n' +
+                '  d.description AS "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_foreign_server s\n' +
+            '     JOIN pg_catalog.pg_foreign_data_wrapper f ON f.oid=s.srvfdw\n';
+    if (verbose) {
+        sql +=
+            'LEFT JOIN pg_catalog.pg_description d ON d.classoid = s.tableoid AND d.objoid = s.oid AND d.objsubid = 0\n';
+    }
+    sql += patternStub(false, undefined, 's.srvname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of foreign servers' };
+};
+/* ------------------------------------------------------------------ */
+/* \deu — listUserMappings                                            */
+/* ------------------------------------------------------------------ */
+export const listUserMappings = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT um.srvname AS "Server",\n  um.usename AS "User name"';
+    if (verbose) {
+        sql +=
+            ",\n CASE WHEN umoptions IS NULL THEN '' ELSE\n" +
+                "  '(' || pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value) FROM pg_catalog.pg_options_to_table(umoptions)), ', ') || ')'\n" +
+                '  END AS "FDW options"';
+    }
+    sql += '\nFROM pg_catalog.pg_user_mappings um\n';
+    sql += patternStub(false, undefined, 'um.srvname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of user mappings' };
+};
+/* ------------------------------------------------------------------ */
+/* \det — listForeignTables                                           */
+/* ------------------------------------------------------------------ */
+export const listForeignTables = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT n.nspname AS "Schema",\n  c.relname AS "Table",\n  s.srvname AS "Server"';
+    if (verbose) {
+        sql +=
+            ",\n CASE WHEN ftoptions IS NULL THEN '' ELSE\n" +
+                "  '(' || pg_catalog.array_to_string(ARRAY(SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value) FROM pg_catalog.pg_options_to_table(ftoptions)), ', ') || ')'\n" +
+                '  END AS "FDW options",\n' +
+                '  d.description AS "Description"';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_foreign_table ft\n' +
+            '  INNER JOIN pg_catalog.pg_class c ON c.oid = ft.ftrelid\n' +
+            '  INNER JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace\n' +
+            '  INNER JOIN pg_catalog.pg_foreign_server s ON s.oid = ft.ftserver\n';
+    if (verbose) {
+        sql +=
+            '   LEFT JOIN pg_catalog.pg_description d ON d.classoid = c.tableoid AND d.objoid = c.oid AND d.objsubid = 0\n';
+    }
+    sql += patternStub(false, 'n.nspname', 'c.relname');
+    sql += orderBy('1, 2');
+    return { sql, params: params(), description: 'List of foreign tables' };
+};
+/* ------------------------------------------------------------------ */
+/* \dx — listExtensions  /  \dx+ — listExtensionContents              */
+/* ------------------------------------------------------------------ */
+export const listExtensions = (opts) => {
+    const { serverVersion } = opts;
+    // PG 18 added the "Default version" column to `\dx` to make it
+    // easy to spot extensions that are behind the available default.
+    const hasDefaultVersion = serverAtLeast(serverVersion, PG_18);
+    let sql = 'SELECT e.extname AS "Name", e.extversion AS "Version", ';
+    if (hasDefaultVersion) {
+        sql += 'ae.default_version AS "Default version",';
+    }
+    sql +=
+        'n.nspname AS "Schema", d.description AS "Description"\n' +
+            'FROM pg_catalog.pg_extension e ' +
+            'LEFT JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace ' +
+            "LEFT JOIN pg_catalog.pg_description d ON d.objoid = e.oid AND d.classoid = 'pg_catalog.pg_extension'::pg_catalog.regclass";
+    if (hasDefaultVersion) {
+        sql +=
+            ' LEFT JOIN pg_catalog.pg_available_extensions() ae(name, default_version, comment) ON ae.name = e.extname';
+    }
+    sql += '\n';
+    sql += patternStub(false, undefined, 'e.extname');
+    sql += orderBy('1');
+    return {
+        sql,
+        params: params(),
+        description: 'List of installed extensions',
+    };
+};
+export const listExtensionContents = () => {
+    let sql = 'SELECT e.extname, e.oid\nFROM pg_catalog.pg_extension e\n';
+    sql += patternStub(false, undefined, 'e.extname');
+    sql += orderBy('1');
+    return {
+        sql,
+        params: params(),
+        description: 'Get matching extensions to list contents for',
+    };
+};
+/**
+ * Per-extension contents (`\dx+ foo`). Caller binds the extension oid.
+ */
+export const listOneExtensionContents = (opts) => {
+    const sql = 'SELECT pg_catalog.pg_describe_object(classid, objid, 0) AS "Object description"\n' +
+        'FROM pg_catalog.pg_depend\n' +
+        `WHERE refclassid = 'pg_catalog.pg_extension'::pg_catalog.regclass AND refobjid = '${opts.oid}' AND deptype = 'e'\n` +
+        'ORDER BY 1;';
+    return { sql, params: [], description: 'Objects in extension' };
+};
+/* ------------------------------------------------------------------ */
+/* \dRp — listPublications  /  describePublications (\dRp+)           */
+/* ------------------------------------------------------------------ */
+export const listPublications = (opts) => {
+    const { serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support publications */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'List of publications',
+        };
+    }
+    let sql = 'SELECT pubname AS "Name",\n' +
+        '  pg_catalog.pg_get_userbyid(pubowner) AS "Owner",\n' +
+        '  puballtables AS "All tables"';
+    if (serverAtLeast(serverVersion, 19)) {
+        sql += ',\n  puballsequences AS "All sequences"';
+    }
+    sql +=
+        ',\n  pubinsert AS "Inserts",\n  pubupdate AS "Updates",\n  pubdelete AS "Deletes"';
+    if (serverAtLeast(serverVersion, PG_11)) {
+        sql += ',\n  pubtruncate AS "Truncates"';
+    }
+    // PG 18 added `pg_publication.pubgencols`, surfaced as "Generated
+    // columns" in `\dRp`. Values: 'n' = none, 's' = stored.
+    if (serverAtLeast(serverVersion, PG_18)) {
+        sql +=
+            ',\n (CASE pubgencols ' +
+                "WHEN 'n' THEN 'none' WHEN 's' THEN 'stored' END) AS \"Generated columns\"";
+    }
+    if (serverAtLeast(serverVersion, PG_13)) {
+        sql += ',\n  pubviaroot AS "Via root"';
+    }
+    sql += '\nFROM pg_catalog.pg_publication\n';
+    sql += patternStub(false, undefined, 'pubname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of publications' };
+};
+/**
+ * Detail-lookup query for `\dRp+`. Output columns match the unmodified
+ * `describePublications` upstream lookup (positional columns are then
+ * fanned-out into per-publication detail blocks by WP-20).
+ */
+export const describePublications = (opts) => {
+    const { serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support publications */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'Details of publications',
+        };
+    }
+    const hasSeq = serverAtLeast(serverVersion, 19);
+    const hasTrunc = serverAtLeast(serverVersion, PG_11);
+    const hasGen = serverAtLeast(serverVersion, PG_18);
+    const hasViaRoot = serverAtLeast(serverVersion, PG_13);
+    let sql = 'SELECT oid, pubname,\n  pg_catalog.pg_get_userbyid(pubowner) AS owner,\n  puballtables';
+    sql += hasSeq ? ', puballsequences' : ', false AS puballsequences';
+    sql += ', pubinsert, pubupdate, pubdelete';
+    sql += hasTrunc ? ', pubtruncate' : ', false AS pubtruncate';
+    if (hasGen) {
+        sql +=
+            ", (CASE pubgencols WHEN 'n' THEN 'none' WHEN 's' THEN 'stored' END) AS pubgencols";
+    }
+    else {
+        sql += ", 'none' AS pubgencols";
+    }
+    sql += hasViaRoot ? ', pubviaroot' : ', false AS pubviaroot';
+    sql += ", pg_catalog.obj_description(oid, 'pg_publication')";
+    sql += '\nFROM pg_catalog.pg_publication\n';
+    sql += patternStub(false, undefined, 'pubname');
+    sql += orderBy('2');
+    return { sql, params: params(), description: 'Details of publications' };
+};
+/* ------------------------------------------------------------------ */
+/* \dRs — describeSubscriptions                                       */
+/* ------------------------------------------------------------------ */
+export const describeSubscriptions = (opts) => {
+    const { verbose, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support subscriptions */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'List of subscriptions',
+        };
+    }
+    let sql = 'SELECT subname AS "Name"\n' +
+        ',  pg_catalog.pg_get_userbyid(subowner) AS "Owner"\n' +
+        ',  subenabled AS "Enabled"\n' +
+        ',  subpublications AS "Publication"\n';
+    if (verbose) {
+        if (serverAtLeast(serverVersion, PG_14)) {
+            sql += ', subbinary AS "Binary"\n';
+            if (serverAtLeast(serverVersion, PG_16)) {
+                sql +=
+                    ', (CASE substream\n' +
+                        "    WHEN 'f' THEN 'off'\n" +
+                        "    WHEN 't' THEN 'on'\n" +
+                        "    WHEN 'p' THEN 'parallel'\n" +
+                        '   END) AS "Streaming"\n';
+            }
+            else {
+                sql += ', substream AS "Streaming"\n';
+            }
+        }
+        if (serverAtLeast(serverVersion, PG_15)) {
+            sql +=
+                ', subtwophasestate AS "Two-phase commit"\n' +
+                    ', subdisableonerr AS "Disable on error"\n';
+        }
+        if (serverAtLeast(serverVersion, PG_16)) {
+            sql +=
+                ', suborigin AS "Origin"\n' +
+                    ', subpasswordrequired AS "Password required"\n' +
+                    ', subrunasowner AS "Run as owner?"\n';
+        }
+        if (serverAtLeast(serverVersion, PG_17)) {
+            sql += ', subfailover AS "Failover"\n';
+        }
+        sql +=
+            ',  subsynccommit AS "Synchronous commit"\n' +
+                ',  subconninfo AS "Conninfo"\n';
+        if (serverAtLeast(serverVersion, PG_15)) {
+            sql += ', subskiplsn AS "Skip LSN"\n';
+        }
+        sql +=
+            ',  pg_catalog.obj_description(oid, \'pg_subscription\') AS "Description"\n';
+    }
+    sql +=
+        'FROM pg_catalog.pg_subscription\n' +
+            'WHERE subdbid = (SELECT oid FROM pg_catalog.pg_database WHERE datname = pg_catalog.current_database())';
+    sql += patternStub(true, undefined, 'subname');
+    sql += orderBy('1');
+    return { sql, params: params(), description: 'List of subscriptions' };
+};
+export const listOperatorClasses = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT\n  am.amname AS "AM",\n' +
+        '  pg_catalog.format_type(c.opcintype, NULL) AS "Input type",\n' +
+        '  CASE\n' +
+        '    WHEN c.opckeytype <> 0 AND c.opckeytype <> c.opcintype\n' +
+        '    THEN pg_catalog.format_type(c.opckeytype, NULL)\n' +
+        '    ELSE NULL\n' +
+        '  END AS "Storage type",\n' +
+        '  CASE\n' +
+        '    WHEN pg_catalog.pg_opclass_is_visible(c.oid)\n' +
+        "    THEN pg_catalog.format('%I', c.opcname)\n" +
+        "    ELSE pg_catalog.format('%I.%I', n.nspname, c.opcname)\n" +
+        '  END AS "Operator class",\n' +
+        "  (CASE WHEN c.opcdefault THEN 'yes' ELSE 'no' END) AS \"Default?\"";
+    if (verbose) {
+        sql +=
+            ',\n  CASE\n' +
+                '    WHEN pg_catalog.pg_opfamily_is_visible(of.oid)\n' +
+                "    THEN pg_catalog.format('%I', of.opfname)\n" +
+                "    ELSE pg_catalog.format('%I.%I', ofn.nspname, of.opfname)\n" +
+                '  END AS "Operator family",\n' +
+                ' pg_catalog.pg_get_userbyid(c.opcowner) AS "Owner"\n';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_opclass c\n' +
+            '  LEFT JOIN pg_catalog.pg_am am on am.oid = c.opcmethod\n' +
+            '  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.opcnamespace\n' +
+            '  LEFT JOIN pg_catalog.pg_type t ON t.oid = c.opcintype\n' +
+            '  LEFT JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n';
+    if (verbose) {
+        sql +=
+            '  LEFT JOIN pg_catalog.pg_opfamily of ON of.oid = c.opcfamily\n' +
+                '  LEFT JOIN pg_catalog.pg_namespace ofn ON ofn.oid = of.opfnamespace\n';
+    }
+    let hasWhere = false;
+    if (opts.amPattern !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'am.amname');
+        hasWhere = true;
+    }
+    if (opts.typePattern !== undefined) {
+        sql += patternStub(hasWhere, 'tn.nspname', 't.typname');
+    }
+    sql += orderBy('1, 2, 4');
+    const ps = [];
+    if (opts.amPattern !== undefined)
+        ps.push(opts.amPattern);
+    if (opts.typePattern !== undefined)
+        ps.push(opts.typePattern);
+    return { sql, params: ps, description: 'List of operator classes' };
+};
+/* ------------------------------------------------------------------ */
+/* \dAf — listOperatorFamilies                                        */
+/* ------------------------------------------------------------------ */
+export const listOperatorFamilies = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT\n  am.amname AS "AM",\n' +
+        '  CASE\n' +
+        '    WHEN pg_catalog.pg_opfamily_is_visible(f.oid)\n' +
+        "    THEN pg_catalog.format('%I', f.opfname)\n" +
+        "    ELSE pg_catalog.format('%I.%I', n.nspname, f.opfname)\n" +
+        '  END AS "Operator family",\n' +
+        '  (SELECT\n' +
+        "     pg_catalog.string_agg(pg_catalog.format_type(oc.opcintype, NULL), ', ')\n" +
+        '   FROM pg_catalog.pg_opclass oc\n' +
+        '   WHERE oc.opcfamily = f.oid) "Applicable types"';
+    if (verbose) {
+        sql += ',\n  pg_catalog.pg_get_userbyid(f.opfowner) AS "Owner"\n';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_opfamily f\n' +
+            '  LEFT JOIN pg_catalog.pg_am am on am.oid = f.opfmethod\n' +
+            '  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = f.opfnamespace\n';
+    let hasWhere = false;
+    if (opts.amPattern !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'am.amname');
+        hasWhere = true;
+    }
+    if (opts.typePattern !== undefined) {
+        sql +=
+            `  ${hasWhere ? 'AND' : 'WHERE'} EXISTS (\n` +
+                '    SELECT 1 FROM pg_catalog.pg_type t\n' +
+                '    JOIN pg_catalog.pg_opclass oc ON oc.opcintype = t.oid\n' +
+                '    LEFT JOIN pg_catalog.pg_namespace tn ON tn.oid = t.typnamespace\n' +
+                '    WHERE oc.opcfamily = f.oid\n' +
+                patternStub(true, 'tn.nspname', 't.typname') +
+                '  )\n';
+    }
+    sql += orderBy('1, 2');
+    const ps = [];
+    if (opts.amPattern !== undefined)
+        ps.push(opts.amPattern);
+    if (opts.typePattern !== undefined)
+        ps.push(opts.typePattern);
+    return { sql, params: ps, description: 'List of operator families' };
+};
+export const listOpFamilyOperators = (opts) => {
+    const { verbose, serverVersion } = opts;
+    let sql = 'SELECT\n  am.amname AS "AM",\n' +
+        '  CASE\n' +
+        '    WHEN pg_catalog.pg_opfamily_is_visible(of.oid)\n' +
+        "    THEN pg_catalog.format('%I', of.opfname)\n" +
+        "    ELSE pg_catalog.format('%I.%I', nsf.nspname, of.opfname)\n" +
+        '  END AS "Operator family",\n' +
+        '  o.amopopr::pg_catalog.regoperator AS "Operator"\n,' +
+        '  o.amopstrategy AS "Strategy",\n' +
+        '  CASE o.amoppurpose\n' +
+        "    WHEN 'o' THEN 'ordering'\n" +
+        "    WHEN 's' THEN 'search'\n" +
+        '  END AS "Purpose"\n';
+    if (verbose) {
+        sql += ', ofs.opfname AS "Sort opfamily"';
+        // PG 18 added "Leakproof?" to verbose `\dAo+`. Same pattern as
+        // `\df+` — the operator's underlying function's proleakproof.
+        if (serverAtLeast(serverVersion, PG_18)) {
+            sql +=
+                ",\n  CASE WHEN p.proleakproof THEN 'yes' ELSE 'no' END AS \"Leakproof?\"";
+        }
+        sql += '\n';
+    }
+    sql +=
+        'FROM pg_catalog.pg_amop o\n' +
+            '  LEFT JOIN pg_catalog.pg_opfamily of ON of.oid = o.amopfamily\n' +
+            '  LEFT JOIN pg_catalog.pg_am am ON am.oid = of.opfmethod AND am.oid = o.amopmethod\n' +
+            '  LEFT JOIN pg_catalog.pg_namespace nsf ON of.opfnamespace = nsf.oid\n';
+    if (verbose) {
+        sql +=
+            '  LEFT JOIN pg_catalog.pg_opfamily ofs ON ofs.oid = o.amopsortfamily\n';
+        if (serverAtLeast(serverVersion, PG_18)) {
+            sql +=
+                '  LEFT JOIN pg_catalog.pg_operator op ON op.oid = o.amopopr\n' +
+                    '  LEFT JOIN pg_catalog.pg_proc p ON p.oid = op.oprcode\n';
+        }
+    }
+    let hasWhere = false;
+    if (opts.amPattern !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'am.amname');
+        hasWhere = true;
+    }
+    if (opts.familyPattern !== undefined) {
+        sql += patternStub(hasWhere, 'nsf.nspname', 'of.opfname');
+    }
+    sql +=
+        'ORDER BY 1, 2,\n' +
+            '  o.amoplefttype = o.amoprighttype DESC,\n' +
+            '  pg_catalog.format_type(o.amoplefttype, NULL),\n' +
+            '  pg_catalog.format_type(o.amoprighttype, NULL),\n' +
+            '  o.amopstrategy;';
+    const ps = [];
+    if (opts.amPattern !== undefined)
+        ps.push(opts.amPattern);
+    if (opts.familyPattern !== undefined)
+        ps.push(opts.familyPattern);
+    return {
+        sql,
+        params: ps,
+        description: 'List of operators of operator families',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dAp — listOpFamilyFunctions                                       */
+/* ------------------------------------------------------------------ */
+export const listOpFamilyFunctions = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT\n  am.amname AS "AM",\n' +
+        '  CASE\n' +
+        '    WHEN pg_catalog.pg_opfamily_is_visible(of.oid)\n' +
+        "    THEN pg_catalog.format('%I', of.opfname)\n" +
+        "    ELSE pg_catalog.format('%I.%I', ns.nspname, of.opfname)\n" +
+        '  END AS "Operator family",\n' +
+        '  pg_catalog.format_type(ap.amproclefttype, NULL) AS "Registered left type",\n' +
+        '  pg_catalog.format_type(ap.amprocrighttype, NULL) AS "Registered right type",\n' +
+        '  ap.amprocnum AS "Number"\n';
+    sql += verbose
+        ? ', ap.amproc::pg_catalog.regprocedure AS "Function"\n'
+        : ', p.proname AS "Function"\n';
+    sql +=
+        'FROM pg_catalog.pg_amproc ap\n' +
+            '  LEFT JOIN pg_catalog.pg_opfamily of ON of.oid = ap.amprocfamily\n' +
+            '  LEFT JOIN pg_catalog.pg_am am ON am.oid = of.opfmethod\n' +
+            '  LEFT JOIN pg_catalog.pg_namespace ns ON of.opfnamespace = ns.oid\n' +
+            '  LEFT JOIN pg_catalog.pg_proc p ON ap.amproc = p.oid\n';
+    let hasWhere = false;
+    if (opts.amPattern !== undefined) {
+        sql += patternStub(hasWhere, undefined, 'am.amname');
+        hasWhere = true;
+    }
+    if (opts.familyPattern !== undefined) {
+        sql += patternStub(hasWhere, 'ns.nspname', 'of.opfname');
+    }
+    sql +=
+        'ORDER BY 1, 2,\n  ap.amproclefttype = ap.amprocrighttype DESC,\n  3, 4, 5;';
+    const ps = [];
+    if (opts.amPattern !== undefined)
+        ps.push(opts.amPattern);
+    if (opts.familyPattern !== undefined)
+        ps.push(opts.familyPattern);
+    return {
+        sql,
+        params: ps,
+        description: 'List of support functions of operator families',
+    };
+};
+/* ------------------------------------------------------------------ */
+/* \dl / \lo_list — listLargeObjects                                  */
+/* ------------------------------------------------------------------ */
+export const listLargeObjects = (opts) => {
+    const { verbose } = opts;
+    let sql = 'SELECT oid as "ID",\n  pg_catalog.pg_get_userbyid(lomowner) as "Owner",\n  ';
+    if (verbose) {
+        sql += aclColumn('lomacl') + ',\n  ';
+    }
+    sql +=
+        'pg_catalog.obj_description(oid, \'pg_largeobject\') as "Description"\n' +
+            'FROM pg_catalog.pg_largeobject_metadata\n' +
+            'ORDER BY oid';
+    return { sql, params: [], description: 'Large objects' };
+};
+/* ------------------------------------------------------------------ */
+/* \sf — show function definition                                     */
+/* \sv — show view definition                                         */
+/* These are command-level (in command.c) but the SQL is trivial and  */
+/* belongs with the rest of the describe SQL.                         */
+/* ------------------------------------------------------------------ */
+/**
+ * Look up function OID by name for `\sf` / `\sf+`. Caller renders
+ * `pg_catalog.pg_get_functiondef(oid)` afterwards. The lookup itself
+ * uses regprocedure casting via the placeholder; WP-20 will replace.
+ */
+export const showFunction = (opts) => {
+    // We emit a select returning the function definition by name; upstream
+    // psql resolves to oid then calls pg_get_functiondef(oid). Combine.
+    const sql = `SELECT pg_catalog.pg_get_functiondef('${opts.name.replace(/'/g, "''")}'::pg_catalog.regprocedure) AS def;`;
+    return { sql, params: [], description: 'Function definition' };
+};
+/**
+ * Look up view definition for `\sv` / `\sv+`.
+ */
+export const showView = (opts) => {
+    const sql = `SELECT pg_catalog.pg_get_viewdef('${opts.name.replace(/'/g, "''")}'::pg_catalog.regclass, true) AS def;`;
+    return { sql, params: [], description: 'View definition' };
+};
+/* ------------------------------------------------------------------ */
+/* Per-relation follow-up queries used by describeOneTableDetails.    */
+/* Each builder takes a relation oid and returns a DescribeQuery the  */
+/* formatter executes after the columns table. These mirror the      */
+/* PSQLexec calls in upstream `describe.c` for the same sections.    */
+/* ------------------------------------------------------------------ */
+/**
+ * Per-relation table-info query. Returns one row carrying the flags
+ * the formatter needs for the optional footer sections: RLS toggles
+ * (relrowsecurity, relforcerowsecurity), replica-identity char,
+ * partition flag, tablespace oid, access-method oid and pre-joined
+ * pg_tablespace.spcname / pg_am.amname so the formatter doesn't have
+ * to fan out for those.
+ *
+ * Columns: relrowsecurity, relforcerowsecurity, relreplident,
+ *          relispartition, reltablespace, relam, spcname, amname.
+ *
+ * Pre-PG 9.5 servers don't expose `relrowsecurity` /
+ * `relforcerowsecurity` / `relispartition`; we synthesize false there.
+ * Pre-PG 12 doesn't carry table AMs in pg_class.relam, so we leave the
+ * amname slot null on those servers.
+ */
+export const fetchTableInfo = (opts) => {
+    const { oid, serverVersion } = opts;
+    const hasRowSec = serverAtLeast(serverVersion, PG_9_5);
+    const hasIsPart = serverAtLeast(serverVersion, PG_10);
+    const hasRelAm = serverAtLeast(serverVersion, PG_12);
+    const rowSec = hasRowSec
+        ? 'c.relrowsecurity, c.relforcerowsecurity'
+        : 'false AS relrowsecurity, false AS relforcerowsecurity';
+    const isPart = hasIsPart ? 'c.relispartition' : 'false AS relispartition';
+    const amCol = hasRelAm ? 'c.relam' : '0::oid AS relam';
+    const amName = hasRelAm ? 'am.amname' : 'NULL::name AS amname';
+    const amJoin = hasRelAm
+        ? '  LEFT JOIN pg_catalog.pg_am am ON am.oid = c.relam\n'
+        : '';
+    const sql = 'SELECT ' +
+        rowSec +
+        ',\n  c.relreplident,\n  ' +
+        isPart +
+        ',\n  c.reltablespace,\n  ' +
+        amCol +
+        ',\n  ts.spcname,\n  ' +
+        amName +
+        '\nFROM pg_catalog.pg_class c\n' +
+        '  LEFT JOIN pg_catalog.pg_tablespace ts ON ts.oid = c.reltablespace\n' +
+        amJoin +
+        `WHERE c.oid = '${oid}';`;
+    return { sql, params: [], description: 'Relation footer info' };
+};
+/**
+ * Named NOT NULL constraints (`pg_constraint.contype = 'n'`), introduced
+ * in PG 18. Output columns mirror upstream `describeOneTableDetails`
+ * (describe.c ~3104):
+ *   conname, attname, connoinherit, conislocal.
+ *
+ * The constraint references a single column via `conkey[1]`; we join
+ * `pg_attribute` on that attnum and order by it so the footer lists the
+ * constraints in column order. On pre-PG-18 servers the catalog never
+ * carries `contype = 'n'` rows, so the query returns empty and the
+ * caller suppresses the footer — no version branch is needed in the SQL.
+ */
+export const fetchNotNullConstraints = (opts) => {
+    const { oid, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_18)) {
+        return {
+            sql: 'SELECT NULL::pg_catalog.text, NULL::pg_catalog.text, false, false WHERE false;',
+            params: [],
+            description: 'Not-null constraints',
+        };
+    }
+    const sql = 'SELECT co.conname, at.attname, co.connoinherit, co.conislocal\n' +
+        'FROM pg_catalog.pg_constraint co\n' +
+        '  JOIN pg_catalog.pg_attribute at\n' +
+        '    ON (at.attrelid = co.conrelid AND at.attnum = co.conkey[1])\n' +
+        `WHERE co.contype = 'n' AND co.conrelid = '${oid}'\n` +
+        'ORDER BY at.attnum;';
+    return { sql, params: [], description: 'Not-null constraints' };
+};
+/**
+ * RLS policies for a relation. Output columns mirror upstream:
+ *   polname, polpermissive, roles (CSV or NULL), polqual, polwithcheck,
+ *   polcmd (mapped to text).
+ *
+ * The polcmd→keyword mapping matches upstream: 'r'→SELECT, 'a'→INSERT,
+ * 'w'→UPDATE, 'd'→DELETE, '*'→NULL (i.e. ALL — emitted as no FOR clause).
+ */
+export const fetchPolicies = (opts) => {
+    const { oid, serverVersion } = opts;
+    const permissive = serverAtLeast(serverVersion, PG_10)
+        ? 'pol.polpermissive'
+        : "'t' AS polpermissive";
+    const sql = 'SELECT pol.polname,\n  ' +
+        permissive +
+        ",\n  CASE WHEN pol.polroles = '{0}' THEN NULL ELSE pg_catalog.array_to_string(array(SELECT rolname FROM pg_catalog.pg_roles WHERE oid = ANY (pol.polroles) ORDER BY 1), ', ') END AS roles,\n" +
+        '  pg_catalog.pg_get_expr(pol.polqual, pol.polrelid) AS qual,\n' +
+        '  pg_catalog.pg_get_expr(pol.polwithcheck, pol.polrelid) AS withcheck,\n' +
+        '  CASE pol.polcmd\n' +
+        "    WHEN 'r' THEN 'SELECT'\n" +
+        "    WHEN 'a' THEN 'INSERT'\n" +
+        "    WHEN 'w' THEN 'UPDATE'\n" +
+        "    WHEN 'd' THEN 'DELETE'\n" +
+        '    END AS cmd\n' +
+        'FROM pg_catalog.pg_policy pol\n' +
+        `WHERE pol.polrelid = '${oid}'\n` +
+        'ORDER BY pol.polname;';
+    return { sql, params: [], description: 'Relation policies' };
+};
+/**
+ * Parents from `pg_inherits`. We exclude partitioned parents so
+ * "Inherits:" only lists genuine inheritance (partition parents go in
+ * "Partition of:" instead). Output: one column with a regclass-formatted
+ * parent name per row.
+ */
+export const fetchInherits = (opts) => {
+    const { oid } = opts;
+    const sql = 'SELECT c.oid::pg_catalog.regclass\n' +
+        'FROM pg_catalog.pg_class c, pg_catalog.pg_inherits i\n' +
+        `WHERE c.oid = i.inhparent AND i.inhrelid = '${oid}'\n` +
+        "  AND c.relkind NOT IN ('p', 'I')\n" +
+        'ORDER BY inhseqno;';
+    return { sql, params: [], description: 'Inherited-from relations' };
+};
+/**
+ * Child tables / partitions from `pg_inherits`. Output columns:
+ *   relname (regclass), relkind, inhdetachpending, partition-bound (or NULL).
+ *
+ * Pre-PG 10 servers don't expose `relpartbound`; pre-PG 14 don't have
+ * `inhdetachpending`. We synthesize NULL / false there.
+ */
+export const fetchInheritedBy = (opts) => {
+    const { oid, serverVersion } = opts;
+    const hasDetach = serverAtLeast(serverVersion, PG_14);
+    const hasPartBound = serverAtLeast(serverVersion, PG_10);
+    const detachCol = hasDetach
+        ? 'i.inhdetachpending'
+        : 'false AS inhdetachpending';
+    const boundCol = hasPartBound
+        ? 'pg_catalog.pg_get_expr(c.relpartbound, c.oid)'
+        : 'NULL::text';
+    const orderBy = hasPartBound
+        ? "pg_catalog.pg_get_expr(c.relpartbound, c.oid) = 'DEFAULT'," +
+            ' c.oid::pg_catalog.regclass::pg_catalog.text'
+        : 'c.oid::pg_catalog.regclass::pg_catalog.text';
+    const sql = 'SELECT c.oid::pg_catalog.regclass, c.relkind,\n  ' +
+        detachCol +
+        ',\n  ' +
+        boundCol +
+        '\nFROM pg_catalog.pg_class c, pg_catalog.pg_inherits i\n' +
+        `WHERE c.oid = i.inhrelid AND i.inhparent = '${oid}'\n` +
+        `ORDER BY ${orderBy};`;
+    return { sql, params: [], description: 'Inheriting / child relations' };
+};
+/**
+ * Partition-of details for a child partition (`relispartition = true`).
+ * Returns parent regclass + partition bound (+ partition constraint when
+ * verbose is requested by the caller). Per upstream, this is invoked
+ * unconditionally for child partitions regardless of verbose, with the
+ * partition-constraint column conditionally selected.
+ */
+export const fetchPartitionOf = (opts) => {
+    const { oid, serverVersion, withConstraint } = opts;
+    const detachCol = serverAtLeast(serverVersion, PG_14)
+        ? 'i.inhdetachpending'
+        : 'false AS inhdetachpending';
+    let sql = 'SELECT inhparent::pg_catalog.regclass,\n' +
+        '  pg_catalog.pg_get_expr(c.relpartbound, c.oid),\n  ' +
+        detachCol;
+    if (withConstraint) {
+        sql += ',\n  pg_catalog.pg_get_partition_constraintdef(c.oid)';
+    }
+    sql +=
+        '\nFROM pg_catalog.pg_class c\n' +
+            '  JOIN pg_catalog.pg_inherits i ON c.oid = i.inhrelid\n' +
+            `WHERE c.oid = '${oid}';`;
+    return { sql, params: [], description: 'Partition-of details' };
+};
+/**
+ * Partition-key definition for a partitioned-table parent
+ * (`relkind = 'p'`). One row, one text column.
+ */
+export const fetchPartitionKey = (opts) => {
+    const sql = `SELECT pg_catalog.pg_get_partkeydef('${opts.oid}'::pg_catalog.oid);`;
+    return { sql, params: [], description: 'Partition key' };
+};
+/**
+ * Foreign-table footer info: server name + ftoptions as a pre-formatted
+ * "key 'val', key 'val'" string. Two-column single-row result; an empty
+ * options string means no FDW options.
+ */
+export const fetchForeignTableInfo = (opts) => {
+    const { oid } = opts;
+    const sql = 'SELECT s.srvname,\n' +
+        '  pg_catalog.array_to_string(ARRAY(\n' +
+        "    SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value)\n" +
+        "    FROM pg_catalog.pg_options_to_table(ftoptions)),  ', ') AS ftoptions\n" +
+        'FROM pg_catalog.pg_foreign_table f,\n' +
+        '     pg_catalog.pg_foreign_server s\n' +
+        `WHERE f.ftrelid = '${oid}' AND s.oid = f.ftserver;`;
+    return { sql, params: [], description: 'Foreign-table footer info' };
+};
+/**
+ * Pull `indexrelid::regclass` for the index marked as REPLICA IDENTITY
+ * on this relation. Returns at most one row when relreplident = 'i'.
+ */
+export const fetchReplicaIdentityIndex = (opts) => {
+    const { oid } = opts;
+    const sql = 'SELECT c2.relname\n' +
+        'FROM pg_catalog.pg_index i\n' +
+        '  JOIN pg_catalog.pg_class c2 ON c2.oid = i.indexrelid\n' +
+        `WHERE i.indrelid = '${oid}' AND i.indisreplident\n` +
+        'LIMIT 1;';
+    return { sql, params: [], description: 'Replica-identity index' };
+};
+/**
+ * Extended-statistics objects defined on a relation. Mirrors the upstream
+ * verbose-only `\d+` section. Output columns:
+ *   stxnsp, stxname, ndist_enabled, deps_enabled, mcv_enabled, columns,
+ *   stxrelname, stxstattarget.
+ *
+ * Only meaningful on PG 10+ (the catalog table `pg_statistic_ext` doesn't
+ * exist before then). Caller gates by `relkind in ('r','m','p','f')` and
+ * verbose mode.
+ */
+export const fetchStatisticsObjects = (opts) => {
+    const { oid, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support extended statistics */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'Statistics objects',
+        };
+    }
+    // `pg_get_statisticsobjdef_columns` was added in PG 14. Older servers
+    // reconstruct the column list from `pg_statistic_ext.stxkeys`.
+    const columnsExpr = serverAtLeast(serverVersion, PG_14)
+        ? 'pg_catalog.pg_get_statisticsobjdef_columns(es.oid)'
+        : "(SELECT pg_catalog.string_agg(pg_catalog.quote_ident(a.attname), ', ')\n" +
+            '   FROM pg_catalog.unnest(es.stxkeys) k(attnum)\n' +
+            '   JOIN pg_catalog.pg_attribute a ON a.attrelid = es.stxrelid AND a.attnum = k.attnum AND NOT a.attisdropped)';
+    // `pg_statistic_ext.stxstattarget` exists on every supported PG; PG 17
+    // changed its type from int4 to int2 but we just CAST to text.
+    const sql = 'SELECT es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text AS stxnsp,\n' +
+        '  es.stxname,\n' +
+        "  'd' = any(es.stxkind) AS ndist_enabled,\n" +
+        "  'f' = any(es.stxkind) AS deps_enabled,\n" +
+        "  'm' = any(es.stxkind) AS mcv_enabled,\n" +
+        '  ' +
+        columnsExpr +
+        ' AS columns,\n' +
+        '  es.stxrelid::pg_catalog.regclass::pg_catalog.text AS stxrelname,\n' +
+        '  es.stxstattarget\n' +
+        'FROM pg_catalog.pg_statistic_ext es\n' +
+        `WHERE es.stxrelid = '${oid}'\n` +
+        'ORDER BY stxnsp, es.stxname;';
+    return { sql, params: [], description: 'Statistics objects' };
+};
+/**
+ * Publications a relation belongs to. Returns one column `pubname` per
+ * publication. Covers the three sources upstream considers:
+ *   - explicit `pg_publication_rel` membership
+ *   - `puballtables` (FOR ALL TABLES)
+ *   - `pg_publication_namespace` (FOR ALL TABLES IN SCHEMA, PG 15+)
+ *
+ * Pre-PG 10 servers return an empty set (publications don't exist).
+ */
+export const fetchTablePublications = (opts) => {
+    const { oid, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support publications */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'Table publications',
+        };
+    }
+    const hasPubNs = serverAtLeast(serverVersion, PG_15);
+    let sql = 'SELECT pub.pubname\n' +
+        'FROM pg_catalog.pg_publication pub\n' +
+        'WHERE pub.puballtables\n' +
+        '   OR EXISTS (\n' +
+        '     SELECT 1 FROM pg_catalog.pg_publication_rel pr\n' +
+        `     WHERE pr.prpubid = pub.oid AND pr.prrelid = '${oid}'\n` +
+        '   )';
+    if (hasPubNs) {
+        sql +=
+            '\n   OR EXISTS (\n' +
+                '     SELECT 1 FROM pg_catalog.pg_publication_namespace pn\n' +
+                `     JOIN pg_catalog.pg_class c ON c.oid = '${oid}'\n` +
+                '     WHERE pn.pnpubid = pub.oid AND pn.pnnspid = c.relnamespace\n' +
+                '   )';
+    }
+    sql += '\nORDER BY 1;';
+    return { sql, params: [], description: 'Table publications' };
+};
+/**
+ * Subscriptions that include this relation. Mirrors the upstream
+ * `\d+` section. Requires read access to `pg_subscription`, which is
+ * only granted to superusers — the formatter must swallow
+ * permission-denied errors silently.
+ *
+ * Pre-PG 10 servers return an empty set.
+ */
+export const fetchTableSubscriptions = (opts) => {
+    const { oid, serverVersion } = opts;
+    if (serverLess(serverVersion, PG_10)) {
+        return {
+            sql: '/* server < 10 does not support subscriptions */ SELECT 1 WHERE false;',
+            params: [],
+            description: 'Table subscriptions',
+        };
+    }
+    const sql = 'SELECT sub.subname\n' +
+        'FROM pg_catalog.pg_subscription sub\n' +
+        'JOIN pg_catalog.pg_subscription_rel sr ON sr.srsubid = sub.oid\n' +
+        `WHERE sr.srrelid = '${oid}'\n` +
+        'ORDER BY 1;';
+    return { sql, params: [], description: 'Table subscriptions' };
+};
+/**
+ * Per-column FDW options for a foreign table. Returns one row per column
+ * that has at least one `attfdwoptions` entry. Output columns:
+ *   attname, opts (pre-formatted "k 'v', k 'v'").
+ *
+ * Only meaningful for `relkind = 'f'`.
+ */
+export const fetchPerColumnFdwOptions = (opts) => {
+    const { oid } = opts;
+    const sql = 'SELECT a.attname,\n' +
+        '  pg_catalog.array_to_string(ARRAY(\n' +
+        "    SELECT pg_catalog.quote_ident(option_name) || ' ' || pg_catalog.quote_literal(option_value)\n" +
+        "    FROM pg_catalog.pg_options_to_table(a.attfdwoptions)), ', ') AS opts\n" +
+        'FROM pg_catalog.pg_attribute a\n' +
+        `WHERE a.attrelid = '${oid}' AND a.attnum > 0 AND NOT a.attisdropped\n` +
+        '  AND a.attfdwoptions IS NOT NULL\n' +
+        'ORDER BY a.attnum;';
+    return { sql, params: [], description: 'Per-column FDW options' };
+};
+/**
+ * For a TOAST table (`relkind = 't'`), look up the owning user table.
+ * Returns at most one row with the parent's regclass-formatted name.
+ */
+export const fetchToastOwningTable = (opts) => {
+    const { oid } = opts;
+    const sql = 'SELECT oid::pg_catalog.regclass::pg_catalog.text AS relname\n' +
+        'FROM pg_catalog.pg_class\n' +
+        `WHERE reltoastrelid = '${oid}'\n` +
+        'LIMIT 1;';
+    return { sql, params: [], description: 'TOAST owning table' };
+};