@dbsp/adapter-pgsql 1.4.0 → 1.5.0

package/dist/index.d.ts

@@ -289,6 +289,8 @@ declare class PlanCompiler {
     private rawJoins;
     /** CTE nodes from include handlers (e.g., CTE strategy) */
     private pendingCtes;
+    /** Local aliases for binding relation-column scalar subqueries. */
+    private bindingRelationColumnSubqueryIndex;
     /**
      * Maps relation-dotted include path → JOIN alias for multi-hop FK resolution.
      * Populated as join decisions are compiled so later hops can find the
@@ -347,6 +349,8 @@ declare class PlanCompiler {
     /** Build a fresh HandlerCompilerState sharing the current parameter array. */
     private createHandlerState;
     private schemaForRangeVar;
+    private isNqlBindingRoot;
+    private compileBindingRelationColumnSubquery;
     private compileExpressionSubquery;
     private compileGenericNqlFunction;
     private compileNqlFunctionArg;

package/dist/index.js

@@ -1457,6 +1457,10 @@ var init_custom = __esm({
 });
 
 // src/select-expression-handlers.ts
+import {
+  getTrustedNqlRelationFilterFields,
+  markNqlTrustedRelationFilter
+} from "@dbsp/types/internal";
 function handleColumnExpression(expr, rootTable, decisions) {
   const decision = {
     type: "select",
@@ -1585,14 +1589,18 @@ function handleCaseExpression(expr, rootTable, decisions, _applyFilter, convertC
   decisions.push(decision);
 }
 function handleRelationColumnExpression(expr, rootTable, decisions) {
+  const trusted = getTrustedNqlRelationFilterFields(expr);
+  const trustedRelation = typeof trusted?.relation === "string" ? trusted.relation : trusted?.relation.join(".");
   const decision = {
     type: "selectRelationColumn",
-    relation: expr.relation,
-    column: expr.column ?? "*",
+    relation: trustedRelation ?? expr.relation,
+    column: trusted?.selectedColumn ?? (expr.column ?? "*"),
     table: rootTable
   };
   if (expr.as) decision.alias = expr.as;
-  decisions.push(decision);
+  decisions.push(
+    trusted?.selectedColumn !== void 0 ? markNqlTrustedRelationFilter(decision, trusted) : decision
+  );
 }
 function handleArithmeticExpression(expr, rootTable, decisions) {
   const decision = {
@@ -1690,6 +1698,9 @@ var init_select_expression_handlers = __esm({
 
 // src/intent-to-decisions.ts
 import { isParamIntent } from "@dbsp/types";
+import {
+  getTrustedNqlRelationFilterFields as getTrustedNqlRelationFilterFields2
+} from "@dbsp/types/internal";
 function intentToDecisions(intent, rootTable) {
   const decisions = [];
   if (intent.select) {
@@ -2075,10 +2086,29 @@ function convertNot(cond, rootTable) {
   if (!subDecision) return null;
   return { type: "whereNot", conditions: [subDecision] };
 }
+function formatRelationName(relation) {
+  return typeof relation === "string" ? relation : relation.join(".");
+}
 function convertExistsLike(cond, operator) {
-  const targetTable = cond.relation;
+  const rawRelation = cond.relation;
+  const preResolved = getTrustedNqlRelationFilterFields2(cond);
+  const trustedRelation = preResolved?.relation;
+  const relationName = trustedRelation !== void 0 ? formatRelationName(trustedRelation) : formatRelationName(rawRelation);
+  const targetTable = preResolved?.targetTable ?? rawRelation;
   const subDecisions = cond.where ? convertWhere(cond.where, targetTable) : [];
-  const base = { type: "where", operator, targetTable };
+  const isPreResolved = preResolved !== void 0;
+  const base = {
+    type: "where",
+    operator,
+    targetTable,
+    ...preResolved !== void 0 && {
+      sourceColumn: preResolved.sourceColumn
+    },
+    ...preResolved !== void 0 && {
+      targetColumn: preResolved.targetColumn
+    },
+    ...isPreResolved && { relationName }
+  };
   return subDecisions.length > 0 ? { ...base, conditions: subDecisions } : base;
 }
 function convertSubquery(cond) {
@@ -3744,6 +3774,7 @@ var init_range = __esm({
 });
 
 // src/compile-where.ts
+import { getTrustedNqlRelationFilterFields as getTrustedNqlRelationFilterFields3 } from "@dbsp/types/internal";
 function toHandlerContext(ctx) {
   return {
     naming: ctx.naming,
@@ -3937,11 +3968,16 @@ function handleSubqueryIntent(intent, ctx, _handlerCtx) {
 }
 function handleRelationFilterIntent(intent, ctx) {
   const rf = intent;
-  const hops = Array.isArray(rf.relation) ? rf.relation : [rf.relation];
+  const preResolved = getTrustedNqlRelationFilterFields3(rf);
+  const relationPath = preResolved?.relation ?? rf.relation;
+  const hops = Array.isArray(relationPath) ? [...relationPath] : [relationPath];
   const existsKind = rf.mode === "none" || rf.mode === "every" ? "notExists" : "exists";
   const rfWhere = rf.where;
   const isVacuousEvery = rf.mode === "every" && (!rfWhere || typeof rfWhere === "object" && rfWhere.kind === "and" && Array.isArray(rfWhere.conditions) && rfWhere.conditions.length === 0);
   if (isVacuousEvery) {
+    if (preResolved) {
+      return { A_Const: { boolval: { boolval: true } } };
+    }
     if (hops.length <= 1) {
       const relation = hops[0] ?? rf.relation;
       if (!ctx.model) {
@@ -3977,6 +4013,19 @@ function handleRelationFilterIntent(intent, ctx) {
   const innermostWhere = rf.mode === "every" ? { kind: "not", condition: rf.where } : rf.where;
   if (hops.length <= 1) {
     const relation = hops[0] ?? rf.relation;
+    if (preResolved) {
+      return compileWhereIntent(
+        {
+          kind: existsKind,
+          relation,
+          targetTable: preResolved.targetTable,
+          sourceColumn: preResolved.sourceColumn,
+          targetColumn: preResolved.targetColumn,
+          where: innermostWhere
+        },
+        ctx
+      );
+    }
     const resolvedRelation = ctx.model?.getRelation(
       `${ctx.rootTable}.${relation}`
     );
@@ -7182,7 +7231,11 @@ import {
   NQL_SELECT_SCALAR_FUNCTION_ALLOWLIST,
   NQL_SELECT_WINDOW_FUNCTION_ALLOWLIST
 } from "@dbsp/types";
-import { getNqlBindingRefName, isNqlBindingRef } from "@dbsp/types/internal";
+import {
+  getNqlBindingRefName,
+  getTrustedNqlRelationFilterFields as getTrustedNqlRelationFilterFields4,
+  isNqlBindingRef
+} from "@dbsp/types/internal";
 
 // src/pgsql-deparser.ts
 function deparse(node) {
@@ -8284,6 +8337,12 @@ function assertNqlSelectWindowFunctionAllowed(functionName) {
   }
 }
 function mapToHandlerDecision(pd, rootTable, defaultPk, deriveFk) {
+  const derivedFkColumns = deriveFkColumns(
+    pd,
+    pd.sourceTable ?? rootTable,
+    defaultPk,
+    deriveFk
+  );
   return {
     type: pd.type,
     table: pd.table,
@@ -8294,7 +8353,8 @@ function mapToHandlerDecision(pd, rootTable, defaultPk, deriveFk) {
     paramIndex: pd.paramIndex,
     direction: pd.direction,
     joinType: pd.joinType,
-    ...deriveFkColumns(pd, pd.sourceTable ?? rootTable, defaultPk, deriveFk),
+    sourceColumn: pd.sourceColumn ?? derivedFkColumns.sourceColumn,
+    targetColumn: pd.targetColumn ?? derivedFkColumns.targetColumn,
     targetTable: pd.targetTable,
     function: pd.function,
     args: pd.args,
@@ -8488,6 +8548,8 @@ var PlanCompiler = class _PlanCompiler {
   rawJoins = [];
   /** CTE nodes from include handlers (e.g., CTE strategy) */
   pendingCtes = [];
+  /** Local aliases for binding relation-column scalar subqueries. */
+  bindingRelationColumnSubqueryIndex = 0;
   /**
    * Maps relation-dotted include path → JOIN alias for multi-hop FK resolution.
    * Populated as join decisions are compiled so later hops can find the
@@ -8875,6 +8937,56 @@ var PlanCompiler = class _PlanCompiler {
       this.naming
     );
   }
+  isNqlBindingRoot(plan) {
+    return hasBindingName(this.bindingNames, plan.rootTable, this.naming);
+  }
+  compileBindingRelationColumnSubquery(fields, plan) {
+    if (fields.selectedColumn === void 0) {
+      throw new Error(
+        `NQL binding relation-column proof for '${plan.rootTable}' is missing selectedColumn.`
+      );
+    }
+    if (fields.cardinality !== "one") {
+      throw new Error(
+        `NQL binding relation-column proof for '${plan.rootTable}' is not scalar (cardinality: ${fields.cardinality ?? "unknown"}).`
+      );
+    }
+    const relatedAlias = `rc_${this.bindingRelationColumnSubqueryIndex++}`;
+    const relatedTable = rangeVar(
+      fields.targetTable,
+      relatedAlias,
+      this.schemaForRangeVar(plan, fields.targetTable),
+      this.naming
+    );
+    const relatedColumn = columnRef(
+      fields.selectedColumn,
+      relatedAlias,
+      void 0,
+      this.naming
+    );
+    const relatedJoinColumn = columnRef(
+      fields.targetColumn,
+      relatedAlias,
+      void 0,
+      this.naming
+    );
+    const bindingJoinColumn = columnRef(
+      fields.sourceColumn,
+      plan.rootTable,
+      void 0,
+      this.naming
+    );
+    return {
+      SubLink: {
+        subLinkType: "EXPR_SUBLINK",
+        subselect: selectStmt({
+          targetList: [{ ResTarget: { val: relatedColumn } }],
+          from: [relatedTable],
+          where: eqExpr(relatedJoinColumn, bindingJoinColumn)
+        })
+      }
+    };
+  }
   compileExpressionSubquery(query, paramOffset) {
     const innerCompiler = new _PlanCompiler(this.childCompilerOptions());
     const innerPlan = {
@@ -9252,6 +9364,27 @@ var PlanCompiler = class _PlanCompiler {
       case "selectRelationColumn":
       case "selectPseudoColumn":
       case "selectArithmetic": {
+        if (decision.type === "selectRelationColumn") {
+          const trusted = getTrustedNqlRelationFilterFields4(decision);
+          if (trusted?.selectedColumn !== void 0) {
+            const node2 = this.compileBindingRelationColumnSubquery(
+              trusted,
+              plan
+            );
+            targetList.push({
+              ResTarget: {
+                val: node2,
+                ...decision.alias ? { name: this.naming.toDatabase(decision.alias) } : {}
+              }
+            });
+            break;
+          }
+          if (this.isNqlBindingRoot(plan)) {
+            throw new Error(
+              `NQL binding-final query '${plan.rootTable}' cannot select relation column '${decision.relation ?? "unknown"}.${decision.column ?? "unknown"}' without a trusted compiler proof.`
+            );
+          }
+        }
         ensureExpressionHandlersRegistered();
         const exprType = decision.type === "selectRelationColumn" ? "relationColumn" : decision.type === "selectPseudoColumn" ? "pseudoColumn" : "arithmetic";
         const handler = getExpressionHandler(exprType);