@rex0220/kintone-sql-tools 3.57.0 → 3.58.0

package/dist-cli/ksql.js

@@ -10780,11 +10780,11 @@ function validatePostImage(record, fieldIndex, numberPrecision, statementNumber,
     else normalizedRecord[field.code] = { value: preserveCodeObjects(raw, field.fieldType, result.value) };
   }
   for (const [tableCode, children] of fieldIndex.subtables) {
-    const sourceRows = record[tableCode]?.value;
-    if (!Array.isArray(sourceRows)) continue;
+    const sourceRows2 = record[tableCode]?.value;
+    if (!Array.isArray(sourceRows2)) continue;
     const normalizedRows = normalizedRecord[tableCode]?.value;
-    for (let rowIndex = 0; rowIndex < sourceRows.length; rowIndex++) {
-      const sourceRow = sourceRows[rowIndex];
+    for (let rowIndex = 0; rowIndex < sourceRows2.length; rowIndex++) {
+      const sourceRow = sourceRows2[rowIndex];
       const normalizedRow = normalizedRows[rowIndex];
       for (const field of children) {
         const raw = sourceRow.value?.[field.code]?.value;
@@ -13539,6 +13539,65 @@ async function deriveEmptyWildcardColumns(fields, subtableCode, loadProcessStatu
 }
 
 // src/engine/process.ts
+var materializedSelectValues = /* @__PURE__ */ new WeakMap();
+var sourceRows = /* @__PURE__ */ new WeakMap();
+function asProcessingRow(source) {
+  if (sourceRows.has(source)) return source;
+  let row;
+  row = new Proxy(source, {
+    get(target, property, receiver) {
+      if (typeof property !== "string" || Object.prototype.hasOwnProperty.call(target, property)) {
+        return Reflect.get(target, property, receiver);
+      }
+      return getMaterializedLookupValue(row, property);
+    },
+    has(target, property) {
+      return Reflect.has(target, property) || typeof property === "string" && getMaterializedLookupValue(row, property) !== void 0;
+    },
+    getOwnPropertyDescriptor(target, property) {
+      const descriptor = Reflect.getOwnPropertyDescriptor(target, property);
+      if (descriptor || typeof property !== "string") return descriptor;
+      const value = getMaterializedLookupValue(row, property);
+      return value === void 0 ? void 0 : { configurable: true, enumerable: false, writable: false, value };
+    }
+  });
+  sourceRows.set(row, source);
+  return row;
+}
+function sourceRowForEvaluation(row) {
+  return sourceRows.get(row) ?? row;
+}
+function materializedValuesFor(row) {
+  let values = materializedSelectValues.get(row);
+  if (!values) {
+    values = { byColumn: /* @__PURE__ */ new Map(), byLookupKey: /* @__PURE__ */ new Map() };
+    materializedSelectValues.set(row, values);
+  }
+  return values;
+}
+function setMaterializedSelectValue(row, columnIndex, value, lookupKeys = []) {
+  const values = materializedValuesFor(row);
+  values.byColumn.set(columnIndex, value);
+  for (const key of lookupKeys) values.byLookupKey.set(key, value);
+}
+function getMaterializedSelectValue(row, columnIndex) {
+  return materializedSelectValues.get(row)?.byColumn.get(columnIndex);
+}
+function getMaterializedLookupValue(row, key) {
+  return materializedSelectValues.get(row)?.byLookupKey.get(key);
+}
+function getLegacyMaterializedValue(row, key) {
+  return materializedSelectValues.has(row) ? void 0 : row[key];
+}
+function havingEvaluationRow(row) {
+  const lookups = materializedSelectValues.get(row)?.byLookupKey;
+  if (!lookups || lookups.size === 0) return row;
+  const evaluationRow = { ...row };
+  for (const [key, value] of lookups) evaluationRow[key] = value;
+  const groupingMeta = getGroupingRowMeta(row);
+  if (groupingMeta) attachGroupingRowMeta(evaluationRow, groupingMeta.includedCanonicalIds);
+  return evaluationRow;
+}
 function flatten(record, alias) {
   const row = {};
   for (const [field, fv] of Object.entries(record)) {
@@ -13643,7 +13702,7 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolution
   }
   const result = [];
   for (const groupRows of groups.values()) {
-    const outRow = { ...groupRows[0] };
+    const outRow = asProcessingRow({ ...groupRows[0] });
     for (const k of groupByKeys) {
       if (k.type === "ARITH_KEY") {
         outRow[arithColDefaultKey(k.expr)] = String(evalArithExpr(k.expr, groupRows[0]));
@@ -13695,7 +13754,7 @@ function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {})
     }
     const includedCanonicalIds = new Set(set.items.map((item) => item.canonicalId));
     for (const groupRows of buckets) {
-      const outRow = { ...groupRows[0] };
+      const outRow = asProcessingRow({ ...groupRows[0] });
       const includedValues = /* @__PURE__ */ new Map();
       for (const item of set.items) {
         if (!includedValues.has(item.canonicalId)) {
@@ -13725,32 +13784,52 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
     if (col.type === "AGGREGATE") {
       const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
       const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
-      outRow[col.alias ?? syntheticKey] = value;
-      if (col.alias) outRow[syntheticKey] = value;
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        value,
+        col.alias ? [col.alias, syntheticKey] : [syntheticKey]
+      );
     } else if (col.type === "ARITH_AGG_COL") {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
-      outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind)),
+        [outputKey]
+      );
     } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
       const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
+      setMaterializedSelectValue(outRow, columnIndex, evalStringFunc(resolvedExpr, outRow), [outputKey]);
     } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
       const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
-      outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        String(evalScalarValueExpr(resolvedExpr, outRow)),
+        [outputKey]
+      );
     } else if (col.type === "CASE_COL" && containsAggregate2(col.expr)) {
       materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const resolvedExpr = resolveAggInCaseExpr(col.expr, groupRows, resolveAggSortKind);
       const resolveAggregateSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, resolveAggSortKind) : void 0;
-      outRow[caseMaterializedKey(col.alias, columnIndex)] = evalCaseWhen(
+      const value = evalCaseWhen(
         resolvedExpr,
         outRow,
         void 0,
         resolveAggregateSemantics
       );
+      setMaterializedSelectValue(
+        outRow,
+        columnIndex,
+        value,
+        [caseMaterializedKey(col.alias, columnIndex)]
+      );
     }
   }
 }
