@rex0220/kintone-sql-tools 3.44.0 → 3.45.0

package/dist-cli/ksql.js

@@ -577,6 +577,9 @@ function compareDecimal(left, right) {
 
 // src/types/ast.ts
 var NO_FROM_CTE_NAME = "__NO_FROM__";
+function isRankingWindow(column) {
+  return column.windowKind !== "AGGREGATE";
+}
 function makeNumberLiteral(raw) {
   return { type: "NUMBER", value: Number(raw), raw };
 }
@@ -1318,6 +1321,11 @@ var Parser = class {
     }
     throw new ParseError(msg, tok);
   }
+  consumeSoftKeyword(word) {
+    if (!this.isSoftKeyword(word)) return false;
+    this.advance();
+    return true;
+  }
   parseTempTableName() {
     const tok = this.peek();
     if (tok.kind === "IDENT" /* IDENT */ && tok.value.startsWith("#")) {
@@ -1957,6 +1965,12 @@ var Parser = class {
       const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return this.withAliasDisplay({ type: "GROUPING_COL", ref, alias: parsedAlias2?.alias ?? null }, parsedAlias2);
     }
+    if (this.tryAggregateFunc() === null && this.hasNestedAggregateWindowInSelectColumn()) {
+      throw new ParseError(
+        "\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306E\u7D50\u679C\u3092\u5F0F\u306B\u542B\u3081\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002CTE \u3067\u4E00\u5EA6\u5B9F\u4F53\u5316\u3057\u3066\u304F\u3060\u3055\u3044",
+        this.peek()
+      );
+    }
     if (this.tryAggregateFunc() === null && this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
       const expr = this.parseScalarValueExpr({ allowAggregateArgs: true });
       const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -2001,6 +2015,9 @@ var Parser = class {
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
       const ref = this.parseAggregateRef(aggFunc);
+      if (this.isSoftKeyword("OVER")) {
+        return this.parseAggregateWindowColumn(ref);
+      }
       if (this.isArithOp(this.peek().kind)) {
         const expr = this.continueAggArith(ref);
         const parsedAlias3 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -2052,6 +2069,28 @@ var Parser = class {
   tryWindowFunc() {
     return PARSER_WINDOW_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
+  hasNestedAggregateWindowInSelectColumn() {
+    let depth = 0;
+    for (let index = this.pos; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (depth === 0 && (token.kind === "," /* COMMA */ || token.kind === "FROM" /* FROM */ || token.kind === ";" /* SEMICOLON */ || token.kind === "EOF" /* EOF */)) return false;
+      if (PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[token.kind] !== void 0 && this.tokens[index + 1]?.kind === "(" /* LPAREN */) {
+        let aggregateDepth = 0;
+        for (let cursor = index + 1; cursor < this.tokens.length; cursor++) {
+          const candidate = this.tokens[cursor];
+          if (candidate.kind === "(" /* LPAREN */) aggregateDepth++;
+          else if (candidate.kind === ")" /* RPAREN */ && --aggregateDepth === 0) {
+            const next = this.tokens[cursor + 1];
+            if (next?.kind === "IDENT" /* IDENT */ && next.value.toUpperCase() === "OVER") return true;
+            break;
+          }
+        }
+      }
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */) depth--;
+    }
+    return false;
+  }
   parseWindowColumn(func) {
     this.advance();
     this.expect("(" /* LPAREN */);
@@ -2078,6 +2117,66 @@ var Parser = class {
     const parsedAlias = this.parseAliasName();
     return this.withAliasDisplay({ type: "WINDOW_COL", func, partitionBy, orderBy, alias: parsedAlias.alias }, parsedAlias);
   }
+  parseAggregateWindowColumn(ref) {
+    const supported = /* @__PURE__ */ new Set(["SUM", "COUNT", "AVG", "MIN", "MAX"]);
+    if (!supported.has(ref.func)) {
+      throw new ParseError(
+        `${ref.func} \u306E\u30A6\u30A3\u30F3\u30C9\u30A6\u96C6\u8A08\u306F\u672A\u5BFE\u5FDC\u3067\u3059\u3002\u5BFE\u5FDC\u306F SUM / COUNT / AVG / MIN / MAX \u3067\u3059`,
+        this.peek()
+      );
+    }
+    if (ref.distinct) {
+      throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u96C6\u8A08\u3067\u306F\u5F15\u6570\u306E DISTINCT \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
+    }
+    this.advance();
+    this.expect("(" /* LPAREN */);
+    const partitionBy = [];
+    if (this.isSoftKeyword("PARTITION")) {
+      this.advance();
+      this.expect("BY" /* BY */, "PARTITION \u306E\u5F8C\u306B\u306F BY \u304C\u5FC5\u8981\u3067\u3059");
+      do {
+        const field = this.parseQualifiedIdent();
+        partitionBy.push({ type: "FIELD", tableAlias: field.tableAlias, field: field.field });
+      } while (this.consume("," /* COMMA */));
+    }
+    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy(false)) : [];
+    let frame = orderBy.length > 0 ? { unit: "RANGE", source: "DEFAULT" } : null;
+    if (this.isSoftKeyword("ROWS") || this.isSoftKeyword("RANGE")) {
+      if (orderBy.length === 0) {
+        throw new ParseError("\u30D5\u30EC\u30FC\u30E0\u53E5\u306B\u306F OVER (ORDER BY ...) \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+      }
+      const unit = this.advance().value.toUpperCase();
+      const valid = this.consume("BETWEEN" /* BETWEEN */) && this.consumeSoftKeyword("UNBOUNDED") && this.consumeSoftKeyword("PRECEDING") && this.consume("AND" /* AND */) && this.consumeSoftKeyword("CURRENT") && this.consumeSoftKeyword("ROW");
+      if (!valid) {
+        throw new ParseError(
+          "\u5BFE\u5FDC\u3059\u308B\u30D5\u30EC\u30FC\u30E0\u306F BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW \u3060\u3051\u3067\u3059",
+          this.peek()
+        );
+      }
+      frame = { unit, source: "EXPLICIT" };
+    }
+    this.expect(")" /* RPAREN */);
+    if (this.isArithOp(this.peek().kind)) {
+      throw new ParseError(
+        "\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306E\u7D50\u679C\u3092\u5F0F\u306B\u542B\u3081\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002CTE \u3067\u4E00\u5EA6\u5B9F\u4F53\u5316\u3057\u3066\u304F\u3060\u3055\u3044",
+        this.peek()
+      );
+    }
+    if (!this.consume("AS" /* AS */)) {
+      throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+    }
+    const parsedAlias = this.parseAliasName();
+    return this.withAliasDisplay({
+      type: "WINDOW_COL",
+      windowKind: "AGGREGATE",
+      aggFunc: ref.func,
+      arg: ref.arg,
+      frame,
+      partitionBy,
+      orderBy,
+      alias: parsedAlias.alias
+    }, parsedAlias);
+  }
   selectColumnHasAggregate(column) {
     if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
     if (column.type === "STRFUNC_COL") return column.expr.args.some((arg) => this.stringFuncArgHasAggregate(arg));
@@ -2156,7 +2255,9 @@ var Parser = class {
     }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
-      return this.parseAggregateRef(aggFunc);
+      const ref = this.parseAggregateRef(aggFunc);
+      this.rejectAggregateWindowOutsideSelect();
+      return ref;
     }
     throw new ParseError("\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u306F\u96C6\u8A08\u95A2\u6570\u307E\u305F\u306F\u6570\u5024\u304C\u5FC5\u8981\u3067\u3059", this.peek());
   }
@@ -2405,7 +2506,9 @@ var Parser = class {
     }
     const aggregateFunc = this.tryAggregateFunc();
     if (aggregateFunc !== null && allowAggregateResult) {
-      return this.continueAggArith(this.parseAggregateRef(aggregateFunc));
+      const ref = this.parseAggregateRef(aggregateFunc);
+      this.rejectAggregateWindowOutsideSelect();
+      return this.continueAggArith(ref);
     }
     if (this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
       return this.parseScalarValueExpr({ allowAggregateArgs: true });
@@ -2930,6 +3033,7 @@ var Parser = class {
         throw new ParseError("\u96C6\u8A08\u95A2\u6570\u306E\u5F15\u6570\u5185\u306B\u96C6\u8A08\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
       }
       const ref = this.parseAggregateRef(aggFunc);
+      this.rejectAggregateWindowOutsideSelect();
       if (this.isArithOp(this.peek().kind)) {
         return {
           type: "AGG_FIELD",
@@ -3388,6 +3492,16 @@ var Parser = class {
    *   フィールド名/alias: 名前 / total
    */
   parseOrderByKey(allowGrouping = true) {
+    const aggregateStart = this.tryAggregateFunc();
+    if (aggregateStart !== null) {
+      const start = this.pos;
+      const ref = this.parseAggregateRef(aggregateStart);
+      if (this.isSoftKeyword("OVER")) {
+        throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F SELECT \u5217\u306B\u306E\u307F\u8A18\u8FF0\u3067\u304D\u307E\u3059", this.peek());
+      }
+      this.pos = start;
+      void ref;
+    }
     if (this.isUnsupportedGroupingIdStart()) {
       throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
     }
@@ -3911,6 +4025,11 @@ var Parser = class {
   isSoftKeyword(value) {
     return this.peek().kind === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === value;
   }
+  rejectAggregateWindowOutsideSelect() {
+    if (this.isSoftKeyword("OVER")) {
+      throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F SELECT \u5217\u306B\u306E\u307F\u8A18\u8FF0\u3067\u304D\u307E\u3059", this.peek());
+    }
+  }
   validateUpdateFromAssignments(assignments, sourceAlias, tok) {
     for (const assignment of assignments) {
       if (assignment.value.type === "STRING_FUNC") {
@@ -4426,7 +4545,11 @@ function selectCompleteInputReasons(stmt) {
   if (stmt.distinct) reasons.add("DISTINCT");
   if (stmt.orderBy.length > 0) reasons.add("LOCAL_ORDER");
   for (const column of stmt.columns) {
-    if (column.type === "WINDOW_COL" && column.orderBy.length > 0) reasons.add("WINDOW_ORDER");
+    if (column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE") {
+      reasons.add("AGGREGATE_WINDOW");
+    } else if (column.type === "WINDOW_COL" && column.orderBy.length > 0) {
+      reasons.add("WINDOW_ORDER");
+    }
     if (column.type === "SCALAR_SUBQUERY_COL") addReasons(reasons, selectCompleteInputReasons(column.query));
     if (column.type === "CASE_COL") {
       for (const branch of column.expr.branches) addReasons(reasons, whereCompleteInputReasons(branch.condition));
@@ -6104,6 +6227,9 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       case "SCALAR_SUBQUERY_COL":
         break;
       case "WINDOW_COL":
+        if (col.windowKind === "AGGREGATE" && col.arg.type !== "WILDCARD") {
+          walkAggregateArg(col.arg, "select");
+        }
         for (const ref of col.partitionBy) addFieldRef(ref.field, ref.tableAlias, "select");
         for (const item of col.orderBy) walkOrderByKey(item.key, "select");
         break;
@@ -11076,7 +11202,7 @@ function valueNeedsFieldMetadata(value) {
   return Object.values(item).some(valueNeedsFieldMetadata);
 }
 function selectNeedsOwnMetadata(statement) {
-  return whereNeedsFieldMetadata(statement.where) || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
+  return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
     (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
   );
 }
@@ -13199,26 +13325,7 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
   if (arg.type === "WILDCARD") {
     return func === "COUNT" ? rows.length : 0;
   }
-  const strValues = [];
-  for (const row of rows) {
-    let strVal;
-    if (arg.type === "FIELD_REF") {
-      const raw = row[arg.field];
-      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") continue;
-      strVal = raw;
-    } else if (arg.type === "ARITH" || arg.type === "NUMBER") {
-      const n = evalArithExpr(arg, row);
-      if (isNaN(n)) continue;
-      strVal = String(n);
-    } else {
-      const value = evalScalarValueExprNullable(arg, row);
-      if (value === null) continue;
-      if (value === "" && func !== "MIN" && func !== "MAX") continue;
-      if (typeof value === "number" && Number.isNaN(value)) continue;
-      strVal = String(value);
-    }
-    strValues.push(strVal);
-  }
+  const strValues = aggregateRowValues(func, arg, rows).filter((value) => value !== null);
   const statistical = func === "STDDEV_POP" || func === "STDDEV_SAMP" || func === "VAR_POP" || func === "VAR_SAMP" || func === "MEDIAN";
   const numericValues = statistical ? strValues.map((value) => {
     const numeric = Number(value);
@@ -13296,6 +13403,27 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
     }
   }
 }
+function aggregateRowValues(func, arg, rows) {
+  return rows.map((row) => {
+    let strVal;
+    if (arg.type === "FIELD_REF") {
+      const raw = row[arg.field];
+      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") return null;
+      strVal = raw;
+    } else if (arg.type === "ARITH" || arg.type === "NUMBER") {
+      const n = evalArithExpr(arg, row);
+      if (isNaN(n)) return null;
+      strVal = String(n);
+    } else {
+      const value = evalScalarValueExprNullable(arg, row);
+      if (value === null) return null;
+      if (value === "" && func !== "MIN" && func !== "MAX") return null;
+      if (typeof value === "number" && Number.isNaN(value)) return null;
+      strVal = String(value);
+    }
+    return strVal;
+  });
+}
 function toAggregateFieldRef(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 };
@@ -13526,7 +13654,7 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
   }
   return (name, row) => evaluators.get(name)?.(row);
 }
-function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
+function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind) {
   const windows = columns.filter((column) => column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
   for (const window of windows) {
@@ -13540,6 +13668,10 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
     for (const partition of partitions.values()) {
       const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
+      if (!isRankingWindow(window)) {
+        applyAggregateWindow(window, sortedResult, resolveAggSortKind);
+        continue;
+      }
       let rank = 1;
       let denseRank = 1;
       for (let index = 0; index < sorted.length; index++) {
@@ -13554,6 +13686,53 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
   }
   return rows;
 }
+function applyAggregateWindow(window, 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);
+  const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? syntheticSemantics("string");
+  const output = [];
+  let count = 0;
+  let sum = 0;
+  let best;
+  for (let index = 0; index < sorted.length; index++) {
+    const value = values?.[index] ?? null;
+    if (window.arg.type === "WILDCARD") {
+      count++;
+    } else if (value !== null) {
+      if (window.aggFunc === "COUNT") {
+        count++;
+      } else if (window.aggFunc === "SUM" || window.aggFunc === "AVG") {
+        sum += Number(value);
+        count++;
+      } else if (best === void 0) {
+        best = value;
+      } else {
+        const cmp = compareCanonicalValues(value, best, semantics);
+        if (window.aggFunc === "MAX" && cmp > 0 || window.aggFunc === "MIN" && cmp < 0) {
+          best = value;
+        }
+      }
+    }
+    const result = window.aggFunc === "COUNT" ? count : window.aggFunc === "SUM" ? sum : window.aggFunc === "AVG" ? count === 0 ? 0 : sum / count : best ?? 0;
+    output.push(String(result));
+  }
+  if (window.frame === null) {
+    const finalValue = output[output.length - 1];
+    for (const item of sorted) item.row[window.alias] = finalValue;
+    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];
+      start = end + 1;
+    }
+    return;
+  }
+  for (let index = 0; index < sorted.length; index++) sorted[index].row[window.alias] = output[index];
+}
 function resolveWindowField(row, ref) {
   const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
   return resolveFieldRef(row, name);
@@ -14020,12 +14199,19 @@ function mergeKnownColumns(left, right, rows) {
     ...Object.keys(rows[0] ?? {})
   ])];
 }
-function deriveOutputOrderSemantics(columns) {
+function deriveOutputOrderSemantics(columns, resolveAggSortKind) {
   const result = /* @__PURE__ */ new Map();
   for (const column of columns) {
     if (!("alias" in column) || !column.alias) continue;
-    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       result.set(column.alias, syntheticSemantics("number"));
+    } else if (column.type === "WINDOW_COL") {
+      if (isRankingWindow(column) || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+        result.set(column.alias, syntheticSemantics("number"));
+      } else if (column.arg.type !== "WILDCARD") {
+        const semantics = resolveAggregateArgSemantics(column.arg, resolveAggSortKind) ?? "string";
+        result.set(column.alias, typeof semantics === "string" ? syntheticSemantics(semantics) : semantics);
+      }
     } else if (column.type === "AGGREGATE") {
       if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG" || column.func === "STDDEV_POP" || column.func === "STDDEV_SAMP" || column.func === "VAR_POP" || column.func === "VAR_SAMP" || column.func === "MEDIAN") {
         result.set(column.alias, syntheticSemantics("number"));
@@ -14060,7 +14246,7 @@ function runFullScan(input) {
     resolvedGroupingSpec,
     plainGroupByPlan
   } = input;
-  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
+  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns, aggregateSortKindResolver);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
   let rows = [];
   const mainAlias = stmt.from.alias;
@@ -14116,7 +14302,14 @@ function runFullScan(input) {
   }
   const resolveHavingSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, aggregateSortKindResolver) : havingFieldSemanticsResolver?.(field);
   rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, resolveHavingSemantics);
-  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
+  rows = applyWindow(
+    rows,
+    stmt.columns,
+    optionOrders,
+    sortKinds,
+    effectiveOrderSemantics,
+    aggregateSortKindResolver
+  );
   if (stmt.distinct) {
     rows = applyDistinct(
       rows,
@@ -16601,8 +16794,8 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
           tempTables
         );
         const first = resolvedStmt2.expr.query.columns[0];
-        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
-        if (first?.type === "AGGREGATE" && first.func === "MODE") {
+        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" && (first.windowKind !== "AGGREGATE" || first.aggFunc === "COUNT" || first.aggFunc === "SUM" || first.aggFunc === "AVG") || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
+        if (first?.type === "AGGREGATE" && first.func === "MODE" || first?.type === "WINDOW_COL" && first.windowKind === "AGGREGATE" && (first.aggFunc === "MIN" || first.aggFunc === "MAX")) {
           const meta = (await inferSelectColumnMeta(
             resolvedStmt2.expr.query,
             ["__scalar__"],
@@ -17228,8 +17421,21 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
     if (!("alias" in column) || !column.alias) continue;
     let semantics;
     if (column.type === "FIELD") semantics = rowResolver(aggregateFieldRef(column.field));
-    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       semantics = syntheticSemantics("number");
+    } else if (column.type === "WINDOW_COL") {
+      if (column.windowKind !== "AGGREGATE" || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+        semantics = syntheticSemantics("number");
+      } else if (column.arg.type !== "WILDCARD") {
+        semantics = inferAggregateArgMeta(column.arg, (ref) => {
+          const resolved = rowResolver(ref);
+          return resolved ? {
+            sortKind: resolved.compareMode === "number" || resolved.compareMode === "recordNumber" ? "number" : "string",
+            fieldType: resolved.fieldType,
+            semantics: resolved
+          } : void 0;
+        }).semantics;
+      }
     } else if (column.type === "AGGREGATE") {
       if (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") {
         if (column.arg.type !== "WILDCARD") {
@@ -17591,6 +17797,7 @@ async function validateSelectGroupingPlanning(stmt, client, cacheContext, materi
 function completeInputErrorPrefix(reasons) {
   const reasonList = [...reasons].join(", ");
   const aggregateSubjects = [
+    ["AGGREGATE_WINDOW", "\u96C6\u8A08\u30A6\u30A3\u30F3\u30C9\u30A6\u306E\u6B63\u3057\u3044\u7D50\u679C"],
     ["GROUPING_SETS", "\u5C0F\u8A08\u30FB\u7DCF\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C"],
     ["STATISTICAL_AGGREGATE", "\u7D71\u8A08\u96C6\u7D04\u306E\u6B63\u3057\u3044\u7D50\u679C"],
     ["AGGREGATE", "\u96C6\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C"],
@@ -18504,12 +18711,18 @@ function inferAggregateArgMeta(arg, resolveField2) {
   if (arg.elseResult) results.push(caseResultColumnMeta(arg.elseResult, resolveField2));
   return mergeExpressionColumnMeta(results);
 }
+function inferWindowColumnMeta(column, resolveField2) {
+  if (column.windowKind !== "AGGREGATE" || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+    return syntheticColumnMeta("number");
+  }
+  return column.arg.type === "WILDCARD" ? unknownStringColumnMeta() : inferAggregateArgMeta(column.arg, resolveField2);
+}
 function withDisplayName(meta, displayName) {
   return { ...meta ?? {}, displayName };
 }
 function selectNeedsSourceColumnMeta(stmt) {
   return stmt.columns.some(
-    (column) => column.type === "FIELD" || column.type === "WILDCARD" || column.type === "PARENT_WILDCARD" || column.type === "CASE_COL" || column.type === "AGGREGATE" && (column.func === "MIN" || column.func === "MAX" || column.func === "MODE")
+    (column) => column.type === "FIELD" || column.type === "WILDCARD" || column.type === "PARENT_WILDCARD" || column.type === "CASE_COL" || column.type === "AGGREGATE" && (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") || column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && (column.aggFunc === "MIN" || column.aggFunc === "MAX")
   );
 }
 async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext, materializedTables, forLibraryCapture = false) {
@@ -18615,7 +18828,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
     } else if (column.type === "STRFUNC_COL") {
       meta = stringFunctionColumnMeta(column.expr);
     } else if (column.type === "WINDOW_COL") {
-      meta = syntheticColumnMeta("number");
+      meta = inferWindowColumnMeta(column, resolveField2);
     } else if (column.type === "CASE_COL") {
       const results = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
       if (column.expr.elseResult) results.push(caseResultColumnMeta(column.expr.elseResult, resolveField2));
@@ -19542,8 +19755,10 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     if (!("alias" in column) || !column.alias) continue;
     let meta;
     if (column.type === "FIELD") meta = resolveField2(aggregateFieldRef(column.field));
-    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       meta = syntheticColumnMeta("number");
+    } else if (column.type === "WINDOW_COL") {
+      meta = inferWindowColumnMeta(column, resolveField2);
     } else if (column.type === "GROUPING_COL") {
       meta = syntheticColumnMeta("number");
     } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") meta = syntheticColumnMeta("string");
@@ -23581,6 +23796,20 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       }
     }
   }
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL" || column.windowKind !== "AGGREGATE") continue;
+    const clauses = [];
+    if (column.partitionBy.length > 0) {
+      clauses.push(`PARTITION BY ${column.partitionBy.map(
+        (ref) => ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field
+      ).join(", ")}`);
+    }
+    if (column.orderBy.length > 0) {
+      clauses.push(`ORDER BY ${column.orderBy.map(formatOrderByItem).join(", ")}`);
+    }
+    lines.push(`  window ${column.alias}: ${column.aggFunc} OVER (${clauses.join(" ")})`);
+    lines.push(column.frame === null ? "    frame: PARTITION ENTIRE" : `    frame: ${column.frame.unit} UNBOUNDED PRECEDING AND CURRENT ROW${column.frame.source === "DEFAULT" ? " (\u65E2\u5B9A)" : ""}`);
+  }
   if (totalCountPlan) {
     const baseQuery = stmt.where === null ? "" : whereToKintone(stmt.where);
     lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);