@rex0220/kintone-sql-tools 3.44.0 → 3.46.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 };
 }
@@ -749,7 +752,7 @@ function caseLabel(expr) {
 }
 function stringFuncArgLabel(arg) {
   if (arg.type === "AGG_REF") return aggregateSyntheticName(arg.func, arg.distinct, arg.arg);
-  if (arg.type === "AGG_ARITH") return aggregateOperandLabel(arg);
+  if (arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return aggregateOperandLabel(arg);
   return scalarValueLabel(arg);
 }
 function stringFuncLabel(expr) {
@@ -787,6 +790,8 @@ function aggregateSyntheticName(func, distinct, arg) {
 function aggregateOperandLabel(node) {
   if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "AGG_REF") return aggregateSyntheticName(node.func, node.distinct, node.arg);
+  if (node.type === "AGG_GROUP_KEY") return node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
+  if (node.type === "VARIABLE") return `@${node.name}`;
   return `${aggregateOperandLabel(node.left)}${node.op}${aggregateOperandLabel(node.right)}`;
 }
 
@@ -1065,6 +1070,8 @@ var Parser = class {
     this.cteNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
     this.tempTableRefs = [];
+    /** GROUP BY を読む前に作る B124 候補 leaf の診断位置。AST 公開型へ位置情報を足さない。 */
+    this.aggregateGroupKeyTokens = /* @__PURE__ */ new WeakMap();
     this.allowSelectArithVariable = false;
   }
   // ----------------------------------------------------------
@@ -1318,6 +1325,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("#")) {
@@ -1871,6 +1883,7 @@ var Parser = class {
     if (grouping && orderMode === "KINTONE_NATIVE") {
       throw new ParseError("B65: KORDER BY cannot be combined with grouping sets in Phase1.", this.peek());
     }
+    this.validateAggregateGroupKeyRefs(columns, having, groupBy, grouping);
     return {
       type: "SELECT",
       distinct,
@@ -1957,6 +1970,18 @@ 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.isNonAggregateArithmeticStartWithAggregate()) {
+      throw new ParseError(
+        `\u96C6\u8A08\u7B97\u8853\u5F0F\u306F\u96C6\u8A08\u95A2\u6570\u304B\u3089\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08${this.peek().value}\uFF09\u3002`,
+        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 +2026,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 +2080,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 +2128,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));
@@ -2095,6 +2205,7 @@ var Parser = class {
   }
   stringFuncArgHasAggregate(arg) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+    if (arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return false;
     return this.scalarValueHasAggregate(arg);
   }
   scalarValueHasAggregate(expr) {
@@ -2137,7 +2248,7 @@ var Parser = class {
   parseAggArithMulDiv() {
     return this.continueAggArithMulDiv(this.parseAggPrimary());
   }
-  /** 集計算術式の一次式: 集計関数 / 数値リテラル / 括弧 */
+  /** 集計算術式の一次式: 集計関数 / 数値 / 変数 / GROUP BY キー候補 / 括弧 */
   parseAggPrimary() {
     if (this.consume("(" /* LPAREN */)) {
       const inner = this.continueAggArith(this.parseAggPrimary());
@@ -2154,12 +2265,99 @@ var Parser = class {
       const tok = this.advance();
       return makeNumberLiteral(tok.value);
     }
+    if (this.peek().kind === "VARIABLE" /* VARIABLE */) {
+      const tok = this.advance();
+      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+    }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
-      return this.parseAggregateRef(aggFunc);
+      const ref = this.parseAggregateRef(aggFunc);
+      this.rejectAggregateWindowOutsideSelect();
+      return ref;
+    }
+    if (this.peek().kind === "IDENT" /* IDENT */ || this.peek().kind === "BIDENT" /* BIDENT */) {
+      const tok = this.peek();
+      const parsed = this.parseQualifiedIdent();
+      const ref = {
+        type: "AGG_GROUP_KEY",
+        field: parsed.field,
+        ...parsed.tableAlias ? { tableAlias: parsed.tableAlias } : {}
+      };
+      this.aggregateGroupKeyTokens.set(ref, tok);
+      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());
   }
+  /** B124 Phase 1 はトップレベルの非集計オペランド開始形を明示拒否する。 */
+  isNonAggregateArithmeticStartWithAggregate() {
+    const first = this.peek();
+    if (this.tryAggregateFunc() !== null || first.kind === "CASE" /* CASE */ || first.kind === "IF" /* IF */) return false;
+    if (this.isGroupingFunctionStart()) return false;
+    if (this.tryStringFuncName() !== null) return false;
+    if (!["IDENT" /* IDENT */, "BIDENT" /* BIDENT */, "VARIABLE" /* VARIABLE */, "(" /* LPAREN */].includes(first.kind)) return false;
+    let depth = 0;
+    let sawArithmetic = false;
+    for (let index = this.pos; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (depth === 0 && index > this.pos && (token.kind === "," /* COMMA */ || token.kind === "AS" /* AS */ || token.kind === "FROM" /* FROM */ || token.kind === ";" /* SEMICOLON */ || token.kind === "EOF" /* EOF */ || token.kind === "=" /* EQ */ || token.kind === "!=" /* NEQ */ || token.kind === "<>" /* LT_GT */ || token.kind === ">" /* GT */ || token.kind === "<" /* LT */ || token.kind === ">=" /* GTE */ || token.kind === "<=" /* LTE */ || token.kind === "AND" /* AND */ || token.kind === "OR" /* OR */)) break;
+      if (this.isArithOp(token.kind)) sawArithmetic = true;
+      if (PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[token.kind] !== void 0 && this.tokens[index + 1]?.kind === "(" /* LPAREN */) return sawArithmetic;
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */) {
+        depth--;
+        if (depth < 0) break;
+      }
+    }
+    return false;
+  }
+  /** SELECT ローカルの B124 leaf だけを ordinary GROUP BY の表記と照合する。 */
+  validateAggregateGroupKeyRefs(columns, having, groupBy, grouping) {
+    const refs = [];
+    const visit = (node) => {
+      if (Array.isArray(node)) {
+        node.forEach(visit);
+        return;
+      }
+      if (node === null || typeof node !== "object") return;
+      const value = node;
+      if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+      if (value["type"] === "AGG_GROUP_KEY") {
+        refs.push(node);
+        return;
+      }
+      Object.values(value).forEach(visit);
+    };
+    visit(columns);
+    visit(having);
+    if (refs.length === 0) return;
+    const first = refs[0];
+    const firstToken = this.aggregateGroupKeyTokens.get(first) ?? this.peek();
+    if (grouping !== void 0) {
+      throw new ParseError(
+        "ROLLUP / CUBE / GROUPING SETS \u3067\u306F\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u66F8\u3051\u307E\u305B\u3093\uFF08\u5C0F\u8A08\u30FB\u7DCF\u8A08\u884C\u3067\u5024\u304C\u5B9A\u307E\u3089\u306A\u3044\u305F\u3081\u3067\u3059\uFF09\u3002",
+        firstToken
+      );
+    }
+    if (groupBy.length === 0) {
+      throw new ParseError(
+        `\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u66F8\u304F\u306B\u306F GROUP BY \u304C\u5FC5\u8981\u3067\u3059\uFF08${this.aggregateGroupKeyDisplay(first)}\uFF09\u3002`,
+        firstToken
+      );
+    }
+    const ordinaryNames = new Set(groupBy.filter((key) => key.type === "FIELD_NAME").map((key) => key.name));
+    for (const ref of refs) {
+      const display = this.aggregateGroupKeyDisplay(ref);
+      if (!ordinaryNames.has(display)) {
+        throw new ParseError(
+          `\u96C6\u8A08\u7B97\u8853\u5F0F\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u306F GROUP BY \u306B\u66F8\u3044\u305F\u8868\u8A18\u3068\u4E00\u81F4\u3059\u308B\u5217\u3060\u3051\u3067\u3059\uFF08${display}\uFF09\u3002\u30B0\u30EB\u30FC\u30D7\u5185\u3067\u5024\u304C\u5B9A\u307E\u3089\u306A\u3044\u305F\u3081\u3067\u3059\u3002`,
+          this.aggregateGroupKeyTokens.get(ref) ?? firstToken
+        );
+      }
+    }
+  }
+  aggregateGroupKeyDisplay(ref) {
+    return ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+  }
   // ──────────────────────────────────────────────────
   // 汎用スカラー値式パーサー（B38）
   // ──────────────────────────────────────────────────
@@ -2405,7 +2603,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 });
@@ -2905,6 +3105,12 @@ var Parser = class {
   // - 集計関数（HAVING のみ）: COUNT(*) / SUM(f) ...
   // - 通常フィールド参照: [alias.]field
   parseFieldValue() {
+    if (this.groupingFieldContext === "HAVING" && this.isNonAggregateArithmeticStartWithAggregate()) {
+      throw new ParseError(
+        `\u96C6\u8A08\u7B97\u8853\u5F0F\u306F\u96C6\u8A08\u95A2\u6570\u304B\u3089\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08${this.peek().value}\uFF09\u3002`,
+        this.peek()
+      );
+    }
     if (this.isUnsupportedGroupingIdStart()) {
       throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
     }
@@ -2930,6 +3136,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 +3595,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 +4128,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 +4648,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));
@@ -5688,7 +5914,7 @@ function collectStringFuncFields(expr, out) {
   }
 }
 function collectStringFuncArgFields(arg, out) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") {
     collectAggOperandFields(arg, out);
     return;
   }
