@rex0220/kintone-sql-tools 3.77.0 → 3.79.0

package/dist-cli/ksql.js

@@ -16622,7 +16622,8 @@ __export(index_exports, {
   runWithArgv: () => runWithArgv,
   shouldExitOnEmpty: () => shouldExitOnEmpty,
   toCliImportError: () => toCliImportError,
-  writeBatchOutput: () => writeBatchOutput
+  writeBatchOutput: () => writeBatchOutput,
+  writeSingleSelectWarnings: () => writeSingleSelectWarnings
 });
 module.exports = __toCommonJS(index_exports);
 var import_fs3 = require("fs");
@@ -23045,6 +23046,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 +23224,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 +23419,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 +23546,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 +23632,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 +23847,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 +24190,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 +27009,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 +27155,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 +27171,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 +31225,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 +31745,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 +31899,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 +32169,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 +32257,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 +32300,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 +32337,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 +32386,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 +32573,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 +32956,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 +33046,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,12 +35199,28 @@ 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);
 }
 var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
 var importSourceByDmlStatement = /* @__PURE__ */ new WeakMap();
+var sourceWarningsByDmlStatement = /* @__PURE__ */ new WeakMap();
+function rememberDmlSourceWarnings(statement, warnings) {
+  if (!warnings?.length) return;
+  sourceWarningsByDmlStatement.set(statement, [...new Set(warnings)]);
+}
+function outcomeWithResultWarnings(statement, result) {
+  const warnings = sourceWarningsByDmlStatement.get(statement);
+  return { result, ...warnings?.length ? { warnings } : {} };
+}
 var statementEvaluationContextKey = /* @__PURE__ */ Symbol("statementEvaluationContext");
 var importSourceMaterializedCallbackKey = /* @__PURE__ */ Symbol("importSourceMaterializedCallback");
 var nativeUpsertExecutionKey = /* @__PURE__ */ Symbol("nativeUpsertExecution");
@@ -35921,13 +36021,17 @@ async function executeBatch(sql, client, options = {}) {
       }
     }
     metrics.elapsedMs = Date.now() - startedAt;
