@onreza/sqlx-js 0.0.0

package/dist/src/pg/analyze.js

@@ -0,0 +1,479 @@
+import { parse } from "libpg-query";
+import { narrowFromWhere, isNarrowed } from "./narrow.js";
+export async function analyzeQuery(sql, rowDesc, schema) {
+    const ast = await parse(sql);
+    const stmt = ast?.stmts?.[0]?.stmt;
+    if (!stmt)
+        return conservative(rowDesc, "libpg-query returned no statements");
+    if (stmt.SelectStmt) {
+        return await analyzeSelect(stmt.SelectStmt, rowDesc, schema);
+    }
+    if (stmt.InsertStmt) {
+        return await analyzeDml(stmt.InsertStmt, rowDesc, schema, "insert");
+    }
+    if (stmt.UpdateStmt) {
+        return await analyzeDml(stmt.UpdateStmt, rowDesc, schema, "update");
+    }
+    if (stmt.DeleteStmt) {
+        return await analyzeDml(stmt.DeleteStmt, rowDesc, schema, "delete");
+    }
+    const kind = Object.keys(stmt)[0] ?? "unknown";
+    return conservative(rowDesc, `unsupported statement type: ${kind}`);
+}
+function conservative(rowDesc, reason) {
+    return {
+        perColumnNullable: rowDesc.map(() => true),
+        referencedTables: [],
+        ...(reason && rowDesc.length > 0 ? { degraded: { reason } } : {}),
+    };
+}
+async function analyzeSelect(select, rowDesc, schema) {
+    if (!select.targetList || !select.fromClause) {
+        if (select.targetList && !select.fromClause) {
+            const scope = await buildScope(select, schema);
+            return runTargets(select.targetList, rowDesc, scope);
+        }
+        return conservative(rowDesc, "SELECT without targetList");
+    }
+    const scope = await buildScope(select, schema);
+    return runTargets(select.targetList, rowDesc, scope);
+}
+async function analyzeDml(stmt, rowDesc, schema, kind) {
+    const returningList = stmt.returningList ?? [];
+    if (returningList.length === 0 && rowDesc.length === 0) {
+        return { perColumnNullable: [], referencedTables: tablesFromRelation(stmt.relation) };
+    }
+    const fakeSelect = dmlAsSelect(stmt, kind, returningList);
+    const scope = await buildScope(fakeSelect, schema);
+    return runTargets(returningList, rowDesc, scope);
+}
+function dmlAsSelect(stmt, kind, targetList) {
+    const fromClause = stmt.relation ? [{ RangeVar: stmt.relation }] : [];
+    if (kind === "update" && Array.isArray(stmt.fromClause)) {
+        fromClause.push(...stmt.fromClause);
+    }
+    if (kind === "delete" && Array.isArray(stmt.usingClause)) {
+        fromClause.push(...stmt.usingClause);
+    }
+    return {
+        targetList,
+        fromClause,
+        whereClause: kind === "update" || kind === "delete" ? stmt.whereClause : undefined,
+        withClause: stmt.withClause,
+    };
+}
+function tablesFromRelation(relation) {
+    if (!relation || typeof relation.relname !== "string")
+        return [];
+    const out = { name: relation.relname };
+    if (relation.schemaname)
+        out.schema = relation.schemaname;
+    return [out];
+}
+async function buildScope(select, schema) {
+    const scope = {
+        aliases: new Map(),
+        aliasOidByName: new Map(),
+        tableRefsByOid: new Map(),
+        hasStar: false,
+        schema,
+        forcedNonNull: narrowFromWhere(select.whereClause),
+        cteColumnInfo: new Map(),
+    };
+    if (select.withClause?.ctes) {
+        for (const cteWrap of select.withClause.ctes) {
+            const cte = cteWrap?.CommonTableExpr;
+            if (!cte)
+                continue;
+            const name = cte.ctename;
+            if (!name)
+                continue;
+            const colsInfo = await analyzeCteColumns(cte, schema);
+            scope.cteColumnInfo.set(name, colsInfo);
+        }
+    }
+    for (const entry of select.fromClause ?? []) {
+        walkFrom(entry, false, scope);
+    }
+    for (const t of select.targetList ?? []) {
+        if (containsStar(t?.ResTarget?.val))
+            scope.hasStar = true;
+    }
+    const referencedTables = [];
+    for (const a of scope.aliases.values()) {
+        if (a.kind === "table")
+            referencedTables.push({ schema: a.schema, name: a.relname });
+    }
+    await schema.loadTableNames(referencedTables);
+    const allOids = [];
+    for (const [aliasName, a] of scope.aliases) {
+        if (a.kind !== "table")
+            continue;
+        const oid = schema.resolveTable(a.schema, a.relname);
+        if (oid === undefined)
+            continue;
+        scope.aliasOidByName.set(aliasName, oid);
+        allOids.push(oid);
+        const arr = scope.tableRefsByOid.get(oid) ?? [];
+        arr.push(a);
+        scope.tableRefsByOid.set(oid, arr);
+    }
+    await schema.loadColumnsForTables(allOids);
+    return scope;
+}
+async function analyzeCteColumns(cte, schema) {
+    const result = new Map();
+    const explicitColNames = Array.isArray(cte.aliascolnames)
+        ? cte.aliascolnames.map((n) => n?.String?.sval).filter((s) => typeof s === "string")
+        : undefined;
+    const inner = cte.ctequery?.SelectStmt
+        ?? cte.ctequery?.InsertStmt
+        ?? cte.ctequery?.UpdateStmt
+        ?? cte.ctequery?.DeleteStmt;
+    if (!inner)
+        return result;
+    let targetList;
+    let dmlKind;
+    if (cte.ctequery?.SelectStmt) {
+        targetList = inner.targetList;
+    }
+    else {
+        targetList = inner.returningList ?? [];
+        if (cte.ctequery?.InsertStmt)
+            dmlKind = "insert";
+        else if (cte.ctequery?.UpdateStmt)
+            dmlKind = "update";
+        else if (cte.ctequery?.DeleteStmt)
+            dmlKind = "delete";
+    }
+    if (!Array.isArray(targetList) || targetList.length === 0)
+        return result;
+    const isSelect = !!cte.ctequery?.SelectStmt;
+    const scope = isSelect
+        ? await buildScope(inner, schema)
+        : await buildScope(dmlAsSelect(inner, dmlKind, targetList), schema);
+    for (let i = 0; i < targetList.length; i++) {
+        const t = targetList[i];
+        const explicit = explicitColNames?.[i];
+        const colName = explicit ?? t?.ResTarget?.name ?? colNameOfColumnRef(t?.ResTarget?.val) ?? `?column?${i}`;
+        const isStar = containsStar(t?.ResTarget?.val);
+        if (isStar)
+            continue;
+        const nullable = computeTargetNullable(t, scope);
+        result.set(colName, nullable);
+    }
+    return result;
+}
+function runTargets(targets, rowDesc, scope) {
+    const referencedTables = [];
+    for (const a of scope.aliases.values()) {
+        if (a.kind === "table")
+            referencedTables.push({ schema: a.schema, name: a.relname });
+    }
+    const nullables = new Array(rowDesc.length).fill(true);
+    if (scope.hasStar || targets.length !== rowDesc.length) {
+        for (let i = 0; i < rowDesc.length; i++) {
+            const f = rowDesc[i];
+            nullables[i] = nullableFromRowDescConservative(f, scope);
+        }
+        return { perColumnNullable: nullables, referencedTables };
+    }
+    for (let i = 0; i < rowDesc.length; i++) {
+        const f = rowDesc[i];
+        const target = targets[i];
+        const val = target.ResTarget?.val;
+        if (f.tableOid !== 0 && f.columnAttr !== 0) {
+            const aliasName = aliasOfColumnRef(val);
+            const refColName = colNameOfColumnRef(val);
+            if (refColName && isNarrowed(scope.forcedNonNull, aliasName ?? undefined, refColName)) {
+                nullables[i] = false;
+                continue;
+            }
+            const notNull = scope.schema.isNotNull(f.tableOid, f.columnAttr);
+            let joinNullable;
+            if (aliasName && scope.aliases.has(aliasName)) {
+                joinNullable = scope.aliases.get(aliasName).joinNullable;
+            }
+            else {
+                joinNullable = anyAliasNullableForOid(f.tableOid, scope);
+            }
+            nullables[i] = !(notNull === true && !joinNullable);
+        }
+        else {
+            nullables[i] = expressionNullable(val, scope);
+        }
+    }
+    return { perColumnNullable: nullables, referencedTables };
+}
+function addForcedNonNull(scope, set) {
+    for (const k of set)
+        scope.forcedNonNull.add(k);
+}
+function computeTargetNullable(target, scope) {
+    const val = target?.ResTarget?.val;
+    return expressionNullable(val, scope);
+}
+function nullableFromRowDescConservative(f, scope) {
+    if (f.tableOid === 0 || f.columnAttr === 0)
+        return true;
+    const notNull = scope.schema.isNotNull(f.tableOid, f.columnAttr);
+    if (notNull !== true)
+        return true;
+    return anyAliasNullableForOid(f.tableOid, scope);
+}
+function anyAliasNullableForOid(tableOid, scope) {
+    const refs = scope.tableRefsByOid.get(tableOid);
+    if (!refs || refs.length === 0)
+        return true;
+    return refs.some((r) => r.joinNullable);
+}
+function walkFrom(node, joinNullable, scope) {
+    if (!node)
+        return;
+    if (node.RangeVar) {
+        const v = node.RangeVar;
+        const alias = v.alias?.aliasname ?? v.relname;
+        const cteCols = scope.cteColumnInfo.get(v.relname);
+        if (cteCols) {
+            scope.aliases.set(alias, { kind: "cte", joinNullable, columns: cteCols });
+            return;
+        }
+        const info = {
+            kind: "table",
+            relname: v.relname,
+            joinNullable,
+        };
+        if (v.schemaname)
+            info.schema = v.schemaname;
+        scope.aliases.set(alias, info);
+        return;
+    }
+    if (node.JoinExpr) {
+        const j = node.JoinExpr;
+        let leftNullable = joinNullable;
+        let rightNullable = joinNullable;
+        switch (j.jointype) {
+            case "JOIN_LEFT":
+                rightNullable = true;
+                break;
+            case "JOIN_RIGHT":
+                leftNullable = true;
+                break;
+            case "JOIN_FULL":
+                leftNullable = true;
+                rightNullable = true;
+                break;
+        }
+        walkFrom(j.larg, leftNullable, scope);
+        walkFrom(j.rarg, rightNullable, scope);
+        if (j.jointype === "JOIN_INNER" && !joinNullable) {
+            addForcedNonNull(scope, narrowFromWhere(j.quals));
+        }
+        return;
+    }
+    if (node.RangeSubselect) {
+        const alias = node.RangeSubselect.alias?.aliasname;
+        if (alias)
+            scope.aliases.set(alias, { kind: "subquery", joinNullable, columns: new Map() });
+        return;
+    }
+    if (node.RangeFunction) {
+        const alias = node.RangeFunction.alias?.aliasname;
+        if (alias)
+            scope.aliases.set(alias, { kind: "function", joinNullable });
+        return;
+    }
+}
+function aliasOfColumnRef(val) {
+    if (!val?.ColumnRef)
+        return null;
+    const fields = val.ColumnRef.fields;
+    if (!Array.isArray(fields) || fields.length < 2)
+        return null;
+    const first = fields[0]?.String?.sval;
+    if (typeof first !== "string")
+        return null;
+    return first;
+}
+function colNameOfColumnRef(val) {
+    if (!val?.ColumnRef)
+        return undefined;
+    const fields = val.ColumnRef.fields;
+    if (!Array.isArray(fields) || fields.length === 0)
+        return undefined;
+    if (fields.some((f) => f.A_Star !== undefined))
+        return undefined;
+    return fields[fields.length - 1]?.String?.sval;
+}
+function containsStar(val) {
+    if (!val?.ColumnRef)
+        return false;
+    const fields = val.ColumnRef.fields;
+    if (!Array.isArray(fields))
+        return false;
+    return fields.some((f) => f.A_Star !== undefined);
+}
+function columnRefNullable(fields, scope) {
+    let aliasName;
+    let colName;
+    if (fields.length >= 2) {
+        aliasName = fields[0]?.String?.sval;
+        colName = fields[fields.length - 1]?.String?.sval;
+    }
+    else if (fields.length === 1) {
+        colName = fields[0]?.String?.sval;
+    }
+    if (typeof colName !== "string")
+        return true;
+    if (isNarrowed(scope.forcedNonNull, aliasName, colName))
+        return false;
+    if (aliasName) {
+        const a = scope.aliases.get(aliasName);
+        if (!a)
+            return true;
+        if (a.kind === "cte" || a.kind === "subquery") {
+            const inner = a.columns.get(colName);
+            if (inner === undefined)
+                return true;
+            return inner || a.joinNullable;
+        }
+        if (a.kind !== "table")
+            return true;
+        const oid = scope.aliasOidByName.get(aliasName);
+        if (oid === undefined)
+            return true;
+        const cols = scope.schema.columnsOf(oid);
+        const info = cols?.get(colName);
+        if (!info)
+            return true;
+        return !info.notNull || a.joinNullable;
+    }
+    const matches = [];
+    for (const [name, a] of scope.aliases) {
+        if (a.kind === "cte" || a.kind === "subquery") {
+            const inner = a.columns.get(colName);
+            if (inner === undefined)
+                continue;
+            matches.push({ alias: name, notNull: !inner, joinNullable: a.joinNullable });
+            continue;
+        }
+        if (a.kind !== "table")
+            continue;
+        const oid = scope.aliasOidByName.get(name);
+        if (oid === undefined)
+            continue;
+        const info = scope.schema.columnsOf(oid)?.get(colName);
+        if (!info)
+            continue;
+        matches.push({ alias: name, notNull: info.notNull, joinNullable: a.joinNullable });
+    }
+    if (matches.length !== 1)
+        return true;
+    const m = matches[0];
+    return !m.notNull || m.joinNullable;
+}
+function funcName(call) {
+    const names = call?.funcname;
+    if (!Array.isArray(names))
+        return null;
+    const last = names[names.length - 1];
+    return last?.String?.sval?.toLowerCase() ?? null;
+}
+const NON_NULL_FUNCS = new Set([
+    "now",
+    "current_timestamp",
+    "current_date",
+    "current_time",
+    "localtime",
+    "localtimestamp",
+    "current_user",
+    "session_user",
+    "user",
+    "current_database",
+    "current_schema",
+    "version",
+    "pg_backend_pid",
+    "txid_current",
+    "random",
+    "gen_random_uuid",
+    "uuid_generate_v4",
+    "length",
+    "char_length",
+    "character_length",
+    "octet_length",
+    "concat",
+    "concat_ws",
+]);
+const COUNT_FUNCS = new Set(["count"]);
+function expressionNullable(val, scope) {
+    if (!val)
+        return true;
+    if (val.A_Const !== undefined) {
+        const c = val.A_Const;
+        if (c.isnull === true)
+            return true;
+        return false;
+    }
+    if (val.ColumnRef) {
+        const fields = val.ColumnRef.fields;
+        if (!Array.isArray(fields))
+            return true;
+        if (fields.some((f) => f.A_Star !== undefined))
+            return true;
+        return columnRefNullable(fields, scope);
+    }
+    if (val.FuncCall) {
+        const name = funcName(val.FuncCall);
+        if (name && COUNT_FUNCS.has(name))
+            return false;
+        if (name && NON_NULL_FUNCS.has(name)) {
+            const args = val.FuncCall.args ?? [];
+            return args.some((a) => expressionNullable(a, scope));
+        }
+        if (name === "greatest" || name === "least") {
+            const args = val.FuncCall.args ?? [];
+            if (args.length === 0)
+                return true;
+            return args.every((a) => expressionNullable(a, scope));
+        }
+        return true;
+    }
+    if (val.CoalesceExpr) {
+        const args = val.CoalesceExpr.args ?? [];
+        if (args.length === 0)
+            return true;
+        return args.every((a) => expressionNullable(a, scope));
+    }
+    if (val.MinMaxExpr) {
+        const args = val.MinMaxExpr.args ?? [];
+        if (args.length === 0)
+            return true;
+        return args.every((a) => expressionNullable(a, scope));
+    }
+    if (val.NullIfExpr) {
+        return true;
+    }
+    if (val.CaseExpr) {
+        const c = val.CaseExpr;
+        const branches = (c.args ?? []).map((arm) => arm.CaseWhen?.result);
+        const hasElse = c.defresult !== undefined && c.defresult !== null;
+        if (!hasElse)
+            return true;
+        const elseExpr = c.defresult;
+        return [...branches, elseExpr].some((b) => expressionNullable(b, scope));
+    }
+    if (val.A_Expr) {
+        const e = val.A_Expr;
+        return expressionNullable(e.lexpr, scope) || expressionNullable(e.rexpr, scope);
+    }
+    if (val.SubLink)
+        return true;
+    if (val.TypeCast) {
+        return expressionNullable(val.TypeCast.arg, scope);
+    }
+    if (val.BoolExpr) {
+        const a = val.BoolExpr.args ?? [];
+        return a.some((x) => expressionNullable(x, scope));
+    }
+    return true;
+}