@@ -5734,6 +5960,9 @@ function collectAggOperandFields(node, out) {
     collectAggOperandFields(node.left, out);
     collectAggOperandFields(node.right, out);
   }
+  if (node.type === "AGG_GROUP_KEY") {
+    out.push(normalizeSimpleFieldRef(node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field));
+  }
 }
 function collectAggregateArgFields(node, out) {
   if (node.type === "FIELD_REF" || node.type === "ARITH") collectArithNode(node, out);
@@ -5742,6 +5971,7 @@ function collectAggregateArgFields(node, out) {
 function hasAggregateInStringFuncExpr(expr) {
   return expr.args.some((arg) => {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+    if (arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return false;
     return scalarValueHasAggregate(arg);
   });
 }
@@ -5929,9 +6159,12 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       walkAgg(node.left, phase);
       walkAgg(node.right, phase);
     }
+    if (node.type === "AGG_GROUP_KEY") {
+      addFieldRef(node.field, node.tableAlias ?? null, phase);
+    }
   };
   const walkStringArg = (arg, phase = "select") => {
-    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") {
       walkAgg(arg, phase);
       return;
     }
@@ -6104,6 +6337,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;
@@ -8029,7 +8265,7 @@ function formatWithComma(num, digits) {
   return decStr ? `${intFmt}.${decStr}` : intFmt;
 }
 function evalStringFuncArg(arg, row, resolveFieldType, resolveFieldSemantics2) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY") {
     return String(evalMaterializedAggregateOperand(arg, row));
   }
   if (arg.type === "NUMBER") return numberLiteralText(arg);
