@onreza/sqlx-js 0.1.0 → 0.3.0

package/dist/src/commands/prepare.d.ts

@@ -1,4 +1,4 @@
-import { PgClient } from "../pg/wire.js";
+import { PgClient, type ConnConfig, type FieldDescription } from "../pg/wire.js";
 import { SchemaCache } from "../pg/schema.js";
 import { type SqlxJsConfig } from "../config.js";
 export type PrepareOptions = {
@@ -15,9 +15,23 @@ export type PrepareSession = {
     userCfg: SqlxJsConfig;
 };
 export declare function openSession(opts: PrepareOptions): Promise<PrepareSession>;
-export declare function prepareOnce(opts: PrepareOptions, session: PrepareSession, log?: (msg: string) => void, err?: (msg: string) => void): Promise<{
+type DescribeOutcome = {
+    ok: true;
+    paramOids: number[];
+    fields: FieldDescription[];
+} | {
+    ok: false;
+    error: unknown;
+};
+export declare function defaultPrepareConcurrency(): number;
+export declare function describeAll(cfg: ConnConfig, sessionClient: PgClient, queries: {
+    fp: string;
+    query: string;
+}[], concurrency: number): Promise<Map<string, DescribeOutcome>>;
+export declare function prepareOnce(opts: PrepareOptions, session: PrepareSession, log?: (msg: string) => void, err?: (msg: string) => void, concurrency?: number): Promise<{
     entries: number;
     failures: number;
     pruned: number;
 }>;
 export declare function runPrepare(opts: PrepareOptions): Promise<void>;
+export {};

package/dist/src/commands/prepare.js

@@ -1,5 +1,5 @@
 import { PgClient, parseDatabaseUrl, PgError } from "../pg/wire.js";
-import { SchemaCache } from "../pg/schema.js";
+import { SchemaCache, compositeLiteral } from "../pg/schema.js";
 import { analyzeQuery } from "../pg/analyze.js";
 import { isBuiltinOid, oidToTs } from "../pg/oids.js";
 import { scanProject } from "../scan/scanner.js";
@@ -10,6 +10,7 @@ import { buildParamMap } from "../pg/param-map.js";
 import { mergeExtensionTypes } from "../pg/extensions.js";
 const JSON_OIDS = new Set([114, 3802]);
 const JSON_ARRAY_OIDS = new Set([199, 3807]);
+const JSON_INPUT = 'import("@onreza/sqlx-js").JsonInput';
 function enumUnion(values) {
     if (values.length === 0)
         return "never";
@@ -26,6 +27,10 @@ function resolveTs(oid, customLookup) {
             return c.tsType;
         if (c.kind === "scalarArray")
             return `(${c.element.tsType})[]`;
+        if (c.kind === "composite")
+            return compositeLiteral(c);
+        if (c.kind === "compositeArray")
+            return `(${compositeLiteral(c.element)})[]`;
     }
     return oidToTs(oid).ts;
 }
@@ -52,13 +57,28 @@ function resolveParamTs(paramIndex, paramOid, paramMap, schema, cfg) {
     if (JSON_OIDS.has(paramOid) || JSON_ARRAY_OIDS.has(paramOid)) {
         const target = paramMap.get(paramIndex);
         if (target) {
-            const decl = lookupJsonbType(cfg, target.schema ?? "public", target.table, target.column);
+            const column = resolveTargetColumn(target, schema);
+            const decl = column ? lookupJsonbType(cfg, target.schema ?? "public", target.table, column) : undefined;
             if (decl)
                 return JSON_ARRAY_OIDS.has(paramOid) ? `(${decl})[]` : decl;
         }
+        return JSON_ARRAY_OIDS.has(paramOid) ? `(${JSON_INPUT})[]` : JSON_INPUT;
     }
     return resolveTs(paramOid, (oid) => schema.customType(oid));
 }
+function resolveTargetColumn(target, schema) {
+    if (target.column)
+        return target.column;
+    if (target.columnIndex === undefined)
+        return undefined;
+    const oid = schema.resolveTable(target.schema, target.table);
+    if (oid === undefined)
+        return undefined;
+    const cols = schema.columnsOf(oid);
+    if (!cols)
+        return undefined;
+    return [...cols.values()].sort((a, b) => a.attnum - b.attnum)[target.columnIndex - 1]?.name;
+}
 function resolveParamNullable(paramIndex, pm, schema) {
     if (pm.forceNullable.has(paramIndex))
         return true;
@@ -69,7 +89,10 @@ function resolveParamNullable(paramIndex, pm, schema) {
         const oid = schema.resolveTable(t.schema, t.table);
         if (oid === undefined)
             return false;
-        const col = schema.columnsOf(oid)?.get(t.column);
+        const column = resolveTargetColumn(t, schema);
+        if (!column)
+            return false;
+        const col = schema.columnsOf(oid)?.get(column);
         if (!col)
             return false;
         return !col.notNull;
@@ -96,6 +119,15 @@ function snippet(query, max = 80) {
     const oneLine = query.replace(/\s+/g, " ").trim();
     return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
 }
+function siteUsage(sites) {
+    const inlineQueries = Array.from(new Set(sites.filter((s) => s.kind !== "file").map((s) => s.query))).sort();
+    const filePaths = Array.from(new Set(sites.filter((s) => s.kind === "file").map((s) => s.sqlFilePath).filter(Boolean))).sort();
+    return {
+        hasInline: inlineQueries.length > 0,
+        ...(inlineQueries.length > 0 ? { inlineQueries } : {}),
+        ...(filePaths.length > 0 ? { filePaths } : {}),
+    };
+}
 export async function openSession(opts) {
     const userCfg = await loadConfig(opts.root);
     const cfg = parseDatabaseUrl(opts.databaseUrl);
@@ -105,7 +137,59 @@ export async function openSession(opts) {
     schema.setTypeRegistry(mergeExtensionTypes(userCfg.customTypes));
     return { client, schema, userCfg };
 }
-export async function prepareOnce(opts, session, log = console.log, err = console.error) {
+export function defaultPrepareConcurrency() {
+    const raw = process.env.SQLX_JS_PREPARE_CONCURRENCY;
+    const n = raw ? Number(raw) : NaN;
+    return Number.isFinite(n) && n >= 1 ? Math.floor(n) : 8;
+}
+// describe() is sequential per PgClient (see wire.ts), so concurrency comes from
+// running several short-lived connections in parallel, each draining a shared
+// cursor. The session connection is reused as one worker; extras are closed after.
+export async function describeAll(cfg, sessionClient, queries, concurrency) {
+    const results = new Map();
+    if (queries.length === 0)
+        return results;
+    const workerCount = Math.max(1, Math.min(concurrency, queries.length));
+    let cursor = 0;
+    const drain = async (client) => {
+        while (true) {
+            const i = cursor++;
+            if (i >= queries.length)
+                return;
+            const { fp, query } = queries[i];
+            try {
+                const d = await client.describe(query);
+                results.set(fp, { ok: true, paramOids: d.paramOids, fields: d.fields });
+            }
+            catch (error) {
+                results.set(fp, { ok: false, error });
+            }
+        }
+    };
+    const extras = [];
+    try {
+        // Open extra connections best-effort. The session connection alone is enough
+        // to drain the queue, so a connection-limited server (low max_connections,
+        // PgBouncer) degrades to fewer workers instead of failing the whole prepare.
+        for (let i = 1; i < workerCount; i++) {
+            const c = new PgClient(cfg);
+            try {
+                await c.connect();
+            }
+            catch {
+                await c.end().catch(() => { });
+                break;
+            }
+            extras.push(c);
+        }
+        await Promise.all([sessionClient, ...extras].map((c) => drain(c)));
+    }
+    finally {
+        await Promise.all(extras.map((c) => c.end().catch(() => { })));
+    }
+    return results;
+}
+export async function prepareOnce(opts, session, log = console.log, err = console.error, concurrency = defaultPrepareConcurrency()) {
     const sites = scanProject(opts.root);
     log(`scanned: found ${sites.length} sql() call site(s)`);
     const cache = new Cache(opts.cacheDir);
@@ -121,30 +205,32 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
     const raw = [];
     let failures = 0;
     const { client, schema, userCfg } = session;
+    const describeList = [...unique.values()].map((u) => ({ fp: u.fp, query: u.query }));
+    const describeResults = await describeAll(parseDatabaseUrl(opts.databaseUrl), client, describeList, concurrency);
     for (const { fp, query, sites: ss } of unique.values()) {
         const site = ss[0];
-        try {
-            const d = await client.describe(query);
-            raw.push({ fp, query, sites: ss, paramOids: d.paramOids, fields: d.fields });
+        const outcome = describeResults.get(fp);
+        if (outcome.ok) {
+            raw.push({ fp, query, sites: ss, paramOids: outcome.paramOids, fields: outcome.fields });
+            continue;
         }
-        catch (e) {
-            failures++;
-            if (e instanceof PgError) {
-                const extras = [];
-                if (e.position)
-                    extras.push(`pos ${e.position}`);
-                if (e.code)
-                    extras.push(`code ${e.code}`);
-                const tail = extras.length > 0 ? ` (${extras.join(", ")})` : "";
-                err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}${tail}`);
-                if (e.hint)
-                    err(`      hint: ${e.hint}`);
-                err(`      query: ${snippet(query)}`);
-            }
-            else {
-                err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
-                err(`      query: ${snippet(query)}`);
-            }
+        failures++;
+        const e = outcome.error;
+        if (e instanceof PgError) {
+            const extras = [];
+            if (e.position)
+                extras.push(`pos ${e.position}`);
+            if (e.code)
+                extras.push(`code ${e.code}`);
+            const tail = extras.length > 0 ? ` (${extras.join(", ")})` : "";
+            err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}${tail}`);
+            if (e.hint)
+                err(`      hint: ${e.hint}`);
+            err(`      query: ${snippet(query)}`);
+        }
+        else {
+            err(`  ✗ ${formatSite(site)} — describe failed: ${e.message}`);
+            err(`      query: ${snippet(query)}`);
         }
     }
     const allAttrRefs = [];
@@ -226,13 +312,9 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
             forceNullable: new Set(),
             dmlBound: new Set(),
         };
-        const fileSites = r.sites.filter((s) => s.kind === "file");
-        const hasInline = r.sites.some((s) => s.kind !== "file");
-        const filePaths = fileSites.length > 0
-            ? Array.from(new Set(fileSites.map((s) => s.sqlFilePath))).sort()
-            : undefined;
         const entry = {
             query: r.query,
+            ...siteUsage(r.sites),
             paramOids: r.paramOids,
             paramTsTypes: r.paramOids.map((o, idx) => resolveParamTs(idx + 1, o, pm.targets, schema, userCfg)),
             paramNullable: r.paramOids.map((_o, idx) => resolveParamNullable(idx + 1, pm, schema)),
@@ -248,8 +330,6 @@ export async function prepareOnce(opts, session, log = console.log, err = consol
                 };
             }),
             hasResultSet: r.fields.length > 0,
-            hasInline,
-            ...(filePaths ? { filePaths } : {}),
             ...(analysis.degraded ? { degraded: analysis.degraded } : {}),
         };
         cache.write(r.fp, entry);
@@ -293,7 +373,10 @@ export async function runPrepare(opts) {
             console.error(`\nsqlx-js prepare --check: ${stale} stale/missing entries. Run \`sqlx-js prepare\` against a live DB.`);
             process.exit(1);
         }
-        const entries = [...unique.values()].map((u) => cache.read(u.fp)).filter(Boolean);
+        const entries = [...unique.values()].map((u) => {
+            const entry = cache.read(u.fp);
+            return entry ? { ...entry, ...siteUsage(u.sites) } : null;
+        }).filter((e) => e !== null);
         emitDts(opts.dtsPath, entries);
         console.log(`ok — ${entries.length} unique queries, types regenerated`);
         return;

package/dist/src/commands/schema.js

@@ -14,6 +14,10 @@ export async function applyShadowMigrations(databaseUrl, migrationsDir, log = co
                 applied++;
                 log(`shadow: applied ${String(e.version).padStart(4, "0")}_${e.name}`);
             }
+            else if (e.kind === "adopted") {
+                applied++;
+                log(`shadow: adopted ${String(e.version).padStart(4, "0")}_${e.name} (${e.replaced} replaced)`);
+            }
             else if (e.kind === "tampered") {
                 throw new Error(`sqlx-js shadow: ${e.version}_${e.name} hash mismatch (applied ${e.applied.slice(0, 16)} vs current ${e.current.slice(0, 16)})`);
             }

package/dist/src/commands/watch.js

@@ -21,7 +21,7 @@ export async function prepareWatchedOnce(opts, state, log, err, deps = DEFAULT_D
     }
     if (!state.session)
         state.session = await deps.openSession(opts);
-    return await deps.prepareOnce(opts, state.session, log, err);
+    return await deps.prepareOnce(opts, state.session, log, err, 1);
 }
 export async function runWatch(opts) {
     const stamp = () => new Date().toTimeString().slice(0, 8);

package/dist/src/index.d.ts

@@ -4,12 +4,24 @@ export interface KnownQueries {
 }
 export interface KnownFileQueries {
 }
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+export type JsonObject = {
+    readonly [key: string]: JsonValue;
+};
+export type JsonArray = readonly JsonValue[];
+export type JsonInput = string | number | boolean | JsonInputObject | JsonInputArray;
+export type JsonInputValue = JsonPrimitive | JsonInputObject | JsonInputArray;
+export type JsonInputObject = {
+    readonly [key: string]: JsonInputValue | undefined;
+};
+export type JsonInputArray = readonly JsonInputValue[];
 export type { SqlxJsConfig } from "./config.js";
 export type { SslMode, ConnConfig } from "./pg/wire.js";
 export { PgError, ConnectionLostError } from "./pg/wire.js";
 export { NoRowsError, TooManyRowsError } from "./runtime.js";
-export type { TransactionOptions, MigrateOptions } from "./runtime.js";
-export type { PostgresClient, PostgresOptions } from "./postgres-runtime.js";
+export type { TransactionOptions, MigrateOptions, OnQueryEvent, OnQueryHook } from "./runtime.js";
+export type { PostgresClient, PostgresOptions, CreateClientOptions } from "./postgres-runtime.js";
 export type TypedFile = TypedFileFor<KnownFileQueries>;
 export type TypedSql = TypedSqlFor<KnownQueries, KnownFileQueries>;
 export type Typed = TypedFor<KnownQueries, KnownFileQueries, import("./runtime.js").TransactionOptions>;

package/dist/src/pg/narrow.js

@@ -78,6 +78,14 @@ function walk(node) {
             }
             return forcedInfo(acc ?? []);
         }
+        if (op === "NOT_EXPR") {
+            const arg = args[0];
+            if (arg?.NullTest?.nulltesttype === "IS_NULL") {
+                const k = keyOfColumnRef(arg.NullTest.arg);
+                return k ? forcedInfo([k]) : emptyInfo();
+            }
+            return emptyInfo();
+        }
         return emptyInfo();
     }
     if (node.A_Expr) {

package/dist/src/pg/oids.js

@@ -1,3 +1,4 @@
+const JSON_VALUE = 'import("@onreza/sqlx-js").JsonValue';
 const SCALAR = {
     16: { ts: "boolean" },
     17: { ts: "Uint8Array" },
@@ -11,7 +12,7 @@ const SCALAR = {
     27: { ts: "string" },
     28: { ts: "string" },
     29: { ts: "string" },
-    114: { ts: "unknown" },
+    114: { ts: JSON_VALUE },
     142: { ts: "string" },
     600: { ts: "string" },
     601: { ts: "string" },
@@ -44,7 +45,7 @@ const SCALAR = {
     3220: { ts: "string" },
     3614: { ts: "string" },
     3615: { ts: "string" },
-    3802: { ts: "unknown" },
+    3802: { ts: JSON_VALUE },
     3904: { ts: "string" },
     3906: { ts: "string" },
     3908: { ts: "string" },

package/dist/src/pg/param-map.d.ts

@@ -1,7 +1,8 @@
 export type ParamTarget = {
     schema?: string;
     table: string;
-    column: string;
+    column?: string;
+    columnIndex?: number;
 };
 export type ParamMap = Map<number, ParamTarget>;
 export type ParamMapResult = {

package/dist/src/pg/param-map.js

@@ -12,9 +12,9 @@ export async function buildParamMap(sql) {
     else if (stmt.UpdateStmt)
         walkUpdate(stmt.UpdateStmt, targets, dmlBound);
     else if (stmt.SelectStmt)
-        walkWhere(stmt.SelectStmt.whereClause, defaultRel(stmt.SelectStmt), targets);
+        walkSelect(stmt.SelectStmt, targets, dmlBound);
     else if (stmt.DeleteStmt)
-        walkWhere(stmt.DeleteStmt.whereClause, relOf(stmt.DeleteStmt.relation), targets);
+        walkDelete(stmt.DeleteStmt, targets, dmlBound);
     walkForceNullable(stmt, false, forceNullable);
     return { targets, forceNullable, dmlBound };
 }
@@ -22,6 +22,7 @@ function walkInsert(ins, map, dmlBound) {
     const rel = relOf(ins.relation);
     if (!rel)
         return;
+    const scope = scopeFromRelationNode(ins.relation, rel);
     const cols = (ins.cols ?? [])
         .map((c) => c?.ResTarget?.name)
         .filter((n) => typeof n === "string");
@@ -29,82 +30,162 @@ function walkInsert(ins, map, dmlBound) {
     for (const row of valuesLists) {
         const items = row?.List?.items ?? [];
         for (let i = 0; i < items.length; i++) {
-            const colName = cols[i];
-            if (!colName)
-                continue;
             const pn = paramNumber(items[i]);
             if (pn !== null) {
-                map.set(pn, { ...rel, column: colName });
-                dmlBound.add(pn);
+                bindParam(map, dmlBound, pn, insertTarget(rel, cols, i), true);
             }
         }
     }
-    if (ins.returningList) {
-        for (const rt of ins.returningList) {
-            collectFromExpr(rt?.ResTarget?.val, rel, map);
+    const select = ins.selectStmt?.SelectStmt;
+    if (select && !select.valuesLists && Array.isArray(select.targetList)) {
+        for (let i = 0; i < select.targetList.length; i++) {
+            const pn = paramNumber(select.targetList[i]?.ResTarget?.val);
+            if (pn !== null) {
+                bindParam(map, dmlBound, pn, insertTarget(rel, cols, i), true);
+            }
         }
+        walkSelect(select, map, dmlBound);
     }
-    walkWhere(ins.whereClause, rel, map);
+    if (ins.returningList)
+        walkExpr(ins.returningList, scope, map, dmlBound);
+    walkOnConflict(ins.onConflictClause, rel, scope, map, dmlBound);
+    walkExpr(ins.whereClause, scope, map, dmlBound);
+}
+function walkOnConflict(conflict, rel, scope, map, dmlBound) {
+    if (!conflict || conflict.action !== "ONCONFLICT_UPDATE")
+        return;
+    for (const rt of conflict.targetList ?? []) {
+        const colName = rt?.ResTarget?.name;
+        if (typeof colName !== "string")
+            continue;
+        const pn = paramNumber(rt.ResTarget.val);
+        if (pn !== null) {
+            bindParam(map, dmlBound, pn, { ...rel, column: colName }, true);
+        }
+    }
+    walkExpr(conflict.whereClause, scope, map, dmlBound);
 }
 function walkUpdate(upd, map, dmlBound) {
     const rel = relOf(upd.relation);
     if (!rel)
         return;
+    const scope = scopeFromRelationNode(upd.relation, rel);
+    addRangeVars(upd.fromClause ?? [], scope);
     for (const rt of upd.targetList ?? []) {
         const colName = rt?.ResTarget?.name;
         if (typeof colName !== "string")
             continue;
         const pn = paramNumber(rt.ResTarget.val);
         if (pn !== null) {
-            map.set(pn, { ...rel, column: colName });
-            dmlBound.add(pn);
+            bindParam(map, dmlBound, pn, { ...rel, column: colName }, true);
         }
     }
-    walkWhere(upd.whereClause, rel, map);
+    walkExpr(upd.whereClause, scope, map, dmlBound);
 }
-function walkWhere(node, defaultRel, map) {
-    if (!node || !defaultRel)
+function walkDelete(del, map, dmlBound) {
+    const rel = relOf(del.relation);
+    if (!rel)
         return;
+    const scope = scopeFromRelationNode(del.relation, rel);
+    addRangeVars(del.usingClause ?? [], scope);
+    walkExpr(del.whereClause, scope, map, dmlBound);
+}
+function walkSelect(select, map, dmlBound) {
+    const scope = scopeFromSelect(select);
+    walkJoinQuals(select.fromClause ?? [], scope, map, dmlBound);
+    walkExpr(select.whereClause, scope, map, dmlBound);
+}
+function walkExpr(node, scope, map, dmlBound) {
+    if (!node)
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walkExpr(item, scope, map, dmlBound);
+        return;
+    }
     if (node.BoolExpr) {
         for (const a of node.BoolExpr.args ?? [])
-            walkWhere(a, defaultRel, map);
+            walkExpr(a, scope, map, dmlBound);
         return;
     }
     if (node.A_Expr) {
-        collectFromExpr(node, defaultRel, map);
+        collectFromExpr(node, scope, map, dmlBound);
+        walkExpr(node.A_Expr.lexpr, scope, map, dmlBound);
+        walkExpr(node.A_Expr.rexpr, scope, map, dmlBound);
+        return;
+    }
+    if (node.TypeCast) {
+        walkExpr(node.TypeCast.arg, scope, map, dmlBound);
+        return;
+    }
+    if (node.NullTest) {
+        walkExpr(node.NullTest.arg, scope, map, dmlBound);
+        return;
+    }
+    if (node.CoalesceExpr) {
+        walkExpr(node.CoalesceExpr.args ?? [], scope, map, dmlBound);
+        return;
+    }
+    if (node.FuncCall) {
+        walkExpr(node.FuncCall.args ?? [], scope, map, dmlBound);
+        return;
+    }
+    if (node.CaseExpr) {
+        walkExpr(node.CaseExpr.arg, scope, map, dmlBound);
+        walkExpr(node.CaseExpr.args ?? [], scope, map, dmlBound);
+        walkExpr(node.CaseExpr.defresult, scope, map, dmlBound);
+        return;
+    }
+    if (node.CaseWhen) {
+        walkExpr(node.CaseWhen.expr, scope, map, dmlBound);
+        walkExpr(node.CaseWhen.result, scope, map, dmlBound);
+        return;
+    }
+    if (node.SubLink) {
+        const sub = node.SubLink.subselect?.SelectStmt;
+        if (sub)
+            walkSelect(sub, map, dmlBound);
+        walkExpr(node.SubLink.testexpr, scope, map, dmlBound);
         return;
     }
 }
-function collectFromExpr(node, defaultRel, map) {
-    if (!node || !defaultRel)
+function collectFromExpr(node, scope, map, dmlBound) {
+    if (!node)
         return;
     if (node.A_Expr) {
         const e = node.A_Expr;
         const opName = e.name?.[0]?.String?.sval;
         if (e.kind === "AEXPR_OP" && opName === "=") {
-            tryBind(e.lexpr, e.rexpr, defaultRel, map);
-            tryBind(e.rexpr, e.lexpr, defaultRel, map);
+            tryBind(e.lexpr, e.rexpr, scope, map, dmlBound);
+            tryBind(e.rexpr, e.lexpr, scope, map, dmlBound);
         }
         if (e.kind === "AEXPR_IN") {
-            const colName = colNameOf(e.lexpr);
-            if (colName) {
-                const list = Array.isArray(e.rexpr) ? e.rexpr : [];
+            const target = targetOfColumnRef(e.lexpr, scope);
+            if (target) {
+                const list = Array.isArray(e.rexpr) ? e.rexpr : e.rexpr?.List?.items ?? [];
                 for (const item of list) {
                     const pn = paramNumber(item);
                     if (pn !== null)
-                        map.set(pn, { ...defaultRel, column: colName });
+                        bindParam(map, dmlBound, pn, target, false);
                 }
             }
         }
     }
 }
-function tryBind(colSide, valSide, defaultRel, map) {
-    const colName = colNameOf(colSide);
+function tryBind(colSide, valSide, scope, map, dmlBound) {
+    const target = targetOfColumnRef(colSide, scope);
     const pn = paramNumber(valSide);
-    if (colName !== null && pn !== null)
-        map.set(pn, { ...defaultRel, column: colName });
+    if (target && pn !== null)
+        bindParam(map, dmlBound, pn, target, false);
 }
-function colNameOf(node) {
+function bindParam(map, dmlBound, pn, target, dml) {
+    if (!dml && dmlBound.has(pn))
+        return;
+    map.set(pn, target);
+    if (dml)
+        dmlBound.add(pn);
+}
+function stringFields(node) {
     if (!node?.ColumnRef)
         return null;
     const fields = node.ColumnRef.fields;
@@ -112,7 +193,25 @@ function colNameOf(node) {
         return null;
     if (fields.some((f) => f.A_Star !== undefined))
         return null;
-    return fields[fields.length - 1]?.String?.sval ?? null;
+    const out = fields.map((f) => f.String?.sval);
+    return out.every((s) => typeof s === "string") ? out : null;
+}
+function targetOfColumnRef(node, scope) {
+    const fields = stringFields(node);
+    if (!fields)
+        return null;
+    const column = fields[fields.length - 1];
+    if (fields.length === 1) {
+        return scope.defaultRel ? { ...scope.defaultRel, column } : null;
+    }
+    if (fields.length === 2) {
+        const qualifier = fields[0];
+        const rel = scope.aliases.get(qualifier) ?? scope.relations.find((r) => r.table === qualifier);
+        return rel ? { ...rel, column } : { table: qualifier, column };
+    }
+    const table = fields[fields.length - 2];
+    const schema = fields[fields.length - 3];
+    return { schema, table, column };
 }
 function paramNumber(node) {
     if (node?.ParamRef && typeof node.ParamRef.number === "number")
@@ -129,14 +228,56 @@ function relOf(relation) {
         return null;
     return { schema: relation.schemaname || undefined, table: name };
 }
-function defaultRel(select) {
-    const from = select?.fromClause;
-    if (!Array.isArray(from) || from.length !== 1)
-        return null;
-    const node = from[0];
-    if (node?.RangeVar)
-        return relOf(node.RangeVar);
-    return null;
+function insertTarget(rel, cols, index) {
+    const column = cols[index];
+    return column ? { ...rel, column } : { ...rel, columnIndex: index + 1 };
+}
+function scopeFromSelect(select) {
+    const scope = scopeFromRelations([], null);
+    addRangeVars(select?.fromClause ?? [], scope);
+    if (scope.relations.length === 1)
+        scope.defaultRel = scope.relations[0];
+    return scope;
+}
+function scopeFromRelations(relations, defaultRel) {
+    const scope = { aliases: new Map(), relations: [], defaultRel };
+    for (const rel of relations)
+        addRelation(scope, rel, rel.table);
+    return scope;
+}
+function scopeFromRelationNode(relation, rel) {
+    const scope = scopeFromRelations([rel], rel);
+    const alias = relation?.alias?.aliasname;
+    if (typeof alias === "string")
+        scope.aliases.set(alias, rel);
+    return scope;
+}
+function addRelation(scope, rel, alias) {
+    scope.relations.push(rel);
+    scope.aliases.set(alias, rel);
+}
+function addRangeVars(nodes, scope) {
+    for (const node of nodes) {
+        if (node?.RangeVar) {
+            const rel = relOf(node.RangeVar);
+            if (!rel)
+                continue;
+            const alias = node.RangeVar.alias?.aliasname ?? rel.table;
+            addRelation(scope, rel, alias);
+            continue;
+        }
+        if (node?.JoinExpr) {
+            addRangeVars([node.JoinExpr.larg, node.JoinExpr.rarg], scope);
+        }
+    }
+}
+function walkJoinQuals(nodes, scope, map, dmlBound) {
+    for (const node of nodes) {
+        if (!node?.JoinExpr)
+            continue;
+        walkExpr(node.JoinExpr.quals, scope, map, dmlBound);
+        walkJoinQuals([node.JoinExpr.larg, node.JoinExpr.rarg], scope, map, dmlBound);
+    }
 }
 function walkForceNullable(node, forceContext, out) {
     if (node === null || node === undefined)