@@ -13776,8 +13855,8 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
   collectAggregateRefs(node, refs);
   for (const ref of refs) {
     const key = aggregateSyntheticName(ref.func, ref.distinct, ref.arg);
-    if (outRow[key] !== void 0) continue;
-    outRow[key] = String(evalAggregate(
+    if (getMaterializedLookupValue(outRow, key) !== void 0) continue;
+    const value = String(evalAggregate(
       ref.func,
       ref.distinct,
       ref.arg,
@@ -13785,6 +13864,7 @@ function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind
       rows,
       resolveAggSortKind
     ));
+    materializedValuesFor(outRow).byLookupKey.set(key, value);
   }
 }
 function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
@@ -13899,7 +13979,8 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
   }
 }
 function aggregateRowValues(func, arg, rows) {
-  return rows.map((row) => {
+  return rows.map((processingRow) => {
+    const row = sourceRowForEvaluation(processingRow);
     let strVal;
     if (arg.type === "FIELD_REF") {
       const raw = row[arg.field];
@@ -13980,7 +14061,13 @@ function aggregateResultSemantics(ref, resolver) {
 }
 function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
   if (having === null) return rows;
-  return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
+  return rows.filter((row) => evalWhere(
+    having,
+    havingEvaluationRow(row),
+    resolveFieldType,
+    void 0,
+    resolveFieldSemantics2
+  ));
 }
 function applyDistinct(rows, columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
   if (rows.length === 0) return rows;
@@ -14092,13 +14179,14 @@ var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
   "WEEK"
 ]);
 function evalOrderKey(key, row, aliasEvaluator) {
+  const sourceRow = sourceRowForEvaluation(row);
   switch (key.type) {
     case "FIELD_NAME":
-      return aliasEvaluator?.(key.name, row) ?? row[key.name] ?? "";
+      return aliasEvaluator?.(key.name, row) ?? getMaterializedLookupValue(row, key.name) ?? sourceRow[key.name] ?? "";
     case "ARITH_KEY":
-      return String(evalArithExpr(key.expr, row));
+      return String(evalArithExpr(key.expr, sourceRow));
     case "FUNC_KEY":
-      return evalStringFunc(key.expr, row);
+      return evalStringFunc(key.expr, sourceRow);
     case "GROUPING_KEY":
       return evalGroupingRef(key.ref, row);
   }
@@ -14110,38 +14198,41 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
     const alias = column.alias;
     switch (column.type) {
       case "FIELD":
-        evaluators.set(alias, (row) => resolveFieldRef(row, column.field));
+        evaluators.set(alias, (row) => resolveFieldRef(sourceRowForEvaluation(row), column.field));
         break;
       case "LITERAL_COL":
         evaluators.set(alias, () => column.value);
         break;
       case "AGGREGATE": {
-        const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "0");
         break;
       }
       case "ARITH_AGG_COL": {
-        const source = aggArithDefaultKey(column.expr);
-        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "0");
         break;
       }
       case "WINDOW_COL":
-        evaluators.set(alias, (row) => row[alias] ?? "");
+        evaluators.set(alias, (row) => getMaterializedSelectValue(row, columnIndex) ?? "");
         break;
       case "ARITH_COL":
-        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, row)));
+        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, sourceRowForEvaluation(row))));
         break;
       case "STRFUNC_COL": {
         const source = stringFuncDefaultKey(column.expr);
-        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? row[alias] ?? row[source] ?? evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
         break;
       }
       case "CASE_COL":
-        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? row[alias] ?? "" : evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? "" : evalCaseWhen(column.expr, sourceRowForEvaluation(row), resolveFieldType, resolveFieldSemantics2));
         break;
       case "SCALAR_VALUE_COL": {
         const source = scalarValueDefaultKey(column.expr);
-        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? row[alias] ?? row[source] ?? "" : String(evalScalarValueExpr(column.expr, row, resolveFieldType, resolveFieldSemantics2)));
+        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? "" : String(evalScalarValueExpr(
+          column.expr,
+          sourceRowForEvaluation(row),
+          resolveFieldType,
+          resolveFieldSemantics2
+        )));
         break;
       }
       case "SCALAR_SUBQUERY_COL":
@@ -14157,9 +14248,10 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
   return (name, row) => evaluators.get(name)?.(row);
 }
 function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind) {
-  const windows = columns.filter((column) => column.type === "WINDOW_COL");
+  const windows = columns.map((column, columnIndex) => ({ column, columnIndex })).filter((item) => item.column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
-  for (const window of windows) {
+  for (let index = 0; index < rows.length; index++) rows[index] = asProcessingRow(rows[index]);
+  for (const { column: window, columnIndex } of windows) {
     const partitions = /* @__PURE__ */ new Map();
     for (const row of rows) {
       const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowField(row, ref)));
@@ -14171,11 +14263,11 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
       const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
       if (isAggregateWindow(window)) {
-        applyAggregateWindow(window, sortedResult, resolveAggSortKind);
+        applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind);
         continue;
       }
       if (isValueWindow(window)) {
-        applyValueWindow(window, sorted);
+        applyValueWindow(window, columnIndex, sorted);
         continue;
       }
       if (!isRankingWindow(window)) {
@@ -14189,27 +14281,32 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
           denseRank++;
         }
         const value = window.func === "ROW_NUMBER" ? index + 1 : window.func === "RANK" ? rank : denseRank;
-        sorted[index].row[window.alias] = String(value);
+        setMaterializedSelectValue(sorted[index].row, columnIndex, String(value), [window.alias]);
       }
     }
   }
   return rows;
 }
 function evaluateValueWindowArg(arg, row) {
-  const value = evalScalarValueExprNullable(arg, row);
+  const value = evalScalarValueExprNullable(arg, sourceRowForEvaluation(row));
   if (value === null || value === void 0) return "";
   if (typeof value === "number" && !Number.isFinite(value)) return "";
   return String(value);
 }
-function applyValueWindow(window, sorted) {
+function applyValueWindow(window, columnIndex, sorted) {
   const values = sorted.map((item) => evaluateValueWindowArg(window.arg, item.row));
   const direction = window.valueFunc === "LAG" ? -1 : 1;
   for (let index = 0; index < sorted.length; index++) {
     const target = index + direction * window.offset;
-    sorted[index].row[window.alias] = target >= 0 && target < values.length ? values[target] : "";
+    setMaterializedSelectValue(
+      sorted[index].row,
+      columnIndex,
+      target >= 0 && target < values.length ? values[target] : "",
+      [window.alias]
+    );
   }
 }
-function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
+function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortKind) {
   const sorted = sortedResult.rows;
   const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(window.aggFunc, window.arg, sorted.map((item) => item.row));
   const comparison = window.arg.type === "WILDCARD" ? void 0 : resolveAggregateArgSemantics(window.arg, resolveAggSortKind);
@@ -14242,23 +14339,29 @@ function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
   }
   if (window.frame === null) {
     const finalValue = output[output.length - 1];
-    for (const item of sorted) item.row[window.alias] = finalValue;
+    for (const item of sorted) {
+      setMaterializedSelectValue(item.row, columnIndex, finalValue, [window.alias]);
+    }
     return;
   }
   if (window.frame.unit === "RANGE") {
     for (let start = 0; start < sorted.length; ) {
       let end = start;
       while (end + 1 < sorted.length && sortedResult.compare(sorted[end], sorted[end + 1]) === 0) end++;
-      for (let index = start; index <= end; index++) sorted[index].row[window.alias] = output[end];
+      for (let index = start; index <= end; index++) {
+        setMaterializedSelectValue(sorted[index].row, columnIndex, output[end], [window.alias]);
+      }
       start = end + 1;
     }
     return;
   }