@@ -8040,6 +8276,13 @@ function evalMaterializedAggregateOperand(node, row) {
   if (node.type === "AGG_REF") {
     return row[aggregateSyntheticName(node.func, node.distinct, node.arg)] ?? "";
   }
+  if (node.type === "AGG_GROUP_KEY") {
+    const field = node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
+    return Number(resolveFieldRef(row, field));
+  }
+  if (node.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved aggregate arithmetic variable @${node.name}.`);
+  }
   const left = Number(evalMaterializedAggregateOperand(node.left, row));
   const right = Number(evalMaterializedAggregateOperand(node.right, row));
   switch (node.op) {
@@ -8541,7 +8784,7 @@ function collectStringFuncFields2(expr, out) {
   for (const arg of expr.args) collectStringFuncArgFields2(arg, out);
 }
 function collectStringFuncArgFields2(arg, out) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") {
     collectAggOperandFields2(arg, out);
     return;
   }
@@ -8572,6 +8815,7 @@ function collectAggOperandFields2(node, out) {
     collectAggOperandFields2(node.left, out);
     collectAggOperandFields2(node.right, out);
   }
+  if (node.type === "AGG_GROUP_KEY") out.add(node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field);
 }
 function collectAggregateArgFields2(node, out) {
   if (node.type === "FIELD_REF" || node.type === "ARITH") collectArithNode2(node, out);
@@ -11076,7 +11320,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 +13443,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 +13521,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 };
@@ -13303,6 +13549,13 @@ function toAggregateFieldRef(field) {
 function evalAggArithExpr(node, rows, resolveAggSortKind) {
   if (node.type === "NUMBER") return node.value;
   if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
+  if (node.type === "AGG_GROUP_KEY") {
+    const field = node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
+    return Number(resolveFieldRef(rows[0] ?? {}, field));
+  }
+  if (node.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved aggregate arithmetic variable @${node.name}.`);
+  }
   const l = evalAggArithExpr(node.left, rows, resolveAggSortKind);
   const r = evalAggArithExpr(node.right, rows, resolveAggSortKind);
   switch (node.op) {
@@ -13526,7 +13779,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 +13793,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 +13811,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);
@@ -13890,7 +14194,8 @@ function arithColDefaultKey(expr) {
 }
 function stringFuncDefaultKey(expr) {
   const argStrs = expr.args.map((a) => {
-    if (a.type === "AGG_REF" || a.type === "AGG_ARITH") return aggArithDefaultKey(a);
+    if (a.type === "AGG_REF" || a.type === "AGG_ARITH" || a.type === "AGG_GROUP_KEY") return aggArithDefaultKey(a);
+    if (a.type === "VARIABLE") return `@${a.name}`;
     return scalarValueDefaultKey(a);
   });
   return `${expr.func}(${argStrs.join(",")})`;
@@ -13917,6 +14222,7 @@ function scalarValueDefaultKey(expr) {
 }
 function hasAggregateInStringFuncArg(arg) {
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+  if (arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return false;
   return scalarValueHasAggregate2(arg);
 }
 function scalarValueHasAggregate2(expr) {
@@ -13946,6 +14252,13 @@ function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
     const value = evalAggArithExpr(arg, rows, resolveAggSortKind);
     return { type: "NUMBER", value, raw: String(value) };
   }
+  if (arg.type === "AGG_GROUP_KEY") {
+    const field = arg.tableAlias ? `${arg.tableAlias}.${arg.field}` : arg.field;
+    return { type: "NUMBER", value: Number(resolveFieldRef(rows[0] ?? {}, field)), raw: resolveFieldRef(rows[0] ?? {}, field) };
+  }
+  if (arg.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved aggregate arithmetic variable @${arg.name}.`);
+  }
   if (arg.type === "STRING_FUNC") {
     return resolveAggInStringFuncExpr(arg, rows, resolveAggSortKind);
   }
@@ -14020,12 +14333,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 +14380,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 +14436,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 +16928,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__"],
@@ -16924,7 +17251,15 @@ function resolveBatchVariableReferencesInternal(node, variables, numericArithmet
           `ArgumentError: variable @${obj["name"]} is not numeric and cannot be used in arithmetic.`
         );
       }
-      return numericArithmeticOperand && value.type === "string" && value.placeholder === true ? { type: "NUMBER", value: 0, raw: value.value } : value.type === "number" ? { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) } : { type: "STRING", value: value.value };
+      return numericArithmeticOperand && value.type === "string" && value.placeholder === true ? {
+        type: "NUMBER",
+        value: 0,
+        raw: numericArithmeticOperand === "AGG_ARITH" ? `@${obj["name"]}` : value.value
+      } : value.type === "number" ? {
+        type: "NUMBER",
+        value: value.value,
+        raw: numericArithmeticOperand === "AGG_ARITH" ? `@${obj["name"]}` : value.raw ?? String(value.value)
+      } : { type: "STRING", value: value.value };
     }
     if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
       const value = variables.get(obj["name"]);
@@ -16943,7 +17278,7 @@ function resolveBatchVariableReferencesInternal(node, variables, numericArithmet
         resolveBatchVariableReferencesInternal(
           value,
           variables,
-          (obj["type"] === "ARITH" || obj["type"] === "SCALAR_ARITH" || obj["type"] === "AGG_ARITH") && (key === "left" || key === "right")
+          key === "left" || key === "right" ? obj["type"] === "AGG_ARITH" ? "AGG_ARITH" : obj["type"] === "ARITH" || obj["type"] === "SCALAR_ARITH" ? "ARITH" : false : false
         )
       ])
     );
@@ -17228,8 +17563,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 +17939,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"],
@@ -17646,6 +17995,8 @@ function arithHasFieldRef(node) {
   return false;
 }
 function stringFuncArgHasFieldRef(arg) {
+  if (arg.type === "AGG_GROUP_KEY") return true;
+  if (arg.type === "VARIABLE") return false;
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
   return scalarValueHasFieldRef(arg);
 }
@@ -18203,7 +18554,11 @@ function collectAggregateArgFieldRefs(arg, out) {
   }
   if (arg.type === "STRING_FUNC") {
     for (const child of arg.args) {
-      if (child.type !== "AGG_REF" && child.type !== "AGG_ARITH") collectAggregateArgFieldRefs(child, out);
+      if (child.type === "AGG_GROUP_KEY") {
+        out.push({ type: "FIELD", tableAlias: child.tableAlias ?? null, field: child.field });
+      } else if (child.type !== "AGG_REF" && child.type !== "AGG_ARITH" && child.type !== "VARIABLE") {
+        collectAggregateArgFieldRefs(child, out);
+      }
     }
     return;
   }
@@ -18223,11 +18578,16 @@ function collectAggregateOperandRefs(node, out) {
     collectAggregateOperandRefs(node.left, out);
     collectAggregateOperandRefs(node.right, out);
   }
+  if (node.type === "AGG_GROUP_KEY") out.push({ type: "FIELD", tableAlias: node.tableAlias ?? null, field: node.field });
 }
 function collectStringFuncAggregateRefs(expr, out) {
   for (const arg of expr.args) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
       collectAggregateOperandRefs(arg, out);
+    } else if (arg.type === "AGG_GROUP_KEY") {
+      out.push({ type: "FIELD", tableAlias: arg.tableAlias ?? null, field: arg.field });
+    } else if (arg.type === "VARIABLE") {
+      continue;
     } else {
       collectScalarAggregateRefs(arg, out);
     }
@@ -18504,12 +18864,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 +18981,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 +19908,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 +23949,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})`);
@@ -24187,7 +24569,8 @@ function collectArithNodeRefs(node, out) {
   }
   if (node.type === "STRING_FUNC") {
     for (const arg of node.args) {
-      if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") collectScalarNodeRefs(arg, out);
+      if (arg.type === "AGG_GROUP_KEY") out.add(arg.tableAlias ? `${arg.tableAlias}.${arg.field}` : arg.field);
+      else if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH" && arg.type !== "VARIABLE") collectScalarNodeRefs(arg, out);
     }
   }
 }
@@ -24249,7 +24632,10 @@ function collectScalarNodeRefs(node, out) {
     return;
   }
   if (node.type === "STRING_FUNC") {
-    for (const arg of node.args) if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") collectScalarNodeRefs(arg, out);
+    for (const arg of node.args) {
+      if (arg.type === "AGG_GROUP_KEY") out.add(arg.tableAlias ? `${arg.tableAlias}.${arg.field}` : arg.field);
+      else if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH" && arg.type !== "VARIABLE") collectScalarNodeRefs(arg, out);
+    }
     return;
   }
   if (node.type === "SCALAR_ARITH" || node.type === "CONCAT_OP") {