@rex0220/kintone-sql-tools 3.79.0 → 3.81.0

package/dist-cli/ksql.js

@@ -17726,6 +17726,10 @@ var Parser = class {
     this.scalarAllowsCase = true;
     this.pos = 0;
     this.insideAggregateArg = 0;
+    /** 現在解析中の SELECT リストから切り出した非公開ウィンドウ列。 */
+    this.hiddenWindows = null;
+    this.insideWindowExpression = 0;
+    this.insideWindowContainingSelectExpression = 0;
     /** GROUPING(field) is limited to the explicitly selected query context. */
     this.groupingFieldContext = "FORBIDDEN";
     /** True only while parsing an actual SQL WHERE clause (including nested groups). */
@@ -18612,7 +18616,16 @@ var Parser = class {
   parseSelect(allowKorder = false) {
     this.expect("SELECT" /* SELECT */);
     const distinct = this.consume("DISTINCT" /* DISTINCT */);
-    const columns = this.parseSelectColumns();
+    const previousHiddenWindows = this.hiddenWindows;
+    this.hiddenWindows = [];
+    let columns;
+    let hiddenWindows;
+    try {
+      columns = this.parseSelectColumns();
+      hiddenWindows = this.hiddenWindows;
+    } finally {
+      this.hiddenWindows = previousHiddenWindows;
+    }
     const hasFrom = this.consume("FROM" /* FROM */);
     const from = hasFrom ? this.parseTableRef() : { appId: 0, alias: null, cteName: NO_FROM_CTE_NAME };
     const joins = hasFrom ? this.parseJoins() : [];
@@ -18656,11 +18669,6 @@ var Parser = class {
     }
     const limit = this.consume("LIMIT" /* LIMIT */) ? this.parseUnsignedInt() : null;
     const offset = this.consume("OFFSET" /* OFFSET */) ? this.parseUnsignedInt() : null;
-    const hasWindow = columns.some((column) => column.type === "WINDOW_COL");
-    const hasAggregate = columns.some((column) => this.selectColumnHasAggregate(column));
-    if (hasWindow && (groupBy.length > 0 || grouping !== void 0 || hasAggregate)) {
-      throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F GROUP BY / \u96C6\u8A08\u95A2\u6570\u3068\u540C\u3058 SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
-    }
     if (grouping && orderMode === "KINTONE_NATIVE") {
       throw new ParseError("B65: KORDER BY cannot be combined with grouping sets in Phase1.", this.peek());
     }
@@ -18669,6 +18677,7 @@ var Parser = class {
       type: "SELECT",
       distinct,
       columns,
+      ...hiddenWindows.length > 0 ? { hiddenWindows } : {},
       from,
       joins,
       where,
@@ -18928,16 +18937,34 @@ 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.startsWithWindowFunction() && this.leadingFunctionArgumentContainsOver()) {
+      throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, this.peek());
+    }
+    if (this.hasNestedAggregateWindowInSelectColumn() && !this.startsWithStandaloneWindowColumn()) {
+      this.insideWindowContainingSelectExpression++;
+      let expr;
+      try {
+        expr = this.parseScalarValueExpr({ allowCase: true, allowAggregateArgs: true });
+      } finally {
+        this.insideWindowContainingSelectExpression--;
+      }
+      const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
+      if (expr.type === "CASE_WHEN") {
+        return this.withAliasDisplay({ type: "CASE_COL", expr, alias: parsedAlias2?.alias ?? null }, parsedAlias2);
+      }
+      if (expr.type === "STRING_FUNC") {
+        return this.withAliasDisplay({ type: "STRFUNC_COL", expr, alias: parsedAlias2?.alias ?? null }, parsedAlias2);
+      }
+      return this.withAliasDisplay({
+        type: "SCALAR_VALUE_COL",
+        expr,
+        alias: parsedAlias2?.alias ?? null
+      }, parsedAlias2);
+    }
     const valueWindowFunc = this.tryValueWindowFunc();
     if (valueWindowFunc !== null) {
       return this.parseValueWindowColumn(valueWindowFunc);
     }
-    if (this.tryAggregateFunc() === null && this.hasNestedAggregateWindowInSelectColumn()) {
-      throw new ParseError(
-        WINDOW_RESULT_IN_EXPRESSION_MESSAGE,
-        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`,
@@ -18993,10 +19020,13 @@ var Parser = class {
     }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
-      const ref = this.parseAggregateRef(aggFunc);
+      const ref = this.parseAggregateRef(aggFunc, true);
       if (this.isSoftKeyword("OVER")) {
         return this.parseAggregateWindowColumn(ref);
       }
+      if (ref.arg.type === "FIELD" && ref.arg.aggregateRef !== void 0) {
+        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());
+      }
       if (this.isArithOp(this.peek().kind)) {
         const expr = this.continueAggArith(ref);
         const parsedAlias3 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -19081,13 +19111,137 @@ var Parser = class {
           }
         }
       }
+      if (PARSER_WINDOW_FUNCTION_TOKEN_MAP[token.kind] !== void 0 && this.tokens[index + 1]?.kind === "(" /* LPAREN */) {
+        let windowDepth = 0;
+        for (let cursor = index + 1; cursor < this.tokens.length; cursor++) {
+          const candidate = this.tokens[cursor];
+          if (candidate.kind === "(" /* LPAREN */) windowDepth++;
+          else if (candidate.kind === ")" /* RPAREN */ && --windowDepth === 0) {
+            const next = this.tokens[cursor + 1];
+            if (next?.kind === "IDENT" /* IDENT */ && next.value.toUpperCase() === "OVER") return true;
+            break;
+          }
+        }
+      }
       if (this.tryValueWindowFunc(index) !== null) return true;
       if (token.kind === "(" /* LPAREN */) depth++;
       else if (token.kind === ")" /* RPAREN */) depth--;
     }
     return false;
   }
-  parseWindowColumn(func) {
+  /** 先頭の window が SELECT 列全体を占める従来の公開 WINDOW_COL か。 */
+  startsWithStandaloneWindowColumn() {
+    const valueWindow = this.tryValueWindowFunc();
+    const rankingWindow = this.tryWindowFunc();
+    const aggregateWindow = this.tryAggregateFunc();
+    if (valueWindow === null && rankingWindow === null && aggregateWindow === null) return false;
+    let depth = 0;
+    let functionClose = -1;
+    for (let index = this.pos + 1; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */ && --depth === 0) {
+        functionClose = index;
+        break;
+      }
+    }
+    const overIndex = functionClose + 1;
+    if (functionClose < 0 || this.tokens[overIndex]?.kind !== "IDENT" /* IDENT */ || this.tokens[overIndex].value.toUpperCase() !== "OVER") return false;
+    if (overIndex < 0 || this.tokens[overIndex + 1]?.kind !== "(" /* LPAREN */) return false;
+    depth = 0;
+    for (let index = overIndex + 1; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */ && --depth === 0) {
+        const next = this.tokens[index + 1]?.kind;
+        return next === "AS" /* AS */ || next === "," /* COMMA */ || next === "FROM" /* FROM */ || next === ";" /* SEMICOLON */ || next === "EOF" /* EOF */;
+      }
+    }
+    return false;
+  }
+  startsWithWindowFunction() {
+    if (this.tryValueWindowFunc() !== null || this.tryWindowFunc() !== null) return true;
+    if (this.tryAggregateFunc() === null) return false;
+    let depth = 0;
+    for (let index = this.pos + 1; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */ && --depth === 0) {
+        const next = this.tokens[index + 1];
+        return next?.kind === "IDENT" /* IDENT */ && next.value.toUpperCase() === "OVER";
+      }
+    }
+    return false;
+  }
+  leadingFunctionArgumentContainsOver() {
+    let depth = 0;
+    for (let index = this.pos + 1; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */ && --depth === 0) return false;
+      if (depth > 0 && token.kind === "IDENT" /* IDENT */ && token.value.toUpperCase() === "OVER") return true;
+    }
+    return false;
+  }
+  registerHiddenWindow(window) {
+    if (this.hiddenWindows === null) {
+      throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, this.peek());
+    }
+    const canonical = JSON.stringify({ ...window, alias: "" });
+    const existing = this.hiddenWindows.find(
+      (candidate) => JSON.stringify({ ...candidate, alias: "" }) === canonical
+    );
+    if (existing) return existing.alias;
+    const alias = `__ksql_window_${this.hiddenWindows.length}`;
+    this.hiddenWindows.push({ ...window, alias });
+    return alias;
+  }
+  parseHiddenWindowReference() {
+    if (this.hiddenWindows === null) return null;
+    const valueFunc = this.tryValueWindowFunc();
+    const rankingFunc = this.tryWindowFunc();
+    const aggregateFunc = this.tryAggregateFunc();
+    if (valueFunc === null && rankingFunc === null && aggregateFunc === null) return null;
+    if (this.insideWindowExpression > 0) {
+      throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, this.peek());
+    }
+    let argumentDepth = 0;
+    for (let index = this.pos + 1; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (token.kind === "(" /* LPAREN */) argumentDepth++;
+      else if (token.kind === ")" /* RPAREN */ && --argumentDepth === 0) break;
+      if (argumentDepth > 0 && token.kind === "IDENT" /* IDENT */ && token.value.toUpperCase() === "OVER") {
+        throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, token);
+      }
+    }
+    const startPos = this.pos;
+    this.insideWindowExpression++;
+    try {
+      let window;
+      if (valueFunc !== null) {
+        window = this.parseValueWindowColumn(valueFunc, "");
+      } else if (rankingFunc !== null) {
+        window = this.parseWindowColumn(rankingFunc, "");
+      } else {
+        const ref = this.parseAggregateRef(aggregateFunc, true);
+        if (!this.isSoftKeyword("OVER")) {
+          this.pos = startPos;
+          return null;
+        }
+        window = this.parseAggregateWindowColumn(ref, "");
+      }
+      const field = this.registerHiddenWindow(window);
+      return { type: "FIELD", tableAlias: null, field, hiddenWindowRef: true };
+    } finally {
+      this.insideWindowExpression--;
+    }
+  }
+  parseWindowPartitionKey() {
+    if (this.isGroupingFunctionStart()) return this.parseGroupingRef();
+    const ref = this.parseQualifiedIdent();
+    return { type: "FIELD", tableAlias: ref.tableAlias, field: ref.field };
+  }
+  parseWindowColumn(func, hiddenAlias) {
     this.advance();
     this.expect("(" /* LPAREN */);
     if (this.peek().kind !== ")" /* RPAREN */) {
@@ -19101,22 +19255,33 @@ var Parser = class {
       this.advance();
       this.expect("BY" /* BY */, "PARTITION \u306E\u5F8C\u306B\u306F BY \u304C\u5FC5\u8981\u3067\u3059");
       do {
-        const ref = this.parseQualifiedIdent();
-        partitionBy.push({ type: "FIELD", tableAlias: ref.tableAlias, field: ref.field });
+        partitionBy.push(this.parseWindowPartitionKey());
       } while (this.consume("," /* COMMA */));
     }
-    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy(false)) : [];
+    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy()) : [];
     this.expect(")" /* RPAREN */);
+    if (hiddenAlias !== void 0) {
+      return { type: "WINDOW_COL", func, partitionBy, orderBy, alias: hiddenAlias };
+    }
     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", func, partitionBy, orderBy, alias: parsedAlias.alias }, parsedAlias);
   }
-  parseValueWindowColumn(valueFunc) {
+  parseValueWindowColumn(valueFunc, hiddenAlias) {
     this.advance();
     this.expect("(" /* LPAREN */);
-    const arg = this.parseScalarValueExpr({ allowCase: true, allowAggregateArgs: false });
+    const aggregateFunc = this.tryAggregateFunc();
+    const arg = aggregateFunc === null ? this.parseScalarValueExpr({ allowCase: true, allowAggregateArgs: false }) : (() => {
+      const ref = this.parseAggregateRef(aggregateFunc);
+      return {
+        type: "FIELD",
+        tableAlias: null,
+        field: aggregateSyntheticName(ref.func, ref.distinct, ref.arg),
+        aggregateRef: ref
+      };
+    })();
     let offset = 1;
     if (this.consume("," /* COMMA */)) {
       const token = this.expect("NUMBER" /* NUMBER */, `${valueFunc} \u306E offset \u306F\u975E\u8CA0\u306E\u6574\u6570\u30EA\u30C6\u30E9\u30EB\u3060\u3051\u3067\u3059`);
@@ -19133,19 +19298,30 @@ var Parser = class {
       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 });
+        partitionBy.push(this.parseWindowPartitionKey());
       } while (this.consume("," /* COMMA */));
     }
     if (!this.consume("ORDER" /* ORDER */)) {
       throw new ParseError(`${valueFunc} \u306E OVER \u306B\u306F ORDER BY \u304C\u5FC5\u8981\u3067\u3059`, this.peek());
     }
     this.expect("BY" /* BY */);
-    const orderBy = this.parseOrderBy(false);
+    const orderBy = this.parseOrderBy();
     this.expect(")" /* RPAREN */);
-    if (this.isArithOp(this.peek().kind) || this.peek().kind === "||" /* CONCAT_OP */) {
+    if (hiddenAlias === void 0 && (this.isArithOp(this.peek().kind) || this.peek().kind === "||" /* CONCAT_OP */)) {
       throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, this.peek());
     }
+    if (hiddenAlias !== void 0) {
+      return {
+        type: "WINDOW_COL",
+        windowKind: "VALUE",
+        valueFunc,
+        arg,
+        offset,
+        partitionBy,
+        orderBy,
+        alias: hiddenAlias
+      };
+    }
     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());
     }
@@ -19161,7 +19337,7 @@ var Parser = class {
       alias: parsedAlias.alias
     }, parsedAlias);
   }
-  parseAggregateWindowColumn(ref) {
+  parseAggregateWindowColumn(ref, hiddenAlias) {
     const supported = /* @__PURE__ */ new Set(["SUM", "COUNT", "AVG", "MIN", "MAX"]);
     if (!supported.has(ref.func)) {
       throw new ParseError(
@@ -19179,11 +19355,10 @@ var Parser = class {
       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 });
+        partitionBy.push(this.parseWindowPartitionKey());
       } while (this.consume("," /* COMMA */));
     }
-    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy(false)) : [];
+    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy()) : [];
     let frame = orderBy.length > 0 ? { unit: "RANGE", source: "DEFAULT" } : null;
     if (this.isSoftKeyword("ROWS") || this.isSoftKeyword("RANGE")) {
       if (orderBy.length === 0) {
@@ -19200,12 +19375,24 @@ var Parser = class {
       frame = { unit, source: "EXPLICIT" };
     }
     this.expect(")" /* RPAREN */);
-    if (this.isArithOp(this.peek().kind)) {
+    if (hiddenAlias === void 0 && this.isArithOp(this.peek().kind)) {
       throw new ParseError(
         WINDOW_RESULT_IN_EXPRESSION_MESSAGE,
         this.peek()
       );
     }
+    if (hiddenAlias !== void 0) {
+      return {
+        type: "WINDOW_COL",
+        windowKind: "AGGREGATE",
+        aggFunc: ref.func,
+        arg: ref.arg,
+        frame,
+        partitionBy,
+        orderBy,
+        alias: hiddenAlias
+      };
+    }
     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());
     }
@@ -19431,6 +19618,8 @@ var Parser = class {
   }
   parseScalarPrimary(allowCase) {
     const tok = this.peek();
+    const hiddenWindow = this.parseHiddenWindowReference();
+    if (hiddenWindow) return hiddenWindow;
     if (tok.kind === "(" /* LPAREN */) {
       if (this.peekAt(1).kind === "SELECT" /* SELECT */) throw new ParseError("\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u306B\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
       this.advance();
@@ -19464,9 +19653,18 @@ var Parser = class {
     }
     if (tok.kind === "CASE" /* CASE */) {
       if (!allowCase) throw new ParseError("\u3053\u306E\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u3067\u306F CASE \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
-      return this.parseCaseWhenExpr();
+      return this.parseCaseWhenExpr(this.hiddenWindows !== null);
     }
     if (this.tryAggregateFunc() !== null) {
+      if (this.scalarAllowsAggregateArgs && this.insideWindowContainingSelectExpression > 0) {
+        const ref = this.parseAggregateRef(this.tryAggregateFunc(), true);
+        return {
+          type: "FIELD",
+          tableAlias: null,
+          field: aggregateSyntheticName(ref.func, ref.distinct, ref.arg),
+          aggregateRef: ref
+        };
+      }
       throw new ParseError(
         this.insideAggregateArg > 0 ? "\u96C6\u8A08\u95A2\u6570\u306E\u5F15\u6570\u5185\u306B\u96C6\u8A08\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093" : "\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u306B\u96C6\u7D04\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
         tok
@@ -19531,6 +19729,10 @@ var Parser = class {
     return left;
   }
   parseArithPrimary() {
+    const hiddenWindow = this.parseHiddenWindowReference();
+    if (hiddenWindow) {
+      return { type: "FIELD_REF", field: hiddenWindow.field, hiddenWindowRef: true };
+    }
     if (this.consume("(" /* LPAREN */)) {
       const expr = this.parseArithAddSub();
       this.expect(")" /* RPAREN */);
@@ -19628,6 +19830,7 @@ var Parser = class {
   /** THEN / ELSE の結果値。`||` を含む場合だけ新スカラー文法へ渡す。 */
   parseCaseResult(allowAggregateResult = false) {
     const tok = this.peek();
+    if (this.hiddenWindows !== null && this.startsWithWindowFunction()) return this.parseArithAddSub();
     if (this.insideAggregateArg > 0 && this.tryAggregateFunc() !== null) {
       throw new ParseError("\u96C6\u8A08\u95A2\u6570\u306E\u5F15\u6570\u5185\u306B\u96C6\u8A08\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
     }
@@ -19759,6 +19962,9 @@ var Parser = class {
   }
   /** 文字列関数の引数: ScalarValueExpr / 集計算術式 */
   parseStringFuncArg() {
+    if (this.insideWindowContainingSelectExpression > 0) {
+      return this.parseScalarAddSubConcat(this.scalarAllowsCase);
+    }
     if (this.scalarAllowsAggregateArgs) {
       const startPos = this.pos;
       try {
@@ -19782,7 +19988,7 @@ var Parser = class {
     return PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
   /** 集計関数参照を読む。SELECT 列の alias は呼び出し側で式全体の後に処理する。 */
-  parseAggregateRef(func) {
+  parseAggregateRef(func, allowMaterializedAggregateArg = false) {
     this.advance();
     this.expect("(" /* LPAREN */);
     const distinct = this.consume("DISTINCT" /* DISTINCT */);
@@ -19791,7 +19997,15 @@ var Parser = class {
       throw new ParseError("MODE \u3067\u306F DISTINCT \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", distinctToken);
     }
     let arg;
-    if (this.consume("*" /* STAR */)) {
+    if (allowMaterializedAggregateArg && this.tryAggregateFunc() !== null) {
+      const nested = this.parseAggregateRef(this.tryAggregateFunc());
+      arg = {
+        type: "FIELD",
+        tableAlias: null,
+        field: aggregateSyntheticName(nested.func, nested.distinct, nested.arg),
+        aggregateRef: nested
+      };
+    } else if (this.consume("*" /* STAR */)) {
       if (!aggregateAcceptsWildcard(func)) {
         throw new ParseError(`${func}(*) \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u30D5\u30A3\u30FC\u30EB\u30C9\u307E\u305F\u306F\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044`, this.prev());
       }
@@ -20180,6 +20394,20 @@ var Parser = class {
   // - 集計関数（HAVING のみ）: COUNT(*) / SUM(f) ...
   // - 通常フィールド参照: [alias.]field
   parseFieldValue() {
+    const hiddenWindow = this.parseHiddenWindowReference();
+    if (hiddenWindow) {
+      if (this.isArithOp(this.peek().kind)) {
+        return {
+          type: "ARITH_FIELD",
+          expr: this.continueArith({
+            type: "FIELD_REF",
+            field: hiddenWindow.field,
+            hiddenWindowRef: true
+          })
+        };
+      }
+      return hiddenWindow;
+    }
     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`,
@@ -20683,7 +20911,14 @@ var Parser = class {
       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());
+        throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, this.peek());
+      }
+      if (!this.isArithOp(this.peek().kind)) {
+        return {
+          type: "FIELD_NAME",
+          name: aggregateSyntheticName(ref.func, ref.distinct, ref.arg),
+          aggregateRef: ref
+        };
       }
       this.pos = start;
       void ref;
@@ -21460,7 +21695,7 @@ var Parser = class {
   }
   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());
+      throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, this.peek());
     }
   }
   validateUpdateFromAssignments(assignments, sourceAlias, tok) {
@@ -21779,6 +22014,9 @@ var Parser = class {
     }
     const digitPrefixed = this.tryParseDigitPrefixedIdentifier();
     if (digitPrefixed !== null) return digitPrefixed;
+    if (this.startsWithWindowFunction()) {
+      throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, tok);
+    }
     throw new ParseError(
       "\u30D5\u30A3\u30FC\u30EB\u30C9\u540D\u307E\u305F\u306F\u30C6\u30FC\u30D6\u30EB\u540D\u304C\u5FC5\u8981\u3067\u3059",
       tok
@@ -21995,7 +22233,7 @@ function selectCompleteInputReasons(stmt) {
   if (grouping.type === "PLAIN") reasons.add("GROUP_BY");
   if (stmt.distinct) reasons.add("DISTINCT");
   if (stmt.orderBy.length > 0) reasons.add("LOCAL_ORDER");
-  for (const column of stmt.columns) {
+  for (const column of [...stmt.columns, ...stmt.hiddenWindows ?? []]) {
     if (column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE") {
       reasons.add("AGGREGATE_WINDOW");
     } else if (column.type === "WINDOW_COL" && column.orderBy.length > 0) {
@@ -23215,6 +23453,7 @@ function walkDependency(node, context) {
     return;
   }
   const value = node;
+  if (value["hiddenWindowRef"] === true) return;
   if (isQueryBoundary(value) || isAggregateBoundary(value) || isWindowBoundary(value)) return;
   if (value["type"] === "GROUPING_REF" || value["type"] === "GROUPING_FIELD" || value["type"] === "GROUPING_COL" || value["type"] === "GROUPING_KEY") return;
   if (value["type"] === "WILDCARD" || value["type"] === "PARENT_WILDCARD") {
@@ -23255,8 +23494,24 @@ function walkDependency(node, context) {
 }
 function validateAggregateDependencies(stmt, policy) {
   const aliases = aliasesByName(stmt.columns);
-  for (const column of stmt.columns) {
-    if (column.type === "WINDOW_COL") continue;
+  for (const column of [...stmt.columns, ...stmt.hiddenWindows ?? []]) {
+    if (column.type === "WINDOW_COL") {
+      const windowExpressions = [
+        ...column.partitionBy,
+        ...column.orderBy.map((order) => order.key.type === "FIELD_NAME" ? order.key.aggregateRef ?? refFromName(order.key.name) : order.key),
+        ...column.windowKind === "AGGREGATE" || column.windowKind === "VALUE" ? [column.arg] : []
+      ];
+      for (const expression of windowExpressions) {
+        walkDependency(expression, {
+          clause: "ORDER BY",
+          expression,
+          policy,
+          aliases,
+          resolvingAliases: /* @__PURE__ */ new Set()
+        });
+      }
+      continue;
+    }
     walkDependency(column, {
       clause: "SELECT",
       expression: column,
@@ -23440,7 +23695,7 @@ function validateGroupingStatic(stmt) {
   const normalized = normalizeGroupingSpec(stmt);
   const groupingRefs = [];
   for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
+    collectGroupingRefs(column, groupingRefs);
   }
   collectGroupingRefs(stmt.having, groupingRefs);
   collectGroupingRefs(stmt.orderBy, groupingRefs);
@@ -23449,9 +23704,6 @@ function validateGroupingStatic(stmt) {
   collectGroupingRefs(stmt.joins, forbiddenGroupingRefs);
   collectAggregateArgumentGroupingRefs(stmt.columns, forbiddenGroupingRefs);
   collectAggregateArgumentGroupingRefs(stmt.having, forbiddenGroupingRefs);
-  for (const column of stmt.columns) {
-    if (column.type === "WINDOW_COL") collectGroupingRefs(column, forbiddenGroupingRefs);
-  }
   if (forbiddenGroupingRefs.length > 0) {
     throw new Error(
       "ArgumentError: GROUPING() is not allowed in WHERE, JOIN, window, aggregate arguments, or DML expressions."
@@ -23467,9 +23719,6 @@ function validateGroupingStatic(stmt) {
   if (stmt.orderMode === "KINTONE_NATIVE") {
     throw new Error("ArgumentError: KORDER BY is not supported with extended grouping.");
   }
-  if (stmt.columns.some((column) => column.type === "WINDOW_COL")) {
-    throw new Error("ArgumentError: window functions are not supported with extended grouping.");
-  }
   if (stmt.columns.some(
     (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
   )) {
@@ -23483,7 +23732,7 @@ function validateGroupingPlanning(stmt, resolve3, planningGuardHook = () => void
   const normalized = normalizeGroupingSpec(stmt);
   const groupingRefs = [];
   for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
+    collectGroupingRefs(column, groupingRefs);
   }
   collectGroupingRefs(stmt.having, groupingRefs);
   collectGroupingRefs(stmt.orderBy, groupingRefs);
@@ -23544,7 +23793,7 @@ function resolveSelectMode(stmt) {
   if (stmt.joins.length > 0) return "FULL_SCAN";
   if (normalizeGroupingSpec(stmt).type !== "NONE") return "FULL_SCAN";
   if (stmt.distinct) return "FULL_SCAN";
-  if (hasWindowColumns(stmt.columns)) return "FULL_SCAN";
+  if (hasWindowColumns(stmt.columns) || (stmt.hiddenWindows?.length ?? 0) > 0) return "FULL_SCAN";
   if (stmt.columns.some(
     (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "SCALAR_SUBQUERY_COL" || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(c.expr)
   )) return "FULL_SCAN";
@@ -23784,6 +24033,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
     }
   }
   const selectAliases = collectSelectOutputNames(stmt.columns);
+  const windowMaterializedAliases = collectAggregateMaterializedNames(stmt.columns);
   const markAll = (table) => {
     const st = states.get(table);
     if (!st) return;
@@ -23896,6 +24146,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       );
     }
     if (node.type === "FIELD_REF") {
+      if (node.hiddenWindowRef) return;
       addFieldName(node.field, phase);
       return;
     }
@@ -23934,6 +24185,11 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
   };
   const walkScalar = (expr, phase = "select") => {
     if (expr.type === "FIELD") {
+      if (expr.hiddenWindowRef) return;
+      if (expr.aggregateRef) {
+        walkAgg(expr.aggregateRef, phase);
+        return;
+      }
       addFieldRef(expr.field, expr.tableAlias, phase);
       return;
     }
@@ -24046,6 +24302,10 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
   };
   const walkOrderByKey = (k, phase = "orderBy") => {
     if (k.type === "FIELD_NAME") {
+      if (k.aggregateRef) {
+        walkAgg(k.aggregateRef, phase);
+        return;
+      }
       addFieldName(k.name, phase);
       return;
     }
@@ -24058,7 +24318,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
     }
     walkStringFunc(k.expr, phase);
   };
-  for (const col of stmt.columns) {
+  for (const col of [...stmt.columns, ...stmt.hiddenWindows ?? []]) {
     switch (col.type) {
       case "WILDCARD":
         markAllTargetTables();
@@ -24099,8 +24359,13 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
         if ((col.windowKind === "AGGREGATE" || col.windowKind === "VALUE") && 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");
+        for (const ref of col.partitionBy) {
+          if (ref.type === "FIELD") addFieldRef(ref.field, ref.tableAlias, "select");
+        }
+        for (const item of col.orderBy) {
+          const isMaterializedAlias = item.key.type === "FIELD_NAME" && (item.key.aggregateRef !== void 0 || windowMaterializedAliases.has(item.key.name));
+          walkOrderByKey(item.key, isMaterializedAlias ? "orderBy" : "select");
+        }
         break;
     }
   }
@@ -24124,6 +24389,16 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
   for (const ob of stmt.orderBy) walkOrderByKey(ob.key);
   return states;
 }
+function collectAggregateMaterializedNames(columns) {
+  const names = /* @__PURE__ */ new Set();
+  for (const col of columns) {
+    const materialized = col.type === "AGGREGATE" || col.type === "ARITH_AGG_COL" || col.type === "ARITH_COL" && containsAggregate2(col.expr) || col.type === "CASE_COL" && containsAggregate2(col.expr) || col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(col.expr) || col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(col.expr);
+    if (!materialized) continue;
+    if (col.alias) names.add(col.alias);
+    if (col.type === "AGGREGATE") names.add(aggregateSyntheticName(col.func, col.distinct, col.arg));
+  }
+  return names;
+}
 function collectSelectOutputNames(columns) {
   const names = /* @__PURE__ */ new Set();
   for (const col of columns) {
@@ -30338,7 +30613,7 @@ function selectNeedsOwnMetadata(statement) {
     (join3) => join3.type !== "CROSS" && join3.table.appId > 0 && join3.table.cteName === null && (join3.on.left.field !== "$id" || join3.on.right.field !== "$id")
   ) || statement.columns.some(
     (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
-  );
+  ) || (statement.hiddenWindows ?? []).some((column) => column.orderBy.length > 0);
 }
 function cteQueriesContainPhysicalSelect(ctes) {
   if (!Array.isArray(ctes)) return false;
@@ -31240,7 +31515,7 @@ function planCanonicalOrder(input) {
   const reasons = [];
   const windowOrderBy = stmt.columns.flatMap(
     (column) => column.type === "WINDOW_COL" ? column.orderBy : []
-  );
+  ).concat((stmt.hiddenWindows ?? []).flatMap((column) => column.orderBy));
   const allOrderBy = [...stmt.orderBy, ...windowOrderBy];
   for (const item of allOrderBy) {
     if (item.key.type !== "FIELD_NAME") continue;
@@ -31564,7 +31839,7 @@ function materializedValuesFor(row) {
 }
 function setMaterializedSelectValue(row, columnIndex, value, lookupKeys = []) {
   const values = materializedValuesFor(row);
-  values.byColumn.set(columnIndex, value);
+  if (columnIndex !== null) values.byColumn.set(columnIndex, value);
   for (const key of lookupKeys) values.byLookupKey.set(key, value);
 }
 function getMaterializedSelectValue(row, columnIndex) {
@@ -31745,10 +32020,10 @@ function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldS
 }
 function hasAggregateColumns(columns) {
   return columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr) || c.type === "WINDOW_COL" && ((c.windowKind === "AGGREGATE" || c.windowKind === "VALUE") && containsAggregate2(c.arg) || c.orderBy.some((item) => item.key.type === "FIELD_NAME" && item.key.aggregateRef !== void 0))
   );
 }
-function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
+function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}, having = null, hiddenWindows = []) {
   if (resolutionPlan && resolutionPlan.items.length !== groupByKeys.length) {
     throw new Error("InternalError: plain GROUP BY resolution plan length does not match group keys.");
   }
@@ -31797,11 +32072,32 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolution
       resolveAggSortKind,
       aliasEvaluationContext.evaluationContext
     );
+    materializeAggregateDependencies(
+      outRow,
+      groupRows,
+      having,
+      resolveAggSortKind,
+      aliasEvaluationContext.evaluationContext
+    );
+    materializeAggregateDependencies(
+      outRow,
+      groupRows,
+      columns.filter((column) => column.type === "WINDOW_COL"),
+      resolveAggSortKind,
+      aliasEvaluationContext.evaluationContext
+    );
+    materializeAggregateDependencies(
+      outRow,
+      groupRows,
+      hiddenWindows,
+      resolveAggSortKind,
+      aliasEvaluationContext.evaluationContext
+    );
     result.push(outRow);
   }
   return result;
 }
-function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}) {
+function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}, having = null, hiddenWindows = []) {
   const result = [];
   let generatedRows = 0;
   const countBucket = () => {
@@ -31861,6 +32157,27 @@ function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {})
         resolveAggSortKind,
         limits.evaluationContext
       );
+      materializeAggregateDependencies(
+        outRow,
+        groupRows,
+        having,
+        resolveAggSortKind,
+        limits.evaluationContext
+      );
+      materializeAggregateDependencies(
+        outRow,
+        groupRows,
+        hiddenWindows,
+        resolveAggSortKind,
+        limits.evaluationContext
+      );
+      materializeAggregateDependencies(
+        outRow,
+        groupRows,
+        columns.filter((column) => column.type === "WINDOW_COL"),
+        resolveAggSortKind,
+        limits.evaluationContext
+      );
       attachGroupingRowMeta(outRow, includedCanonicalIds);
       result.push(outRow);
     }
@@ -31873,6 +32190,10 @@ function groupingItemValue(item, row) {
 }
 function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind, evaluationContext = {}) {
   for (const [columnIndex, col] of columns.entries()) {
+    if (containsHiddenWindowRef(col)) {
+      materializeAggregateDependencies(outRow, groupRows, col, resolveAggSortKind, evaluationContext);
+      continue;
+    }
     if (col.type === "AGGREGATE") {
       const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
       const value = String(evalAggregate(
@@ -31949,6 +32270,14 @@ function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortK
     }
   }
 }
+function containsHiddenWindowRef(node) {
+  if (node === null || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(containsHiddenWindowRef);
+  const value = node;
+  if (value["hiddenWindowRef"] === true) return true;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
+  return Object.values(value).some(containsHiddenWindowRef);
+}
 function caseMaterializedKey(alias, columnIndex) {
   return alias ?? `__ksql_case_column_${columnIndex}`;
 }
@@ -32165,7 +32494,7 @@ function aggArithDefaultKey(node) {
 }
 function resolveAggregateArgSemantics(arg, resolver) {
   if (arg.type === "FIELD_REF") return resolver?.(toAggregateFieldRef(arg.field)) ?? "string";
-  if (arg.type === "FIELD") return resolver?.(arg) ?? "string";
+  if (arg.type === "FIELD") return arg.aggregateRef ? aggregateResultSemantics(arg.aggregateRef, resolver) : resolver?.(arg) ?? "string";
   if (arg.type === "NUMBER" || arg.type === "ARITH" || arg.type === "SCALAR_ARITH") return "number";
   if (arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "VARIABLE") return "string";
   if (arg.type === "STRING_FUNC") {
@@ -32391,14 +32720,15 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
     return resolved === void 0 ? void 0 : evaluators.get(resolved)?.(row);
   };
 }
-function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind, evaluationContext = {}) {
+function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind, evaluationContext = {}, hiddenWindows = []) {
   const windows = columns.map((column, columnIndex) => ({ column, columnIndex })).filter((item) => item.column.type === "WINDOW_COL");
+  windows.push(...hiddenWindows.map((column) => ({ column, columnIndex: null })));
   if (rows.length === 0 || windows.length === 0) return rows;
   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)));
+      const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowPartitionKey(row, ref)));
       const partition = partitions.get(key);
       if (partition) partition.push(row);
       else partitions.set(key, [row]);
@@ -32448,7 +32778,7 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
 function evaluateValueWindowArg(arg, row, evaluationContext = {}) {
   const value = evalScalarValueExprNullable(
     arg,
-    sourceRowForEvaluation(row),
+    havingEvaluationRow(row),
     void 0,
     void 0,
     evaluationContext
@@ -32479,7 +32809,7 @@ function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortK
   const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(
     window.aggFunc,
     window.arg,
-    sorted.map((item) => item.row),
+    sorted.map((item) => havingEvaluationRow(item.row)),
     evaluationContext
   );
   const comparison = window.arg.type === "WILDCARD" ? void 0 : resolveAggregateArgSemantics(window.arg, resolveAggSortKind);
@@ -32532,9 +32862,10 @@ function applyAggregateWindow(window, columnIndex, sortedResult, resolveAggSortK
     setMaterializedSelectValue(sorted[index].row, columnIndex, output[index], [window.alias]);
   }
 }
-function resolveWindowField(row, ref) {
+function resolveWindowPartitionKey(row, ref) {
+  if (ref.type === "GROUPING_REF") return evalGroupingRef(ref, row);
   const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
-  return resolveFieldRef(sourceRowForEvaluation(row), name);
+  return resolveFieldRef(havingEvaluationRow(row), name);
 }
 function applyLimit(rows, limit, offset) {
   const start = offset ?? 0;
@@ -32542,7 +32873,8 @@ function applyLimit(rows, limit, offset) {
   return rows.slice(start, start + limit);
 }
 function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
-  const sourceRow = sourceRowForEvaluation(row);
+  const hasHiddenWindow = containsHiddenWindowRef(column);
+  const sourceRow = hasHiddenWindow ? havingEvaluationRow(row) : sourceRowForEvaluation(row);
   switch (column.type) {
     case "VARIABLE_COL":
       throw new Error(`internal error: unresolved SELECT variable @${column.name}`);
@@ -32573,9 +32905,9 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, source) ?? "0";
     }
     case "ARITH_COL":
-      return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? arithColDefaultKey(column.expr)) ?? "" : String(evalArithExpr(column.expr, sourceRow, context.evaluationContext));
+      return containsAggregate2(column.expr) && !hasHiddenWindow ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? arithColDefaultKey(column.expr)) ?? "" : String(evalArithExpr(column.expr, sourceRow, context.evaluationContext));
     case "CASE_COL":
-      return containsAggregate2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
+      return containsAggregate2(column.expr) && !hasHiddenWindow ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? getLegacyMaterializedValue(row, caseMaterializedKey(column.alias, columnIndex)) ?? "" : evalCaseWhen(
         column.expr,
         sourceRow,
         context.resolveFieldType,
@@ -32586,7 +32918,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
       return evalGroupingRef(column.ref, row);
     case "STRFUNC_COL": {
       const source = stringFuncDefaultKey(column.expr);
-      return hasAggregateInStringFuncExpr2(column.expr) ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? evalStringFunc(
+      return hasAggregateInStringFuncExpr2(column.expr) && !hasHiddenWindow ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? evalStringFunc(
         column.expr,
         sourceRow,
         context.resolveFieldType,
@@ -32602,7 +32934,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
     }
     case "SCALAR_VALUE_COL": {
       const source = scalarValueDefaultKey(column.expr);
-      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(
+      return scalarValueHasAggregate2(column.expr) && !hasHiddenWindow ? getMaterializedSelectValue(row, columnIndex) ?? getMaterializedLookupValue(row, column.alias ?? source) ?? getMaterializedLookupValue(row, source) ?? getLegacyMaterializedValue(row, column.alias ?? source) ?? getLegacyMaterializedValue(row, source) ?? "" : String(evalScalarValueExpr(
         column.expr,
         sourceRow,
         context.resolveFieldType,
@@ -33024,9 +33356,33 @@ function mergeKnownColumns(left, right, rows) {
     ...Object.keys(rows[0] ?? {})
   ])];
 }
-function deriveOutputOrderSemantics(columns, resolveAggSortKind) {
+function deriveOutputOrderSemantics(columns, resolveAggSortKind, hiddenWindows = []) {
   const result = /* @__PURE__ */ new Map();
+  const hiddenSemantics = new Map(hiddenWindows.map((window) => [
+    window.alias,
+    windowResultSemantics(window, resolveAggSortKind)
+  ]));
+  const resolveExpressionField = (field) => hiddenSemantics.get(field.field) ?? resolveAggSortKind?.(field);
   for (const column of columns) {
+    if (column.type === "AGGREGATE") {
+      result.set(
+        aggregateSyntheticName(column.func, column.distinct, column.arg),
+        aggregateResultSemantics({
+          type: "AGG_REF",
+          func: column.func,
+          distinct: column.distinct,
+          arg: column.arg,
+          ...column.separator !== void 0 ? { separator: column.separator } : {}
+        }, resolveAggSortKind)
+      );
+    }
+    if (column.type === "WINDOW_COL") {
+      for (const item of column.orderBy) {
+        if (item.key.type === "FIELD_NAME" && item.key.aggregateRef) {
+          result.set(item.key.name, aggregateResultSemantics(item.key.aggregateRef, resolveAggSortKind));
+        }
+      }
+    }
     if (!("alias" in column) || !column.alias) continue;
     if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       result.set(column.alias, syntheticSemantics("number"));
@@ -33043,17 +33399,29 @@ function deriveOutputOrderSemantics(columns, resolveAggSortKind) {
       } else if (column.func === "GROUP_CONCAT") {
         result.set(column.alias, syntheticSemantics("string"));
       }
-    } else if (column.type === "LITERAL_COL" || column.type === "CASE_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "SCALAR_VALUE_COL") {
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_SUBQUERY_COL") {
       result.set(column.alias, syntheticSemantics("string"));
+    } else if (column.type === "CASE_COL" || column.type === "SCALAR_VALUE_COL") {
+      result.set(column.alias, syntheticSemantics(expressionSemanticKind(column.expr, resolveExpressionField)));
     } else if (column.type === "STRFUNC_COL") {
       result.set(column.alias, syntheticSemantics(stringFunctionSemanticKind(
         column.expr,
-        (field) => resolveAggSortKind?.(field)
+        resolveExpressionField
       )));
     }
   }
   return result;
 }
+function windowResultSemantics(window, resolveAggSortKind) {
+  if (isRankingWindow(window) || isAggregateWindow(window) && (window.aggFunc === "COUNT" || window.aggFunc === "SUM" || window.aggFunc === "AVG")) {
+    return syntheticSemantics("number");
+  }
+  if ((isAggregateWindow(window) || isValueWindow(window)) && window.arg.type !== "WILDCARD") {
+    const semantics = resolveAggregateArgSemantics(window.arg, resolveAggSortKind) ?? "string";
+    return typeof semantics === "string" ? syntheticSemantics(semantics) : semantics;
+  }
+  return syntheticSemantics("string");
+}
 function runFullScan(input) {
   const {
     stmt,
@@ -33076,8 +33444,17 @@ function runFullScan(input) {
     warnings,
     evaluationContext
   } = input;
-  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns, aggregateSortKindResolver);
+  const effectiveOrderSemantics = deriveOutputOrderSemantics(
+    stmt.columns,
+    aggregateSortKindResolver,
+    stmt.hiddenWindows
+  );
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
+  const hiddenWindowSemantics = new Map((stmt.hiddenWindows ?? []).map((window) => [
+    window.alias,
+    windowResultSemantics(window, aggregateSortKindResolver)
+  ]));
+  const expressionFieldSemanticsResolver = (field) => hiddenWindowSemantics.get(field.field) ?? fieldSemanticsResolver?.(field);
   let rows = [];
   const mainAlias = stmt.from.alias;
   const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
@@ -33121,9 +33498,14 @@ function runFullScan(input) {
       resolvedGroupingSpec,
       stmt.columns,
       aggregateSortKindResolver,
-      { maxGeneratedRows: B65_MAX_GENERATED_ROWS, evaluationContext }
+      { maxGeneratedRows: B65_MAX_GENERATED_ROWS, evaluationContext },
+      stmt.having,
+      stmt.hiddenWindows
     );
-  } else if (grouping.type === "PLAIN" || hasAggregateColumns(stmt.columns)) {
+  } else if (grouping.type === "PLAIN" || hasAggregateColumns([
+    ...stmt.columns,
+    ...stmt.hiddenWindows ?? []
+  ])) {
     rows = applyGroupBy(
       rows,
       grouping.type === "PLAIN" ? grouping.allItems : [],
@@ -33135,7 +33517,9 @@ function runFullScan(input) {
         resolveFieldType: fieldTypeResolver,
         resolveFieldSemantics: fieldSemanticsResolver,
         evaluationContext
-      }
+      },
+      stmt.having,
+      stmt.hiddenWindows
     );
   }
   warnOnUnresolvedAggregateComparisons(stmt.columns, rows, warnings);
@@ -33155,7 +33539,8 @@ function runFullScan(input) {
     sortKinds,
     effectiveOrderSemantics,
     aggregateSortKindResolver,
-    evaluationContext
+    evaluationContext,
+    stmt.hiddenWindows
   );
   if (stmt.distinct) {
     rows = applyDistinct(
@@ -33163,7 +33548,7 @@ function runFullScan(input) {
       stmt.columns,
       scalarCache,
       fieldTypeResolver,
-      fieldSemanticsResolver,
+      expressionFieldSemanticsResolver,
       evaluationContext
     );
   }
@@ -33177,7 +33562,7 @@ function runFullScan(input) {
       stmt.columns,
       scalarCache,
       fieldTypeResolver,
-      fieldSemanticsResolver,
+      expressionFieldSemanticsResolver,
       evaluationContext
     ),
     evaluationContext
@@ -33189,7 +33574,7 @@ function runFullScan(input) {
     scalarCache,
     fieldTypeResolver,
     sourceColumns2,
-    fieldSemanticsResolver,
+    expressionFieldSemanticsResolver,
     hiddenQualifiedAliases,
     evaluationContext
   );
@@ -36804,15 +37189,46 @@ async function normalizeSelectChoiceEquality(stmt, client, cacheContext, materia
   }
   return { resolver, rewrites: normalization.rewrites };
 }
+function selectWindowColumns(stmt) {
+  return [
+    ...stmt.columns.filter((column) => column.type === "WINDOW_COL"),
+    ...stmt.hiddenWindows ?? []
+  ];
+}
 function hasDefaultRangeAggregateWindow(stmt) {
-  return stmt.columns.some(
-    (column) => column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && column.orderBy.length > 0 && column.frame?.source === "DEFAULT"
+  return selectWindowColumns(stmt).some(
+    (column) => column.windowKind === "AGGREGATE" && column.orderBy.length > 0 && column.frame?.source === "DEFAULT"
   );
 }
 function hasWindowNeedingOrderProof(stmt) {
-  return hasDefaultRangeAggregateWindow(stmt) || stmt.columns.some((column) => column.type === "WINDOW_COL" && column.windowKind === "VALUE");
+  return hasDefaultRangeAggregateWindow(stmt) || selectWindowColumns(stmt).some((column) => column.windowKind === "VALUE");
+}
+function sameSelectGroupOrderIsUnique(stmt, orderBy) {
+  const grouping = normalizeGroupingSpec(stmt);
+  if (grouping.type !== "PLAIN" || grouping.allItems.length === 0) return false;
+  return grouping.allItems.every((groupKey) => {
+    if (orderBy.some((item) => {
+      if (groupKey.type === "FIELD_NAME" && item.key.type === "FIELD_NAME") {
+        return item.key.name === groupKey.name;
+      }
+      return groupKey.type === item.key.type && JSON.stringify(groupKey) === JSON.stringify(item.key);
+    })) return true;
+    return stmt.columns.some((column) => {
+      if (!("alias" in column) || column.alias === null) return false;
+      if (!orderBy.some((item) => item.key.type === "FIELD_NAME" && item.key.name === column.alias)) return false;
+      if (groupKey.type === "FIELD_NAME" && column.type === "FIELD") return column.field === groupKey.name;
+      if (groupKey.type === "ARITH_KEY" && column.type === "ARITH_COL") {
+        return JSON.stringify(groupKey.expr) === JSON.stringify(column.expr);
+      }
+      if (groupKey.type === "FUNC_KEY" && column.type === "STRFUNC_COL") {
+        return JSON.stringify(groupKey.expr) === JSON.stringify(column.expr);
+      }
+      return false;
+    });
+  });
 }
 function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context, generatedColumn) {
+  if (sameSelectGroupOrderIsUnique(stmt, orderBy)) return true;
   if (generatedColumn !== void 0 && stmt.joins.length === 0 && stmt.from.cteName !== null) {
     return orderBy.some((item) => {
       if (item.key.type !== "FIELD_NAME") return false;
@@ -36935,9 +37351,7 @@ function formatWhereCapabilityFailure(result) {
   return details || "reason=WHERE_UNSUPPORTED";
 }
 function hasCanonicalOrder(stmt) {
-  return stmt.orderBy.length > 0 || stmt.columns.some(
-    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
-  );
+  return stmt.orderBy.length > 0 || selectWindowColumns(stmt).some((column) => column.orderBy.length > 0);
 }
 async function resolveDmlWhereCapability(stmt, client, cacheContext) {
   if (stmt.subtableCode || stmt.type === "UPDATE" && stmt.from != null) {
@@ -37395,7 +37809,7 @@ function arithHasFieldRef(node) {
       `InternalError: unresolved arithmetic variable @${node.name} reached SELECT planning.`
     );
   }
-  if (node.type === "FIELD_REF") return true;
+  if (node.type === "FIELD_REF") return node.hiddenWindowRef !== true;
   if (node.type === "ARITH") return arithHasFieldRef(node.left) || arithHasFieldRef(node.right);
   if (node.type === "STRING_FUNC") return stringFuncHasFieldRef(node);
   return false;
@@ -37407,7 +37821,7 @@ function stringFuncArgHasFieldRef(arg) {
   return scalarValueHasFieldRef(arg);
 }
 function scalarValueHasFieldRef(expr) {
-  if (expr.type === "FIELD") return true;
+  if (expr.type === "FIELD") return expr.hiddenWindowRef !== true;
   if (expr.type === "STRING_FUNC") return stringFuncHasFieldRef(expr);
   if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
     return scalarValueHasFieldRef(expr.left) || scalarValueHasFieldRef(expr.right);
@@ -37465,7 +37879,8 @@ function executeNoFromSelect(stmt, options) {
     void 0,
     void 0,
     void 0,
-    statementEvaluationContext(options)
+    statementEvaluationContext(options),
+    stmt.hiddenWindows
   );
   const { rows: projected, columns } = project(
     windowed,
@@ -37744,7 +38159,7 @@ function bindProjectedNamesForSelect(stmt, materializedTables, physicalMayHave)
     }
     for (const child of Object.values(value)) visit(child, allowSelectAlias);
   };
-  for (const column of stmt.columns) visit(column);
+  for (const column of [...stmt.columns, ...stmt.hiddenWindows ?? []]) visit(column);
   visit(stmt.where);
   visit(stmt.having, true);
   visit(stmt.grouping);
@@ -37759,9 +38174,9 @@ function bindProjectedNamesForSelect(stmt, materializedTables, physicalMayHave)
     if (item.key.type === "FIELD_NAME") item.key.name = resolveText(item.key.name, true);
     else visit(item.key);
   }
-  for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL") continue;
+  for (const column of selectWindowColumns(stmt)) {
     for (const ref of column.partitionBy) {
+      if (ref.type !== "FIELD") continue;
       ref.field = resolveReference(ref.field, ref.tableAlias, false);
     }
     for (const item of column.orderBy) {
@@ -38468,7 +38883,7 @@ function mergeExpressionColumnMeta(candidates) {
 }
 function inferAggregateArgMeta(arg, resolveField2) {
   if (arg.type === "FIELD_REF") return resolveField2(aggregateFieldRef(arg.field)) ?? unknownStringColumnMeta();
-  if (arg.type === "FIELD") return resolveField2(arg) ?? unknownStringColumnMeta();
+  if (arg.type === "FIELD") return arg.aggregateRef ? aggregateResultColumnMeta(arg.aggregateRef, resolveField2) : resolveField2(arg) ?? unknownStringColumnMeta();
   if (arg.type === "NUMBER" || arg.type === "ARITH" || arg.type === "SCALAR_ARITH") return syntheticColumnMeta("number");
   if (arg.type === "STRING" || arg.type === "CONCAT_OP" || arg.type === "VARIABLE") return syntheticColumnMeta("string");
   if (arg.type === "STRING_FUNC") return stringFunctionColumnMeta(arg, resolveField2);
@@ -38476,6 +38891,15 @@ function inferAggregateArgMeta(arg, resolveField2) {
   if (arg.elseResult) results.push(caseResultColumnMeta(arg.elseResult, resolveField2));
   return mergeExpressionColumnMeta(results);
 }
+function aggregateResultColumnMeta(ref, resolveField2) {
+  if (ref.func === "COUNT" || ref.func === "SUM" || ref.func === "AVG" || ref.func === "STDDEV_POP" || ref.func === "STDDEV_SAMP" || ref.func === "VAR_POP" || ref.func === "VAR_SAMP" || ref.func === "MEDIAN") {
+    return syntheticColumnMeta("number");
+  }
+  if (ref.func === "GROUP_CONCAT" || ref.func === "MODE" || ref.arg.type === "WILDCARD") {
+    return syntheticColumnMeta("string");
+  }
+  return inferAggregateArgMeta(ref.arg, resolveField2);
+}
 function inferWindowColumnMeta(column, resolveField2) {
   if (column.windowKind === "VALUE") {
     return inferAggregateArgMeta(column.arg, resolveField2);
@@ -38492,7 +38916,7 @@ function withDisplayName(meta, displayName) {
   return { ...meta ?? {}, displayName };
 }
 function selectNeedsSourceColumnMeta(stmt) {
-  return stmt.columns.some(
+  return (stmt.hiddenWindows?.length ?? 0) > 0 || 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.type === "WINDOW_COL" && (column.windowKind === "VALUE" || column.windowKind === "AGGREGATE" && (column.aggFunc === "MIN" || column.aggFunc === "MAX"))
   );
 }
@@ -38550,6 +38974,11 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
     return meta && publicSourceApp !== void 0 ? { ...meta, publicSourceApp } : meta;
   };
   const inferred = /* @__PURE__ */ new Map();
+  const hiddenWindowMeta = new Map((stmt.hiddenWindows ?? []).map((window) => [
+    window.alias,
+    inferWindowColumnMeta(window, resolveField2)
+  ]));
+  const resolveExpressionField = (ref) => ref.hiddenWindowRef ? hiddenWindowMeta.get(ref.field) : resolveField2(ref);
   const hasWildcard = stmt.columns.some((column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD");
   if (stmt.columns.length === 1 && (stmt.columns[0].type === "WILDCARD" || stmt.columns[0].type === "PARENT_WILDCARD")) {
     for (const output of outputColumns) {
@@ -38592,17 +39021,17 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       meta = syntheticColumnMeta("string");
     } else if (column.type === "SCALAR_VALUE_COL") {
       const expr = column.expr;
-      if (expr.type === "STRING_FUNC") meta = stringFunctionColumnMeta(expr, resolveField2);
+      if (expr.type === "STRING_FUNC") meta = stringFunctionColumnMeta(expr, resolveExpressionField);
       else if (expr.type === "NUMBER" || expr.type === "SCALAR_ARITH") meta = syntheticColumnMeta("number");
-      else if (expr.type === "FIELD") meta = resolveField2(expr);
+      else if (expr.type === "FIELD") meta = resolveExpressionField(expr);
       else meta = syntheticColumnMeta("string");
     } else if (column.type === "STRFUNC_COL") {
-      meta = stringFunctionColumnMeta(column.expr, resolveField2);
+      meta = stringFunctionColumnMeta(column.expr, resolveExpressionField);
     } else if (column.type === "WINDOW_COL") {
       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));
+      const results = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveExpressionField));
+      if (column.expr.elseResult) results.push(caseResultColumnMeta(column.expr.elseResult, resolveExpressionField));
       meta = mergeExpressionColumnMeta(results);
     } else if (column.type === "SCALAR_SUBQUERY_COL") {
       meta = unknownStringColumnMeta();
@@ -40261,7 +40690,7 @@ async function getSortKindMapByApp(appId, client, cacheContext) {
 function orderByFieldNames(stmt) {
   const items = [
     ...stmt.orderBy,
-    ...stmt.columns.flatMap((column) => column.type === "WINDOW_COL" ? column.orderBy : [])
+    ...selectWindowColumns(stmt).flatMap((column) => column.orderBy)
   ];
   return [...new Set(items.flatMap(
     (item) => item.key.type === "FIELD_NAME" ? [item.key.name] : []
@@ -40311,6 +40740,11 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     return matches.length === 1 ? matches[0] : void 0;
   };
   const aliasSemantics = /* @__PURE__ */ new Map();
+  const hiddenWindowMeta = new Map((stmt.hiddenWindows ?? []).map((window) => [
+    window.alias,
+    inferWindowColumnMeta(window, resolveField2)
+  ]));
+  const resolveExpressionField = (ref) => ref.hiddenWindowRef ? hiddenWindowMeta.get(ref.field) : resolveField2(ref);
   for (const column of stmt.columns) {
     if (!("alias" in column) || !column.alias) continue;
     let meta;
@@ -40321,12 +40755,18 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
       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");
-    else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr, resolveField2);
+    } else if (column.type === "LITERAL_COL") meta = syntheticColumnMeta("string");
+    else if (column.type === "SCALAR_VALUE_COL") {
+      const expr = column.expr;
+      if (expr.type === "STRING_FUNC") meta = stringFunctionColumnMeta(expr, resolveExpressionField);
+      else if (expr.type === "NUMBER" || expr.type === "SCALAR_ARITH") meta = syntheticColumnMeta("number");
+      else if (expr.type === "FIELD") meta = resolveExpressionField(expr);
+      else meta = syntheticColumnMeta("string");
+    } else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr, resolveExpressionField);
     else if (column.type === "SCALAR_SUBQUERY_COL") meta = unknownStringColumnMeta();
     else if (column.type === "CASE_COL") {
-      const candidates = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
-      if (column.expr.elseResult) candidates.push(caseResultColumnMeta(column.expr.elseResult, resolveField2));
+      const candidates = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveExpressionField));
+      if (column.expr.elseResult) candidates.push(caseResultColumnMeta(column.expr.elseResult, resolveExpressionField));
       meta = mergeExpressionColumnMeta(candidates);
     } else if (column.type === "AGGREGATE") {
       if (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") {
@@ -40337,10 +40777,16 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     }
     if (meta?.semantics) aliasSemantics.set(column.alias, meta.semantics);
   }
+  const aggregateOrderRefs = /* @__PURE__ */ new Map();
+  for (const item of selectWindowColumns(stmt).flatMap((column) => column.orderBy)) {
+    if (item.key.type === "FIELD_NAME" && item.key.aggregateRef) {
+      aggregateOrderRefs.set(item.key.name, item.key.aggregateRef);
+    }
+  }
   const result = /* @__PURE__ */ new Map();
   for (const name of names) {
     const resolvedAlias = resolveProjectedName(name, aliasSemantics.keys());
-    const base = (resolvedAlias === void 0 ? void 0 : aliasSemantics.get(resolvedAlias)) ?? resolveField2(aggregateFieldRef(name))?.semantics;
+    const base = (resolvedAlias === void 0 ? void 0 : aliasSemantics.get(resolvedAlias)) ?? (aggregateOrderRefs.has(name) ? aggregateResultColumnMeta(aggregateOrderRefs.get(name), resolveField2).semantics : void 0) ?? resolveField2(aggregateFieldRef(name))?.semantics;
     if (!base) {
       const ref = aggregateFieldRef(name);
       if (ref.tableAlias === null && ambiguousFields.has(ref.field)) {
@@ -40363,9 +40809,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
   return result;
 }
 async function buildOrderByMetaForSelect(stmt, client, cacheContext, materializedTables) {
-  const hasWindowOrderBy = stmt.columns.some(
-    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
-  );
+  const hasWindowOrderBy = selectWindowColumns(stmt).some((column) => column.orderBy.length > 0);
   if (stmt.orderBy.length === 0 && !hasWindowOrderBy) {
     return { optionOrders: /* @__PURE__ */ new Map(), sortKinds: /* @__PURE__ */ new Map(), semantics: /* @__PURE__ */ new Map() };
   }
@@ -43590,7 +44034,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     if (isConstantFalseWhere(select.where)) currentRows = 0;
     else if (select.where !== null) currentRows = null;
     const grouping = normalizeGroupingSpec(select);
-    if (grouping.type !== "NONE" || select.distinct || select.having !== null || isAggregateQueryBlock(select) || select.columns.some((column) => column.type === "WINDOW_COL")) {
+    if (grouping.type !== "NONE" || select.distinct || select.having !== null || isAggregateQueryBlock(select) || selectWindowColumns(select).length > 0) {
       currentRows = null;
     }
     if (currentRows !== null) {
@@ -43779,7 +44223,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       }
       const physicalApps = [select.from, ...select.joins.map((join3) => join3.table)].filter((table) => table.cteName === null).map((table) => table.appId);
       const needsWhereSchema = whereNeedsFieldMetadata(select.where);
-      if (needsWhereSchema || select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
+      if (needsWhereSchema || select.orderBy.length > 0 || selectWindowColumns(select).some((column) => column.orderBy.length > 0)) {
         physicalApps.forEach((appId) => fieldApps.add(appId));
       }
       const { resolver, rewrites } = await normalizeSelectChoiceEquality(
@@ -43859,7 +44303,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         joinKeyPlans.set(joinAlias, { plan, queries, additionalQuery, additionalRelation });
       }
       if (joinKeyPlans.size > 0) explainJoinKeyPrefilters.set(select, joinKeyPlans);
-      if (select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
+      if (select.orderBy.length > 0 || selectWindowColumns(select).some((column) => column.orderBy.length > 0)) {
         const meta = await buildOrderByMetaForSelect(select, tracedClient, cacheContext);
         if (select.orderMode !== "KINTONE_NATIVE") {
           for (const semantics of meta.semantics.values()) {
@@ -45175,7 +45619,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     const clauses = [];
     if (column.partitionBy.length > 0) {
       clauses.push(`PARTITION BY ${column.partitionBy.map(
-        (ref) => ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field
+        (ref) => ref.type === "GROUPING_REF" ? `GROUPING(${ref.field.tableAlias ? `${ref.field.tableAlias}.` : ""}${ref.field.field})` : ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field
       ).join(", ")}`);
     }
     if (column.orderBy.length > 0) {
@@ -45476,7 +45920,7 @@ function populateWithCrossJoinExplain(stmt) {
     if (steps.length > 0) explainCrossJoinSteps.set(select, steps);
     if (isConstantFalseWhere(select.where)) current = 0;
     else if (select.where !== null) current = null;
-    if (normalizeGroupingSpec(select).type !== "NONE" || select.distinct || select.having !== null || isAggregateQueryBlock(select) || select.columns.some((column) => column.type === "WINDOW_COL")) return null;
+    if (normalizeGroupingSpec(select).type !== "NONE" || select.distinct || select.having !== null || isAggregateQueryBlock(select) || selectWindowColumns(select).length > 0) return null;
     if (current === null) return null;
     current = Math.max(0, current - (select.offset ?? 0));
     return select.limit === null ? current : Math.min(current, select.limit);
@@ -45636,7 +46080,7 @@ function collectFullScanReasons(stmt) {
     r.push("DISTINCT \u3042\u308A");
   if (hasAggregateColumns(stmt.columns))
     r.push("\u96C6\u8A08\u95A2\u6570\uFF08COUNT / SUM \u7B49\uFF09\u3042\u308A");
-  if (stmt.columns.some((c) => c.type === "WINDOW_COL"))
+  if (selectWindowColumns(stmt).length > 0)
     r.push("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u3042\u308A");
   if (stmt.columns.some((c) => c.type === "SCALAR_SUBQUERY_COL"))
     r.push("SELECT \u5217\u306B\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA");