@rex0220/kintone-sql-tools 3.77.0 → 3.78.0

package/dist-cli/ksql.js

@@ -23045,6 +23045,14 @@ function planPlainGroupByResolution(groupBy, columns, schemas) {
   };
 }
 
+// src/core/projectedNameResolution.ts
+function resolveProjectedName(requested, available) {
+  const names = [...available];
+  if (names.includes(requested)) return requested;
+  const canonical = requested.toLowerCase();
+  return names.find((name) => name === canonical);
+}
+
 // src/core/aggregateDependencyValidation.ts
 var NON_GROUPED_DEPENDENCY_REASON = "B65_NON_GROUPED_DEPENDENCY";
 var WRAPPER_EXPR = /* @__PURE__ */ new Map([
@@ -23215,10 +23223,11 @@ function walkDependency(node, context) {
   if (ref !== null) {
     if (context.clause !== "SELECT" && ref.tableAlias === null && AGGREGATE_SYNTHETIC_REFERENCE.test(ref.field)) return;
     if (context.clause !== "SELECT" && ref.tableAlias === null) {
-      const targets = context.aliases.get(ref.field) ?? [];
-      if (targets.length === 1 && !context.resolvingAliases.has(ref.field)) {
+      const alias = resolveProjectedName(ref.field, context.aliases.keys());
+      const targets = alias === void 0 ? [] : context.aliases.get(alias) ?? [];
+      if (targets.length === 1 && alias !== void 0 && !context.resolvingAliases.has(alias)) {
         const resolvingAliases = new Set(context.resolvingAliases);
-        resolvingAliases.add(ref.field);
+        resolvingAliases.add(alias);
         walkDependency(targets[0], { ...context, resolvingAliases });
         return;
       }
@@ -23409,7 +23418,7 @@ function containsAggregate2(node) {
 function isAggregateMaterializedAlias(column) {
   if (!("alias" in column) || column.alias === null) return false;
   if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
-  if (column.type === "STRFUNC_COL" || column.type === "SCALAR_VALUE_COL" || column.type === "CASE_COL") {
+  if (column.type === "ARITH_COL" || column.type === "STRFUNC_COL" || column.type === "SCALAR_VALUE_COL" || column.type === "CASE_COL") {
     return containsAggregate2(column);
   }
   return false;
@@ -23536,7 +23545,7 @@ function resolveSelectMode(stmt) {
   if (stmt.distinct) return "FULL_SCAN";
   if (hasWindowColumns(stmt.columns)) return "FULL_SCAN";
   if (stmt.columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "SCALAR_SUBQUERY_COL" || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(c.expr)
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "SCALAR_SUBQUERY_COL" || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(c.expr)
   )) return "FULL_SCAN";
   if (whereRequiresJsEval(stmt.where)) return "FULL_SCAN";
   if (stmt.orderBy.some((o) => o.key.type !== "FIELD_NAME")) return "FULL_SCAN";
@@ -23622,7 +23631,7 @@ function convertOrderBy(item) {
 }
 function extractFields(columns) {
   const hasWildcard = columns.some(
-    (c) => c.type === "WILDCARD" || c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "CASE_COL" || c.type === "SCALAR_SUBQUERY_COL"
+    (c) => c.type === "WILDCARD" || c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "CASE_COL" || c.type === "SCALAR_SUBQUERY_COL"
   );
   if (hasWildcard) return [];
   const fields = [];
@@ -23837,7 +23846,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       }
       return;
     }
-    if ((phase === "orderBy" || phase === "having" || phase === "groupBy") && selectAliases.has(rawName)) {
+    if ((phase === "orderBy" || phase === "having" || phase === "groupBy") && resolveProjectedName(rawName, selectAliases) !== void 0) {
       return;
     }
     if ((phase === "orderBy" || phase === "having" || phase === "groupBy") && isAggregateSyntheticName(rawName)) {
@@ -24180,9 +24189,7 @@ function canInlineSingleCte(stmt) {
   if (finalQuery.type !== "SELECT") return false;
   if (finalQuery.from.cteName !== cteDef.name || finalQuery.joins.length > 0) return false;
   if (hasGroupingClause(finalQuery) || finalQuery.distinct) return false;
-  return !finalQuery.columns.some(
-    (column) => column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL"
-  );
+  return !isAggregateQueryBlock(finalQuery);
 }
 function buildInlinedQuery(stmt) {
   const cteBody = stmt.ctes[0].query;
@@ -27001,6 +27008,93 @@ function resolveFieldRef(row, field) {
   return "";
 }
 
+// src/core/expressionSemantics.ts
+var NUMBER_RETURNING_FUNCTIONS = /* @__PURE__ */ new Set([
+  "LENGTH",
+  "LENGTH_CHAR",
+  "INSTR",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "TRUNCATE",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "DATEDIFF",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT",
+  "DAYOFWEEK",
+  "QUARTER",
+  "WEEK"
+]);
+var ALL_NUMERIC_ARGUMENT_FUNCTIONS = /* @__PURE__ */ new Set([
+  "COALESCE",
+  "ISNULL",
+  "NULLIF",
+  "GREATEST",
+  "LEAST"
+]);
+function resolvedKind(value) {
+  if (value === "number" || value === "string") return value;
+  return value?.compareMode === "number" || value?.compareMode === "recordNumber" ? "number" : "string";
+}
+function fieldRefFromLegacyName(field) {
+  const dot = field.indexOf(".");
+  return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
+}
+function aggregateResultKind(ref, resolveField2) {
+  if (ref.func === "COUNT" || ref.func === "SUM" || ref.func === "AVG" || ref.func === "STDDEV_POP" || ref.func === "STDDEV_SAMP" || ref.func === "VAR_POP" || ref.func === "VAR_SAMP" || ref.func === "MEDIAN") return "number";
+  if (ref.func === "GROUP_CONCAT") return "string";
+  return ref.arg.type === "WILDCARD" ? "string" : expressionSemanticKind(ref.arg, resolveField2);
+}
+function stringFunctionSemanticKind(expr, resolveField2) {
+  if (expr.func === "CAST") {
+    const target = expr.args[1];
+    return target?.type === "STRING" && target.value === "NUMBER" ? "number" : "string";
+  }
+  if (NUMBER_RETURNING_FUNCTIONS.has(expr.func)) return "number";
+  if (ALL_NUMERIC_ARGUMENT_FUNCTIONS.has(expr.func) && expr.args.length > 0 && expr.args.every((arg) => expressionSemanticKind(arg, resolveField2) === "number")) return "number";
+  return "string";
+}
+function expressionSemanticKind(expr, resolveField2) {
+  if (expr === null || typeof expr !== "object") return "string";
+  const value = expr;
+  switch (value["type"]) {
+    case "NUMBER":
+    case "ARITH":
+    case "SCALAR_ARITH":
+    case "AGG_ARITH":
+      return "number";
+    case "STRING_FUNC":
+      return stringFunctionSemanticKind(expr, resolveField2);
+    case "AGG_REF":
+      return aggregateResultKind(expr, resolveField2);
+    case "FIELD":
+      return resolvedKind(resolveField2?.(expr));
+    case "FIELD_REF":
+      return resolvedKind(resolveField2?.(fieldRefFromLegacyName(value["field"])));
+    case "AGG_GROUP_KEY":
+      return resolvedKind(resolveField2?.({
+        type: "FIELD",
+        tableAlias: typeof value["tableAlias"] === "string" ? value["tableAlias"] : null,
+        field: value["field"]
+      }));
+    case "CASE_WHEN": {
+      const branches = value["branches"];
+      const elseResult = value["elseResult"];
+      const results = [
+        ...branches.map((branch) => branch.result),
+        ...elseResult === null || elseResult === void 0 ? [] : [elseResult]
+      ];
+      return results.length > 0 && results.every((result) => expressionSemanticKind(result, resolveField2) === "number") ? "number" : "string";
+    }
+    default:
+      return "string";
+  }
+}
+
 // src/engine/evalWhere.ts
 function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2, context = {}) {
   switch (expr.type) {
@@ -27060,33 +27154,13 @@ function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics
   const rightStr = resolveValue(right, row, resolveFieldType, resolveFieldSemantics2, context);
   return compareScalarValues(op, leftStr, rightStr, semantics);
 }
-var NUMERIC_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
-  "LENGTH",
-  "LENGTH_CHAR",
-  "INSTR",
-  "ROUND",
-  "FLOOR",
-  "CEIL",
-  "TRUNCATE",
-  "YEAR",
-  "MONTH",
-  "DAY",
-  "DATEDIFF",
-  "ABS",
-  "MOD",
-  "POWER",
-  "SQRT",
-  "DAYOFWEEK",
-  "QUARTER",
-  "WEEK"
-]);
 function semanticsForLeft(left, fieldType, resolveSemantics) {
   if (left.type === "FIELD") {
     return resolveSemantics?.(left) ?? (fieldType ? resolveFieldSemantics({ fieldType }) : syntheticSemantics("string"));
   }
   if (left.type === "ARITH_FIELD" || left.type === "AGG_FIELD") return syntheticSemantics("number");
   if (left.type === "FUNC_FIELD") {
-    return syntheticSemantics(NUMERIC_STRING_FUNCTIONS.has(left.expr.func) ? "number" : "string");
+    return syntheticSemantics(stringFunctionSemanticKind(left.expr, (ref) => resolveSemantics?.(ref)));
   }
   if (left.type === "CASE_FIELD") {
     const results = [
@@ -27096,7 +27170,7 @@ function semanticsForLeft(left, fieldType, resolveSemantics) {
     const modes = results.map((result) => {
       if (result.type === "NUMBER" || result.type === "ARITH") return syntheticSemantics("number");
       if (result.type === "STRING_FUNC") {
-        return syntheticSemantics(NUMERIC_STRING_FUNCTIONS.has(result.func) ? "number" : "string");
+        return syntheticSemantics(stringFunctionSemanticKind(result, (ref) => resolveSemantics?.(ref)));
       }
       if (result.type === "FIELD_REF") {
         const dot = result.field.indexOf(".");
@@ -31150,10 +31224,15 @@ function buildApplyParentSelectionPlan(where, metadata) {
 var REST_OFFSET_MAX = 1e4;
 var REST_LIMIT_MAX = 500;
 function fieldSemantics(item, semantics) {
-  return item.key.type === "FIELD_NAME" ? semantics.get(item.key.name) : void 0;
+  if (item.key.type !== "FIELD_NAME") return void 0;
+  const resolved = resolveProjectedName(item.key.name, semantics.keys());
+  return resolved === void 0 ? void 0 : semantics.get(resolved);
 }
 function hasSelectOutputAlias(stmt, name) {
-  return stmt.columns.some((column) => "alias" in column && column.alias === name);
+  const aliases = stmt.columns.flatMap(
+    (column) => "alias" in column && column.alias !== null ? [column.alias] : []
+  );
+  return resolveProjectedName(name, aliases) !== void 0;
 }
 function planCanonicalOrder(input) {
   const { stmt } = input;
@@ -31665,7 +31744,7 @@ function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldS
 }
 function hasAggregateColumns(columns) {
   return columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
   );
 }
 function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
@@ -31819,6 +31898,16 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
         String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind, evaluationContext)),
         [outputKey]
       );
+    } else if (col.type === "ARITH_COL" && containsAggregate2(col.expr)) {
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind, evaluationContext);
+      const outputKey = col.alias ?? arithColDefaultKey(col.expr);
+      const resolvedExpr = resolveAggInArithNode(col.expr, groupRows, resolveAggSortKind);
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalArithExpr(resolvedExpr, outRow, evaluationContext)),
+        [outputKey]
+      );
     } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind, evaluationContext);
       const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
@@ -32079,9 +32168,7 @@ function resolveAggregateArgSemantics(arg, resolver) {
   if (arg.type === "NUMBER" || arg.type === "ARITH" || arg.type === "SCALAR_ARITH") return "number";
   if (arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "VARIABLE") return "string";
   if (arg.type === "STRING_FUNC") {
-    const numeric = /* @__PURE__ */ new Set(["LENGTH", "LENGTH_CHAR", "INSTR", "ROUND", "FLOOR", "CEIL", "TRUNCATE", "YEAR", "MONTH", "DAY", "DATEDIFF", "ABS", "MOD", "POWER", "SQRT", "DAYOFWEEK", "QUARTER", "WEEK"]);
-    if (arg.func === "CAST") return arg.args[1]?.type === "STRING" && arg.args[1].value === "NUMBER" ? "number" : "string";
-    return numeric.has(arg.func) ? "number" : "string";
+    return stringFunctionSemanticKind(arg, (field) => resolver?.(field));
   }
   const results = [...arg.branches.map((branch) => branch.result), ...arg.elseResult === null ? [] : [arg.elseResult]].filter((result) => result.type !== "ARRAY").map((result) => resolveAggregateArgSemantics(result, resolver));
   if (results.length === 0 || results.some((result) => result === void 0)) return "string";
@@ -32169,7 +32256,10 @@ function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantic
   const keyMeta = orderBy.map(({ key }) => {
     if (key.type === "ARITH_KEY") return { semantics: syntheticSemantics("number") };
     if (key.type === "FUNC_KEY") {
-      return { semantics: syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(key.expr.func) ? "number" : "string") };
+      return { semantics: syntheticSemantics(stringFunctionSemanticKind(
+        key.expr,
+        (field) => fieldSemantics2?.get(field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field)
+      )) };
     }
     if (key.type === "GROUPING_KEY") return { semantics: syntheticSemantics("number") };
     const semantics = fieldSemantics2?.get(key.name);
@@ -32209,26 +32299,6 @@ function compareDecoratedRows(a, b, orderBy, keyMeta) {
 function compareSortKeys(a, b, meta) {
   return compareCanonicalValues(a.s, b.s, meta.semantics);
 }
-var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
-  "LENGTH",
-  "LENGTH_CHAR",
-  "INSTR",
-  "ROUND",
-  "FLOOR",
-  "CEIL",
-  "TRUNCATE",
-  "YEAR",
-  "MONTH",
-  "DAY",
-  "DATEDIFF",
-  "ABS",
-  "MOD",
-  "POWER",
-  "SQRT",
-  "DAYOFWEEK",
-  "QUARTER",
-  "WEEK"
-]);
 function evalOrderKey(key, row, aliasEvaluator, evaluationContext = {}) {
   const sourceRow = sourceRowForEvaluation(row);
   switch (key.type) {
@@ -32266,11 +32336,7 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
         evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "");
         break;
       case "ARITH_COL":
-        evaluators.set(alias, (row) => String(evalArithExpr(
-          column.expr,
-          sourceRowForEvaluation(row),
-          evaluationContext
-        )));
+        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? "" : String(evalArithExpr(column.expr, sourceRowForEvaluation(row), evaluationContext)));
         break;
       case "STRFUNC_COL": {
         const source = stringFuncDefaultKey(column.expr);
@@ -32319,7 +32385,10 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
         break;
     }
   }
-  return (name, row) => evaluators.get(name)?.(row);
+  return (name, row) => {
+    const resolved = resolveProjectedName(name, evaluators.keys());
+    return resolved === void 0 ? void 0 : evaluators.get(resolved)?.(row);
+  };
 }
 function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind, evaluationContext = {}) {
   const windows = columns.map((column, columnIndex) => ({ column, columnIndex })).filter((item) => item.column.type === "WINDOW_COL");
@@ -32503,7 +32572,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_COL":
-      return String(evalArithExpr(column.expr, sourceRow, context.evaluationContext));
+      return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? arithColDefaultKey(column.expr)) ?? "" : String(evalArithExpr(column.expr, sourceRow, context.evaluationContext));
     case "CASE_COL":
       return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
         column.expr,
@@ -32886,6 +32955,17 @@ function resolveAggInScalarValue(expr, rows, resolveAggSortKind) {
   }
   return expr;
 }
+function resolveAggInArithNode(expr, rows, resolveAggSortKind) {
+  if (expr.type === "STRING_FUNC") return resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind);
+  if (expr.type === "ARITH") {
+    return {
+      ...expr,
+      left: resolveAggInArithNode(expr.left, rows, resolveAggSortKind),
+      right: resolveAggInArithNode(expr.right, rows, resolveAggSortKind)
+    };
+  }
+  return expr;
+}
 function resolveAggInCaseResult(result, rows, resolveAggSortKind) {
   if (result.type === "AGG_REF") {
     const value = evalAggregate(
@@ -32965,7 +33045,10 @@ function deriveOutputOrderSemantics(columns, resolveAggSortKind) {
     } else if (column.type === "LITERAL_COL" || column.type === "CASE_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "SCALAR_VALUE_COL") {
       result.set(column.alias, syntheticSemantics("string"));
     } else if (column.type === "STRFUNC_COL") {
-      result.set(column.alias, syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(column.expr.func) ? "number" : "string"));
+      result.set(column.alias, syntheticSemantics(stringFunctionSemanticKind(
+        column.expr,
+        (field) => resolveAggSortKind?.(field)
+      )));
     }
   }
   return result;
@@ -35115,6 +35198,13 @@ var SearchAbortedError = class extends Error {
     this.name = "SearchAbortedError";
   }
 };
+function resolveMaterializedColumn(table, requested) {
+  return table?.columns.includes(requested) ? requested : void 0;
+}
+function resolveMaterializedColumnMeta(table, requested) {
+  const resolved = resolveMaterializedColumn(table, requested);
+  return resolved === void 0 ? void 0 : table?.columnMeta?.get(resolved);
+}
 var materializedMetaBySelectResult = /* @__PURE__ */ new WeakMap();
 function getSelectColumnMeta(result) {
   return materializedMetaBySelectResult.get(result);
@@ -36558,7 +36648,7 @@ async function evaluateScalarSubquery(sourceQuery, client, options, cacheContext
   return result.rows[0]?.[result.columns[0]] ?? "";
 }
 function withScalarProbeLimit(query) {
-  const hasAgg = normalizeGroupingSpec(query).type !== "NONE" || query.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL");
+  const hasAgg = isAggregateQueryBlock(query);
   if (hasAgg || query.distinct || query.limit !== null) return { query, probed: false };
   return { query: { ...query, limit: 2 }, probed: true };
 }
@@ -36656,18 +36746,18 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
       const table = tables.find((candidate) => effectiveTableAlias(candidate) === field.tableAlias);
       if (!table) return void 0;
       if (table.cteName !== null) {
-        return materializedTables?.get(table.cteName)?.columnMeta?.get(field.field)?.semantics ?? syntheticSemantics("string");
+        return resolveMaterializedColumnMeta(materializedTables?.get(table.cteName), field.field)?.semantics ?? syntheticSemantics("string");
       }
       return fromPhysical(table, field.field, true);
     }
     if (stmt.joins.length === 0) {
       if (stmt.from.cteName !== null) {
-        return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(field.field)?.semantics ?? syntheticSemantics("string");
+        return resolveMaterializedColumnMeta(materializedTables?.get(stmt.from.cteName), field.field)?.semantics ?? syntheticSemantics("string");
       }
       return fromPhysical(stmt.from, field.field, true);
     }
     const matches = tables.flatMap((table) => {
-      const semantics = table.cteName !== null ? materializedTables?.get(table.cteName)?.columnMeta?.get(field.field)?.semantics : fromPhysical(table, field.field, true);
+      const semantics = table.cteName !== null ? resolveMaterializedColumnMeta(materializedTables?.get(table.cteName), field.field)?.semantics : fromPhysical(table, field.field, true);
       return semantics ? [semantics] : [];
     });
     if (matches.length === 1) return matches[0];
@@ -36795,13 +36885,20 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
         semantics = column.func === "GROUP_CONCAT" ? syntheticSemantics("string") : syntheticSemantics("number");
       }
     } else if (column.type === "STRFUNC_COL") {
-      semantics = stringFunctionColumnMeta(column.expr).semantics;
+      semantics = stringFunctionColumnMeta(column.expr, (ref) => {
+        const resolved = rowResolver(ref);
+        return resolved ? { compareMode: resolved.compareMode } : void 0;
+      }).semantics;
     } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "CASE_COL" || column.type === "SCALAR_VALUE_COL") {
       semantics = syntheticSemantics("string");
     }
     if (semantics) aliases.set(column.alias, semantics);
   }
