@rex0220/kintone-sql-tools 3.43.0 → 3.45.0

package/dist-cli/ksql.js

@@ -577,6 +577,9 @@ function compareDecimal(left, right) {
 
 // src/types/ast.ts
 var NO_FROM_CTE_NAME = "__NO_FROM__";
+function isRankingWindow(column) {
+  return column.windowKind !== "AGGREGATE";
+}
 function makeNumberLiteral(raw) {
   return { type: "NUMBER", value: Number(raw), raw };
 }
@@ -683,6 +686,7 @@ function arithLabel(node, topLevel = false) {
 function fieldValueLabel(value) {
   if (value.type === "FIELD") return value.tableAlias ? `${value.tableAlias}.${value.field}` : value.field;
   if (value.type === "FUNC_FIELD") return stringFuncLabel(value.expr);
+  if (value.type === "AGG_FIELD") return aggregateOperandLabel(value.expr);
   if (value.type === "ARITH_FIELD") return arithLabel(value.expr);
   if (value.type === "GROUPING_FIELD") {
     const field = value.ref.field;
@@ -736,6 +740,8 @@ function whereLabel(expr) {
 }
 function caseResultLabel(result) {
   if (result.type === "ARRAY") return `[${result.elements.map((entry) => quote(entry.value)).join(",")}]`;
+  if (result.type === "AGG_REF") return aggregateSyntheticName(result.func, result.distinct, result.arg);
+  if (result.type === "AGG_ARITH") return aggregateOperandLabel(result);
   if (result.type === "FIELD_REF" || result.type === "ARITH") return arithLabel(result);
   return scalarValueLabel(result);
 }
@@ -1315,6 +1321,11 @@ var Parser = class {
     }
     throw new ParseError(msg, tok);
   }
+  consumeSoftKeyword(word) {
+    if (!this.isSoftKeyword(word)) return false;
+    this.advance();
+    return true;
+  }
   parseTempTableName() {
     const tok = this.peek();
     if (tok.kind === "IDENT" /* IDENT */ && tok.value.startsWith("#")) {
@@ -1954,6 +1965,12 @@ var Parser = class {
       const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return this.withAliasDisplay({ type: "GROUPING_COL", ref, alias: parsedAlias2?.alias ?? null }, parsedAlias2);
     }
+    if (this.tryAggregateFunc() === null && this.hasNestedAggregateWindowInSelectColumn()) {
+      throw new ParseError(
+        "\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306E\u7D50\u679C\u3092\u5F0F\u306B\u542B\u3081\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093\u3002CTE \u3067\u4E00\u5EA6\u5B9F\u4F53\u5316\u3057\u3066\u304F\u3060\u3055\u3044",
+        this.peek()
+      );
+    }
     if (this.tryAggregateFunc() === null && this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
       const expr = this.parseScalarValueExpr({ allowAggregateArgs: true });
       const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -1998,6 +2015,9 @@ var Parser = class {
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
       const ref = this.parseAggregateRef(aggFunc);
+      if (this.isSoftKeyword("OVER")) {
+        return this.parseAggregateWindowColumn(ref);
+      }
       if (this.isArithOp(this.peek().kind)) {
         const expr = this.continueAggArith(ref);
         const parsedAlias3 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -2049,6 +2069,28 @@ var Parser = class {
   tryWindowFunc() {
     return PARSER_WINDOW_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
+  hasNestedAggregateWindowInSelectColumn() {
+    let depth = 0;
+    for (let index = this.pos; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (depth === 0 && (token.kind === "," /* COMMA */ || token.kind === "FROM" /* FROM */ || token.kind === ";" /* SEMICOLON */ || token.kind === "EOF" /* EOF */)) return false;
+      if (PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[token.kind] !== void 0 && this.tokens[index + 1]?.kind === "(" /* LPAREN */) {
+        let aggregateDepth = 0;
+        for (let cursor = index + 1; cursor < this.tokens.length; cursor++) {
+          const candidate = this.tokens[cursor];
+          if (candidate.kind === "(" /* LPAREN */) aggregateDepth++;
+          else if (candidate.kind === ")" /* RPAREN */ && --aggregateDepth === 0) {
+            const next = this.tokens[cursor + 1];
+            if (next?.kind === "IDENT" /* IDENT */ && next.value.toUpperCase() === "OVER") return true;
+            break;
+          }
+        }
+      }
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */) depth--;
+    }
+    return false;
+  }
   parseWindowColumn(func) {
     this.advance();
     this.expect("(" /* LPAREN */);
@@ -2075,12 +2117,81 @@ 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));
     if (column.type === "SCALAR_VALUE_COL") return this.scalarValueHasAggregate(column.expr);
+    if (column.type === "CASE_COL") return this.nodeHasAggregate(column.expr);
     return false;
   }
+  nodeHasAggregate(node) {
+    if (node === null || typeof node !== "object") return false;
+    if (Array.isArray(node)) return node.some((value2) => this.nodeHasAggregate(value2));
+    const value = node;
+    if (value["type"] === "AGG_REF" || value["type"] === "AGG_ARITH") return true;
+    if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
+    return Object.values(value).some((child) => this.nodeHasAggregate(child));
+  }
   stringFuncArgHasAggregate(arg) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
     return this.scalarValueHasAggregate(arg);
@@ -2091,11 +2202,7 @@ var Parser = class {
       return this.scalarValueHasAggregate(expr.left) || this.scalarValueHasAggregate(expr.right);
     }
     if (expr.type === "CASE_WHEN") {
-      const results = [...expr.branches.map((b) => b.result), ...expr.elseResult ? [expr.elseResult] : []];
-      return results.some((result) => {
-        if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
-        return this.scalarValueHasAggregate(result);
-      });
+      return this.nodeHasAggregate(expr);
     }
     return false;
   }
@@ -2148,7 +2255,9 @@ var Parser = class {
     }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
-      return this.parseAggregateRef(aggFunc);
+      const ref = this.parseAggregateRef(aggFunc);
+      this.rejectAggregateWindowOutsideSelect();
+      return ref;
     }
     throw new ParseError("\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u306F\u96C6\u8A08\u95A2\u6570\u307E\u305F\u306F\u6570\u5024\u304C\u5FC5\u8981\u3067\u3059", this.peek());
   }
@@ -2352,9 +2461,9 @@ var Parser = class {
     this.expect("(" /* LPAREN */);
     const condition = this.parseCaseCondition(allowGroupingCondition);
     this.expect("," /* COMMA */);
-    const thenResult = this.parseCaseResult();
+    const thenResult = this.parseCaseResult(allowGroupingCondition);
     this.expect("," /* COMMA */);
-    const elseResult = this.parseCaseResult();
+    const elseResult = this.parseCaseResult(allowGroupingCondition);
     this.expect(")" /* RPAREN */);
     return {
       type: "CASE_WHEN",
@@ -2369,7 +2478,7 @@ var Parser = class {
       this.advance();
       const condition = this.parseCaseCondition(allowGroupingCondition);
       this.expect("THEN" /* THEN */);
-      const result = this.parseCaseResult();
+      const result = this.parseCaseResult(allowGroupingCondition);
       branches.push({ condition, result });
     }
     if (branches.length === 0) {
@@ -2377,7 +2486,7 @@ var Parser = class {
     }
     let elseResult = null;
     if (this.consume("ELSE" /* ELSE */)) {
-      elseResult = this.parseCaseResult();
+      elseResult = this.parseCaseResult(allowGroupingCondition);
     }
     this.expect("END" /* END */);
     return { type: "CASE_WHEN", branches, elseResult };
@@ -2387,7 +2496,7 @@ var Parser = class {
     return this.parseWhereExpr("SELECT_CASE");
   }
   /** THEN / ELSE の結果値。`||` を含む場合だけ新スカラー文法へ渡す。 */
-  parseCaseResult() {
+  parseCaseResult(allowAggregateResult = false) {
     const tok = this.peek();
     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);
@@ -2395,6 +2504,12 @@ var Parser = class {
     if (tok.kind === "[" /* LBRACKET */) {
       return this.parseArrayLiteral();
     }
+    const aggregateFunc = this.tryAggregateFunc();
+    if (aggregateFunc !== null && allowAggregateResult) {
+      const ref = this.parseAggregateRef(aggregateFunc);
+      this.rejectAggregateWindowOutsideSelect();
+      return this.continueAggArith(ref);
+    }
     if (this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
       return this.parseScalarValueExpr({ allowAggregateArgs: true });
     }
@@ -2918,8 +3033,20 @@ 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",
+          expr: this.continueAggArith(ref)
+        };
+      }
       const syntheticName = aggregateSyntheticName(ref.func, ref.distinct, ref.arg);
-      return { type: "FIELD", tableAlias: null, field: syntheticName };
+      return {
+        type: "FIELD",
+        tableAlias: null,
+        field: syntheticName,
+        ...this.groupingFieldContext === "SELECT_CASE" || this.groupingFieldContext === "HAVING" ? { aggregateRef: ref } : {}
+      };
     }
     if (this.peek().kind === "CASE" /* CASE */) {
       const expr = this.parseCaseWhenExpr();
@@ -3365,6 +3492,16 @@ var Parser = class {
    *   フィールド名/alias: 名前 / total
    */
   parseOrderByKey(allowGrouping = true) {
+    const aggregateStart = this.tryAggregateFunc();
+    if (aggregateStart !== null) {
+      const start = this.pos;
+      const ref = this.parseAggregateRef(aggregateStart);
+      if (this.isSoftKeyword("OVER")) {
+        throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F SELECT \u5217\u306B\u306E\u307F\u8A18\u8FF0\u3067\u304D\u307E\u3059", this.peek());
+      }
+      this.pos = start;
+      void ref;
+    }
     if (this.isUnsupportedGroupingIdStart()) {
       throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
     }
@@ -3888,6 +4025,11 @@ var Parser = class {
   isSoftKeyword(value) {
     return this.peek().kind === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === value;
   }
+  rejectAggregateWindowOutsideSelect() {
+    if (this.isSoftKeyword("OVER")) {
+      throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F SELECT \u5217\u306B\u306E\u307F\u8A18\u8FF0\u3067\u304D\u307E\u3059", this.peek());
+    }
+  }
   validateUpdateFromAssignments(assignments, sourceAlias, tok) {
     for (const assignment of assignments) {
       if (assignment.value.type === "STRING_FUNC") {
@@ -4403,7 +4545,11 @@ function selectCompleteInputReasons(stmt) {
   if (stmt.distinct) reasons.add("DISTINCT");
   if (stmt.orderBy.length > 0) reasons.add("LOCAL_ORDER");
   for (const column of stmt.columns) {
-    if (column.type === "WINDOW_COL" && column.orderBy.length > 0) reasons.add("WINDOW_ORDER");
+    if (column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE") {
+      reasons.add("AGGREGATE_WINDOW");
+    } else if (column.type === "WINDOW_COL" && column.orderBy.length > 0) {
+      reasons.add("WINDOW_ORDER");
+    }
     if (column.type === "SCALAR_SUBQUERY_COL") addReasons(reasons, selectCompleteInputReasons(column.query));
     if (column.type === "CASE_COL") {
       for (const branch of column.expr.branches) addReasons(reasons, whereCompleteInputReasons(branch.condition));
@@ -5118,6 +5264,9 @@ function convertField(field) {
       `WHERE \u53E5\u306E\u95A2\u6570\uFF08${field.expr.func}\uFF09\u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093`
     );
   }
+  if (field.type === "AGG_FIELD") {
+    throw new KintoneQueryError("HAVING \u53E5\u306E\u96C6\u8A08\u7B97\u8853\u5F0F\u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093");
+  }
   if (field.type === "ARITH_FIELD") {
     throw new KintoneQueryError("WHERE \u53E5\u306E\u7B97\u8853\u5F0F\u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093");
   }
@@ -5256,292 +5405,564 @@ var KintoneQueryError = class extends Error {
   }
 };
 
-// src/converter/selectToKintone.ts
-function hasWindowColumns(columns) {
-  return columns.some((column) => column.type === "WINDOW_COL");
-}
-function resolveSelectMode(stmt) {
-  if (stmt.from.subtableCode) return "FULL_SCAN";
-  if (stmt.joins.some((j) => j.table.subtableCode)) return "FULL_SCAN";
-  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 (stmt.columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "SCALAR_SUBQUERY_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(c.expr)
-  )) return "FULL_SCAN";
-  if (whereRequiresJsEval(stmt.where)) return "FULL_SCAN";
-  if (stmt.orderBy.some((o) => o.key.type !== "FIELD_NAME")) return "FULL_SCAN";
-  return "SIMPLE";
+// src/engine/groupingRowMeta.ts
+var groupingRowMetaKey = /* @__PURE__ */ Symbol("ksql.groupingRowMeta");
+var groupingRefCanonicalIds = /* @__PURE__ */ new WeakMap();
+function attachGroupingRowMeta(row, includedCanonicalIds) {
+  Object.defineProperty(row, groupingRowMetaKey, {
+    value: { includedCanonicalIds },
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  return row;
 }
-function whereRequiresJsEval(where) {
-  if (where === null) return false;
-  switch (where.type) {
-    case "BOOLEAN":
-      return true;
-    case "BINARY":
-      return isFunc(where.left) || where.right.type === "ARITH_VALUE" || where.right.type === "CASE_VALUE" || where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY" || isLike(where);
-    case "NULL_CHECK":
-      return isFunc(where.field);
-    case "LOGICAL":
-      return whereRequiresJsEval(where.left) || whereRequiresJsEval(where.right);
-    case "NOT":
-    case "GROUP":
-      return whereRequiresJsEval(where.expr);
-    case "EXISTS":
-      return true;
-  }
+function getGroupingRowMeta(row) {
+  return row[groupingRowMetaKey];
 }
-function isFunc(fv) {
-  return fv.type === "FUNC_FIELD" || fv.type === "ARITH_FIELD" || fv.type === "CASE_FIELD";
+function readGroupingMembership(row) {
+  return getGroupingRowMeta(row)?.includedCanonicalIds;
 }
-function selectToKintoneParams(stmt) {
-  const queryParts = [];
-  const hasPagination = stmt.limit !== null || stmt.offset !== null;
-  const shouldInjectDefaultOrder = hasPagination && stmt.orderBy.length === 0;
-  if (stmt.where !== null) {
-    queryParts.push(whereToKintone(stmt.where));
-  }
-  if (stmt.orderBy.length > 0) {
-    const orderStr = stmt.orderBy.map(convertOrderBy).join(", ");
-    queryParts.push(`order by ${orderStr}`);
-  } else if (shouldInjectDefaultOrder) {
-    queryParts.push("order by $id asc");
-  }
-  if (stmt.limit !== null) {
-    queryParts.push(`limit ${stmt.limit}`);
-  }
-  if (stmt.offset !== null) {
-    queryParts.push(`offset ${stmt.offset}`);
-  }
-  return {
-    app: stmt.from.appId,
-    query: queryParts.join(" "),
-    fields: extractFields(stmt.columns),
-    totalCount: false
-  };
+function bindGroupingRefCanonicalId(ref, canonicalId) {
+  groupingRefCanonicalIds.set(ref, canonicalId);
 }
-function selectToFetchAllParams(stmt, appId) {
-  const queryParts = [];
-  if (stmt.where !== null && stmt.joins.length === 0 && !whereRequiresJsEval(stmt.where)) {
-    queryParts.push(whereToKintone(stmt.where));
+function evalGroupingRef(ref, row) {
+  const membership = readGroupingMembership(row);
+  if (!membership) {
+    throw new Error("internal error: GROUPING() evaluation requires B65 grouping row membership.");
   }
-  return {
-    app: appId,
-    query: queryParts.join(" "),
-    fields: []
-    // 全件取得なので全フィールドを取得する
-  };
-}
-function selectToFetchAllFields(stmt, targetTable, plainGroupByPlan) {
-  const plan = collectRequiredFieldsByTable(stmt, plainGroupByPlan);
-  const target = plan.get(targetTable);
-  if (!target) return [];
-  if (target.allFields) return [];
-  const fields = new Set(target.fields);
-  if (target.table.subtableCode) {
-    fields.add(target.table.subtableCode);
+  const canonicalId = groupingRefCanonicalIds.get(ref);
+  if (!canonicalId) {
+    throw new Error("internal error: GROUPING() reference was not resolved during B65 planning.");
   }
-  if (fields.size === 0) fields.add("$id");
-  return [...fields];
+  return membership.has(canonicalId) ? "0" : "1";
 }
-function convertOrderBy(item) {
-  const dir = item.direction === "ASC" ? "asc" : "desc";
-  if (item.key.type !== "FIELD_NAME") {
-    throw new Error("ORDER BY \u5F0F\u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093\uFF08FULL_SCAN \u304C\u5FC5\u8981\u3067\u3059\uFF09");
+
+// src/core/groupingValidation.ts
+var enforceGroupingPlanningCandidateLimits = (facts) => {
+  if (facts.expandedSetCount > B65_MAX_GROUPING_SETS) {
+    throw new Error(
+      `ArgumentError: B65 expanded grouping set count ${facts.expandedSetCount} exceeds limit ${B65_MAX_GROUPING_SETS} (reason=GROUPING_SET_LIMIT_EXCEEDED).`
+    );
   }
-  return `${item.key.name} ${dir}`;
-}
-function extractFields(columns) {
-  const hasWildcard = columns.some(
-    (c) => c.type === "WILDCARD" || c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "CASE_COL" || c.type === "SCALAR_SUBQUERY_COL"
-  );
-  if (hasWildcard) return [];
-  const fields = [];
-  for (const col of columns) {
-    if (col.type === "FIELD") {
-      fields.push(normalizeSimpleFieldRef(col.field));
-    } else if (col.type === "ARITH_COL") {
-      collectArithNode(col.expr, fields);
-    } else if (col.type === "STRFUNC_COL") {
-      collectStringFuncFields(col.expr, fields);
-    } else if (col.type === "SCALAR_VALUE_COL") {
-      collectScalarValueFields(col.expr, fields);
-    }
+  if (facts.canonicalItemCount > B65_MAX_GROUPING_ITEMS) {
+    throw new Error(
+      `ArgumentError: B65 canonical grouping item count ${facts.canonicalItemCount} exceeds limit ${B65_MAX_GROUPING_ITEMS} (reason=GROUPING_ITEM_LIMIT_EXCEEDED).`
+    );
   }
-  return [...new Set(fields)];
-}
-function collectArithFields(expr, out) {
-  collectArithNode(expr.left, out);
-  collectArithNode(expr.right, out);
-}
-function collectArithNode(node, out) {
-  if (node.type === "VARIABLE") throw new Error(
-    `InternalError: unresolved arithmetic variable @${node.name} reached SELECT field collection.`
-  );
-  if (node.type === "FIELD_REF") out.push(normalizeSimpleFieldRef(node.field));
-  else if (node.type === "ARITH") collectArithFields(node, out);
-  else if (node.type === "STRING_FUNC") collectStringFuncFields(node, out);
+};
+function displayField(field) {
+  return field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
 }
-function normalizeSimpleFieldRef(field) {
-  const dot = field.indexOf(".");
-  if (dot <= 0) return field;
-  const unqualified = field.slice(dot + 1);
-  return unqualified || field;
+function refFromName(name) {
+  const dot = name.indexOf(".");
+  return dot > 0 ? { type: "FIELD", tableAlias: name.slice(0, dot), field: name.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field: name };
 }
-function collectStringFuncFields(expr, out) {
-  for (const arg of expr.args) {
-    collectStringFuncArgFields(arg, out);
+function collectGroupingRefs(node, out) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((item) => collectGroupingRefs(item, out));
+    return;
   }
-}
-function collectStringFuncArgFields(arg, out) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
-    collectAggOperandFields(arg, out);
+  const value = node;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+  if (value["type"] === "GROUPING_REF") {
+    out.push(value);
     return;
   }
-  collectScalarValueFields(arg, out);
+  Object.values(value).forEach((item) => collectGroupingRefs(item, out));
 }
-function collectScalarValueFields(expr, out) {
-  if (expr.type === "FIELD") {
-    out.push(normalizeSimpleFieldRef(expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field));
+function collectAggregateArgumentGroupingRefs(node, out) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((item) => collectAggregateArgumentGroupingRefs(item, out));
     return;
   }
-  if (expr.type === "STRING_FUNC") {
-    collectStringFuncFields(expr, out);
+  const value = node;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+  if (value["type"] === "AGGREGATE" || value["type"] === "AGG_REF") {
+    collectGroupingRefs(value["arg"], out);
     return;
   }
-  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
-    collectScalarValueFields(expr.left, out);
-    collectScalarValueFields(expr.right, out);
+  Object.values(value).forEach((item) => collectAggregateArgumentGroupingRefs(item, out));
+}
+function collectNonAggregateFieldRefs(node, out) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((item) => collectNonAggregateFieldRefs(item, out));
     return;
   }
-  if (expr.type === "CASE_WHEN") {
-    for (const branch of expr.branches) collectCaseResultScalarFields(branch.result, out);
-    if (expr.elseResult) collectCaseResultScalarFields(expr.elseResult, out);
-  }
-}
-function collectCaseResultScalarFields(result, out) {
-  if (result.type === "ARRAY") return;
-  if (result.type === "FIELD_REF" || result.type === "ARITH") {
-    collectArithNode(result, out);
+  const value = node;
+  const type = value["type"];
+  if (type === "SELECT" || type === "SCALAR_SUBQUERY" || type === "GROUPING_REF" || type === "AGG_REF" || type === "AGG_ARITH") return;
+  if (type === "FIELD" && value["aggregateRef"] !== void 0) return;
+  if (type === "FIELD" && typeof value["field"] === "string") {
+    out.push({
+      type: "FIELD",
+      tableAlias: typeof value["tableAlias"] === "string" ? value["tableAlias"] : null,
+      field: value["field"]
+    });
     return;
   }
-  collectScalarValueFields(result, out);
-}
-function collectAggOperandFields(node, out) {
-  if (node.type === "AGG_REF") {
-    if (node.arg.type !== "WILDCARD") collectAggregateArgFields(node.arg, out);
+  if (type === "FIELD_REF" && typeof value["field"] === "string") {
+    out.push(refFromName(value["field"]));
     return;
   }
-  if (node.type === "AGG_ARITH") {
-    collectAggOperandFields(node.left, out);
-    collectAggOperandFields(node.right, out);
+  Object.values(value).forEach((item) => collectNonAggregateFieldRefs(item, out));
+}
+function containsAggregate2(node) {
+  if (node === null || typeof node !== "object") return false;
+  if (Array.isArray(node)) return node.some(containsAggregate2);
+  const value = node;
+  if (value["type"] === "AGG_REF" || value["type"] === "AGG_ARITH") return true;
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
+  return Object.values(value).some(containsAggregate2);
+}
+function isAggregateMaterializedAlias(column) {
+  if (!("alias" in column) || column.alias === null) return false;
+  if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
+  if (column.type === "STRFUNC_COL" || column.type === "SCALAR_VALUE_COL" || column.type === "CASE_COL") {
+    return containsAggregate2(column);
   }
+  return false;
 }
-function collectAggregateArgFields(node, out) {
-  if (node.type === "FIELD_REF" || node.type === "ARITH") collectArithNode(node, out);
-  else collectScalarValueFields(node, out);
+function outputAliases(columns) {
+  return new Set(columns.flatMap(
+    (column) => "alias" in column && typeof column.alias === "string" ? [column.alias] : []
+  ));
 }
-function hasAggregateInStringFuncExpr(expr) {
-  return expr.args.some((arg) => {
-    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
-    return scalarValueHasAggregate(arg);
-  });
+function isAggregateSyntheticReference(ref) {
+  return ref.tableAlias === null && /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/.test(ref.field);
 }
-function scalarValueHasAggregate(expr) {
-  if (expr.type === "STRING_FUNC") return hasAggregateInStringFuncExpr(expr);
-  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
-    return scalarValueHasAggregate(expr.left) || scalarValueHasAggregate(expr.right);
+function validateGroupingRefMembership(ref, resolve2, canonicalItems) {
+  const resolved = resolve2(ref.field);
+  if (!resolved.physical) {
+    throw new Error(`ArgumentError: B65 grouping reference ${displayField(ref.field)} must resolve to a physical APP field.`);
   }
-  if (expr.type === "CASE_WHEN") {
-    return expr.branches.some((b) => caseResultHasAggregate(b.result)) || expr.elseResult !== null && caseResultHasAggregate(expr.elseResult);
+  if (!canonicalItems.has(resolved.canonicalId)) {
+    throw new Error(
+      `ArgumentError: B65 GROUPING argument ${displayField(ref.field)} is not present in grouping allItems (reason=B65_GROUPING_ARG_NOT_ITEM).`
+    );
   }
-  return false;
+  bindGroupingRefCanonicalId(ref, resolved.canonicalId);
 }
-function caseResultHasAggregate(result) {
-  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
-  return scalarValueHasAggregate(result);
+function validateDependency(ref, resolve2, canonicalItems, context) {
+  const resolved = resolve2(ref);
+  if (!resolved.physical || !canonicalItems.has(resolved.canonicalId)) {
+    throw new Error(
+      `ArgumentError: B65 non-aggregate field ${displayField(ref)} in ${context} is not a grouping item (reason=B65_NON_GROUPED_DEPENDENCY).`
+    );
+  }
 }
-function collectSelectFieldReferencesBySource(stmt, plainGroupByPlan) {
-  const unqualified = /* @__PURE__ */ new Set();
-  const states = collectRequiredFieldsByTable(stmt, plainGroupByPlan, {
-    includeMaterialized: true,
-    unqualified
-  });
-  return {
-    bySource: new Map(
-      [...states.entries()].map(([table, state]) => [table, new Set(state.fields)])
-    ),
-    unqualified
-  };
+function keyDependencies(key) {
+  if (key.type === "GROUPING_KEY") return [];
+  if (key.type === "FIELD_NAME") return [refFromName(key.name)];
+  const refs = [];
+  collectNonAggregateFieldRefs(key, refs);
+  return refs;
 }
-function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
-  const allTables = [stmt.from, ...stmt.joins.map((j) => j.table)];
-  const physicalTables = [stmt.from, ...stmt.joins.map((j) => j.table)].filter((t) => t.cteName === null);
-  const targetTables = sourceAware ? allTables : physicalTables;
-  const states = /* @__PURE__ */ new Map();
-  for (const table of targetTables) {
-    states.set(table, { table, allFields: false, fields: /* @__PURE__ */ new Set() });
+function validateGroupingStatic(stmt) {
+  const normalized = normalizeGroupingSpec(stmt);
+  const groupingRefs = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
   }
-  if (states.size === 0) return states;
-  const firstTargetTable = targetTables[0] ?? null;
-  const subtableTable = targetTables.find((t) => !!t.subtableCode) ?? null;
-  const aliasToTable = /* @__PURE__ */ new Map();
-  for (const table of targetTables) {
-    if (table.alias) aliasToTable.set(table.alias, table);
-    if (table.cteName !== null) {
-      aliasToTable.set(table.cteName, table);
-    } else if (!table.subtableCode) {
-      aliasToTable.set(`APP${table.appId}`, table);
-      aliasToTable.set(`app${table.appId}`, table);
+  collectGroupingRefs(stmt.having, groupingRefs);
+  collectGroupingRefs(stmt.orderBy, groupingRefs);
+  const forbiddenGroupingRefs = [];
+  collectGroupingRefs(stmt.where, forbiddenGroupingRefs);
+  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: B65 GROUPING() is not allowed in WHERE, JOIN, window, aggregate arguments, or DML expressions."
+    );
+  }
+  if (normalized.type !== "GROUPING_SETS") {
+    if (groupingRefs.length > 0) {
+      throw new Error("ArgumentError: B65 GROUPING() requires GROUP BY ROLLUP or GROUPING SETS.");
     }
+    return;
   }
-  const selectAliases = collectSelectOutputNames(stmt.columns);
-  const markAll = (table) => {
-    const st = states.get(table);
-    if (!st) return;
-    st.allFields = true;
-    st.fields.clear();
-  };
-  const markAllTargetTables = () => {
-    for (const t of targetTables) markAll(t);
-  };
-  const markAllSubtableTables = () => {
-    for (const t of targetTables) {
-      if (t.subtableCode) markAll(t);
+  if (stmt.orderMode === "KINTONE_NATIVE") {
+    throw new Error("ArgumentError: B65 KORDER BY is not supported in Phase1.");
+  }
+  if (stmt.columns.some((column) => column.type === "WINDOW_COL")) {
+    throw new Error("ArgumentError: B65 window functions are not supported in Phase1.");
+  }
+  if (stmt.columns.some(
+    (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
+  )) {
+    throw new Error("ArgumentError: B65 wildcard projection is not supported in Phase1.");
+  }
+}
+function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void 0) {
+  validateGroupingStatic(stmt);
+  const normalized = normalizeGroupingSpec(stmt);
+  const groupingRefs = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
+  }
+  collectGroupingRefs(stmt.having, groupingRefs);
+  collectGroupingRefs(stmt.orderBy, groupingRefs);
+  if (normalized.type !== "GROUPING_SETS") {
+    return null;
+  }
+  const resolvedSpec = resolveGroupingSpec(stmt, resolve2);
+  const canonicalItems = /* @__PURE__ */ new Set();
+  const resolvedItems = [];
+  for (const item of resolvedSpec.allItems) {
+    const resolved = item;
+    if (!resolved.physical) {
+      throw new Error(`ArgumentError: B65 grouping item ${displayField(item.field)} must resolve to a physical APP field.`);
     }
-  };
-  const addFieldToTable = (table, fieldName) => {
-    const st = states.get(table);
-    if (!st || st.allFields) return;
-    if (table.subtableCode) {
-      if (fieldName.startsWith("_p.")) {
-        const parentField = fieldName.slice(3);
-        if (parentField && parentField !== "*") st.fields.add(parentField);
-        return;
-      }
-      if (fieldName === "_pid" || fieldName === "_rid" || fieldName === "_idx" || fieldName === "$id") {
-        return;
-      }
-      return;
+    if (!canonicalItems.has(resolved.canonicalId)) {
+      canonicalItems.add(resolved.canonicalId);
+      resolvedItems.push(resolved);
     }
-    if (!fieldName) return;
-    st.fields.add(fieldName);
-  };
-  const addFieldName = (rawName, phase = "select", groupResolution) => {
-    if (!rawName || rawName === "*") return;
-    if (rawName === "_p.*") {
-      markAllSubtableTables();
-      return;
+  }
+  planningGuardHook({
+    expandedSetCount: normalized.sets.length,
+    canonicalItemCount: canonicalItems.size
+  });
+  for (const ref of groupingRefs) {
+    validateGroupingRefMembership(ref, resolve2, canonicalItems);
+  }
+  const aliases = outputAliases(stmt.columns);
+  for (const column of stmt.columns) {
+    if (column.type === "GROUPING_COL" || column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL" || column.type === "LITERAL_COL" || column.type === "VARIABLE_COL" || column.type === "SCALAR_SUBQUERY_COL") continue;
+    const refs = [];
+    if (column.type === "FIELD") refs.push(refFromName(column.field));
+    else collectNonAggregateFieldRefs(column, refs);
+    for (const ref of refs) validateDependency(ref, resolve2, canonicalItems, "SELECT");
+  }
+  if (stmt.having) {
+    const refs = [];
+    collectNonAggregateFieldRefs(stmt.having, refs);
+    for (const ref of refs) {
+      if (ref.tableAlias === null && aliases.has(ref.field) || isAggregateSyntheticReference(ref)) continue;
+      validateDependency(ref, resolve2, canonicalItems, "HAVING");
     }
-    if (rawName.endsWith(".*")) {
-      const qualifier = rawName.slice(0, -2);
-      if (!qualifier) {
-        markAllTargetTables();
-        return;
-      }
-      if (qualifier === "_p") {
-        markAllSubtableTables();
+  }
+  for (const order of stmt.orderBy) {
+    for (const ref of keyDependencies(order.key)) {
+      if (ref.tableAlias === null && aliases.has(ref.field) || isAggregateSyntheticReference(ref)) continue;
+      validateDependency(ref, resolve2, canonicalItems, "ORDER BY");
+    }
+  }
+  const collisionKeys = /* @__PURE__ */ new Set();
+  for (const item of resolvedItems) {
+    collisionKeys.add(item.directKey);
+    if (item.unqualifiedBridgeKey !== null) collisionKeys.add(item.unqualifiedBridgeKey);
+  }
+  for (const column of stmt.columns) {
+    if (!isAggregateMaterializedAlias(column)) continue;
+    const alias = "alias" in column ? column.alias : null;
+    if (alias === null) continue;
+    if (collisionKeys.has(alias)) {
+      throw new Error(
+        `ArgumentError: B65 aggregate alias ${alias} collides with a grouping runtime key (reason=B65_AGGREGATE_ALIAS_COLLISION).`
+      );
+    }
+  }
+  return resolvedSpec;
+}
+
+// src/converter/selectToKintone.ts
+function hasWindowColumns(columns) {
+  return columns.some((column) => column.type === "WINDOW_COL");
+}
+function resolveSelectMode(stmt) {
+  if (stmt.from.subtableCode) return "FULL_SCAN";
+  if (stmt.joins.some((j) => j.table.subtableCode)) return "FULL_SCAN";
+  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 (stmt.columns.some(
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "SCALAR_SUBQUERY_COL" || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(c.expr)
+  )) return "FULL_SCAN";
+  if (whereRequiresJsEval(stmt.where)) return "FULL_SCAN";
+  if (stmt.orderBy.some((o) => o.key.type !== "FIELD_NAME")) return "FULL_SCAN";
+  return "SIMPLE";
+}
+function whereRequiresJsEval(where) {
+  if (where === null) return false;
+  switch (where.type) {
+    case "BOOLEAN":
+      return true;
+    case "BINARY":
+      return isFunc(where.left) || where.right.type === "ARITH_VALUE" || where.right.type === "CASE_VALUE" || where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY" || isLike(where);
+    case "NULL_CHECK":
+      return isFunc(where.field);
+    case "LOGICAL":
+      return whereRequiresJsEval(where.left) || whereRequiresJsEval(where.right);
+    case "NOT":
+    case "GROUP":
+      return whereRequiresJsEval(where.expr);
+    case "EXISTS":
+      return true;
+  }
+}
+function isFunc(fv) {
+  return fv.type === "FUNC_FIELD" || fv.type === "ARITH_FIELD" || fv.type === "CASE_FIELD";
+}
+function selectToKintoneParams(stmt) {
+  const queryParts = [];
+  const hasPagination = stmt.limit !== null || stmt.offset !== null;
+  const shouldInjectDefaultOrder = hasPagination && stmt.orderBy.length === 0;
+  if (stmt.where !== null) {
+    queryParts.push(whereToKintone(stmt.where));
+  }
+  if (stmt.orderBy.length > 0) {
+    const orderStr = stmt.orderBy.map(convertOrderBy).join(", ");
+    queryParts.push(`order by ${orderStr}`);
+  } else if (shouldInjectDefaultOrder) {
+    queryParts.push("order by $id asc");
+  }
+  if (stmt.limit !== null) {
+    queryParts.push(`limit ${stmt.limit}`);
+  }
+  if (stmt.offset !== null) {
+    queryParts.push(`offset ${stmt.offset}`);
+  }
+  return {
+    app: stmt.from.appId,
+    query: queryParts.join(" "),
+    fields: extractFields(stmt.columns),
+    totalCount: false
+  };
+}
+function selectToFetchAllParams(stmt, appId) {
+  const queryParts = [];
+  if (stmt.where !== null && stmt.joins.length === 0 && !whereRequiresJsEval(stmt.where)) {
+    queryParts.push(whereToKintone(stmt.where));
+  }
+  return {
+    app: appId,
+    query: queryParts.join(" "),
+    fields: []
+    // 全件取得なので全フィールドを取得する
+  };
+}
+function selectToFetchAllFields(stmt, targetTable, plainGroupByPlan) {
+  const plan = collectRequiredFieldsByTable(stmt, plainGroupByPlan);
+  const target = plan.get(targetTable);
+  if (!target) return [];
+  if (target.allFields) return [];
+  const fields = new Set(target.fields);
+  if (target.table.subtableCode) {
+    fields.add(target.table.subtableCode);
+  }
+  if (fields.size === 0) fields.add("$id");
+  return [...fields];
+}
+function convertOrderBy(item) {
+  const dir = item.direction === "ASC" ? "asc" : "desc";
+  if (item.key.type !== "FIELD_NAME") {
+    throw new Error("ORDER BY \u5F0F\u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093\uFF08FULL_SCAN \u304C\u5FC5\u8981\u3067\u3059\uFF09");
+  }
+  return `${item.key.name} ${dir}`;
+}
+function extractFields(columns) {
+  const hasWildcard = columns.some(
+    (c) => c.type === "WILDCARD" || c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "CASE_COL" || c.type === "SCALAR_SUBQUERY_COL"
+  );
+  if (hasWildcard) return [];
+  const fields = [];
+  for (const col of columns) {
+    if (col.type === "FIELD") {
+      fields.push(normalizeSimpleFieldRef(col.field));
+    } else if (col.type === "ARITH_COL") {
+      collectArithNode(col.expr, fields);
+    } else if (col.type === "STRFUNC_COL") {
+      collectStringFuncFields(col.expr, fields);
+    } else if (col.type === "SCALAR_VALUE_COL") {
+      collectScalarValueFields(col.expr, fields);
+    }
+  }
+  return [...new Set(fields)];
+}
+function collectArithFields(expr, out) {
+  collectArithNode(expr.left, out);
+  collectArithNode(expr.right, out);
+}
+function collectArithNode(node, out) {
+  if (node.type === "VARIABLE") throw new Error(
+    `InternalError: unresolved arithmetic variable @${node.name} reached SELECT field collection.`
+  );
+  if (node.type === "FIELD_REF") out.push(normalizeSimpleFieldRef(node.field));
+  else if (node.type === "ARITH") collectArithFields(node, out);
+  else if (node.type === "STRING_FUNC") collectStringFuncFields(node, out);
+}
+function normalizeSimpleFieldRef(field) {
+  const dot = field.indexOf(".");
+  if (dot <= 0) return field;
+  const unqualified = field.slice(dot + 1);
+  return unqualified || field;
+}
+function collectStringFuncFields(expr, out) {
+  for (const arg of expr.args) {
+    collectStringFuncArgFields(arg, out);
+  }
+}
+function collectStringFuncArgFields(arg, out) {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+    collectAggOperandFields(arg, out);
+    return;
+  }
+  collectScalarValueFields(arg, out);
+}
+function collectScalarValueFields(expr, out) {
+  if (expr.type === "FIELD") {
+    out.push(normalizeSimpleFieldRef(expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field));
+    return;
+  }
+  if (expr.type === "STRING_FUNC") {
+    collectStringFuncFields(expr, out);
+    return;
+  }
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    collectScalarValueFields(expr.left, out);
+    collectScalarValueFields(expr.right, out);
+    return;
+  }
+  if (expr.type === "CASE_WHEN") {
+    for (const branch of expr.branches) collectCaseResultScalarFields(branch.result, out);
+    if (expr.elseResult) collectCaseResultScalarFields(expr.elseResult, out);
+  }
+}
+function collectCaseResultScalarFields(result, out) {
+  if (result.type === "ARRAY") return;
+  if (result.type === "AGG_REF" || result.type === "AGG_ARITH") {
+    collectAggOperandFields(result, out);
+    return;
+  }
+  if (result.type === "FIELD_REF" || result.type === "ARITH") {
+    collectArithNode(result, out);
+    return;
+  }
+  collectScalarValueFields(result, out);
+}
+function collectAggOperandFields(node, out) {
+  if (node.type === "AGG_REF") {
+    if (node.arg.type !== "WILDCARD") collectAggregateArgFields(node.arg, out);
+    return;
+  }
+  if (node.type === "AGG_ARITH") {
+    collectAggOperandFields(node.left, out);
+    collectAggOperandFields(node.right, out);
+  }
+}
+function collectAggregateArgFields(node, out) {
+  if (node.type === "FIELD_REF" || node.type === "ARITH") collectArithNode(node, out);
+  else collectScalarValueFields(node, out);
+}
+function hasAggregateInStringFuncExpr(expr) {
+  return expr.args.some((arg) => {
+    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+    return scalarValueHasAggregate(arg);
+  });
+}
+function scalarValueHasAggregate(expr) {
+  if (expr.type === "STRING_FUNC") return hasAggregateInStringFuncExpr(expr);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return scalarValueHasAggregate(expr.left) || scalarValueHasAggregate(expr.right);
+  }
+  if (expr.type === "CASE_WHEN") {
+    return expr.branches.some((b) => caseResultHasAggregate(b.result)) || expr.elseResult !== null && caseResultHasAggregate(expr.elseResult);
+  }
+  return false;
+}
+function caseResultHasAggregate(result) {
+  if (result.type === "AGG_REF" || result.type === "AGG_ARITH") return true;
+  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
+  return scalarValueHasAggregate(result);
+}
+function collectSelectFieldReferencesBySource(stmt, plainGroupByPlan) {
+  const unqualified = /* @__PURE__ */ new Set();
+  const states = collectRequiredFieldsByTable(stmt, plainGroupByPlan, {
+    includeMaterialized: true,
+    unqualified
+  });
+  return {
+    bySource: new Map(
+      [...states.entries()].map(([table, state]) => [table, new Set(state.fields)])
+    ),
+    unqualified
+  };
+}
+function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
+  const allTables = [stmt.from, ...stmt.joins.map((j) => j.table)];
+  const physicalTables = [stmt.from, ...stmt.joins.map((j) => j.table)].filter((t) => t.cteName === null);
+  const targetTables = sourceAware ? allTables : physicalTables;
+  const states = /* @__PURE__ */ new Map();
+  for (const table of targetTables) {
+    states.set(table, { table, allFields: false, fields: /* @__PURE__ */ new Set() });
+  }
+  if (states.size === 0) return states;
+  const firstTargetTable = targetTables[0] ?? null;
+  const subtableTable = targetTables.find((t) => !!t.subtableCode) ?? null;
+  const aliasToTable = /* @__PURE__ */ new Map();
+  for (const table of targetTables) {
+    if (table.alias) aliasToTable.set(table.alias, table);
+    if (table.cteName !== null) {
+      aliasToTable.set(table.cteName, table);
+    } else if (!table.subtableCode) {
+      aliasToTable.set(`APP${table.appId}`, table);
+      aliasToTable.set(`app${table.appId}`, table);
+    }
+  }
+  const selectAliases = collectSelectOutputNames(stmt.columns);
+  const markAll = (table) => {
+    const st = states.get(table);
+    if (!st) return;
+    st.allFields = true;
+    st.fields.clear();
+  };
+  const markAllTargetTables = () => {
+    for (const t of targetTables) markAll(t);
+  };
+  const markAllSubtableTables = () => {
+    for (const t of targetTables) {
+      if (t.subtableCode) markAll(t);
+    }
+  };
+  const addFieldToTable = (table, fieldName) => {
+    const st = states.get(table);
+    if (!st || st.allFields) return;
+    if (table.subtableCode) {
+      if (fieldName.startsWith("_p.")) {
+        const parentField = fieldName.slice(3);
+        if (parentField && parentField !== "*") st.fields.add(parentField);
+        return;
+      }
+      if (fieldName === "_pid" || fieldName === "_rid" || fieldName === "_idx" || fieldName === "$id") {
+        return;
+      }
+      return;
+    }
+    if (!fieldName) return;
+    st.fields.add(fieldName);
+  };
+  const addFieldName = (rawName, phase = "select", groupResolution) => {
+    if (!rawName || rawName === "*") return;
+    if (rawName === "_p.*") {
+      markAllSubtableTables();
+      return;
+    }
+    if (rawName.endsWith(".*")) {
+      const qualifier = rawName.slice(0, -2);
+      if (!qualifier) {
+        markAllTargetTables();
+        return;
+      }
+      if (qualifier === "_p") {
+        markAllSubtableTables();
         return;
       }
       const target = aliasToTable.get(qualifier);
@@ -5667,6 +6088,10 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
   };
   const walkCaseResult = (result, phase = "select") => {
     if (result.type === "ARRAY") return;
+    if (result.type === "AGG_REF" || result.type === "AGG_ARITH") {
+      walkAgg(result, phase);
+      return;
+    }
     if (result.type === "FIELD_REF" || result.type === "ARITH") {
       walkArith(result, phase);
       return;
@@ -5682,6 +6107,10 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
   };
   const walkFieldValue = (fv, phase = "select") => {
     if (fv.type === "FIELD") {
+      if (fv.aggregateRef) {
+        walkAgg(fv.aggregateRef, phase);
+        return;
+      }
       addFieldRef(fv.field, fv.tableAlias, phase);
       return;
     }
@@ -5689,6 +6118,10 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       walkStringFunc(fv.expr, phase);
       return;
     }
+    if (fv.type === "AGG_FIELD") {
+      walkAgg(fv.expr, phase);
+      return;
+    }
     if (fv.type === "ARITH_FIELD") {
       walkArith(fv.expr, phase);
       return;
@@ -5794,6 +6227,9 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       case "SCALAR_SUBQUERY_COL":
         break;
       case "WINDOW_COL":
+        if (col.windowKind === "AGGREGATE" && col.arg.type !== "WILDCARD") {
+          walkAggregateArg(col.arg, "select");
+        }
         for (const ref of col.partitionBy) addFieldRef(ref.field, ref.tableAlias, "select");
         for (const item of col.orderBy) walkOrderByKey(item.key, "select");
         break;
@@ -6449,464 +6885,198 @@ function containsKlikeOutsideWhereAndNestedSelects(node, allowedWhere) {
     if (obj.type === "SELECT") return;
     if (obj.type === "BINARY" && (obj.op === "KLIKE" || obj.op === "NOT_KLIKE")) {
       found = true;
-      return;
-    }
-    for (const child of Object.values(obj)) visit(child);
-  };
-  visit(node);
-  return found;
-}
-function isDescendantOf(root, target) {
-  if (root === null) return false;
-  if (root === target) return true;
-  switch (root.type) {
-    case "LOGICAL":
-      return isDescendantOf(root.left, target) || isDescendantOf(root.right, target);
-    case "NOT":
-    case "GROUP":
-      return isDescendantOf(root.expr, target);
-    case "BINARY":
-    case "NULL_CHECK":
-    case "EXISTS":
-      return false;
-    case "BOOLEAN":
-      return false;
-  }
-}
-function walkWithoutNestedSelects(node, visitWhere) {
-  if (Array.isArray(node)) {
-    for (const value of node) walkWithoutNestedSelects(value, visitWhere);
-    return;
-  }
-  if (node === null || typeof node !== "object") return;
-  const obj = node;
-  if (obj.type === "BINARY" || obj.type === "NULL_CHECK" || obj.type === "LOGICAL" || obj.type === "NOT" || obj.type === "GROUP" || obj.type === "EXISTS") {
-    visitWhere(obj);
-  }
-  for (const value of Object.values(obj)) {
-    if (value !== node && isSelectObject(value)) continue;
-    walkWithoutNestedSelects(value, visitWhere);
-  }
-}
-function walkObjects(node, visit, skipRoot = false) {
-  if (Array.isArray(node)) {
-    for (const value of node) walkObjects(value, visit);
-    return;
-  }
-  if (node === null || typeof node !== "object") return;
-  const obj = node;
-  if (!skipRoot) visit(obj);
-  for (const value of Object.values(obj)) walkObjects(value, visit);
-}
-function isSelectObject(value) {
-  return value !== null && typeof value === "object" && value.type === "SELECT";
-}
-
-// src/core/primaryOrganizationDmlValidation.ts
-var PrimaryOrganizationDmlValidationError = class extends Error {
-  constructor() {
-    super(
-      "ArgumentError: PRIMARY_ORGANIZATION() \u306F DML \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
-    );
-    this.name = "ArgumentError";
-  }
-};
-function validatePrimaryOrganizationDmlStatement(stmt) {
-  const target = stmt.type === "EXPLAIN" ? stmt.query : stmt;
-  switch (target.type) {
-    case "UPDATE":
-    case "DELETE":
-    case "UPSERT":
-    case "UPSERT_SELECT":
-    case "INSERT_SELECT":
-      if (hasPrimaryOrganizationInWhere(target)) {
-        throw new PrimaryOrganizationDmlValidationError();
-      }
-      return;
-    default:
-      return;
-  }
-}
-function hasPrimaryOrganizationInWhere(node) {
-  let found = false;
-  walkObjects2(node, (obj) => {
-    if (found || !Object.prototype.hasOwnProperty.call(obj, "where")) return;
-    if (containsPrimaryOrganization(obj.where)) found = true;
-  });
-  return found;
-}
-function containsPrimaryOrganization(node) {
-  let found = false;
-  walkObjects2(node, (obj) => {
-    if (obj.type === "KINTONE_FUNC" && obj.name === "PRIMARY_ORGANIZATION") {
-      found = true;
-    }
-  });
-  return found;
-}
-function walkObjects2(node, visit) {
-  if (Array.isArray(node)) {
-    for (const value of node) walkObjects2(value, visit);
-    return;
-  }
-  if (node === null || typeof node !== "object") return;
-  const obj = node;
-  visit(obj);
-  for (const value of Object.values(obj)) walkObjects2(value, visit);
-}
-
-// src/core/functionArity.ts
-function assertArity(func, args, min, max = Number.POSITIVE_INFINITY) {
-  if (args.length >= min && args.length <= max) return;
-  const expected = min === max ? String(min) : max === Number.POSITIVE_INFINITY ? `${min} or more` : `${min} to ${max}`;
-  throw new Error(`ArgumentError: ${func} expects ${expected} argument(s).`);
-}
-function assertStringFunctionArity(func, args) {
-  switch (func) {
-    case "UPPER":
-    case "LOWER":
-    case "TRIM":
-    case "LTRIM":
-    case "RTRIM":
-    case "LENGTH":
-    case "LENGTH_CHAR":
-    case "YEAR":
-    case "MONTH":
-    case "DAY":
-    case "DAYOFWEEK":
-    case "QUARTER":
-    case "WEEK":
-    case "LAST_DAY":
-    case "ABS":
-    case "SQRT":
-      return assertArity(func, args, 1, 1);
-    case "SUBSTRING":
-    case "LPAD":
-    case "RPAD":
-    case "REGEXP_LIKE":
-    case "REGEXP_SUBSTR":
-      return assertArity(func, args, 2, 3);
-    case "LEFT":
-    case "RIGHT":
-    case "INSTR":
-    case "ISNULL":
-    case "NULLIF":
-    case "MOD":
-    case "POWER":
-    case "FORMAT":
-    case "CAST":
-    case "DATE_FORMAT":
-    case "DATEDIFF":
-      return assertArity(func, args, 2, 2);
-    case "CONCAT":
-    case "COALESCE":
-    case "GREATEST":
-    case "LEAST":
-      return assertArity(func, args, 2);
-    case "REPLACE":
-    case "TRANSLATE":
-    case "DATE_ADD":
-      return assertArity(func, args, 3, 3);
-    case "REGEXP_REPLACE":
-      return assertArity(func, args, 3, 5);
-    case "ROUND":
-    case "FLOOR":
-    case "CEIL":
-    case "TRUNCATE":
-      return assertArity(func, args, 1, 2);
-    case "CURRENT_DATE":
-    case "CURRENT_TIMESTAMP":
-      return assertArity(func, args, 0, 0);
-  }
-}
-
-// src/core/statementValidation.ts
-function validateStatementStatic(stmt) {
-  validateStringFunctionArities(stmt);
-  validatePrimaryOrganizationDmlStatement(stmt);
-  validateKlikeStatement(stmt);
-}
-function validateStringFunctionArities(stmt) {
-  const visit = (value) => {
-    if (value === null || typeof value !== "object") return;
-    if (Array.isArray(value)) {
-      value.forEach(visit);
-      return;
-    }
-    const node = value;
-    if (node.type === "STRING_FUNC") {
-      const expr = node;
-      assertStringFunctionArity(expr.func, expr.args);
-    }
-    Object.values(node).forEach(visit);
-  };
-  visit(stmt);
-}
-
-// src/engine/groupingRowMeta.ts
-var groupingRowMetaKey = /* @__PURE__ */ Symbol("ksql.groupingRowMeta");
-var groupingRefCanonicalIds = /* @__PURE__ */ new WeakMap();
-function attachGroupingRowMeta(row, includedCanonicalIds) {
-  Object.defineProperty(row, groupingRowMetaKey, {
-    value: { includedCanonicalIds },
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-  return row;
-}
-function getGroupingRowMeta(row) {
-  return row[groupingRowMetaKey];
-}
-function readGroupingMembership(row) {
-  return getGroupingRowMeta(row)?.includedCanonicalIds;
-}
-function bindGroupingRefCanonicalId(ref, canonicalId) {
-  groupingRefCanonicalIds.set(ref, canonicalId);
-}
-function evalGroupingRef(ref, row) {
-  const membership = readGroupingMembership(row);
-  if (!membership) {
-    throw new Error("internal error: GROUPING() evaluation requires B65 grouping row membership.");
-  }
-  const canonicalId = groupingRefCanonicalIds.get(ref);
-  if (!canonicalId) {
-    throw new Error("internal error: GROUPING() reference was not resolved during B65 planning.");
-  }
-  return membership.has(canonicalId) ? "0" : "1";
+      return;
+    }
+    for (const child of Object.values(obj)) visit(child);
+  };
+  visit(node);
+  return found;
 }
-
-// src/core/groupingValidation.ts
-var enforceGroupingPlanningCandidateLimits = (facts) => {
-  if (facts.expandedSetCount > B65_MAX_GROUPING_SETS) {
-    throw new Error(
-      `ArgumentError: B65 expanded grouping set count ${facts.expandedSetCount} exceeds limit ${B65_MAX_GROUPING_SETS} (reason=GROUPING_SET_LIMIT_EXCEEDED).`
-    );
-  }
-  if (facts.canonicalItemCount > B65_MAX_GROUPING_ITEMS) {
-    throw new Error(
-      `ArgumentError: B65 canonical grouping item count ${facts.canonicalItemCount} exceeds limit ${B65_MAX_GROUPING_ITEMS} (reason=GROUPING_ITEM_LIMIT_EXCEEDED).`
-    );
+function isDescendantOf(root, target) {
+  if (root === null) return false;
+  if (root === target) return true;
+  switch (root.type) {
+    case "LOGICAL":
+      return isDescendantOf(root.left, target) || isDescendantOf(root.right, target);
+    case "NOT":
+    case "GROUP":
+      return isDescendantOf(root.expr, target);
+    case "BINARY":
+    case "NULL_CHECK":
+    case "EXISTS":
+      return false;
+    case "BOOLEAN":
+      return false;
   }
-};
-function displayField(field) {
-  return field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
-}
-function refFromName(name) {
-  const dot = name.indexOf(".");
-  return dot > 0 ? { type: "FIELD", tableAlias: name.slice(0, dot), field: name.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field: name };
 }
-function collectGroupingRefs(node, out) {
-  if (node === null || typeof node !== "object") return;
+function walkWithoutNestedSelects(node, visitWhere) {
   if (Array.isArray(node)) {
-    node.forEach((item) => collectGroupingRefs(item, out));
-    return;
-  }
-  const value = node;
-  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
-  if (value["type"] === "GROUPING_REF") {
-    out.push(value);
+    for (const value of node) walkWithoutNestedSelects(value, visitWhere);
     return;
   }
-  Object.values(value).forEach((item) => collectGroupingRefs(item, out));
-}
-function collectAggregateArgumentGroupingRefs(node, out) {
   if (node === null || typeof node !== "object") return;
-  if (Array.isArray(node)) {
-    node.forEach((item) => collectAggregateArgumentGroupingRefs(item, out));
-    return;
+  const obj = node;
+  if (obj.type === "BINARY" || obj.type === "NULL_CHECK" || obj.type === "LOGICAL" || obj.type === "NOT" || obj.type === "GROUP" || obj.type === "EXISTS") {
+    visitWhere(obj);
   }
-  const value = node;
-  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
-  if (value["type"] === "AGGREGATE" || value["type"] === "AGG_REF") {
-    collectGroupingRefs(value["arg"], out);
-    return;
+  for (const value of Object.values(obj)) {
+    if (value !== node && isSelectObject(value)) continue;
+    walkWithoutNestedSelects(value, visitWhere);
   }
-  Object.values(value).forEach((item) => collectAggregateArgumentGroupingRefs(item, out));
 }
-function collectNonAggregateFieldRefs(node, out) {
-  if (node === null || typeof node !== "object") return;
+function walkObjects(node, visit, skipRoot = false) {
   if (Array.isArray(node)) {
-    node.forEach((item) => collectNonAggregateFieldRefs(item, out));
-    return;
-  }
-  const value = node;
-  const type = value["type"];
-  if (type === "SELECT" || type === "SCALAR_SUBQUERY" || type === "GROUPING_REF" || type === "AGG_REF" || type === "AGG_ARITH") return;
-  if (type === "FIELD" && typeof value["field"] === "string") {
-    out.push({
-      type: "FIELD",
-      tableAlias: typeof value["tableAlias"] === "string" ? value["tableAlias"] : null,
-      field: value["field"]
-    });
-    return;
-  }
-  if (type === "FIELD_REF" && typeof value["field"] === "string") {
-    out.push(refFromName(value["field"]));
+    for (const value of node) walkObjects(value, visit);
     return;
   }
-  Object.values(value).forEach((item) => collectNonAggregateFieldRefs(item, out));
-}
-function containsAggregate2(node) {
-  if (node === null || typeof node !== "object") return false;
-  if (Array.isArray(node)) return node.some(containsAggregate2);
-  const value = node;
-  if (value["type"] === "AGG_REF" || value["type"] === "AGG_ARITH") return true;
-  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return false;
-  return Object.values(value).some(containsAggregate2);
-}
-function isAggregateMaterializedAlias(column) {
-  if (!("alias" in column) || column.alias === null) return false;
-  if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
-  if (column.type === "STRFUNC_COL" || column.type === "SCALAR_VALUE_COL") {
-    return containsAggregate2(column);
-  }
-  return false;
-}
-function outputAliases(columns) {
-  return new Set(columns.flatMap(
-    (column) => "alias" in column && typeof column.alias === "string" ? [column.alias] : []
-  ));
-}
-function isAggregateSyntheticReference(ref) {
-  return ref.tableAlias === null && /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/.test(ref.field);
-}
-function validateGroupingRefMembership(ref, resolve2, canonicalItems) {
-  const resolved = resolve2(ref.field);
-  if (!resolved.physical) {
-    throw new Error(`ArgumentError: B65 grouping reference ${displayField(ref.field)} must resolve to a physical APP field.`);
-  }
-  if (!canonicalItems.has(resolved.canonicalId)) {
-    throw new Error(
-      `ArgumentError: B65 GROUPING argument ${displayField(ref.field)} is not present in grouping allItems (reason=B65_GROUPING_ARG_NOT_ITEM).`
-    );
-  }
-  bindGroupingRefCanonicalId(ref, resolved.canonicalId);
-}
-function validateDependency(ref, resolve2, canonicalItems, context) {
-  const resolved = resolve2(ref);
-  if (!resolved.physical || !canonicalItems.has(resolved.canonicalId)) {
-    throw new Error(
-      `ArgumentError: B65 non-aggregate field ${displayField(ref)} in ${context} is not a grouping item (reason=B65_NON_GROUPED_DEPENDENCY).`
-    );
-  }
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  if (!skipRoot) visit(obj);
+  for (const value of Object.values(obj)) walkObjects(value, visit);
 }
-function keyDependencies(key) {
-  if (key.type === "GROUPING_KEY") return [];
-  if (key.type === "FIELD_NAME") return [refFromName(key.name)];
-  const refs = [];
-  collectNonAggregateFieldRefs(key, refs);
-  return refs;
+function isSelectObject(value) {
+  return value !== null && typeof value === "object" && value.type === "SELECT";
 }
-function validateGroupingStatic(stmt) {
-  const normalized = normalizeGroupingSpec(stmt);
-  const groupingRefs = [];
-  for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
-  }
-  collectGroupingRefs(stmt.having, groupingRefs);
-  collectGroupingRefs(stmt.orderBy, groupingRefs);
-  const forbiddenGroupingRefs = [];
-  collectGroupingRefs(stmt.where, forbiddenGroupingRefs);
-  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: B65 GROUPING() is not allowed in WHERE, JOIN, window, aggregate arguments, or DML expressions."
+
+// src/core/primaryOrganizationDmlValidation.ts
+var PrimaryOrganizationDmlValidationError = class extends Error {
+  constructor() {
+    super(
+      "ArgumentError: PRIMARY_ORGANIZATION() \u306F DML \u306E WHERE \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093"
     );
+    this.name = "ArgumentError";
   }
-  if (normalized.type !== "GROUPING_SETS") {
-    if (groupingRefs.length > 0) {
-      throw new Error("ArgumentError: B65 GROUPING() requires GROUP BY ROLLUP or GROUPING SETS.");
-    }
-    return;
-  }
-  if (stmt.orderMode === "KINTONE_NATIVE") {
-    throw new Error("ArgumentError: B65 KORDER BY is not supported in Phase1.");
-  }
-  if (stmt.columns.some((column) => column.type === "WINDOW_COL")) {
-    throw new Error("ArgumentError: B65 window functions are not supported in Phase1.");
-  }
-  if (stmt.columns.some(
-    (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
-  )) {
-    throw new Error("ArgumentError: B65 wildcard projection is not supported in Phase1.");
-  }
-}
-function validateGroupingPlanning(stmt, resolve2, planningGuardHook = () => void 0) {
-  validateGroupingStatic(stmt);
-  const normalized = normalizeGroupingSpec(stmt);
-  const groupingRefs = [];
-  for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL") collectGroupingRefs(column, groupingRefs);
-  }
-  collectGroupingRefs(stmt.having, groupingRefs);
-  collectGroupingRefs(stmt.orderBy, groupingRefs);
-  if (normalized.type !== "GROUPING_SETS") {
-    return null;
-  }
-  const resolvedSpec = resolveGroupingSpec(stmt, resolve2);
-  const canonicalItems = /* @__PURE__ */ new Set();
-  const resolvedItems = [];
-  for (const item of resolvedSpec.allItems) {
-    const resolved = item;
-    if (!resolved.physical) {
-      throw new Error(`ArgumentError: B65 grouping item ${displayField(item.field)} must resolve to a physical APP field.`);
-    }
-    if (!canonicalItems.has(resolved.canonicalId)) {
-      canonicalItems.add(resolved.canonicalId);
-      resolvedItems.push(resolved);
-    }
-  }
-  planningGuardHook({
-    expandedSetCount: normalized.sets.length,
-    canonicalItemCount: canonicalItems.size
-  });
-  for (const ref of groupingRefs) {
-    validateGroupingRefMembership(ref, resolve2, canonicalItems);
-  }
-  const aliases = outputAliases(stmt.columns);
-  for (const column of stmt.columns) {
-    if (column.type === "GROUPING_COL" || column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL" || column.type === "LITERAL_COL" || column.type === "VARIABLE_COL" || column.type === "SCALAR_SUBQUERY_COL") continue;
-    const refs = [];
-    if (column.type === "FIELD") refs.push(refFromName(column.field));
-    else collectNonAggregateFieldRefs(column, refs);
-    for (const ref of refs) validateDependency(ref, resolve2, canonicalItems, "SELECT");
-  }
-  if (stmt.having) {
-    const refs = [];
-    collectNonAggregateFieldRefs(stmt.having, refs);
-    for (const ref of refs) {
-      if (ref.tableAlias === null && aliases.has(ref.field) || isAggregateSyntheticReference(ref)) continue;
-      validateDependency(ref, resolve2, canonicalItems, "HAVING");
-    }
-  }
-  for (const order of stmt.orderBy) {
-    for (const ref of keyDependencies(order.key)) {
-      if (ref.tableAlias === null && aliases.has(ref.field) || isAggregateSyntheticReference(ref)) continue;
-      validateDependency(ref, resolve2, canonicalItems, "ORDER BY");
+};
+function validatePrimaryOrganizationDmlStatement(stmt) {
+  const target = stmt.type === "EXPLAIN" ? stmt.query : stmt;
+  switch (target.type) {
+    case "UPDATE":
+    case "DELETE":
+    case "UPSERT":
+    case "UPSERT_SELECT":
+    case "INSERT_SELECT":
+      if (hasPrimaryOrganizationInWhere(target)) {
+        throw new PrimaryOrganizationDmlValidationError();
+      }
+      return;
+    default:
+      return;
+  }
+}
+function hasPrimaryOrganizationInWhere(node) {
+  let found = false;
+  walkObjects2(node, (obj) => {
+    if (found || !Object.prototype.hasOwnProperty.call(obj, "where")) return;
+    if (containsPrimaryOrganization(obj.where)) found = true;
+  });
+  return found;
+}
+function containsPrimaryOrganization(node) {
+  let found = false;
+  walkObjects2(node, (obj) => {
+    if (obj.type === "KINTONE_FUNC" && obj.name === "PRIMARY_ORGANIZATION") {
+      found = true;
     }
+  });
+  return found;
+}
+function walkObjects2(node, visit) {
+  if (Array.isArray(node)) {
+    for (const value of node) walkObjects2(value, visit);
+    return;
   }
-  const collisionKeys = /* @__PURE__ */ new Set();
-  for (const item of resolvedItems) {
-    collisionKeys.add(item.directKey);
-    if (item.unqualifiedBridgeKey !== null) collisionKeys.add(item.unqualifiedBridgeKey);
+  if (node === null || typeof node !== "object") return;
+  const obj = node;
+  visit(obj);
+  for (const value of Object.values(obj)) walkObjects2(value, visit);
+}
+
+// src/core/functionArity.ts
+function assertArity(func, args, min, max = Number.POSITIVE_INFINITY) {
+  if (args.length >= min && args.length <= max) return;
+  const expected = min === max ? String(min) : max === Number.POSITIVE_INFINITY ? `${min} or more` : `${min} to ${max}`;
+  throw new Error(`ArgumentError: ${func} expects ${expected} argument(s).`);
+}
+function assertStringFunctionArity(func, args) {
+  switch (func) {
+    case "UPPER":
+    case "LOWER":
+    case "TRIM":
+    case "LTRIM":
+    case "RTRIM":
+    case "LENGTH":
+    case "LENGTH_CHAR":
+    case "YEAR":
+    case "MONTH":
+    case "DAY":
+    case "DAYOFWEEK":
+    case "QUARTER":
+    case "WEEK":
+    case "LAST_DAY":
+    case "ABS":
+    case "SQRT":
+      return assertArity(func, args, 1, 1);
+    case "SUBSTRING":
+    case "LPAD":
+    case "RPAD":
+    case "REGEXP_LIKE":
+    case "REGEXP_SUBSTR":
+      return assertArity(func, args, 2, 3);
+    case "LEFT":
+    case "RIGHT":
+    case "INSTR":
+    case "ISNULL":
+    case "NULLIF":
+    case "MOD":
+    case "POWER":
+    case "FORMAT":
+    case "CAST":
+    case "DATE_FORMAT":
+    case "DATEDIFF":
+      return assertArity(func, args, 2, 2);
+    case "CONCAT":
+    case "COALESCE":
+    case "GREATEST":
+    case "LEAST":
+      return assertArity(func, args, 2);
+    case "REPLACE":
+    case "TRANSLATE":
+    case "DATE_ADD":
+      return assertArity(func, args, 3, 3);
+    case "REGEXP_REPLACE":
+      return assertArity(func, args, 3, 5);
+    case "ROUND":
+    case "FLOOR":
+    case "CEIL":
+    case "TRUNCATE":
+      return assertArity(func, args, 1, 2);
+    case "CURRENT_DATE":
+    case "CURRENT_TIMESTAMP":
+      return assertArity(func, args, 0, 0);
   }
-  for (const column of stmt.columns) {
-    if (!isAggregateMaterializedAlias(column)) continue;
-    const alias = "alias" in column ? column.alias : null;
-    if (alias === null) continue;
-    if (collisionKeys.has(alias)) {
-      throw new Error(
-        `ArgumentError: B65 aggregate alias ${alias} collides with a grouping runtime key (reason=B65_AGGREGATE_ALIAS_COLLISION).`
-      );
+}
+
+// src/core/statementValidation.ts
+function validateStatementStatic(stmt) {
+  validateStringFunctionArities(stmt);
+  validatePrimaryOrganizationDmlStatement(stmt);
+  validateKlikeStatement(stmt);
+}
+function validateStringFunctionArities(stmt) {
+  const visit = (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
     }
-  }
-  return resolvedSpec;
+    const node = value;
+    if (node.type === "STRING_FUNC") {
+      const expr = node;
+      assertStringFunctionArity(expr.func, expr.args);
+    }
+    Object.values(node).forEach(visit);
+  };
+  visit(stmt);
 }
 
 // src/core/batch.ts
@@ -7985,10 +8155,32 @@ function formatWithComma(num, digits) {
   return decStr ? `${intFmt}.${decStr}` : intFmt;
 }
 function evalStringFuncArg(arg, row, resolveFieldType, resolveFieldSemantics2) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return "";
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+    return String(evalMaterializedAggregateOperand(arg, row));
+  }
   if (arg.type === "NUMBER") return numberLiteralText(arg);
   return String(evalScalarValueExpr(arg, row, resolveFieldType, resolveFieldSemantics2));
 }
+function evalMaterializedAggregateOperand(node, row) {
+  if (node.type === "NUMBER") return node.value;
+  if (node.type === "AGG_REF") {
+    return row[aggregateSyntheticName(node.func, node.distinct, node.arg)] ?? "";
+  }
+  const left = Number(evalMaterializedAggregateOperand(node.left, row));
+  const right = Number(evalMaterializedAggregateOperand(node.right, row));
+  switch (node.op) {
+    case "+":
+      return left + right;
+    case "-":
+      return left - right;
+    case "*":
+      return left * right;
+    case "/":
+      return right !== 0 ? left / right : NaN;
+    case "%":
+      return right !== 0 ? left % right : NaN;
+  }
+}
 function resolveFieldRef(row, field) {
   const direct = row[field];
   if (direct !== void 0) return direct;
@@ -8083,7 +8275,7 @@ function semanticsForLeft(left, fieldType, resolveSemantics) {
   if (left.type === "FIELD") {
     return resolveSemantics?.(left) ?? (fieldType ? resolveFieldSemantics({ fieldType }) : syntheticSemantics("string"));
   }
-  if (left.type === "ARITH_FIELD") return syntheticSemantics("number");
+  if (left.type === "ARITH_FIELD" || left.type === "AGG_FIELD") return syntheticSemantics("number");
   if (left.type === "FUNC_FIELD") {
     return syntheticSemantics(NUMERIC_STRING_FUNCTIONS.has(left.expr.func) ? "number" : "string");
   }
@@ -8176,6 +8368,7 @@ function evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSem
 }
 function resolveField(field, row, resolveFieldType, resolveFieldSemantics2) {
   if (field.type === "FUNC_FIELD") return evalStringFunc(field.expr, row);
+  if (field.type === "AGG_FIELD") return String(evalMaterializedAggregateOperand(field.expr, row));
   if (field.type === "ARITH_FIELD") return String(evalArithExpr(field.expr, row));
   if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType, resolveFieldSemantics2);
   if (field.type === "GROUPING_FIELD") return evalGroupingRef(field.ref, row);
@@ -8233,12 +8426,20 @@ function evalCaseWhenNullable(expr, row, resolveFieldType, resolveFieldSemantics
 }
 function evalCaseResultNullable(result, row, resolveFieldType, resolveFieldSemantics2) {
   if (result.type === "ARRAY") return result.elements.map((entry) => entry.value).join(",");
+  if (result.type === "AGG_REF") {
+    return row[aggregateSyntheticName(result.func, result.distinct, result.arg)] ?? "";
+  }
+  if (result.type === "AGG_ARITH") return row[aggregateOperandLabel(result)] ?? "";
   if (result.type === "FIELD_REF") return row[result.field] ?? "";
   if (result.type === "ARITH") return evalArithExpr(result, row);
   return evalScalarValueExprNullable(result, row, resolveFieldType, resolveFieldSemantics2);
 }
 function evalCaseResult(result, row, resolveFieldType, resolveFieldSemantics2) {
   if (result.type === "ARRAY") return result.elements.map((e) => e.value).join(",");
+  if (result.type === "AGG_REF") {
+    return row[aggregateSyntheticName(result.func, result.distinct, result.arg)] ?? "";
+  }
+  if (result.type === "AGG_ARITH") return row[aggregateOperandLabel(result)] ?? "";
   if (result.type === "FIELD_REF") {
     return row[result.field] ?? "";
   }
@@ -8504,6 +8705,10 @@ function collectAggregateArgFields2(node, out) {
 }
 function collectCaseResultFields(result, out) {
   if (result.type === "ARRAY") return;
+  if (result.type === "AGG_REF" || result.type === "AGG_ARITH") {
+    collectAggOperandFields2(result, out);
+    return;
+  }
   if (result.type === "FIELD_REF" || result.type === "ARITH") {
     collectArithNode2(result, out);
     return;
@@ -8725,6 +8930,9 @@ function evalCaseResultValue(result, row, fieldType) {
   if (result.type === "ARRAY") {
     return convertArray(result.elements.map((e) => e.value), fieldType);
   }
+  if (result.type === "AGG_REF" || result.type === "AGG_ARITH") {
+    throw new Error("InternalError: aggregate CASE result reached DML evaluation.");
+  }
   if (result.type === "STRING") {
     return convertString2(result.value, fieldType);
   }
@@ -10994,7 +11202,7 @@ function valueNeedsFieldMetadata(value) {
   return Object.values(item).some(valueNeedsFieldMetadata);
 }
 function selectNeedsOwnMetadata(statement) {
-  return whereNeedsFieldMetadata(statement.where) || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
+  return whereNeedsFieldMetadata(statement.where) || statement.groupBy.length > 0 || normalizeGroupingSpec(statement).type === "GROUPING_SETS" || statement.orderBy.length > 0 || statement.columns.some(
     (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
   );
 }
@@ -12913,7 +13121,7 @@ function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldS
 }
 function hasAggregateColumns(columns) {
   return columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
   );
 }
 function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
@@ -13018,26 +13226,72 @@ function groupingItemValue(item, row) {
   return row[item.directKey] ?? (item.unqualifiedBridgeKey === null ? void 0 : row[item.unqualifiedBridgeKey]) ?? "";
 }
 function materializeAggregateColumns(outRow, groupRows, columns, resolveAggSortKind) {
-  for (const col of columns) {
+  for (const [columnIndex, col] of columns.entries()) {
     if (col.type === "AGGREGATE") {
       const syntheticKey = aggregateSyntheticName(col.func, col.distinct, col.arg);
       const value = String(evalAggregate(col.func, col.distinct, col.arg, col.separator, groupRows, resolveAggSortKind));
       outRow[col.alias ?? syntheticKey] = value;
       if (col.alias) outRow[syntheticKey] = value;
     } else if (col.type === "ARITH_AGG_COL") {
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? aggArithDefaultKey(col.expr);
       outRow[outputKey] = String(evalAggArithExpr(col.expr, groupRows, resolveAggSortKind));
     } else if (col.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(col.expr)) {
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
       const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
       outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
     } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
       const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
       const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
       outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
+    } else if (col.type === "CASE_COL" && containsAggregate2(col.expr)) {
+      materializeAggregateDependencies(outRow, groupRows, col.expr, resolveAggSortKind);
+      const resolvedExpr = resolveAggInCaseExpr(col.expr, groupRows, resolveAggSortKind);
+      const resolveAggregateSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, resolveAggSortKind) : void 0;
+      outRow[caseMaterializedKey(col.alias, columnIndex)] = evalCaseWhen(
+        resolvedExpr,
+        outRow,
+        void 0,
+        resolveAggregateSemantics
+      );
     }
   }
 }
+function caseMaterializedKey(alias, columnIndex) {
+  return alias ?? `__ksql_case_column_${columnIndex}`;
+}
+function collectAggregateRefs(node, out) {
+  if (node === null || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    node.forEach((value2) => collectAggregateRefs(value2, out));
+    return;
+  }
+  const value = node;
+  if (value["type"] === "AGG_REF") {
+    out.push(value);
+    return;
+  }
+  if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+  Object.values(value).forEach((child) => collectAggregateRefs(child, out));
+}
+function materializeAggregateDependencies(outRow, rows, node, resolveAggSortKind) {
+  const refs = [];
+  collectAggregateRefs(node, refs);
+  for (const ref of refs) {
+    const key = aggregateSyntheticName(ref.func, ref.distinct, ref.arg);
+    if (outRow[key] !== void 0) continue;
+    outRow[key] = String(evalAggregate(
+      ref.func,
+      ref.distinct,
+      ref.arg,
+      ref.separator,
+      rows,
+      resolveAggSortKind
+    ));
+  }
+}
 function evalGroupByKey(key, row, resolution, columns, aliasEvaluationContext) {
   if (key.type === "FIELD_NAME") {
     if (!resolution) return row[key.name] ?? "";
@@ -13071,26 +13325,7 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
   if (arg.type === "WILDCARD") {
     return func === "COUNT" ? rows.length : 0;
   }
-  const strValues = [];
-  for (const row of rows) {
-    let strVal;
-    if (arg.type === "FIELD_REF") {
-      const raw = row[arg.field];
-      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") continue;
-      strVal = raw;
-    } else if (arg.type === "ARITH" || arg.type === "NUMBER" || arg.type === "STRING_FUNC") {
-      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);
@@ -13168,6 +13403,27 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
     }
   }
 }
+function aggregateRowValues(func, arg, rows) {
+  return rows.map((row) => {
+    let strVal;
+    if (arg.type === "FIELD_REF") {
+      const raw = row[arg.field];
+      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") return null;
+      strVal = raw;
+    } else if (arg.type === "ARITH" || arg.type === "NUMBER") {
+      const n = evalArithExpr(arg, row);
+      if (isNaN(n)) return null;
+      strVal = String(n);
+    } else {
+      const value = evalScalarValueExprNullable(arg, row);
+      if (value === null) return null;
+      if (value === "" && func !== "MIN" && func !== "MAX") return null;
+      if (typeof value === "number" && Number.isNaN(value)) return null;
+      strVal = String(value);
+    }
+    return strVal;
+  });
+}
 function toAggregateFieldRef(field) {
   const dot = field.indexOf(".");
   return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
@@ -13210,6 +13466,16 @@ function resolveAggregateArgSemantics(arg, resolver) {
   const first = results[0];
   return results.every((result) => JSON.stringify(result) === JSON.stringify(first)) ? first : kinds[0];
 }
+function aggregateResultSemantics(ref, resolver) {
+  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 syntheticSemantics("number");
+  }
+  if (ref.func === "GROUP_CONCAT" || ref.func === "MODE") {
+    return syntheticSemantics("string");
+  }
+  const semantics = ref.arg.type === "WILDCARD" ? "string" : resolveAggregateArgSemantics(ref.arg, resolver) ?? "string";
+  return typeof semantics === "string" ? syntheticSemantics(semantics) : semantics;
+}
 function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
   if (having === null) return rows;
   return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
@@ -13369,7 +13635,7 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
         break;
       }
       case "CASE_COL":
-        evaluators.set(alias, (row) => evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        evaluators.set(alias, (row) => containsAggregate2(column.expr) ? row[alias] ?? "" : evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
         break;
       case "SCALAR_VALUE_COL": {
         const source = scalarValueDefaultKey(column.expr);
@@ -13388,7 +13654,7 @@ function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, reso
   }
   return (name, row) => evaluators.get(name)?.(row);
 }
-function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
+function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, resolveAggSortKind) {
   const windows = columns.filter((column) => column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
   for (const window of windows) {
@@ -13402,6 +13668,10 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
     for (const partition of partitions.values()) {
       const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
+      if (!isRankingWindow(window)) {
+        applyAggregateWindow(window, sortedResult, resolveAggSortKind);
+        continue;
+      }
       let rank = 1;
       let denseRank = 1;
       for (let index = 0; index < sorted.length; index++) {
@@ -13416,6 +13686,53 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
   }
   return rows;
 }
+function applyAggregateWindow(window, sortedResult, resolveAggSortKind) {
+  const sorted = sortedResult.rows;
+  const values = window.arg.type === "WILDCARD" ? null : aggregateRowValues(window.aggFunc, window.arg, sorted.map((item) => item.row));
+  const comparison = window.arg.type === "WILDCARD" ? void 0 : resolveAggregateArgSemantics(window.arg, resolveAggSortKind);
+  const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? syntheticSemantics("string");
+  const output = [];
+  let count = 0;
+  let sum = 0;
+  let best;
+  for (let index = 0; index < sorted.length; index++) {
+    const value = values?.[index] ?? null;
+    if (window.arg.type === "WILDCARD") {
+      count++;
+    } else if (value !== null) {
+      if (window.aggFunc === "COUNT") {
+        count++;
+      } else if (window.aggFunc === "SUM" || window.aggFunc === "AVG") {
+        sum += Number(value);
+        count++;
+      } else if (best === void 0) {
+        best = value;
+      } else {
+        const cmp = compareCanonicalValues(value, best, semantics);
+        if (window.aggFunc === "MAX" && cmp > 0 || window.aggFunc === "MIN" && cmp < 0) {
+          best = value;
+        }
+      }
+    }
+    const result = window.aggFunc === "COUNT" ? count : window.aggFunc === "SUM" ? sum : window.aggFunc === "AVG" ? count === 0 ? 0 : sum / count : best ?? 0;
+    output.push(String(result));
+  }
+  if (window.frame === null) {
+    const finalValue = output[output.length - 1];
+    for (const item of sorted) item.row[window.alias] = finalValue;
+    return;
+  }
+  if (window.frame.unit === "RANGE") {
+    for (let start = 0; start < sorted.length; ) {
+      let end = start;
+      while (end + 1 < sorted.length && sortedResult.compare(sorted[end], sorted[end + 1]) === 0) end++;
+      for (let index = start; index <= end; index++) sorted[index].row[window.alias] = output[end];
+      start = end + 1;
+    }
+    return;
+  }
+  for (let index = 0; index < sorted.length; index++) sorted[index].row[window.alias] = output[index];
+}
 function resolveWindowField(row, ref) {
   const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
   return resolveFieldRef(row, name);
@@ -13458,7 +13775,7 @@ function evaluateSelectColumnValue(column, row, columnIndex, context = {}) {
     case "ARITH_COL":
       return String(evalArithExpr(column.expr, row));
     case "CASE_COL":
-      return evalCaseWhen(
+      return containsAggregate2(column.expr) ? row[caseMaterializedKey(column.alias, columnIndex)] ?? "" : evalCaseWhen(
         column.expr,
         row,
         context.resolveFieldType,
@@ -13523,13 +13840,14 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, r
     return { rows: projected2, columns: cols };
   }
   const defaultFieldKeys = buildDefaultFieldOutputKeys(columns);
+  const defaultCaseKeys = buildDefaultCaseOutputKeys(columns);
   const hasWildcard = columns.some(
     (col) => col.type === "WILDCARD" || col.type === "PARENT_WILDCARD"
   );
-  const outputKeys = hasWildcard ? null : computeOutputKeys(columns, defaultFieldKeys);
+  const outputKeys = hasWildcard ? null : computeOutputKeys(columns, defaultFieldKeys, defaultCaseKeys);
   const orderedKeys = outputKeys ?? [];
   if (hasWildcard && rows.length === 0) {
-    return { rows: [], columns: computeExplicitOutputKeys(columns, defaultFieldKeys) };
+    return { rows: [], columns: computeExplicitOutputKeys(columns, defaultFieldKeys, defaultCaseKeys) };
   }
   const projected = rows.map((row, rowIdx) => {
     const out = {};
@@ -13596,7 +13914,7 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, r
           break;
         }
         case "CASE_COL": {
-          const key = outputKeys?.[colIdx] ?? col.alias ?? "case";
+          const key = outputKeys?.[colIdx] ?? col.alias ?? defaultCaseKeys.get(colIdx) ?? "case";
           out[key] = value;
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
@@ -13637,15 +13955,15 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns2, r
   });
   return { rows: projected, columns: orderedKeys };
 }
-function computeOutputKeys(columns, defaultFieldKeys) {
-  return columns.map((col, colIdx) => computeOutputKey(col, colIdx, defaultFieldKeys));
+function computeOutputKeys(columns, defaultFieldKeys, defaultCaseKeys) {
+  return columns.map((col, colIdx) => computeOutputKey(col, colIdx, defaultFieldKeys, defaultCaseKeys));
 }
-function computeExplicitOutputKeys(columns, defaultFieldKeys) {
+function computeExplicitOutputKeys(columns, defaultFieldKeys, defaultCaseKeys) {
   const keys = [];
   const seen = /* @__PURE__ */ new Set();
   for (const [colIdx, col] of columns.entries()) {
     if (col.type === "WILDCARD" || col.type === "PARENT_WILDCARD") continue;
-    const key = computeOutputKey(col, colIdx, defaultFieldKeys);
+    const key = computeOutputKey(col, colIdx, defaultFieldKeys, defaultCaseKeys);
     if (!seen.has(key)) {
       seen.add(key);
       keys.push(key);
@@ -13653,7 +13971,7 @@ function computeExplicitOutputKeys(columns, defaultFieldKeys) {
   }
   return keys;
 }
-function computeOutputKey(col, colIdx, defaultFieldKeys) {
+function computeOutputKey(col, colIdx, defaultFieldKeys, defaultCaseKeys) {
   switch (col.type) {
     case "VARIABLE_COL":
       throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
@@ -13668,7 +13986,7 @@ function computeOutputKey(col, colIdx, defaultFieldKeys) {
     case "ARITH_COL":
       return col.alias ?? arithColDefaultKey(col.expr);
     case "CASE_COL":
-      return col.alias ?? "case";
+      return col.alias ?? defaultCaseKeys.get(colIdx) ?? "case";
     case "STRFUNC_COL":
       return col.alias ?? stringFuncDefaultKey(col.expr);
     case "SCALAR_VALUE_COL":
@@ -13684,6 +14002,24 @@ function computeOutputKey(col, colIdx, defaultFieldKeys) {
       throw new Error("internal: computeOutputKey received a wildcard column");
   }
 }
+function buildDefaultCaseOutputKeys(columns) {
+  const used = new Set(columns.flatMap(
+    (column) => "alias" in column && column.alias !== null ? [column.alias] : []
+  ));
+  const keys = /* @__PURE__ */ new Map();
+  let suffix = 1;
+  for (const [columnIndex, column] of columns.entries()) {
+    if (column.type !== "CASE_COL" || column.alias !== null) continue;
+    let key;
+    do {
+      key = suffix === 1 ? "case" : `case_${suffix}`;
+      suffix++;
+    } while (used.has(key));
+    used.add(key);
+    keys.set(columnIndex, key);
+  }
+  return keys;
+}
 function buildDefaultFieldOutputKeys(columns) {
   const qualifierCollisionCount = /* @__PURE__ */ new Map();
   for (const col of columns) {
@@ -13773,6 +14109,7 @@ function scalarValueHasAggregate2(expr) {
   return false;
 }
 function caseResultHasAggregate2(result) {
+  if (result.type === "AGG_REF" || result.type === "AGG_ARITH") return true;
   if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
   return scalarValueHasAggregate2(result);
 }
@@ -13795,6 +14132,7 @@ function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
 }
 function resolveAggInScalarValue(expr, rows, resolveAggSortKind) {
   if (expr.type === "STRING_FUNC") return resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind);
+  if (expr.type === "CASE_WHEN") return resolveAggInCaseExpr(expr, rows, resolveAggSortKind);
   if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
     return {
       ...expr,
@@ -13804,6 +14142,35 @@ function resolveAggInScalarValue(expr, rows, resolveAggSortKind) {
   }
   return expr;
 }
+function resolveAggInCaseResult(result, rows, resolveAggSortKind) {
+  if (result.type === "AGG_REF") {
+    const value = evalAggregate(
+      result.func,
+      result.distinct,
+      result.arg,
+      result.separator,
+      rows,
+      resolveAggSortKind
+    );
+    return typeof value === "number" ? { type: "NUMBER", value, raw: String(value) } : { type: "STRING", value };
+  }
+  if (result.type === "AGG_ARITH") {
+    const value = evalAggArithExpr(result, rows, resolveAggSortKind);
+    return { type: "NUMBER", value, raw: String(value) };
+  }
+  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return result;
+  return resolveAggInScalarValue(result, rows, resolveAggSortKind);
+}
+function resolveAggInCaseExpr(expr, rows, resolveAggSortKind) {
+  return {
+    ...expr,
+    branches: expr.branches.map((branch) => ({
+      ...branch,
+      result: resolveAggInCaseResult(branch.result, rows, resolveAggSortKind)
+    })),
+    elseResult: expr.elseResult === null ? null : resolveAggInCaseResult(expr.elseResult, rows, resolveAggSortKind)
+  };
+}
 function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
   return {
     type: "STRING_FUNC",
@@ -13832,12 +14199,19 @@ function mergeKnownColumns(left, right, rows) {
     ...Object.keys(rows[0] ?? {})
   ])];
 }
-function deriveOutputOrderSemantics(columns) {
+function deriveOutputOrderSemantics(columns, resolveAggSortKind) {
   const result = /* @__PURE__ */ new Map();
   for (const column of columns) {
     if (!("alias" in column) || !column.alias) continue;
-    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       result.set(column.alias, syntheticSemantics("number"));
+    } else if (column.type === "WINDOW_COL") {
+      if (isRankingWindow(column) || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+        result.set(column.alias, syntheticSemantics("number"));
+      } else if (column.arg.type !== "WILDCARD") {
+        const semantics = resolveAggregateArgSemantics(column.arg, resolveAggSortKind) ?? "string";
+        result.set(column.alias, typeof semantics === "string" ? syntheticSemantics(semantics) : semantics);
+      }
     } else if (column.type === "AGGREGATE") {
       if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG" || column.func === "STDDEV_POP" || column.func === "STDDEV_SAMP" || column.func === "VAR_POP" || column.func === "VAR_SAMP" || column.func === "MEDIAN") {
         result.set(column.alias, syntheticSemantics("number"));
@@ -13872,7 +14246,7 @@ function runFullScan(input) {
     resolvedGroupingSpec,
     plainGroupByPlan
   } = input;
-  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
+  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns, aggregateSortKindResolver);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
   let rows = [];
   const mainAlias = stmt.from.alias;
@@ -13926,8 +14300,16 @@ function runFullScan(input) {
       }
     );
   }
-  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
-  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
+  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,
+    aggregateSortKindResolver
+  );
   if (stmt.distinct) {
     rows = applyDistinct(
       rows,
@@ -16412,8 +16794,8 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
           tempTables
         );
         const first = resolvedStmt2.expr.query.columns[0];
-        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
-        if (first?.type === "AGGREGATE" && first.func === "MODE") {
+        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" && (first.windowKind !== "AGGREGATE" || first.aggFunc === "COUNT" || first.aggFunc === "SUM" || first.aggFunc === "AVG") || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
+        if (first?.type === "AGGREGATE" && first.func === "MODE" || first?.type === "WINDOW_COL" && first.windowKind === "AGGREGATE" && (first.aggFunc === "MIN" || first.aggFunc === "MAX")) {
           const meta = (await inferSelectColumnMeta(
             resolvedStmt2.expr.query,
             ["__scalar__"],
@@ -17039,8 +17421,21 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
     if (!("alias" in column) || !column.alias) continue;
     let semantics;
     if (column.type === "FIELD") semantics = rowResolver(aggregateFieldRef(column.field));
-    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       semantics = syntheticSemantics("number");
+    } else if (column.type === "WINDOW_COL") {
+      if (column.windowKind !== "AGGREGATE" || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+        semantics = syntheticSemantics("number");
+      } else if (column.arg.type !== "WILDCARD") {
+        semantics = inferAggregateArgMeta(column.arg, (ref) => {
+          const resolved = rowResolver(ref);
+          return resolved ? {
+            sortKind: resolved.compareMode === "number" || resolved.compareMode === "recordNumber" ? "number" : "string",
+            fieldType: resolved.fieldType,
+            semantics: resolved
+          } : void 0;
+        }).semantics;
+      }
     } else if (column.type === "AGGREGATE") {
       if (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") {
         if (column.arg.type !== "WILDCARD") {
@@ -17402,6 +17797,7 @@ async function validateSelectGroupingPlanning(stmt, client, cacheContext, materi
 function completeInputErrorPrefix(reasons) {
   const reasonList = [...reasons].join(", ");
   const aggregateSubjects = [
+    ["AGGREGATE_WINDOW", "\u96C6\u8A08\u30A6\u30A3\u30F3\u30C9\u30A6\u306E\u6B63\u3057\u3044\u7D50\u679C"],
     ["GROUPING_SETS", "\u5C0F\u8A08\u30FB\u7DCF\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C"],
     ["STATISTICAL_AGGREGATE", "\u7D71\u8A08\u96C6\u7D04\u306E\u6B63\u3057\u3044\u7D50\u679C"],
     ["AGGREGATE", "\u96C6\u8A08\u306E\u6B63\u3057\u3044\u7D50\u679C"],
@@ -17468,7 +17864,7 @@ function scalarValueHasFieldRef(expr) {
   }
   if (expr.type === "CASE_WHEN") {
     const results = [...expr.branches.map((branch) => branch.result), ...expr.elseResult ? [expr.elseResult] : []];
-    return results.some((result) => result.type !== "ARRAY" && (result.type === "FIELD_REF" || result.type === "ARITH" ? arithHasFieldRef(result) : scalarValueHasFieldRef(result)));
+    return results.some((result) => result.type !== "ARRAY" && (result.type === "FIELD_REF" || result.type === "ARITH" ? arithHasFieldRef(result) : result.type === "AGG_REF" || result.type === "AGG_ARITH" ? true : scalarValueHasFieldRef(result)));
   }
   return false;
 }
@@ -18020,7 +18416,8 @@ function collectAggregateArgFieldRefs(arg, out) {
   }
   if (arg.type === "CASE_WHEN") {
     for (const result of [...arg.branches.map((branch) => branch.result), ...arg.elseResult ? [arg.elseResult] : []]) {
-      if (result.type !== "ARRAY") collectAggregateArgFieldRefs(result, out);
+      if (result.type === "AGG_REF" || result.type === "AGG_ARITH") collectAggregateOperandRefs(result, out);
+      else if (result.type !== "ARRAY") collectAggregateArgFieldRefs(result, out);
     }
   }
 }
@@ -18057,10 +18454,29 @@ function collectScalarAggregateRefs(expr, out) {
     const results = [...expr.branches.map((branch) => branch.result), ...expr.elseResult ? [expr.elseResult] : []];
     for (const result of results) {
       if (result.type === "STRING_FUNC") collectStringFuncAggregateRefs(result, out);
+      else if (result.type === "AGG_REF" || result.type === "AGG_ARITH") collectAggregateOperandRefs(result, out);
       else if (result.type !== "ARRAY" && result.type !== "FIELD_REF" && result.type !== "ARITH") collectScalarAggregateRefs(result, out);
     }
   }
 }
+function collectCaseAggregateRefs(expr, out) {
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    const value = node;
+    if (value["type"] === "AGG_REF") {
+      const aggregate = value;
+      collectAggregateRef(aggregate.func, aggregate.arg, out);
+      return;
+    }
+    if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+    Object.values(value).forEach(visit);
+  };
+  visit(expr);
+}
 function collectSelectAggregateSortRefs(columns) {
   const refs = [];
   for (const column of columns) {
@@ -18072,6 +18488,8 @@ function collectSelectAggregateSortRefs(columns) {
       collectStringFuncAggregateRefs(column.expr, refs);
     } else if (column.type === "SCALAR_VALUE_COL") {
       collectScalarAggregateRefs(column.expr, refs);
+    } else if (column.type === "CASE_COL") {
+      collectCaseAggregateRefs(column.expr, refs);
     }
   }
   return refs;
@@ -18249,6 +18667,13 @@ function stringFunctionColumnMeta(expr) {
 function caseResultColumnMeta(result, resolveField2) {
   if (result.type === "STRING") return syntheticColumnMeta("string");
   if (result.type === "ARRAY") return unsupportedColumnMeta();
+  if (result.type === "AGG_REF") {
+    if (result.func === "MIN" || result.func === "MAX" || result.func === "MODE") {
+      return result.arg.type === "WILDCARD" ? unknownStringColumnMeta() : inferAggregateArgMeta(result.arg, resolveField2);
+    }
+    return result.func === "GROUP_CONCAT" ? syntheticColumnMeta("string") : syntheticColumnMeta("number");
+  }
+  if (result.type === "AGG_ARITH") return syntheticColumnMeta("number");
   if (result.type === "NUMBER" || result.type === "ARITH" || result.type === "SCALAR_ARITH") return syntheticColumnMeta("number");
   if (result.type === "STRING_FUNC") return stringFunctionColumnMeta(result);
   if (result.type === "FIELD_REF") return resolveField2(aggregateFieldRef(result.field)) ?? unknownStringColumnMeta();
@@ -18286,12 +18711,18 @@ function inferAggregateArgMeta(arg, resolveField2) {
   if (arg.elseResult) results.push(caseResultColumnMeta(arg.elseResult, resolveField2));
   return mergeExpressionColumnMeta(results);
 }
+function inferWindowColumnMeta(column, resolveField2) {
+  if (column.windowKind !== "AGGREGATE" || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+    return syntheticColumnMeta("number");
+  }
+  return column.arg.type === "WILDCARD" ? unknownStringColumnMeta() : inferAggregateArgMeta(column.arg, resolveField2);
+}
 function withDisplayName(meta, displayName) {
   return { ...meta ?? {}, displayName };
 }
 function selectNeedsSourceColumnMeta(stmt) {
   return stmt.columns.some(
-    (column) => column.type === "FIELD" || column.type === "WILDCARD" || column.type === "PARENT_WILDCARD" || column.type === "CASE_COL" || column.type === "AGGREGATE" && (column.func === "MIN" || column.func === "MAX" || column.func === "MODE")
+    (column) => column.type === "FIELD" || column.type === "WILDCARD" || column.type === "PARENT_WILDCARD" || column.type === "CASE_COL" || column.type === "AGGREGATE" && (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") || column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && (column.aggFunc === "MIN" || column.aggFunc === "MAX")
   );
 }
 async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext, materializedTables, forLibraryCapture = false) {
@@ -18397,7 +18828,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
     } else if (column.type === "STRFUNC_COL") {
       meta = stringFunctionColumnMeta(column.expr);
     } else if (column.type === "WINDOW_COL") {
-      meta = syntheticColumnMeta("number");
+      meta = inferWindowColumnMeta(column, resolveField2);
     } else if (column.type === "CASE_COL") {
       const results = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
       if (column.expr.elseResult) results.push(caseResultColumnMeta(column.expr.elseResult, resolveField2));
@@ -19324,8 +19755,10 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     if (!("alias" in column) || !column.alias) continue;
     let meta;
     if (column.type === "FIELD") meta = resolveField2(aggregateFieldRef(column.field));
-    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL") {
       meta = syntheticColumnMeta("number");
+    } else if (column.type === "WINDOW_COL") {
+      meta = inferWindowColumnMeta(column, resolveField2);
     } else if (column.type === "GROUPING_COL") {
       meta = syntheticColumnMeta("number");
     } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") meta = syntheticColumnMeta("string");
@@ -23363,6 +23796,20 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       }
     }
   }
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL" || column.windowKind !== "AGGREGATE") continue;
+    const clauses = [];
+    if (column.partitionBy.length > 0) {
+      clauses.push(`PARTITION BY ${column.partitionBy.map(
+        (ref) => ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field
+      ).join(", ")}`);
+    }
+    if (column.orderBy.length > 0) {
+      clauses.push(`ORDER BY ${column.orderBy.map(formatOrderByItem).join(", ")}`);
+    }
+    lines.push(`  window ${column.alias}: ${column.aggFunc} OVER (${clauses.join(" ")})`);
+    lines.push(column.frame === null ? "    frame: PARTITION ENTIRE" : `    frame: ${column.frame.unit} UNBOUNDED PRECEDING AND CURRENT ROW${column.frame.source === "DEFAULT" ? " (\u65E2\u5B9A)" : ""}`);
+  }
   if (totalCountPlan) {
     const baseQuery = stmt.where === null ? "" : whereToKintone(stmt.where);
     lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);