@dbsp/adapter-pgsql 1.10.0 → 1.10.1

package/dist/index.d.ts

@@ -123,6 +123,7 @@ interface PlanDecision {
     readonly targetColumn?: ColumnListInput;
     readonly targetTable?: string;
     readonly function?: string;
+    readonly distinct?: boolean;
     readonly args?: readonly unknown[];
     readonly conditions?: readonly PlanDecision[];
     readonly columns?: readonly string[];
@@ -173,6 +174,13 @@ interface PlanDecision {
     readonly jsonMode?: 'json' | 'text';
     readonly selectColumn?: string;
     readonly aggregate?: string;
+    /**
+     * Apply DISTINCT to a scalar subquery's aggregate (e.g. AVG(DISTINCT price)).
+     * Deliberately NOT named `distinct` — that field means "this decision's own
+     * query-level DISTINCT modifier" and `assertNoDroppedDecisionModifiers`
+     * (subquery-emission.ts) rejects it as unsupported on subquery decisions.
+     */
+    readonly aggregateDistinct?: boolean;
     readonly subqueryOperator?: string;
     readonly filterCondition?: PlanDecision;
     readonly expressionIntent?: unknown;
@@ -1165,6 +1173,8 @@ interface Decision {
     readonly targetColumn?: ColumnListInput;
     readonly targetTable?: string;
     readonly function?: string;
+    /** Apply DISTINCT to a SELECT-list aggregate (e.g. COUNT(DISTINCT col)). */
+    readonly distinct?: boolean;
     readonly args?: readonly unknown[];
     readonly conditions?: readonly Decision[];
     readonly columns?: readonly string[];
@@ -1201,6 +1211,15 @@ interface Decision {
     readonly cycleDetection?: boolean;
     readonly selectColumn?: string;
     readonly aggregate?: string;
+    /**
+     * Apply DISTINCT to a scalar subquery's aggregate (e.g. AVG(DISTINCT price)).
+     * Deliberately NOT named `distinct` — `assertNoDroppedDecisionModifiers`
+     * (subquery-emission.ts) treats a top-level `distinct === true` on ANY
+     * subquery decision as an unsupported query-level DISTINCT modifier and
+     * throws. This field is scoped to the aggregate projection only, so it
+     * must not collide with that generic guard.
+     */
+    readonly aggregateDistinct?: boolean;
     readonly subqueryOperator?: string;
     readonly traversal?: string;
     readonly traversals?: readonly {

package/dist/index.js

@@ -1268,6 +1268,7 @@ function compileExpressionIntent(intent, ctx, state) {
         return sortBy(colNode, ob.direction === "desc" ? "DESC" : "ASC");
       }) : void 0;
       return funcCall(nameParts, argNodes, {
+        distinct: i.distinct === true,
         ...orderByNodes ? { orderBy: orderByNodes } : {}
       });
     }
@@ -1488,6 +1489,7 @@ function handleAggregateExpression(expr, rootTable, decisions, applyFilter) {
       table: rootTable
     };
     if (aggAs) decision.alias = aggAs;
+    if (aggDistinct === true) decision.distinct = true;
     decisions.push(decision);
   } else if (aggFunc === "count" && !aggField) {
     const decision = {
@@ -1496,10 +1498,11 @@ function handleAggregateExpression(expr, rootTable, decisions, applyFilter) {
       column: "*",
       table: rootTable
     };
+    if (aggDistinct === true) decision.distinct = true;
     if (aggAs) decision.alias = aggAs;
     applyFilter(decision, aggFilter, rootTable);
     decisions.push(decision);
-  } else if (aggFunc === "count" && aggDistinct && aggField) {
+  } else if (aggFunc === "count" && aggDistinct === true && aggField) {
     const decision = {
       type: "selectFunction",
       function: "countDistinct",
@@ -1517,6 +1520,7 @@ function handleAggregateExpression(expr, rootTable, decisions, applyFilter) {
     };
     if (aggField) decision.column = aggField;
     if (aggAs) decision.alias = aggAs;
+    if (aggDistinct === true) decision.distinct = true;
     applyFilter(decision, aggFilter, rootTable);
     decisions.push(decision);
   }
@@ -1797,6 +1801,9 @@ function convertSelect(select, rootTable) {
       if (agg.as) {
         aggDecision.alias = agg.as;
       }
+      if (agg.distinct === true) {
+        aggDecision.distinct = true;
+      }
       applyFilterCondition(aggDecision, agg.filter, rootTable);
       decisions.push(aggDecision);
     }
@@ -2127,6 +2134,7 @@ function convertSubquery(cond) {
   const targetTable = subquery.from;
   let selectColumn = "*";
   let aggregate;
+  let aggregateDistinct;
   const select = subquery.select;
   if (select) {
     if ("type" in select && select.type === "aggregate") {
@@ -2134,6 +2142,7 @@ function convertSubquery(cond) {
       if (agg) {
         aggregate = agg.function;
         selectColumn = agg.field ?? "*";
+        aggregateDistinct = agg.distinct === true ? true : void 0;
       }
     } else if ("fields" in select && select.fields?.length) {
       selectColumn = select.fields[0];
@@ -2167,6 +2176,7 @@ function convertSubquery(cond) {
     // Provenance: original QueryIntent for validation in buildPredicateSubquerySelect
     subqueryIntent: subquery,
     ...aggregate && { aggregate },
+    ...aggregateDistinct && { aggregateDistinct },
     ...subConditions.length > 0 && { conditions: subConditions },
     ...rawLimit != null && { limit: rawLimit },
     ...rawOrderBy && rawOrderBy.length > 0 && {
@@ -4564,21 +4574,19 @@ function buildSubqueryFromIntent(intent, paramOffset, naming = identityNaming, s
   if (select?.type === "aggregate" && select.aggregates && select.aggregates.length > 0) {
     targetList = select.aggregates.map((agg) => {
       let aggNode;
-      if (!agg.field || agg.field === "*") {
-        aggNode = {
-          FuncCall: {
-            funcname: [{ String: { sval: agg.function.toLowerCase() } }],
-            agg_star: true
-          }
-        };
+      const field = agg.field;
+      if (!field || field === "*") {
+        if (agg.distinct === true) {
+          throw new Error(
+            `${agg.function}(DISTINCT *) is not valid SQL \u2014 PostgreSQL does not support DISTINCT on a star aggregate; provide a specific column.`
+          );
+        }
+        aggNode = funcCall(agg.function.toLowerCase(), [], { star: true });
       } else {
-        const aggArg = columnRef(agg.field, innerAlias, void 0, naming);
-        aggNode = {
-          FuncCall: {
-            funcname: [{ String: { sval: agg.function.toLowerCase() } }],
-            args: [aggArg]
-          }
-        };
+        const aggArg = columnRef(field, innerAlias, void 0, naming);
+        aggNode = funcCall(agg.function.toLowerCase(), [aggArg], {
+          distinct: agg.distinct === true
+        });
       }
       return { ResTarget: { val: aggNode } };
     });
@@ -5222,6 +5230,8 @@ function assertNoDroppedDecisionModifiers(decision, use) {
   if (d.having != null) unsupported.push("HAVING");
   if (d.offset != null) unsupported.push("OFFSET");
   if (d.distinct === true) unsupported.push("DISTINCT");
+  if (d.aggregateDistinct === true && d.aggregate == null)
+    unsupported.push("aggregate DISTINCT without an aggregate function");
   if (Array.isArray(d.distinctOn) && d.distinctOn.length > 0)
     unsupported.push("DISTINCT ON");
   if (Array.isArray(d.include) && d.include.length > 0)
@@ -5271,6 +5281,11 @@ function buildPredicateSubquerySelect(use, sourceIntent, decision, ctx, state, d
   let targetVal;
   if (aggregate) {
     if (selectColumn === "*") {
+      if (decision.aggregateDistinct === true) {
+        throw new Error(
+          `${aggregate}(DISTINCT *) is not valid SQL \u2014 PostgreSQL does not support DISTINCT on a star aggregate; provide a specific column.`
+        );
+      }
       targetVal = {
         FuncCall: {
           funcname: [{ String: { sval: aggregate.toLowerCase() } }],
@@ -5287,7 +5302,8 @@ function buildPredicateSubquerySelect(use, sourceIntent, decision, ctx, state, d
       targetVal = {
         FuncCall: {
           funcname: [{ String: { sval: aggregate.toLowerCase() } }],
-          args: [aggArg]
+          args: [aggArg],
+          ...decision.aggregateDistinct === true && { agg_distinct: true }
         }
       };
     }
@@ -6503,7 +6519,13 @@ var init_handlers = __esm({
 
 // src/handlers/expression/aggregate.ts
 function buildAggregate(funcName, column, distinct, ctx, filterNode) {
-  const isCountStar = funcName === "count" && (!column || column === "*");
+  const isStarColumn = !column || column === "*";
+  if (distinct && isStarColumn) {
+    throw new Error(
+      `${funcName}(DISTINCT *) is not valid SQL \u2014 PostgreSQL does not support DISTINCT on a star aggregate; provide a specific column.`
+    );
+  }
+  const isCountStar = funcName === "count" && isStarColumn;
   if (isCountStar) {
     return funcCall(funcName, [], {
       star: true,
@@ -6535,7 +6557,7 @@ function createSimpleAggregateHandler(funcName, types) {
       return buildAggregate(
         funcName,
         decision.column,
-        false,
+        decision.distinct === true,
         ctx,
         decision.filterWhere
       );
@@ -6551,7 +6573,7 @@ var init_aggregate = __esm({
       types: ["count", "COUNT"],
       compile(decision, ctx, _state) {
         const column = decision.column;
-        const distinct = decision.operator === "countDistinct" || Boolean(decision.args?.[0]);
+        const distinct = decision.distinct === true || decision.operator === "countDistinct";
         return buildAggregate("count", column, distinct, ctx, decision.filterWhere);
       }
     };
@@ -6583,7 +6605,7 @@ var init_aggregate = __esm({
         return buildAggregate(
           funcName,
           decision.column,
-          false,
+          decision.distinct === true,
           ctx,
           decision.filterWhere
         );
@@ -9189,6 +9211,7 @@ function mapToHandlerDecision(pd, rootTable, defaultPk, deriveFk) {
     targetColumn: pd.targetColumn ?? derivedFkColumns.targetColumn,
     targetTable: pd.targetTable,
     function: pd.function,
+    distinct: pd.distinct,
     args: pd.args,
     columns: pd.columns,
     values: pd.values,
@@ -9226,6 +9249,7 @@ function mapToHandlerDecision(pd, rootTable, defaultPk, deriveFk) {
     subqueryOperator: pd.subqueryOperator,
     selectColumn: pd.selectColumn,
     aggregate: pd.aggregate,
+    aggregateDistinct: pd.aggregateDistinct,
     columnAliases: pd.columnAliases,
     escape: pd.escape,
     subqueryIntent: pd.subqueryIntent
@@ -10054,13 +10078,13 @@ var PlanCompiler = class _PlanCompiler {
     const renumbered = renumberParamRefsInAst(innerResult.ast, paramOffset);
     return { ast: renumbered, parameters: innerResult.parameters };
   }
-  compileGenericNqlFunction(functionName, args, ctx, state) {
+  compileGenericNqlFunction(functionName, args, ctx, state, distinct = false) {
     assertNqlSelectScalarFunctionAllowed(functionName);
     validateIdentifier(functionName, "function");
     const argNodes = args.map(
       (arg) => this.compileNqlFunctionArg(arg, ctx, state)
     );
-    return funcCall(functionName, argNodes);
+    return funcCall(functionName, argNodes, { distinct });
   }
   compileNqlFunctionArg(arg, ctx, state) {
     if (isNqlBindingRef(arg)) {
@@ -10139,6 +10163,7 @@ var PlanCompiler = class _PlanCompiler {
               "NQL aggregate expression requires a function name"
             );
           }
+          const isDistinct = record.distinct === true;
           const aggregateArgs = [];
           if (record.field === "*") {
             aggregateArgs.push({ kind: "star" });
@@ -10148,7 +10173,13 @@ var PlanCompiler = class _PlanCompiler {
           if (Array.isArray(record.extraArgs)) {
             aggregateArgs.push(...record.extraArgs);
           }
-          return this.compileGenericNqlFunction(fn4, aggregateArgs, ctx, state);
+          return this.compileGenericNqlFunction(
+            fn4,
+            aggregateArgs,
+            ctx,
+            state,
+            isDistinct
+          );
         }
         case "arithmetic": {
           const operator = record.operator;
@@ -10355,7 +10386,8 @@ var PlanCompiler = class _PlanCompiler {
           funcType,
           decision.args ?? [],
           ctx,
-          state
+          state,
+          decision.distinct === true
         );
         this.state.paramIndex = state.paramIndex;
         targetList.push({