-  for (let index = 0; index < sorted.length; index++) sorted[index].row[window.alias] = output[index];
+  for (let index = 0; index < sorted.length; index++) {
+    setMaterializedSelectValue(sorted[index].row, columnIndex, output[index], [window.alias]);
+  }
 }
 function resolveWindowField(row, ref) {
   const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
-  return resolveFieldRef(row, name);
+  return resolveFieldRef(sourceRowForEvaluation(row), name);
 }
 function applyLimit(rows, limit, offset) {
   const start = offset ?? 0;
@@ -14266,41 +14369,42 @@ function applyLimit(rows, limit, offset) {
   return rows.slice(start, start + limit);
 }
 function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
+  const sourceRow = sourceRowForEvaluation(row);
   switch (column.type) {
     case "VARIABLE_COL":
       throw new Error(`internal error: unresolved SELECT variable @${column.name}`);
     case "WILDCARD": {
-      const keys = context.wildcardKeys ?? Object.keys(row);
+      const keys = context.wildcardKeys ?? Object.keys(sourceRow);
       return {
         kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+        entries: keys.map((key) => [key, sourceRow[key] !== void 0 ? sourceRow[key] : null])
       };
     }
     case "PARENT_WILDCARD": {
-      const keys = context.parentWildcardKeys ?? Object.keys(row).filter((key) => key.startsWith("_p.")).sort();
+      const keys = context.parentWildcardKeys ?? Object.keys(sourceRow).filter((key) => key.startsWith("_p.")).sort();
       return {
         kind: "EXPANDED",
-        entries: keys.map((key) => [key, row[key] !== void 0 ? row[key] : null])
+        entries: keys.map((key) => [key, sourceRow[key] !== void 0 ? sourceRow[key] : null])
       };
     }
     case "FIELD":
-      return resolveFieldRef(row, column.field);
+      return resolveFieldRef(sourceRow, column.field);
     case "LITERAL_COL":
       return column.value;
     case "AGGREGATE": {
       const source = aggregateSyntheticName(column.func, column.distinct, column.arg);
-      return row[column.alias ?? source] ?? row[source] ?? "0";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_AGG_COL": {
       const source = column.alias ?? aggArithDefaultKey(column.expr);
-      return row[source] ?? "0";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_COL":
-      return String(evalArithExpr(column.expr, row));
+      return String(evalArithExpr(column.expr, sourceRow));
     case "CASE_COL":
-      return containsAggregate2(column.expr) ? row[caseMaterializedKey(column.alias, columnIndex)] ?? "" : evalCaseWhen(
+      return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       );
@@ -14308,23 +14412,23 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return evalGroupingRef(column.ref, row);
     case "STRFUNC_COL": {
       const source = stringFuncDefaultKey(column.expr);
-      return hasAggregateInStringFuncExpr2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? evalStringFunc(
+      return hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? evalStringFunc(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       ) : evalStringFunc(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       );
     }
     case "SCALAR_VALUE_COL": {
       const source = scalarValueDefaultKey(column.expr);
-      return scalarValueHasAggregate2(column.expr) ? row[column.alias ?? source] ?? row[source] ?? "" : String(evalScalarValueExpr(
+      return scalarValueHasAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "" : String(evalScalarValueExpr(
         column.expr,
-        row,
+        sourceRow,
         context.resolveFieldType,
         context.resolveFieldSemantics
       ));
@@ -14332,7 +14436,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
     case "SCALAR_SUBQUERY_COL":
       return context.scalarCache?.get(columnIndex) ?? "";
     case "WINDOW_COL":
-      return row[column.alias] ?? "";
+      return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias) ?? getLegacyMaterializedValue(row, column.alias) ?? "";
   }
 }
 function buildDistinctTuple(columns, row, context = {}) {
@@ -16426,9 +16530,9 @@ function render(value) {
 function buildImportRecordPayload(top, subtables, rowIdMode) {
   const record = {};
   for (const [code, value] of top) record[code] = { value };
-  for (const [tableCode, sourceRows] of subtables) {
+  for (const [tableCode, sourceRows2] of subtables) {
     record[tableCode] = {
-      value: sourceRows.map((sourceRow) => ({
+      value: sourceRows2.map((sourceRow) => ({
         ...rowIdMode === "PRESERVE" && sourceRow.rowId ? { id: sourceRow.rowId } : {},
         value: Object.fromEntries([...sourceRow.values].map(([childCode, value]) => [childCode, { value }]))
       }))
@@ -17991,7 +18095,7 @@ function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context) {
 }
 function tieBreakAdvice(context, kind) {
   if (context !== "DIRECT") {
-    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002";
+    return "\u305D\u306E\u8868\u306E\u4E2D\u3067\u4E00\u610F\u306B\u306A\u308B\u5217\uFF08\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u306A\u3069\uFF09\u3092 ORDER BY \u306B\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002\u96C6\u7D04\u7D50\u679C\u306E\u5217\u306F\u4E00\u610F\u3067\u3082\u8A3C\u660E\u3067\u304D\u306A\u3044\u305F\u3081\u3001\u3059\u3067\u306B\u4E00\u610F\u306A\u5834\u5408\u3082\u3053\u306E\u8B66\u544A\u304C\u51FA\u307E\u3059\u3002\u5143\u306E\u96C6\u7D04\u306E\u30AD\u30FC\u3092\u3059\u3079\u3066 ORDER BY \u306B\u542B\u3081\u3066\u3044\u308B\u306A\u3089\u3001\u3053\u306E\u8B66\u544A\u306F\u7121\u8996\u3057\u3066\u69CB\u3044\u307E\u305B\u3093\u3002";
   }
   return kind === "RANGE" ? "ORDER BY \u306B\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u306A\u3069\u306E\u30BF\u30A4\u30D6\u30EC\u30FC\u30AF\u30AD\u30FC\u3092\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u7B49\u3092 ORDER BY \u306B\u8FFD\u52A0\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 }
@@ -20370,10 +20474,10 @@ async function tryFetchJoinRecordsBySourceKeys(stmt, join2, tables, client, maxR
   } else {
     return null;
   }
-  const sourceRows = tables.get(sourceAlias);
-  if (!sourceRows) return null;
+  const sourceRows2 = tables.get(sourceAlias);
+  if (!sourceRows2) return null;
   const keys = /* @__PURE__ */ new Set();
-  for (const row of sourceRows) {
+  for (const row of sourceRows2) {
     const raw = row[sourceField]?.value;
     const txt = toScalarText(raw).trim();
     if (txt.length > 0) keys.add(txt);
@@ -21283,7 +21387,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     );
   }
   let rows;
-  let sourceRows;
+  let sourceRows2;
   let sourcePresence;
   let sourceRowErrors;
   let evaluationTypes;
@@ -21304,7 +21408,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
       throw customCheckParseError("CHECK \u4ED8\u304D DML \u30BD\u30FC\u30B9 SELECT \u306E\u51FA\u529B\u540D\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
     }
     assertInsertCheckRefs(stmt, selectResult.columns);
-    sourceRows = selectResult.rows;
+    sourceRows2 = selectResult.rows;
     sourcePresence = selectResult.importPresence;
     sourceRowErrors = selectResult.importRowErrors;
     const meta = selectResult.columnMeta;
@@ -21325,7 +21429,7 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     )),
     preErrors: [...sourceRowErrors?.[index] ?? []],
     record: {},
-    evaluationRow: sourceRows?.[index] ?? Object.fromEntries(
+    evaluationRow: sourceRows2?.[index] ?? Object.fromEntries(
       stmt.fields.map((field, i) => [field, renderValidationValue(values[i])])
     ),
     evaluationFieldTypes: evaluationTypes
@@ -21621,7 +21725,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   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))];
   const requiredSourceFields = [.../* @__PURE__ */ new Set([from.joinKeyField, ...sourceFields])];
-  const sourceRows = await loadUpdateFromSourceRows(
+  const sourceRows2 = await loadUpdateFromSourceRows(
     from,
     requiredSourceFields,
     sourceFields,
@@ -21632,7 +21736,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   );
   const sourceByKey = /* @__PURE__ */ new Map();
   const sourceQueryByKey = /* @__PURE__ */ new Map();
-  for (const row of sourceRows) {
+  for (const row of sourceRows2) {
     if (!Object.prototype.hasOwnProperty.call(row, from.joinKeyField)) {
       throw new Error(`ArgumentError: UPDATE ... FROM source column ${from.joinKeyField} does not exist.`);
     }