@dbsp/adapter-pgsql 1.7.0 → 1.8.0

package/dist/index.js

@@ -4859,10 +4859,7 @@ var init_where = __esm({
       hasRelationHandler,
       hasNoRelationHandler
     ];
-    allWhereHandlers = [
-      ...simpleWhereHandlers,
-      ...complexWhereHandlers
-    ];
+    allWhereHandlers = [...simpleWhereHandlers, ...complexWhereHandlers];
   }
 });
 
@@ -5385,10 +5382,6 @@ __export(handlers_exports, {
   LOGICAL_OPERATORS: () => LOGICAL_OPERATORS,
   NULL_OPERATORS: () => NULL_OPERATORS,
   PATTERN_OPERATORS: () => PATTERN_OPERATORS,
-  aggregateExpressionHandlers: () => aggregateExpressionHandlers,
-  allExpressionHandlers: () => allExpressionHandlers,
-  allIncludeHandlers: () => allIncludeHandlers,
-  allWhereHandlers: () => allWhereHandlers,
   andHandler: () => andHandler,
   anyHandler: () => anyHandler,
   arithmeticHandler: () => arithmeticHandler,
@@ -5399,12 +5392,9 @@ __export(handlers_exports, {
   clearHandlers: () => clearHandlers,
   coalesceHandler: () => coalesceHandler,
   columnAliasHandler: () => columnAliasHandler,
-  columnExpressionHandlers: () => columnExpressionHandlers,
   columnHandler: () => columnHandler,
   comparisonHandler: () => comparisonHandler,
   compileExpressionIntent: () => compileExpressionIntent,
-  complexWhereHandlers: () => complexWhereHandlers,
-  conditionalExpressionHandlers: () => conditionalExpressionHandlers,
   countDistinctHandler: () => countDistinctHandler,
   countHandler: () => countHandler,
   createCompilerState: () => createCompilerState,
@@ -5441,7 +5431,6 @@ __export(handlers_exports, {
   jsonComparisonHandler: () => jsonComparisonHandler,
   jsonContainsHandler: () => jsonContainsHandler,
   jsonExistsHandler: () => jsonExistsHandler,
-  jsonExpressionHandlers: () => jsonExpressionHandlers,
   jsonExtractHandler: () => jsonExtractHandler,
   jsonPathExtractHandler: () => jsonPathExtractHandler,
   lagHandler: () => lagHandler,
@@ -5462,11 +5451,9 @@ __export(handlers_exports, {
   orHandler: () => orHandler,
   prefixedRelationColumnHandler: () => prefixedRelationColumnHandler,
   pseudoColumnHandler: () => pseudoColumnHandler,
-  pseudoExpressionHandlers: () => pseudoExpressionHandlers,
   rangeHandler: () => rangeHandler,
   rankHandler: () => rankHandler,
   rawExistsHandler: () => rawExistsHandler,
-  rawExpressionHandlers: () => rawExpressionHandlers,
   rawHandler: () => rawHandler,
   registerAllExpressionHandlers: () => registerAllExpressionHandlers,
   registerAllIncludeHandlers: () => registerAllIncludeHandlers,
@@ -5478,7 +5465,6 @@ __export(handlers_exports, {
   relationAliasHandler: () => relationAliasHandler,
   relationColumnHandler: () => relationColumnHandler,
   relationColumnsHandler: () => relationColumnsHandler,
-  relationExpressionHandlers: () => relationExpressionHandlers,
   relationFilterHandler: () => relationFilterHandler,
   relationStarHandler: () => relationStarHandler,
   rowNumberHandler: () => rowNumberHandler,
@@ -5488,8 +5474,7 @@ __export(handlers_exports, {
   singleHopPseudoHandler: () => singleHopPseudoHandler,
   sqlFunctionHandler: () => sqlFunctionHandler,
   starHandler: () => starHandler,
-  sumHandler: () => sumHandler,
-  windowExpressionHandlers: () => windowExpressionHandlers
+  sumHandler: () => sumHandler
 });
 function registerWhereHandler(handler) {
   for (const op3 of handler.operators) {
@@ -6929,6 +6914,14 @@ var init_raw = __esm({
 });
 
 // src/handlers/expression/relation.ts
+function resolveRelationAlias(relation, state, options = {}) {
+  if (options.resolveDottedLeaf && relation.includes(".")) {
+    const segments = relation.split(".");
+    const leaf = segments[segments.length - 1];
+    return state.aliases.get(relation) ?? state.aliases.get(leaf) ?? leaf;
+  }
+  return state.aliases.get(relation) ?? relation;
+}
 var relationStarHandler, relationColumnHandler, relationColumnsHandler, relationAliasHandler, prefixedRelationColumnHandler;
 var init_relation = __esm({
   "src/handlers/expression/relation.ts"() {
@@ -6961,14 +6954,9 @@ var init_relation = __esm({
         if (!column) {
           throw new Error("Relation column handler requires column name");
         }
-        let alias;
-        if (relation.includes(".")) {
-          const segments = relation.split(".");
-          const leaf = segments[segments.length - 1];
-          alias = state.aliases.get(relation) ?? state.aliases.get(leaf) ?? leaf;
-        } else {
-          alias = state.aliases.get(relation) ?? relation;
-        }
+        const alias = resolveRelationAlias(relation, state, {
+          resolveDottedLeaf: true
+        });
         if (column === "*") {
           return columnRefStar(alias, ctx.naming);
         }
@@ -6986,7 +6974,7 @@ var init_relation = __esm({
         if (!columns || columns.length === 0) {
           throw new Error("Relation columns handler requires columns array");
         }
-        const alias = state.aliases.get(relation) ?? relation;
+        const alias = resolveRelationAlias(relation, state);
         const column = columns[0];
         const colRef = columnRef(column, alias, void 0, ctx.naming);
         const outputAlias = decision.alias;
@@ -7012,7 +7000,7 @@ var init_relation = __esm({
         if (!column) {
           throw new Error("Relation alias handler requires column name");
         }
-        const tableAlias = state.aliases.get(relation) ?? relation;
+        const tableAlias = resolveRelationAlias(relation, state);
         const colRef = columnRef(column, tableAlias, void 0, ctx.naming);
         if (!outputAlias) {
           return colRef;
@@ -7283,15 +7271,8 @@ var init_expression = __esm({
       lastValueHandler,
       genericWindowHandler
     ];
-    rawExpressionHandlers = [
-      rawHandler,
-      sqlFunctionHandler,
-      literalHandler
-    ];
-    jsonExpressionHandlers = [
-      jsonExtractHandler,
-      jsonPathExtractHandler
-    ];
+    rawExpressionHandlers = [rawHandler, sqlFunctionHandler, literalHandler];
+    jsonExpressionHandlers = [jsonExtractHandler, jsonPathExtractHandler];
     pseudoExpressionHandlers = [
       pseudoColumnHandler,
       singleHopPseudoHandler,
@@ -15960,9 +15941,6 @@ function assertSafeTypeName(typeName, colIndex) {
     }
   }
 }
-function bridgeLegacyDecisions(decisions) {
-  return decisions;
-}
 function buildBatchValuesRangeFn(bv, startParamIndex, aliasOverride) {
   const params = [];
   let paramIdx = startParamIndex - 1;
@@ -16369,7 +16347,7 @@ function compileSelect(plan, options, deps) {
   } else {
     simplifiedPlan = {
       rootTable: plan.rootTable,
-      decisions: bridgeLegacyDecisions(plan.decisions),
+      decisions: plan.decisions,
       ...schemaName ? { schema: schemaName } : {}
     };
   }
@@ -18505,6 +18483,73 @@ function assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset
     `NQL runtime binding '${name}' would materialize ${valueParameterCount} VALUES parameters; limit is ${MAX_NQL_RUNTIME_BINDING_VALUES_PARAMETERS}. Current parameter offset is ${parameterOffset}, which would make ${totalParameterCount} total parameters before compiling the final statement.`
   );
 }
+function resolvePgTypeForColumnTypeInfo(bindingName, column, info) {
+  if (info.kind === "aggregate" && info.fn !== "count") {
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}': unsupported aggregate kind '${String(info.fn)}'.`
+    );
+  }
+  const rawType = info.kind === "aggregate" ? "bigint" : info.originalDbType?.trim() || mapRuntimeBindingColumnType(info.type);
+  if (rawType === void 0 || rawType.trim() === "") {
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot resolve a PostgreSQL type for projected column '${column}'.`
+    );
+  }
+  const typeName = rawType.trim();
+  try {
+    validateTypeName4(typeName);
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `NQL runtime binding '${bindingName}' cannot use PostgreSQL cast type for projected column '${column}': ${reason}`
+    );
+  }
+  return typeName;
+}
+function resolveRuntimeBindingCteColumnTypes(name, binding) {
+  const columnTypes = binding.columnTypes;
+  if (columnTypes === void 0) {
+    throw new Error(
+      `NQL runtime binding '${name}' cannot resolve typed columns without a columnTypes map.`
+    );
+  }
+  return binding.columns.map((column) => {
+    const info = columnTypes[column];
+    if (info === void 0) {
+      throw new Error(
+        `NQL runtime binding '${name}' is missing type info for projected column '${column}'.`
+      );
+    }
+    return resolvePgTypeForColumnTypeInfo(name, column, info);
+  });
+}
+function compileTypedNqlRuntimeBindingCte(name, binding, naming, parameterOffset, cteName, columnSql) {
+  const pgTypes = resolveRuntimeBindingCteColumnTypes(name, binding);
+  const anchorColumns = binding.columns.map(
+    (column, columnIndex) => `CAST(NULL AS ${pgTypes[columnIndex]}) AS ${quoteIdent2(naming.toDatabase(column), "column")}`
+  ).join(", ");
+  const sourceAnchorSql = `SELECT ${anchorColumns} WHERE false`;
+  if (binding.rows.length === 0) {
+    return {
+      cte: `${cteName} (${columnSql}) as (${sourceAnchorSql})`,
+      parameters: []
+    };
+  }
+  assertRuntimeBindingValuesParameterCount(name, binding, parameterOffset);
+  const parameters = [];
+  let nextParam = parameterOffset + 1;
+  const valuesSql = binding.rows.map((row) => {
+    const placeholders = binding.columns.map((column, columnIndex) => {
+      parameters.push(row[column]);
+      return `$${nextParam++}::${pgTypes[columnIndex]}`;
+    });
+    return `(${placeholders.join(", ")})`;
+  }).join(", ");
+  return {
+    cte: `${cteName} (${columnSql}) as (${sourceAnchorSql} UNION ALL VALUES ${valuesSql})`,
+    parameters
+  };
+}
 function compileNqlRuntimeBindingCte(name, binding, naming, parameterOffset, sourceTable, schemaName, model) {
   if (binding.columns.length === 0) {
     throw new Error(
@@ -18513,6 +18558,16 @@ function compileNqlRuntimeBindingCte(name, binding, naming, parameterOffset, sou
   }
   const cteName = quoteIdent2(emittedBindName(name, naming), "alias");
   const columnSql = binding.columns.map((column) => quoteIdent2(naming.toDatabase(column), "column")).join(", ");
+  if (binding.columnTypes !== void 0) {
+    return compileTypedNqlRuntimeBindingCte(
+      name,
+      binding,
+      naming,
+      parameterOffset,
+      cteName,
+      columnSql
+    );
+  }
   if (sourceTable === void 0) {
     throw new Error(
       `NQL runtime binding '${name}' cannot materialize a typed relation because its source table is unavailable.`