+    const warnings = [.../* @__PURE__ */ new Set([
+      ...dialect1Warnings,
+      ...results.flatMap((statement) => statement.warnings ?? [])
+    ])];
     const batchResult = {
       ok: results.every((r) => r.status === "success" || r.skippedReason === "exit"),
       statementCount: statements.length,
       statements: results,
       analysis,
       metrics,
-      ...dialect1Warnings.length > 0 ? { warnings: dialect1Warnings } : {}
+      ...warnings.length > 0 ? { warnings } : {}
     };
     const observer = options[batchCompletionObserverKey];
     if (observer) {
@@ -36038,7 +36142,7 @@ async function executeBatchStatement(context) {
   }
   await assertRelativeDateExecutionPlan(resolvedStmt, client, cacheContext);
   if (resolvedStmt.type === "VALIDATE") {
-    const result = await executeExistingRecordValidationCore(
+    const result2 = await executeExistingRecordValidationCore(
       resolvedStmt,
       client,
       { ...options, onLimitReached: "error" },
@@ -36048,19 +36152,20 @@ async function executeBatchStatement(context) {
       appendValidationErrors(
         tempTables,
         resolvedStmt.errorTable,
-        result.columns,
-        result.rows,
+        result2.columns,
+        result2.rows,
         options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
-        materializedMetaBySelectResult.get(result) ?? existingValidationColumnMeta(resolvedStmt.summary === true)
+        materializedMetaBySelectResult.get(result2) ?? existingValidationColumnMeta(resolvedStmt.summary === true)
       );
     }
-    return { result };
+    return { result: result2 };
   }
   if (resolvedStmt.type === "IMPORT") {
-    return { result: await executeImport(resolvedStmt, client, options, cacheContext, tempTables) };
+    const result2 = await executeImport(resolvedStmt, client, options, cacheContext, tempTables);
+    return outcomeWithResultWarnings(resolvedStmt, result2);
   }
   if ("validateOnly" in resolvedStmt && resolvedStmt.validateOnly === true) {
-    const result = await executeDmlValidation(
+    const result2 = await executeDmlValidation(
       resolvedStmt,
       client,
       { ...options, onLimitReached: "error" },
@@ -36072,25 +36177,24 @@ async function executeBatchStatement(context) {
       appendValidationErrors(
         tempTables,
         resolvedStmt.validationErrorTable,
-        result.columns,
-        result.errors,
+        result2.columns,
+        result2.errors,
         options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
-        materializedMetaByValidationResult.get(result) ?? /* @__PURE__ */ new Map()
+        materializedMetaByValidationResult.get(result2) ?? /* @__PURE__ */ new Map()
       );
     }
-    return { result };
+    return outcomeWithResultWarnings(resolvedStmt, result2);
   }
   if ("onErrorSkip" in resolvedStmt && resolvedStmt.onErrorSkip === true) {
-    return {
-      result: await executeOnErrorSkip(
-        resolvedStmt,
-        client,
-        { ...options, onLimitReached: "error" },
-        cacheContext,
-        tempTables,
-        info.index + 1
-      )
-    };
+    const result2 = await executeOnErrorSkip(
+      resolvedStmt,
+      client,
+      { ...options, onLimitReached: "error" },
+      cacheContext,
+      tempTables,
+      info.index + 1
+    );
+    return outcomeWithResultWarnings(resolvedStmt, result2);
   }
   if (resolvedStmt.type === "CREATE_TEMP_TABLE") {
     const materializeOptions = {
@@ -36098,13 +36202,17 @@ async function executeBatchStatement(context) {
       maxRecords: options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
       onLimitReached: "error"
     };
-    const result = await runSelectLike(resolvedStmt.query, client, materializeOptions, cacheContext, tempTables);
+    const result2 = await runSelectLike(resolvedStmt.query, client, materializeOptions, cacheContext, tempTables);
     tempTables.set(resolvedStmt.name, {
-      rows: result.rows,
-      columns: result.columns,
-      columnMeta: materializedMetaBySelectResult.get(result)
+      rows: result2.rows,
+      columns: result2.columns,
+      columnMeta: materializedMetaBySelectResult.get(result2)
     });
-    return { tempTable: resolvedStmt.name, rowCount: result.rows.length };
+    return {
+      tempTable: resolvedStmt.name,
+      rowCount: result2.rows.length,
+      ...result2.warnings?.length ? { warnings: [...result2.warnings] } : {}
+    };
   }
   if (stmt.type === "DROP_TEMP_TABLE") {
     tempTables.delete(stmt.name);
@@ -36120,12 +36228,12 @@ async function executeBatchStatement(context) {
     }
   }
   if (resolvedStmt.type === "ASSERT") {
-    const result = await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
-    return result.warning !== void 0 ? { result } : {};
+    const result2 = await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
+    return result2.warning !== void 0 ? { result: result2 } : {};
   }
   if (resolvedStmt.type === "EXIT") {
-    const result = await executeExit(resolvedStmt, client, options, cacheContext, tempTables);
-    return { result, ...result.exited ? { exitTriggered: true } : {} };
+    const result2 = await executeExit(resolvedStmt, client, options, cacheContext, tempTables);
+    return { result: result2, ...result2.exited ? { exitTriggered: true } : {} };
   }
   if (info.tempTablesReferenced.length > 0) {
     if (resolvedStmt.type === "SELECT" || resolvedStmt.type === "UNION") {
@@ -36144,17 +36252,20 @@ async function executeBatchStatement(context) {
       return { result: await executeWith(resolvedStmt, client, options, cacheContext, tempTables) };
     }
     if (resolvedStmt.type === "INSERT_SELECT") {
-      return { result: await executeInsertSelect(resolvedStmt, client, options, cacheContext, tempTables) };
+      const result2 = await executeInsertSelect(resolvedStmt, client, options, cacheContext, tempTables);
+      return outcomeWithResultWarnings(resolvedStmt, result2);
     }
     if (resolvedStmt.type === "UPSERT_SELECT") {
-      return { result: await executeUpsertSelect(resolvedStmt, client, options, cacheContext, tempTables) };
+      const result2 = await executeUpsertSelect(resolvedStmt, client, options, cacheContext, tempTables);
+      return outcomeWithResultWarnings(resolvedStmt, result2);
     }
     if (resolvedStmt.type === "UPDATE" && resolvedStmt.from?.cteName != null) {
       return { result: await executeUpdate(resolvedStmt, client, options, cacheContext, tempTables) };
     }
     throw new Error(`ArgumentError: temp table references in ${stmt.type} are not supported yet.`);
   }
-  return { result: await executeParsedStatement(resolvedStmt, client, options, cacheContext) };
+  const result = await executeParsedStatement(resolvedStmt, client, options, cacheContext);
+  return outcomeWithResultWarnings(resolvedStmt, result);
 }
 async function runSelectLike(query, client, options, cacheContext, tempTables) {
   if (query.type === "WITH") {
@@ -36558,7 +36669,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 +36767,19 @@ 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 materialized = table.cteName !== null ? materializedTables?.get(table.cteName) : void 0;
+      const semantics = table.cteName !== null ? resolveMaterializedColumn(materialized, field.field) !== void 0 ? resolveMaterializedColumnMeta(materialized, field.field)?.semantics ?? syntheticSemantics("string") : void 0 : fromPhysical(table, field.field, true);
       return semantics ? [semantics] : [];
     });
     if (matches.length === 1) return matches[0];
@@ -36795,13 +36907,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 +36967,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 +37249,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 +37652,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) => {
@@ -37569,9 +37828,10 @@ function collectB86Subqueries(stmt) {
   }
   return queries;
 }
-async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext) {
+async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext, cachedPhysicalFieldsOnly = false) {
   const tables = [stmt.from, ...stmt.joins.map((join3) => join3.table)];
   const materializedByTable = /* @__PURE__ */ new Map();
+  const unavailableMaterializedTables = /* @__PURE__ */ new Set();
   const effectiveAliases = /* @__PURE__ */ new Set();
   for (const table of tables) {
     const alias = effectiveTableAlias(table);
@@ -37585,6 +37845,10 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
     if (table.cteName === null || table.cteName === NO_FROM_CTE_NAME) continue;
     const materialized = cteCache.get(table.cteName);
     if (!materialized) {
+      if (cachedPhysicalFieldsOnly) {
+        unavailableMaterializedTables.add(table);
+        continue;
+      }
       throw new Error(`ArgumentError: materialized source ${table.cteName} is not available.`);
     }
     if (materialized.rows.length > 0 && materialized.columns.length === 0) {
@@ -37601,6 +37865,16 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
   }
   const schemas = /* @__PURE__ */ new Map();
   await Promise.all(tables.map(async (table) => {
+    if (unavailableMaterializedTables.has(table)) {
+      schemas.set(table, {
+        table,
+        label: b86SourceLabel(table),
+        validCodes: /* @__PURE__ */ new Set(),
+        authoritative: false,
+        schemaUnavailable: true
+      });
+      return;
+    }
     const materialized = materializedByTable.get(table);
     if (materialized) {
       schemas.set(table, {
@@ -37613,12 +37887,12 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
       return;
     }
     if (table.cteName === NO_FROM_CTE_NAME) return;
-    const defs = await getFieldsCached(table.appId, client, cacheContext);
+    const defs = cachedPhysicalFieldsOnly ? await getFieldsIfCached(table.appId, cacheContext) : await getFieldsCached(table.appId, client, cacheContext);
     schemas.set(table, {
       table,
       label: b86SourceLabel(table),
-      validCodes: new Set(defs.map((def) => def.code)),
-      authoritative: defs.length > 0,
+      validCodes: new Set((defs ?? []).map((def) => def.code)),
+      authoritative: defs !== null && defs.length > 0,
       schemaUnavailable: false
     });
   }));
@@ -37666,6 +37940,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 +38241,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 +38266,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 +38343,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 +38421,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 +38440,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 +38471,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 +38515,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 +38592,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 +39024,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 +39232,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 +40091,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 +40288,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 +40322,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 +40339,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 +41379,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 +41493,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.`);
       }
     }
@@ -41522,6 +41804,8 @@ async function executeImport(stmt, client, options, cacheContext, tempTables) {
   importSourceByDmlStatement.set(generated, executionSource);
   const withAudit = (result2) => {
     if (executionSource.audit) Object.assign(result2, { importAudit: executionSource.audit });
+    const warnings = sourceWarningsByDmlStatement.get(generated);
+    if (warnings?.length) sourceWarningsByDmlStatement.set(stmt, warnings);
     return result2;
   };
   if (generated.validateOnly) {
@@ -41811,6 +42095,7 @@ async function materializeDmlSource(stmt, client, options, cacheContext, tempTab
   const imported = importSourceByDmlStatement.get(stmt);
   if (!imported) {
     const selected2 = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, options, tempTables, cacheContext, true) : await executeSelect(stmt.select, client, options, cacheContext, void 0, true);
+    rememberDmlSourceWarnings(stmt, selected2.warnings);
     return { rows: selected2.rows, columns: selected2.columns, columnMeta: materializedMetaBySelectResult.get(selected2) };
   }
   const payload = await loadImportSource(imported.handle, imported.cache);
@@ -41826,6 +42111,7 @@ async function materializeDmlSource(stmt, client, options, cacheContext, tempTab
   const tables = new Map(tempTables ?? []);
   tables.set(IMPORT_PROJECTION_SOURCE, raw);
   const selected = await executeQueryWithCte(projection, client, { ...options, onLimitReached: "error" }, tables, cacheContext, true);
+  rememberDmlSourceWarnings(stmt, selected.warnings);
   return { rows: selected.rows, columns: selected.columns, columnMeta: materializedMetaBySelectResult.get(selected) };
 }
 var dmlSourceMaterializer = { materialize: materializeDmlSource };
@@ -42974,7 +43260,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;
   }
@@ -43255,6 +43544,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   const capabilities = /* @__PURE__ */ new Map();
   const orderPlans = /* @__PURE__ */ new Map();
   const plainGroupByPlans = /* @__PURE__ */ new Map();
+  const explainSelectsForColumnCheck = [];
   const seen = /* @__PURE__ */ new Set();
   const sharedRelativeDatePlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(query, tracedClient, cacheContext);
   const relativeNodeFor = (source) => sharedRelativeDatePlan.nodes.find(
@@ -43388,6 +43678,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     if (typed["type"] === "WITH") {
       const withStatement = node;
       for (const cte of withStatement.ctes) {
+        if (cte.recursiveSpec) {
+          const columns2 = recursiveOutputColumns(cte);
+          if (cte.recursiveSpec.cycle) columns2.push(cte.recursiveSpec.cycle.markColumn);
+          explainRelations.set(cte.name, { rows: [], columns: columns2 });
+          await preflightExplainRelations(cte.query);
+          continue;
+        }
         await preflightExplainRelations(cte.query);
         if (cte.query.type === "GENERATE_SERIES") {
           if (cte.query.args.some((arg) => arg.type === "VARIABLE")) {
@@ -43422,6 +43719,9 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     }
     if (typed["type"] === "SELECT") {
       const select = node;
+      await bindProjectedNamesForSelectWithSchemas(select, explainRelations, tracedClient, cacheContext);
+      await validateB86SelectFieldCodes(select, tracedClient, explainRelations, cacheContext, true);
+      explainSelectsForColumnCheck.push(select);
       analyzeStaticSelectRows(select);
       for (const column of select.columns) {
         if (column.type === "SCALAR_SUBQUERY_COL") await preflightExplainRelations(column.query);
@@ -43485,7 +43785,8 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       const { resolver, rewrites } = await normalizeSelectChoiceEquality(
         select,
         tracedClient,
-        cacheContext
+        cacheContext,
+        explainRelations
       );
       if (rewrites.length > 0) explainChoiceEqualityRewrites.set(select, rewrites);
       const capability = classifyWhereCapability(select.where, resolver);
@@ -43514,7 +43815,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 +43826,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]));
@@ -43683,6 +43984,9 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       }));
     }
   }
+  for (const select of explainSelectsForColumnCheck) {
+    await validateB86SelectFieldCodes(select, tracedClient, explainRelations, cacheContext, true);
+  }
   return {
     capabilities,
     orderPlans,
@@ -45330,7 +45634,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");
@@ -46455,6 +46759,7 @@ function buildBatchEnvelope(batch, options = {}) {
     if (s.status === "skipped" && s.skippedReason) entry.skippedReason = s.skippedReason;
     if (s.tempTable !== void 0) entry.tempTable = s.tempTable;
     if (s.rowCount !== void 0) entry.rowCount = s.rowCount;
+    if (s.warnings?.length) entry.warnings = s.warnings;
     if (s.status === "success" && s.result?.type === "SELECT") {
       totalRows += s.result.rowCount;
       if (maxTotalRecords !== void 0 && totalRows > maxTotalRecords) {
@@ -46511,8 +46816,9 @@ function buildBatchEnvelope(batch, options = {}) {
     statementCount: batch.statementCount,
     statements,
     results,
-    // バッチ全体の警告（仕様 §6.2）。文ごとの警告は results[].warnings に入る
-    warnings: []
+    // バッチ全体の警告（仕様 §6.2）＝dialect 1 の警告 + 結果セットを持たない文（CREATE TEMP TABLE・
+    // SELECT-based DML）の実行時警告（B188・文順・重複なし）。SELECT の文ごとの警告は従来どおり results[].warnings
+    warnings: batch.warnings ?? []
   };
 }
 
@@ -49074,12 +49380,23 @@ function buildBatchStatementSummary(s) {
     }
   }
   if (s.status === "skipped" && s.skippedReason) parts.push(`reason=${s.skippedReason}`);
+  const warnings = s.warnings ?? (s.result?.type === "SELECT" ? s.result.warnings : void 0);
+  if (s.status === "success" && warnings) {
+    for (const warning of warnings) parts.push(`warning=${warning}`);
+  }
   return parts.join(" ");
 }
 function buildSelectSummary(result) {
   const validateSummary = result.validateStats ? ` errorRecords=${result.validateStats.errorRecords} errorCount=${result.validateStats.errorCount}` : "";
   return `rowCount=${result.rowCount}${validateSummary}`;
 }
+function writeSingleSelectWarnings(result, format, quiet) {
+  if (quiet || format === "json") return;
+  for (const warning of result.warnings ?? []) {
+    process.stderr.write(`warning=${warning}
+`);
+  }
+}
 function buildBatchDmlConfirmMessage(analysis) {
   const lines = ["[DML Confirm] batch"];
   for (const s of analysis.statements) {
@@ -50543,6 +50860,7 @@ query=${label}`);
       process.stderr.write(`${buildSelectSummary(result)}
 `);
     }
+    writeSingleSelectWarnings(result, format, quiet);
     if (exportPlan) {
       const exportCode = runSingleSelectCliExport(exportPlan, result, quiet);
       if (exportCode !== 0) return exportCode;
@@ -50603,5 +50921,6 @@ if (isDirectCliRun()) {
   runWithArgv,
   shouldExitOnEmpty,
   toCliImportError,
-  writeBatchOutput
+  writeBatchOutput,
+  writeSingleSelectWarnings
 });