-  return (field) => field.tableAlias === null && aliases.has(field.field) ? aliases.get(field.field) : rowResolver(field);
+  return (field) => {
+    if (field.tableAlias !== null) return rowResolver(field);
+    const alias = resolveProjectedName(field.field, aliases.keys());
+    return alias === void 0 ? rowResolver(field) : aliases.get(alias);
+  };
 }
 function formatWhereCapabilityFailure(result) {
   const reason = result.reasons.find(
@@ -36848,6 +36945,7 @@ async function assertDmlWhereCapability(stmt, client, cacheContext) {
   }
 }
 async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false, forLibraryCapture = false, windowWarningContext = "DIRECT") {
+  bindSelectAliasesInHaving(stmt);
   let result;
   const subqueryWarnings = /* @__PURE__ */ new Set();
   await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
@@ -37129,7 +37227,7 @@ async function buildGroupingFieldResolver(stmt, client, cacheContext, materializ
   const materializedHas = (table, field) => {
     if (table.cteName === null) return false;
     const materialized = materializedTables?.get(table.cteName);
-    return materialized ? materialized.columns.includes(field) : true;
+    return materialized ? resolveMaterializedColumn(materialized, field) !== void 0 : true;
   };
   const resolved = (table, tableIndex, field, code) => {
     const sameNamePhysical = tables.filter(
@@ -37532,6 +37630,145 @@ function b86FieldExists(schema, field) {
   if (schema.table.cteName !== null) return schema.validCodes.has(field);
   return b86PhysicalFieldExists(schema, field);
 }
+async function buildPhysicalFieldProbe(stmt, client, cacheContext) {
+  const physical = [stmt.from, ...stmt.joins.map((join3) => join3.table)].filter((table) => table.cteName === null);
+  const codesByApp = /* @__PURE__ */ new Map();
+  await Promise.all([...new Set(physical.map((table) => table.appId))].map(async (appId) => {
+    const defs = await getFieldsCached(appId, client, cacheContext);
+    codesByApp.set(appId, new Set(defs.map((def) => def.code)));
+  }));
+  return (table, field) => {
+    if (table.cteName !== null) return false;
+    if (table.subtableCode || isSystemLikeFieldCode(field)) return true;
+    const codes = codesByApp.get(table.appId);
+    if (!codes || codes.size === 0) return true;
+    return codes.has(fieldCodeForTypeLookup(table, field));
+  };
+}
+async function bindProjectedNamesForSelectWithSchemas(stmt, materializedTables, client, cacheContext) {
+  let consulted = false;
+  bindProjectedNamesForSelect(stmt, materializedTables, () => {
+    consulted = true;
+    return true;
+  });
+  if (!consulted) return;
+  bindProjectedNamesForSelect(
+    stmt,
+    materializedTables,
+    await buildPhysicalFieldProbe(stmt, client, cacheContext)
+  );
+}
+function bindProjectedNamesForSelect(stmt, materializedTables, physicalMayHave) {
+  const tables = [stmt.from, ...stmt.joins.map((join3) => join3.table)];
+  const tableByAlias = /* @__PURE__ */ new Map();
+  for (const table of tables) {
+    for (const alias of b86SourceAliases(table)) tableByAlias.set(alias, table);
+  }
+  const aliases = stmt.columns.flatMap(
+    (column) => "alias" in column && column.alias !== null ? [column.alias] : []
+  );
+  const materializedColumns = (table) => table.cteName === null || table.cteName === NO_FROM_CTE_NAME ? [] : materializedTables.get(table.cteName)?.columns ?? [];
+  const resolveFromTable = (table, requested) => table ? resolveProjectedName(requested, materializedColumns(table)) : void 0;
+  const resolveUnqualified = (requested) => {
+    if (tables.some((table) => materializedColumns(table).includes(requested))) return requested;
+    const matches = tables.flatMap((table) => {
+      const resolved = resolveFromTable(table, requested);
+      return resolved === void 0 ? [] : [resolved];
+    });
+    const unique2 = [...new Set(matches)];
+    if (unique2.length !== 1) return void 0;
+    if (tables.some((table) => physicalMayHave(table, requested))) return requested;
+    return unique2[0];
+  };
+  const resolveReference = (requested, tableAlias, allowSelectAlias) => {
+    if (allowSelectAlias && tableAlias === null) {
+      const alias = resolveProjectedName(requested, aliases);
+      if (alias !== void 0) return alias;
+    }
+    return tableAlias === null ? resolveUnqualified(requested) ?? requested : resolveFromTable(tableByAlias.get(tableAlias), requested) ?? requested;
+  };
+  const resolveText = (requested, allowSelectAlias) => {
+    const dot = requested.indexOf(".");
+    if (dot <= 0) return resolveReference(requested, null, allowSelectAlias);
+    const qualifier = requested.slice(0, dot);
+    const field = requested.slice(dot + 1);
+    const resolved = resolveReference(field, qualifier, false);
+    return resolved === field ? requested : `${qualifier}.${resolved}`;
+  };
+  for (const join3 of stmt.joins) {
+    if (join3.type === "CROSS") continue;
+    join3.on.left.field = resolveReference(join3.on.left.field, join3.on.left.tableAlias, false);
+    join3.on.right.field = resolveReference(join3.on.right.field, join3.on.right.tableAlias, false);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node, allowSelectAlias = false) => {
+    if (node === null || typeof node !== "object") return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const child of node) visit(child, allowSelectAlias);
+      return;
+    }
+    const value = node;
+    if (node !== stmt && (value["type"] === "SELECT" || value["type"] === "UNION")) return;
+    if (value["type"] === "FIELD" && typeof value["field"] === "string") {
+      const tableAlias = typeof value["tableAlias"] === "string" ? value["tableAlias"] : null;
+      value["field"] = tableAlias === null ? resolveText(value["field"], allowSelectAlias) : resolveReference(value["field"], tableAlias, allowSelectAlias);
+    } else if (value["type"] === "FIELD_REF" && typeof value["field"] === "string") {
+      value["field"] = resolveText(value["field"], allowSelectAlias);
+    } else if (value["type"] === "AGG_GROUP_KEY" && typeof value["field"] === "string") {
+      const tableAlias = typeof value["tableAlias"] === "string" ? value["tableAlias"] : null;
+      value["field"] = resolveReference(value["field"], tableAlias, allowSelectAlias);
+    }
+    for (const child of Object.values(value)) visit(child, allowSelectAlias);
+  };
+  for (const column of stmt.columns) visit(column);
+  visit(stmt.where);
+  visit(stmt.having, true);
+  visit(stmt.grouping);
+  const grouping = normalizeGroupingSpec(stmt);
+  if (grouping.type === "PLAIN") {
+    for (const item of grouping.allItems) {
+      if (item.type === "FIELD_NAME") item.name = resolveText(item.name, true);
+      else visit(item);
+    }
+  }
+  for (const item of stmt.orderBy) {
+    if (item.key.type === "FIELD_NAME") item.key.name = resolveText(item.key.name, true);
+    else visit(item.key);
+  }
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL") continue;
+    for (const ref of column.partitionBy) {
+      ref.field = resolveReference(ref.field, ref.tableAlias, false);
+    }
+    for (const item of column.orderBy) {
+      if (item.key.type === "FIELD_NAME") item.key.name = resolveText(item.key.name, false);
+      else visit(item.key);
+    }
+  }
+}
+function bindSelectAliasesInHaving(stmt) {
+  const aliases = stmt.columns.flatMap(
+    (column) => "alias" in column && column.alias !== null ? [column.alias] : []
+  );
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    const value = node;
+    if (value["type"] === "AGG_REF" || value["type"] === "AGG_ARITH") return;
+    if (value["type"] === "FIELD" && (value["tableAlias"] === null || value["tableAlias"] === void 0) && typeof value["field"] === "string") {
+      const resolved = resolveProjectedName(value["field"], aliases);
+      if (resolved !== void 0) value["field"] = resolved;
+    }
+    if (value["type"] === "SELECT" || value["type"] === "UNION") return;
+    Object.values(value).forEach(visit);
+  };
+  visit(stmt.having);
+}
 function collectB86Subqueries(stmt) {
   const queries = [];
   const visitWhere = (where) => {
@@ -37666,6 +37903,7 @@ async function preflightB86QueryWithCte(query, client, cteCache, cacheContext, s
     await preflightB86QueryWithCte(query.right, client, cteCache, cacheContext, seen);
     return;
   }
+  await bindProjectedNamesForSelectWithSchemas(query, cteCache, client, cacheContext);
   await validateB86SelectFieldCodes(query, client, cteCache, cacheContext);
   for (const subquery of collectB86Subqueries(query)) {
     await preflightB86QueryWithCte(subquery, client, cteCache, cacheContext, seen);
@@ -37966,7 +38204,7 @@ function collectScalarAggregateRefs(expr, out) {
     }
   }
 }
-function collectCaseAggregateRefs(expr, out) {
+function collectNestedAggregateRefs(expr, out) {
   const visit = (node) => {
     if (node === null || typeof node !== "object") return;
     if (Array.isArray(node)) {
@@ -37991,12 +38229,14 @@ function collectSelectAggregateSortRefs(columns) {
       collectAggregateRef(column.func, column.arg, refs);
     } else if (column.type === "ARITH_AGG_COL") {
       collectAggregateOperandRefs(column.expr, refs);
+    } else if (column.type === "ARITH_COL") {
+      collectNestedAggregateRefs(column.expr, refs);
     } else if (column.type === "STRFUNC_COL") {
       collectStringFuncAggregateRefs(column.expr, refs);
     } else if (column.type === "SCALAR_VALUE_COL") {
       collectScalarAggregateRefs(column.expr, refs);
     } else if (column.type === "CASE_COL") {
-      collectCaseAggregateRefs(column.expr, refs);
+      collectNestedAggregateRefs(column.expr, refs);
     }
   }
   return refs;
@@ -38066,20 +38306,20 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
         const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
         if (!table) return void 0;
         if (table.cteName !== null) {
-          return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string");
+          return resolveMaterializedColumnMeta(materializedTables?.get(table.cteName), ref.field)?.semantics ?? syntheticSemantics("string");
         }
         info = fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
       }
     } else if (stmt.joins.length === 0) {
       if (stmt.from.cteName !== null) {
-        return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string");
+        return resolveMaterializedColumnMeta(materializedTables?.get(stmt.from.cteName), ref.field)?.semantics ?? syntheticSemantics("string");
       }
       info = fieldInfosByApp.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
     } else {
       const matches = tables.flatMap((table) => {
         if (table.cteName !== null) {
           const materialized = materializedTables?.get(table.cteName);
-          return materialized?.columns.includes(ref.field) ? [materialized.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string")] : [];
+          return resolveMaterializedColumn(materialized, ref.field) !== void 0 ? [resolveMaterializedColumnMeta(materialized, ref.field)?.semantics ?? syntheticSemantics("string")] : [];
         }
         const candidate = fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
         return candidate ? [semanticsForInfo(candidate, table.appId)] : [];
@@ -38144,32 +38384,13 @@ function systemColumnMeta(field) {
   if (field === "$revision") return syntheticColumnMeta("number");
   return void 0;
 }
-var NUMBER_RETURNING_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
-  "LENGTH",
-  "LENGTH_CHAR",
-  "INSTR",
-  "ROUND",
-  "FLOOR",
-  "CEIL",
-  "TRUNCATE",
-  "YEAR",
-  "MONTH",
-  "DAY",
-  "DATEDIFF",
-  "ABS",
-  "MOD",
-  "POWER",
-  "SQRT",
-  "DAYOFWEEK",
-  "QUARTER",
-  "WEEK"
-]);
-function stringFunctionColumnMeta(expr) {
-  if (expr.func === "CAST") {
-    const target = expr.args[1];
-    return target?.type === "STRING" && target.value === "NUMBER" ? syntheticColumnMeta("number") : syntheticColumnMeta("string");
-  }
-  return NUMBER_RETURNING_STRING_FUNCTIONS.has(expr.func) ? syntheticColumnMeta("number") : syntheticColumnMeta("string");
+function stringFunctionColumnMeta(expr, resolveField2) {
+  return syntheticColumnMeta(stringFunctionSemanticKind(expr, (ref) => {
+    const resolved = resolveField2?.(ref);
+    if (!resolved) return void 0;
+    if ("compareMode" in resolved) return resolved;
+    return resolved.semantics;
+  }));
 }
 function caseResultColumnMeta(result, resolveField2) {
   if (result.type === "STRING") return syntheticColumnMeta("string");
@@ -38182,7 +38403,7 @@ function caseResultColumnMeta(result, resolveField2) {
   }
   if (result.type === "AGG_ARITH") return syntheticColumnMeta("number");
   if (result.type === "NUMBER" || result.type === "ARITH" || result.type === "SCALAR_ARITH") return syntheticColumnMeta("number");
-  if (result.type === "STRING_FUNC") return stringFunctionColumnMeta(result);
+  if (result.type === "STRING_FUNC") return stringFunctionColumnMeta(result, resolveField2);
   if (result.type === "FIELD_REF") return resolveField2(aggregateFieldRef(result.field)) ?? unknownStringColumnMeta();
   if (result.type === "FIELD") return resolveField2(result) ?? unknownStringColumnMeta();
   return unknownStringColumnMeta();
@@ -38213,7 +38434,7 @@ function inferAggregateArgMeta(arg, resolveField2) {
   if (arg.type === "FIELD") return resolveField2(arg) ?? unknownStringColumnMeta();
   if (arg.type === "NUMBER" || arg.type === "ARITH" || arg.type === "SCALAR_ARITH") return syntheticColumnMeta("number");
   if (arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "VARIABLE") return syntheticColumnMeta("string");
-  if (arg.type === "STRING_FUNC") return stringFunctionColumnMeta(arg);
+  if (arg.type === "STRING_FUNC") return stringFunctionColumnMeta(arg, resolveField2);
   const results = arg.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
   if (arg.elseResult) results.push(caseResultColumnMeta(arg.elseResult, resolveField2));
   return mergeExpressionColumnMeta(results);
@@ -38257,20 +38478,20 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       }
       const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
       if (!table) return void 0;
-      if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
+      if (table.cteName !== null) return resolveMaterializedColumnMeta(materializedTables?.get(table.cteName), ref.field);
       const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
       return info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
     }
     if (stmt.joins.length === 0) {
-      if (stmt.from.cteName !== null) return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field);
+      if (stmt.from.cteName !== null) return resolveMaterializedColumnMeta(materializedTables?.get(stmt.from.cteName), ref.field);
       const info = physicalInfos.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
       return info ? materializedMetaFromFieldInfo(info, stmt.from.appId) : systemColumnMeta(ref.field);
     }
     const matches = tables.flatMap((table) => {
       if (table.cteName !== null) {
         const materialized = materializedTables?.get(table.cteName);
-        if (!materialized?.columns.includes(ref.field)) return [];
-        return [materialized.columnMeta?.get(ref.field)];
+        if (resolveMaterializedColumn(materialized, ref.field) === void 0) return [];
+        return [resolveMaterializedColumnMeta(materialized, ref.field)];
       }
       const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
       const meta = info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
@@ -38334,12 +38555,12 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       meta = syntheticColumnMeta("string");
     } else if (column.type === "SCALAR_VALUE_COL") {
       const expr = column.expr;
-      if (expr.type === "STRING_FUNC") meta = stringFunctionColumnMeta(expr);
+      if (expr.type === "STRING_FUNC") meta = stringFunctionColumnMeta(expr, resolveField2);
       else if (expr.type === "NUMBER" || expr.type === "SCALAR_ARITH") meta = syntheticColumnMeta("number");
       else if (expr.type === "FIELD") meta = resolveField2(expr);
       else meta = syntheticColumnMeta("string");
     } else if (column.type === "STRFUNC_COL") {
-      meta = stringFunctionColumnMeta(column.expr);
+      meta = stringFunctionColumnMeta(column.expr, resolveField2);
     } else if (column.type === "WINDOW_COL") {
       meta = inferWindowColumnMeta(column, resolveField2);
     } else if (column.type === "CASE_COL") {
@@ -38766,7 +38987,7 @@ async function buildRecursiveFieldResolver(stmt, client, cacheContext, materiali
     physical.set(table.appId, new Map(infos.map((info) => [info.code, info])));
   }));
   const resolveInTable = (table, field) => {
-    if (table.cteName !== null) return materializedTables.get(table.cteName)?.columnMeta?.get(field);
+    if (table.cteName !== null) return resolveMaterializedColumnMeta(materializedTables.get(table.cteName), field);
     const info = physical.get(table.appId)?.get(fieldCodeForTypeLookup(table, field));
     return info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(field);
   };
@@ -38974,7 +39195,7 @@ function rewriteRecursivePhysicalSources(stmt, sources) {
   };
 }
 function tableMetaForJoinKey(table, field, cache) {
-  return table.cteName === null ? void 0 : cache.get(table.cteName)?.columnMeta?.get(field);
+  return table.cteName === null ? void 0 : resolveMaterializedColumnMeta(cache.get(table.cteName), field);
 }
 function recursiveJoinKey(value, semantics) {
   if (semantics.compareMode !== "number" && semantics.compareMode !== "recordNumber") return value;
@@ -39833,7 +40054,7 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join3, tables, client, maxR
   const targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join3.table.appId) : systemColumnMeta(joinField);
   let sourceMeta;
   if (sourceTable?.cteName !== null && sourceTable?.cteName !== void 0) {
-    sourceMeta = materializedTables?.get(sourceTable.cteName)?.columnMeta?.get(sourceField);
+    sourceMeta = resolveMaterializedColumnMeta(materializedTables?.get(sourceTable.cteName), sourceField);
   } else if (sourceTable) {
     const sourceInfo = (await getFieldsCached(sourceTable.appId, client, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(sourceTable, sourceField));
     sourceMeta = sourceInfo ? materializedMetaFromFieldInfo(sourceInfo, sourceTable.appId) : systemColumnMeta(sourceField);
@@ -40030,19 +40251,19 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
       }
       const table = tables.find((candidate) => effectiveTableAlias(candidate) === ref.tableAlias);
       if (!table) return void 0;
-      if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
+      if (table.cteName !== null) return resolveMaterializedColumnMeta(materializedTables?.get(table.cteName), ref.field);
       const info = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
       return info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
     }
     if (stmt.joins.length === 0) {
-      if (stmt.from.cteName !== null) return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field);
+      if (stmt.from.cteName !== null) return resolveMaterializedColumnMeta(materializedTables?.get(stmt.from.cteName), ref.field);
       const info = infosByApp.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
       return info ? materializedMetaFromFieldInfo(info, stmt.from.appId) : systemColumnMeta(ref.field);
     }
     const matches = tables.flatMap((table) => {
       if (table.cteName !== null) {
         const materialized = materializedTables?.get(table.cteName);
-        const meta2 = materialized?.columns.includes(ref.field) ? materialized.columnMeta?.get(ref.field) : void 0;
+        const meta2 = resolveMaterializedColumnMeta(materialized, ref.field);
         return meta2 ? [meta2] : [];
       }
       const info = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
@@ -40064,7 +40285,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     } else if (column.type === "GROUPING_COL") {
       meta = syntheticColumnMeta("number");
     } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") meta = syntheticColumnMeta("string");
-    else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr);
+    else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr, resolveField2);
     else if (column.type === "SCALAR_SUBQUERY_COL") meta = unknownStringColumnMeta();
     else if (column.type === "CASE_COL") {
       const candidates = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
@@ -40081,7 +40302,8 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
   }
   const result = /* @__PURE__ */ new Map();
   for (const name of names) {
-    const base = aliasSemantics.get(name) ?? resolveField2(aggregateFieldRef(name))?.semantics;
+    const resolvedAlias = resolveProjectedName(name, aliasSemantics.keys());
+    const base = (resolvedAlias === void 0 ? void 0 : aliasSemantics.get(resolvedAlias)) ?? resolveField2(aggregateFieldRef(name))?.semantics;
     if (!base) {
       const ref = aggregateFieldRef(name);
       if (ref.tableAlias === null && ambiguousFields.has(ref.field)) {
@@ -41120,6 +41342,29 @@ var UPDATE_FROM_UNSUPPORTED_SOURCE_TYPES = /* @__PURE__ */ new Set([
   "FILE"
 ]);
 async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables, snapshotFields) {
+  if (from.cteName !== null) {
+    const materialized = tempTables?.get(from.cteName);
+    const resolveSource = (requested) => resolveProjectedName(requested, materialized?.columns ?? []) ?? requested;
+    from.joinKeyField = resolveSource(from.joinKeyField);
+    for (const assignment of stmt.assignments) {
+      if (assignment.value.type === "SOURCE_FIELD" && assignment.value.alias === from.alias) {
+        assignment.value.field = resolveSource(assignment.value.field);
+      }
+    }
+    const visitSourceChecks = (node) => {
+      if (node === null || typeof node !== "object") return;
+      if (Array.isArray(node)) {
+        node.forEach(visitSourceChecks);
+        return;
+      }
+      const value = node;
+      if (value["type"] === "FIELD" && value["tableAlias"] === from.alias && typeof value["field"] === "string") {
+        value["field"] = resolveSource(value["field"]);
+      }
+      Object.values(value).forEach(visitSourceChecks);
+    };
+    visitSourceChecks(stmt.checkGroups);
+  }
   const joinKind = await resolveUpdateFromTargetJoinKind(stmt, from, client, cacheContext);
   const checkScope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
   const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : "").concat(checkScope.sourceFields))];
@@ -41211,7 +41456,7 @@ async function loadUpdateFromSourceRows(from, requiredSourceFields, sourceValueF
     const table = tempTables?.get(from.cteName);
     if (!table) throw new Error(`ArgumentError: temp table ${from.cteName} is not available.`);
     for (const field of requiredSourceFields) {
-      if (!table.columns.includes(field)) {
+      if (resolveMaterializedColumn(table, field) === void 0) {
         throw new Error(`ArgumentError: UPDATE ... FROM source column ${field} does not exist.`);
       }
     }
@@ -42974,7 +43219,10 @@ function compareByOrder(a, b, orderBy, resolveSemantics, evaluationContext = {})
   for (const item of orderBy) {
     const av = evalOrderKeyForRow(item.key, a, evaluationContext);
     const bv = evalOrderKeyForRow(item.key, b, evaluationContext);
-    const semantics = item.key.type === "FIELD_NAME" ? resolveSemantics(aggregateFieldRef(item.key.name)) : item.key.type === "ARITH_KEY" ? syntheticSemantics("number") : item.key.type === "FUNC_KEY" ? stringFunctionColumnMeta(item.key.expr).semantics ?? syntheticSemantics("string") : syntheticSemantics("number");
+    const semantics = item.key.type === "FIELD_NAME" ? resolveSemantics(aggregateFieldRef(item.key.name)) : item.key.type === "ARITH_KEY" ? syntheticSemantics("number") : item.key.type === "FUNC_KEY" ? stringFunctionColumnMeta(item.key.expr, (ref) => {
+      const semantics2 = resolveSemantics(ref);
+      return semantics2 ? { compareMode: semantics2.compareMode } : void 0;
+    }).semantics ?? syntheticSemantics("string") : syntheticSemantics("number");
     const cmp = compareCanonicalValues(av, bv, semantics ?? syntheticSemantics("string"));
     if (cmp !== 0) return item.direction === "ASC" ? cmp : -cmp;
   }
@@ -43422,6 +43670,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     }
     if (typed["type"] === "SELECT") {
       const select = node;
+      await bindProjectedNamesForSelectWithSchemas(select, explainRelations, tracedClient, cacheContext);
       analyzeStaticSelectRows(select);
       for (const column of select.columns) {
         if (column.type === "SCALAR_SUBQUERY_COL") await preflightExplainRelations(column.query);
@@ -43514,7 +43763,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         const sourceTable = [select.from, ...select.joins.map((candidate) => candidate.table)].find((table) => effectiveTableAlias(table) === sourceAlias);
         let targetMeta;
         if (join3.table.cteName !== null) {
-          targetMeta = explainRelations.get(join3.table.cteName)?.columnMeta?.get(joinField);
+          targetMeta = resolveMaterializedColumnMeta(explainRelations.get(join3.table.cteName), joinField);
         } else {
           const targetInfo = (await getFieldsCached(join3.table.appId, tracedClient, cacheContext)).find((info) => info.code === fieldCodeForTypeLookup(join3.table, joinField));
           targetMeta = targetInfo ? materializedMetaFromFieldInfo(targetInfo, join3.table.appId) : systemColumnMeta(joinField);
@@ -43525,7 +43774,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         let hasEmptyValue;
         if (sourceTable?.cteName !== null && sourceTable?.cteName !== void 0) {
           const relation = explainRelations.get(sourceTable.cteName);
-          sourceMeta = relation?.columnMeta?.get(sourceField);
+          sourceMeta = resolveMaterializedColumnMeta(relation, sourceField);
           if (staticExplainRelations.has(sourceTable.cteName) && relation) {
             sourceRowCount = relation.rows.length;
             values = relation.rows.map((row) => toScalarText(row[sourceField]));
@@ -45330,7 +45579,7 @@ function collectFullScanReasons(stmt) {
     );
   if (stmt.distinct)
     r.push("DISTINCT \u3042\u308A");
-  if (stmt.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL"))
+  if (hasAggregateColumns(stmt.columns))
     r.push("\u96C6\u8A08\u95A2\u6570\uFF08COUNT / SUM \u7B49\uFF09\u3042\u308A");
   if (stmt.columns.some((c) => c.type === "WINDOW_COL"))
     r.push("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u3042\u308A");