package/dist/src/pg/extensions.d.ts

@@ -0,0 +1,2 @@
+export declare const BUILTIN_EXTENSION_TYPES: Record<string, string>;
+export declare function mergeExtensionTypes(user?: Record<string, string>): Record<string, string>;

package/dist/src/pg/extensions.js

@@ -0,0 +1,15 @@
+export const BUILTIN_EXTENSION_TYPES = {
+    vector: "number[]",
+    halfvec: "number[]",
+    sparsevec: "string",
+    hstore: "Record<string, string | null>",
+    citext: "string",
+    ltree: "string",
+    lquery: "string",
+    ltxtquery: "string",
+};
+export function mergeExtensionTypes(user) {
+    if (!user)
+        return { ...BUILTIN_EXTENSION_TYPES };
+    return { ...BUILTIN_EXTENSION_TYPES, ...user };
+}

package/dist/src/pg/narrow.d.ts

@@ -0,0 +1,3 @@
+export type NonNullSet = Set<string>;
+export declare function narrowFromWhere(whereClause: any): NonNullSet;
+export declare function isNarrowed(set: NonNullSet, alias: string | undefined, col: string): boolean;

package/dist/src/pg/narrow.js

@@ -0,0 +1,146 @@
+const NULL_REJECTING_OPS = new Set(["=", "!=", "<>", "<", ">", "<=", ">="]);
+export function narrowFromWhere(whereClause) {
+    if (!whereClause)
+        return new Set();
+    return walk(whereClause).forced;
+}
+function emptyInfo() {
+    return { forced: new Set(), equalities: [] };
+}
+function forcedInfo(keys) {
+    return { forced: new Set(keys), equalities: [] };
+}
+function propagateEqualities(info) {
+    if (info.forced.size === 0 || info.equalities.length === 0)
+        return info;
+    const graph = new Map();
+    for (const [left, right] of info.equalities) {
+        if (left === right)
+            continue;
+        const l = graph.get(left) ?? new Set();
+        l.add(right);
+        graph.set(left, l);
+        const r = graph.get(right) ?? new Set();
+        r.add(left);
+        graph.set(right, r);
+    }
+    const forced = new Set(info.forced);
+    const queue = [...forced];
+    for (let i = 0; i < queue.length; i++) {
+        const current = queue[i];
+        for (const next of graph.get(current) ?? []) {
+            if (forced.has(next))
+                continue;
+            forced.add(next);
+            queue.push(next);
+        }
+    }
+    return { forced, equalities: info.equalities };
+}
+function walk(node) {
+    if (!node)
+        return emptyInfo();
+    if (node.NullTest) {
+        if (node.NullTest.nulltesttype === "IS_NOT_NULL") {
+            const k = keyOfColumnRef(node.NullTest.arg);
+            return k ? forcedInfo([k]) : emptyInfo();
+        }
+        return emptyInfo();
+    }
+    if (node.BoolExpr) {
+        const op = node.BoolExpr.boolop;
+        const args = node.BoolExpr.args ?? [];
+        if (op === "AND_EXPR") {
+            const out = { forced: new Set(), equalities: [] };
+            for (const a of args) {
+                const child = walk(a);
+                for (const k of child.forced)
+                    out.forced.add(k);
+                out.equalities.push(...child.equalities);
+            }
+            return propagateEqualities(out);
+        }
+        if (op === "OR_EXPR") {
+            if (args.length === 0)
+                return emptyInfo();
+            let acc;
+            for (const a of args) {
+                const s = walk(a).forced;
+                if (!acc)
+                    acc = new Set(s);
+                else {
+                    const next = new Set();
+                    for (const k of acc)
+                        if (s.has(k))
+                            next.add(k);
+                    acc = next;
+                }
+            }
+            return forcedInfo(acc ?? []);
+        }
+        return emptyInfo();
+    }
+    if (node.A_Expr) {
+        const e = node.A_Expr;
+        const kind = e.kind;
+        const opName = e.name?.[0]?.String?.sval;
+        const lk = keyOfColumnRef(e.lexpr);
+        const rk = keyOfColumnRef(e.rexpr);
+        if (kind === "AEXPR_OP" && opName && NULL_REJECTING_OPS.has(opName)) {
+            const out = new Set();
+            const lIsNull = isNullLiteral(e.lexpr);
+            const rIsNull = isNullLiteral(e.rexpr);
+            if (lk && !rIsNull)
+                out.add(lk);
+            if (rk && !lIsNull)
+                out.add(rk);
+            const equalities = opName === "=" && lk && rk ? [[lk, rk]] : [];
+            return { forced: out, equalities };
+        }
+        if (kind === "AEXPR_NOT_DISTINCT" && opName === "=" && lk && rk) {
+            return { forced: new Set(), equalities: [[lk, rk]] };
+        }
+        if (kind === "AEXPR_IN" || kind === "AEXPR_LIKE" || kind === "AEXPR_ILIKE" || kind === "AEXPR_BETWEEN") {
+            const k = keyOfColumnRef(e.lexpr);
+            return k ? forcedInfo([k]) : emptyInfo();
+        }
+        return emptyInfo();
+    }
+    return emptyInfo();
+}
+function keyOfColumnRef(node) {
+    if (!node?.ColumnRef)
+        return null;
+    const fields = node.ColumnRef.fields;
+    if (!Array.isArray(fields) || fields.length === 0)
+        return null;
+    if (fields.some((f) => f.A_Star !== undefined))
+        return null;
+    if (fields.length === 1) {
+        const col = fields[0]?.String?.sval;
+        return typeof col === "string" ? `|${col}` : null;
+    }
+    const alias = fields[0]?.String?.sval;
+    const col = fields[fields.length - 1]?.String?.sval;
+    if (typeof alias !== "string" || typeof col !== "string")
+        return null;
+    return `${alias}|${col}`;
+}
+function isNullLiteral(node) {
+    return node?.A_Const?.isnull === true;
+}
+export function isNarrowed(set, alias, col) {
+    if (set.size === 0)
+        return false;
+    if (alias && set.has(`${alias}|${col}`))
+        return true;
+    if (set.has(`|${col}`))
+        return true;
+    if (!alias) {
+        const suffix = `|${col}`;
+        for (const k of set)
+            if (k.endsWith(suffix))
+                return true;
+    }
+    return false;
+}

package/dist/src/pg/oids.d.ts

@@ -0,0 +1,10 @@
+export type TsTypeInfo = {
+    ts: string;
+    bigint?: boolean;
+};
+export declare function oidToTs(oid: number): TsTypeInfo;
+export declare function isBuiltinOid(oid: number): boolean;
+export declare function builtinArrayOids(): number[];
+export declare function arrayElementOid(oid: number): number | undefined;
+export type ResolveTs = (oid: number) => string;
+export declare function makeResolver(custom: (oid: number) => string | undefined): ResolveTs;