@rex0220/kintone-sql-tools 3.45.0 → 3.47.0

package/dist-cli/ksql.js

@@ -752,7 +752,7 @@ function caseLabel(expr) {
 }
 function stringFuncArgLabel(arg) {
   if (arg.type === "AGG_REF") return aggregateSyntheticName(arg.func, arg.distinct, arg.arg);
-  if (arg.type === "AGG_ARITH") return aggregateOperandLabel(arg);
+  if (arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return aggregateOperandLabel(arg);
   return scalarValueLabel(arg);
 }
 function stringFuncLabel(expr) {
@@ -790,6 +790,8 @@ function aggregateSyntheticName(func, distinct, arg) {
 function aggregateOperandLabel(node) {
   if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "AGG_REF") return aggregateSyntheticName(node.func, node.distinct, node.arg);
+  if (node.type === "AGG_GROUP_KEY") return node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
+  if (node.type === "VARIABLE") return `@${node.name}`;
   return `${aggregateOperandLabel(node.left)}${node.op}${aggregateOperandLabel(node.right)}`;
 }
 
@@ -1068,6 +1070,8 @@ var Parser = class {
     this.cteNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
     this.tempTableRefs = [];
+    /** GROUP BY を読む前に作る B124 候補 leaf の診断位置。AST 公開型へ位置情報を足さない。 */
+    this.aggregateGroupKeyTokens = /* @__PURE__ */ new WeakMap();
     this.allowSelectArithVariable = false;
   }
   // ----------------------------------------------------------
@@ -1879,6 +1883,7 @@ var Parser = class {
     if (grouping && orderMode === "KINTONE_NATIVE") {
       throw new ParseError("B65: KORDER BY cannot be combined with grouping sets in Phase1.", this.peek());
     }
+    this.validateAggregateGroupKeyRefs(columns, having, groupBy, grouping);
     return {
       type: "SELECT",
       distinct,
@@ -1971,6 +1976,12 @@ var Parser = class {
         this.peek()
       );
     }
+    if (this.isNonAggregateArithmeticStartWithAggregate()) {
+      throw new ParseError(
+        `\u96C6\u8A08\u7B97\u8853\u5F0F\u306F\u96C6\u8A08\u95A2\u6570\u304B\u3089\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08${this.peek().value}\uFF09\u3002`,
+        this.peek()
+      );
+    }
     if (this.tryAggregateFunc() === null && this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
       const expr = this.parseScalarValueExpr({ allowAggregateArgs: true });
       const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -2194,6 +2205,7 @@ var Parser = class {
   }
   stringFuncArgHasAggregate(arg) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+    if (arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return false;
     return this.scalarValueHasAggregate(arg);
   }
   scalarValueHasAggregate(expr) {
@@ -2236,7 +2248,7 @@ var Parser = class {
   parseAggArithMulDiv() {
     return this.continueAggArithMulDiv(this.parseAggPrimary());
   }
-  /** 集計算術式の一次式: 集計関数 / 数値リテラル / 括弧 */
+  /** 集計算術式の一次式: 集計関数 / 数値 / 変数 / GROUP BY キー候補 / 括弧 */
   parseAggPrimary() {
     if (this.consume("(" /* LPAREN */)) {
       const inner = this.continueAggArith(this.parseAggPrimary());
@@ -2253,14 +2265,99 @@ var Parser = class {
       const tok = this.advance();
       return makeNumberLiteral(tok.value);
     }
+    if (this.peek().kind === "VARIABLE" /* VARIABLE */) {
+      const tok = this.advance();
+      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+    }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
       const ref = this.parseAggregateRef(aggFunc);
       this.rejectAggregateWindowOutsideSelect();
       return ref;
     }
+    if (this.peek().kind === "IDENT" /* IDENT */ || this.peek().kind === "BIDENT" /* BIDENT */) {
+      const tok = this.peek();
+      const parsed = this.parseQualifiedIdent();
+      const ref = {
+        type: "AGG_GROUP_KEY",
+        field: parsed.field,
+        ...parsed.tableAlias ? { tableAlias: parsed.tableAlias } : {}
+      };
+      this.aggregateGroupKeyTokens.set(ref, tok);
+      return ref;
+    }
     throw new ParseError("\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u306F\u96C6\u8A08\u95A2\u6570\u307E\u305F\u306F\u6570\u5024\u304C\u5FC5\u8981\u3067\u3059", this.peek());
   }
+  /** B124 Phase 1 はトップレベルの非集計オペランド開始形を明示拒否する。 */
+  isNonAggregateArithmeticStartWithAggregate() {
+    const first = this.peek();
+    if (this.tryAggregateFunc() !== null || first.kind === "CASE" /* CASE */ || first.kind === "IF" /* IF */) return false;
+    if (this.isGroupingFunctionStart()) return false;
+    if (this.tryStringFuncName() !== null) return false;
+    if (!["IDENT" /* IDENT */, "BIDENT" /* BIDENT */, "VARIABLE" /* VARIABLE */, "(" /* LPAREN */].includes(first.kind)) return false;
+    let depth = 0;
+    let sawArithmetic = false;
+    for (let index = this.pos; index < this.tokens.length; index++) {
+      const token = this.tokens[index];
+      if (depth === 0 && index > this.pos && (token.kind === "," /* COMMA */ || token.kind === "AS" /* AS */ || token.kind === "FROM" /* FROM */ || token.kind === ";" /* SEMICOLON */ || token.kind === "EOF" /* EOF */ || token.kind === "=" /* EQ */ || token.kind === "!=" /* NEQ */ || token.kind === "<>" /* LT_GT */ || token.kind === ">" /* GT */ || token.kind === "<" /* LT */ || token.kind === ">=" /* GTE */ || token.kind === "<=" /* LTE */ || token.kind === "AND" /* AND */ || token.kind === "OR" /* OR */)) break;
+      if (this.isArithOp(token.kind)) sawArithmetic = true;
+      if (PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[token.kind] !== void 0 && this.tokens[index + 1]?.kind === "(" /* LPAREN */) return sawArithmetic;
+      if (token.kind === "(" /* LPAREN */) depth++;
+      else if (token.kind === ")" /* RPAREN */) {
+        depth--;
+        if (depth < 0) break;
+      }
+    }
+    return false;
+  }
+  /** SELECT ローカルの B124 leaf だけを ordinary GROUP BY の表記と照合する。 */
+  validateAggregateGroupKeyRefs(columns, having, groupBy, grouping) {
+    const refs = [];
+    const visit = (node) => {
+      if (Array.isArray(node)) {
+        node.forEach(visit);
+        return;
+      }
+      if (node === null || typeof node !== "object") return;
+      const value = node;
+      if (value["type"] === "SELECT" || value["type"] === "SCALAR_SUBQUERY") return;
+      if (value["type"] === "AGG_GROUP_KEY") {
+        refs.push(node);
+        return;
+      }
+      Object.values(value).forEach(visit);
+    };
+    visit(columns);
+    visit(having);
+    if (refs.length === 0) return;
+    const first = refs[0];
+    const firstToken = this.aggregateGroupKeyTokens.get(first) ?? this.peek();
+    if (grouping !== void 0) {
+      throw new ParseError(
+        "ROLLUP / CUBE / GROUPING SETS \u3067\u306F\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u66F8\u3051\u307E\u305B\u3093\uFF08\u5C0F\u8A08\u30FB\u7DCF\u8A08\u884C\u3067\u5024\u304C\u5B9A\u307E\u3089\u306A\u3044\u305F\u3081\u3067\u3059\uFF09\u3002",
+        firstToken
+      );
+    }
+    if (groupBy.length === 0) {
+      throw new ParseError(
+        `\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u66F8\u304F\u306B\u306F GROUP BY \u304C\u5FC5\u8981\u3067\u3059\uFF08${this.aggregateGroupKeyDisplay(first)}\uFF09\u3002`,
+        firstToken
+      );
+    }
+    const ordinaryNames = new Set(groupBy.filter((key) => key.type === "FIELD_NAME").map((key) => key.name));
+    for (const ref of refs) {
+      const display = this.aggregateGroupKeyDisplay(ref);
+      if (!ordinaryNames.has(display)) {
+        throw new ParseError(
+          `\u96C6\u8A08\u7B97\u8853\u5F0F\u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u306F GROUP BY \u306B\u66F8\u3044\u305F\u8868\u8A18\u3068\u4E00\u81F4\u3059\u308B\u5217\u3060\u3051\u3067\u3059\uFF08${display}\uFF09\u3002\u30B0\u30EB\u30FC\u30D7\u5185\u3067\u5024\u304C\u5B9A\u307E\u3089\u306A\u3044\u305F\u3081\u3067\u3059\u3002`,
+          this.aggregateGroupKeyTokens.get(ref) ?? firstToken
+        );
+      }
+    }
+  }
+  aggregateGroupKeyDisplay(ref) {
+    return ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+  }
   // ──────────────────────────────────────────────────
   // 汎用スカラー値式パーサー（B38）
   // ──────────────────────────────────────────────────
@@ -3008,6 +3105,12 @@ var Parser = class {
   // - 集計関数（HAVING のみ）: COUNT(*) / SUM(f) ...
   // - 通常フィールド参照: [alias.]field
   parseFieldValue() {
+    if (this.groupingFieldContext === "HAVING" && this.isNonAggregateArithmeticStartWithAggregate()) {
+      throw new ParseError(
+        `\u96C6\u8A08\u7B97\u8853\u5F0F\u306F\u96C6\u8A08\u95A2\u6570\u304B\u3089\u59CB\u307E\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08${this.peek().value}\uFF09\u3002`,
+        this.peek()
+      );
+    }
     if (this.isUnsupportedGroupingIdStart()) {
       throw new ParseError("B65: GROUPING_ID is not supported in Phase1.", this.peek());
     }
@@ -5811,7 +5914,7 @@ function collectStringFuncFields(expr, out) {
   }
 }
 function collectStringFuncArgFields(arg, out) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") {
     collectAggOperandFields(arg, out);
     return;
   }
@@ -5857,6 +5960,9 @@ function collectAggOperandFields(node, out) {
     collectAggOperandFields(node.left, out);
     collectAggOperandFields(node.right, out);
   }
+  if (node.type === "AGG_GROUP_KEY") {
+    out.push(normalizeSimpleFieldRef(node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field));
+  }
 }
 function collectAggregateArgFields(node, out) {
   if (node.type === "FIELD_REF" || node.type === "ARITH") collectArithNode(node, out);
@@ -5865,6 +5971,7 @@ function collectAggregateArgFields(node, out) {
 function hasAggregateInStringFuncExpr(expr) {
   return expr.args.some((arg) => {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+    if (arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return false;
     return scalarValueHasAggregate(arg);
   });
 }
@@ -6052,9 +6159,12 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       walkAgg(node.left, phase);
       walkAgg(node.right, phase);
     }
+    if (node.type === "AGG_GROUP_KEY") {
+      addFieldRef(node.field, node.tableAlias ?? null, phase);
+    }
   };
   const walkStringArg = (arg, phase = "select") => {
-    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") {
       walkAgg(arg, phase);
       return;
     }
@@ -8155,7 +8265,7 @@ function formatWithComma(num, digits) {
   return decStr ? `${intFmt}.${decStr}` : intFmt;
 }
 function evalStringFuncArg(arg, row, resolveFieldType, resolveFieldSemantics2) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY") {
     return String(evalMaterializedAggregateOperand(arg, row));
   }
   if (arg.type === "NUMBER") return numberLiteralText(arg);
@@ -8166,6 +8276,13 @@ function evalMaterializedAggregateOperand(node, row) {
   if (node.type === "AGG_REF") {
     return row[aggregateSyntheticName(node.func, node.distinct, node.arg)] ?? "";
   }
+  if (node.type === "AGG_GROUP_KEY") {
+    const field = node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
+    return Number(resolveFieldRef(row, field));
+  }
+  if (node.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved aggregate arithmetic variable @${node.name}.`);
+  }
   const left = Number(evalMaterializedAggregateOperand(node.left, row));
   const right = Number(evalMaterializedAggregateOperand(node.right, row));
   switch (node.op) {
@@ -8667,7 +8784,7 @@ function collectStringFuncFields2(expr, out) {
   for (const arg of expr.args) collectStringFuncArgFields2(arg, out);
 }
 function collectStringFuncArgFields2(arg, out) {
-  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
+  if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH" || arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") {
     collectAggOperandFields2(arg, out);
     return;
   }
@@ -8698,6 +8815,7 @@ function collectAggOperandFields2(node, out) {
     collectAggOperandFields2(node.left, out);
     collectAggOperandFields2(node.right, out);
   }
+  if (node.type === "AGG_GROUP_KEY") out.add(node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field);
 }
 function collectAggregateArgFields2(node, out) {
   if (node.type === "FIELD_REF" || node.type === "ARITH") collectArithNode2(node, out);
@@ -11501,6 +11619,42 @@ var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
 function nativeWhereOperatorsForType(fieldType) {
   return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
 }
+function normalizeChoiceEquality(where, resolveField2) {
+  const rewrites = [];
+  const visit = (node) => {
+    if (node.type === "BINARY") {
+      if ((node.op === "=" || node.op === "!=" || node.op === "<>") && node.left.type === "FIELD" && node.right.type === "STRING" && node.right.value !== "") {
+        const semantics = resolveField2(node.left);
+        if (semantics !== void 0 && semantics.compareMode === "option" && LOCAL_SCALAR_TYPES.has(semantics.fieldType) && nativeWhereOperatorsForType(semantics.fieldType).has("in") && semantics.optionOrder?.has(node.right.value) === true) {
+          const normalizedOperator = node.op === "=" ? "IN" : "NOT_IN";
+          rewrites.push({
+            field: node.left,
+            originalOperator: node.op,
+            normalizedOperator,
+            value: node.right.value
+          });
+          return {
+            ...node,
+            op: normalizedOperator,
+            right: { type: "IN_LIST", values: [node.right] }
+          };
+        }
+      }
+      return node;
+    }
+    if (node.type === "LOGICAL") {
+      const left = visit(node.left);
+      const right = visit(node.right);
+      return left === node.left && right === node.right ? node : { ...node, left, right };
+    }
+    if (node.type === "GROUP" || node.type === "NOT") {
+      const expr = visit(node.expr);
+      return expr === node.expr ? node : { ...node, expr };
+    }
+    return node;
+  };
+  return { normalizedWhere: visit(where), rewrites };
+}
 function classifyWhereCapability(where, resolveField2) {
   if (where === null) {
     return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
@@ -13431,6 +13585,13 @@ function toAggregateFieldRef(field) {
 function evalAggArithExpr(node, rows, resolveAggSortKind) {
   if (node.type === "NUMBER") return node.value;
   if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
+  if (node.type === "AGG_GROUP_KEY") {
+    const field = node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field;
+    return Number(resolveFieldRef(rows[0] ?? {}, field));
+  }
+  if (node.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved aggregate arithmetic variable @${node.name}.`);
+  }
   const l = evalAggArithExpr(node.left, rows, resolveAggSortKind);
   const r = evalAggArithExpr(node.right, rows, resolveAggSortKind);
   switch (node.op) {
@@ -14069,7 +14230,8 @@ function arithColDefaultKey(expr) {
 }
 function stringFuncDefaultKey(expr) {
   const argStrs = expr.args.map((a) => {
-    if (a.type === "AGG_REF" || a.type === "AGG_ARITH") return aggArithDefaultKey(a);
+    if (a.type === "AGG_REF" || a.type === "AGG_ARITH" || a.type === "AGG_GROUP_KEY") return aggArithDefaultKey(a);
+    if (a.type === "VARIABLE") return `@${a.name}`;
     return scalarValueDefaultKey(a);
   });
   return `${expr.func}(${argStrs.join(",")})`;
@@ -14096,6 +14258,7 @@ function scalarValueDefaultKey(expr) {
 }
 function hasAggregateInStringFuncArg(arg) {
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+  if (arg.type === "AGG_GROUP_KEY" || arg.type === "VARIABLE") return false;
   return scalarValueHasAggregate2(arg);
 }
 function scalarValueHasAggregate2(expr) {
@@ -14125,6 +14288,13 @@ function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
     const value = evalAggArithExpr(arg, rows, resolveAggSortKind);
     return { type: "NUMBER", value, raw: String(value) };
   }
+  if (arg.type === "AGG_GROUP_KEY") {
+    const field = arg.tableAlias ? `${arg.tableAlias}.${arg.field}` : arg.field;
+    return { type: "NUMBER", value: Number(resolveFieldRef(rows[0] ?? {}, field)), raw: resolveFieldRef(rows[0] ?? {}, field) };
+  }
+  if (arg.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved aggregate arithmetic variable @${arg.name}.`);
+  }
   if (arg.type === "STRING_FUNC") {
     return resolveAggInStringFuncExpr(arg, rows, resolveAggSortKind);
   }
@@ -16265,18 +16435,18 @@ async function assertRelativeDateExecutionPlan(stmt, client, cacheContext) {
 }
 async function resolveRelativeDateExecutionPlan(stmt, client, cacheContext) {
   return buildRelativeDatePushdownPlan(stmt, {
-    select: (select) => resolveSelectWhereCapability(select, client, cacheContext),
+    select: async (select) => {
+      const { resolver } = await normalizeSelectChoiceEquality(select, client, cacheContext);
+      return classifyWhereCapability(select.where, resolver);
+    },
     dml: (dml) => resolveDmlWhereCapability(dml, client, cacheContext),
     prefilterDecomposition: async (select) => {
       if (select.where === null) return null;
-      const resolver = await buildWhereFieldSemanticsResolver(
-        select,
-        client,
-        cacheContext
-      );
+      const { resolver } = await normalizeSelectChoiceEquality(select, client, cacheContext);
       return decomposeRelativeDatePrefilter(select, resolver);
     },
     joinServerFunctionPlan: async (select) => {
+      await normalizeSelectChoiceEquality(select, client, cacheContext);
       const metadata = await loadTypedPushdownMeta(select, client, cacheContext);
       const runtimePlan = buildRuntimeJoinPushdownPlan(select, metadata);
       if (runtimePlan === null) return null;
@@ -17117,7 +17287,15 @@ function resolveBatchVariableReferencesInternal(node, variables, numericArithmet
           `ArgumentError: variable @${obj["name"]} is not numeric and cannot be used in arithmetic.`
         );
       }
-      return numericArithmeticOperand && value.type === "string" && value.placeholder === true ? { type: "NUMBER", value: 0, raw: value.value } : value.type === "number" ? { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) } : { type: "STRING", value: value.value };
+      return numericArithmeticOperand && value.type === "string" && value.placeholder === true ? {
+        type: "NUMBER",
+        value: 0,
+        raw: numericArithmeticOperand === "AGG_ARITH" ? `@${obj["name"]}` : value.value
+      } : value.type === "number" ? {
+        type: "NUMBER",
+        value: value.value,
+        raw: numericArithmeticOperand === "AGG_ARITH" ? `@${obj["name"]}` : value.raw ?? String(value.value)
+      } : { type: "STRING", value: value.value };
     }
     if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
       const value = variables.get(obj["name"]);
@@ -17136,7 +17314,7 @@ function resolveBatchVariableReferencesInternal(node, variables, numericArithmet
         resolveBatchVariableReferencesInternal(
           value,
           variables,
-          (obj["type"] === "ARITH" || obj["type"] === "SCALAR_ARITH" || obj["type"] === "AGG_ARITH") && (key === "left" || key === "right")
+          key === "left" || key === "right" ? obj["type"] === "AGG_ARITH" ? "AGG_ARITH" : obj["type"] === "ARITH" || obj["type"] === "SCALAR_ARITH" ? "ARITH" : false : false
         )
       ])
     );
@@ -17338,7 +17516,10 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
     if (node === null || typeof node !== "object") return;
     const value = node;
     if (value["type"] === "SELECT") return;
-    if (value["type"] === "BINARY" && [">", "<", ">=", "<="].includes(String(value["op"]))) {
+    const operator = String(value["op"]);
+    const right = value["right"];
+    const needsOptionExistence = ["=", "!=", "<>"].includes(operator) && right?.["type"] === "STRING" && right["value"] !== "";
+    if (value["type"] === "BINARY" && ([">", "<", ">=", "<="].includes(operator) || needsOptionExistence)) {
       const left = value["left"];
       if (left?.["type"] === "FIELD" && typeof left["field"] === "string") {
         orderedFields.add(left["field"]);
@@ -17405,6 +17586,49 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
     return matches.length > 1 ? syntheticSemantics("string") : void 0;
   };
 }
+var choiceEqualityRewritesBySelect = /* @__PURE__ */ new WeakMap();
+async function normalizeSelectChoiceEquality(stmt, client, cacheContext, materializedTables, forcePhysicalMetadata = false) {
+  const resolver = await buildWhereFieldSemanticsResolver(
+    stmt,
+    client,
+    cacheContext,
+    materializedTables,
+    forcePhysicalMetadata
+  );
+  if (stmt.where === null) return { resolver, rewrites: [] };
+  const normalization = normalizeChoiceEquality(stmt.where, resolver);
+  stmt.where = normalization.normalizedWhere;
+  if (normalization.rewrites.length > 0) {
+    choiceEqualityRewritesBySelect.set(stmt, normalization.rewrites);
+  }
+  return { resolver, rewrites: normalization.rewrites };
+}
+function hasDefaultRangeAggregateWindow(stmt) {
+  return stmt.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && column.orderBy.length > 0 && column.frame?.source === "DEFAULT"
+  );
+}
+function collectDefaultRangeWindowWarnings(stmt, resolveField2, context) {
+  const canProveSinglePhysicalInput = context === "DIRECT" && stmt.joins.length === 0 && stmt.from.cteName === null && stmt.from.subtableCode == null;
+  const warnings = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL" || column.windowKind !== "AGGREGATE" || column.orderBy.length === 0 || column.frame?.source !== "DEFAULT") continue;
+    const hasTotalOrderKey = canProveSinglePhysicalInput && column.orderBy.some((item) => {
+      if (item.key.type !== "FIELD_NAME") return false;
+      const ref = aggregateFieldRef(item.key.name);
+      return ref.field === "$id" || resolveField2(ref)?.fieldType === "RECORD_NUMBER";
+    });
+    if (hasTotalOrderKey) continue;
+    warnings.push(
+      `${column.alias} \u306F\u65E2\u5B9A\u30D5\u30EC\u30FC\u30E0\uFF08RANGE\uFF09\u3067\u8A55\u4FA1\u3055\u308C\u307E\u3059\u3002ORDER BY \u306E\u5024\u304C\u540C\u3058\u884C\u306F\u3059\u3079\u3066\u540C\u3058\u5024\u306B\u306A\u308A\u307E\u3059\u3002\u884C\u3054\u3068\u306E\u5024\u304C\u5FC5\u8981\u306A\u3089 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW \u3092\u660E\u793A\u3059\u308B\u304B\u3001ORDER BY \u306B\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u306A\u3069\u306E\u30BF\u30A4\u30D6\u30EC\u30FC\u30AF\u30AD\u30FC\u3092\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    );
+  }
+  return warnings;
+}
+function mergeSelectWarnings(result, additional) {
+  if (additional.length === 0) return result;
+  return { ...result, warnings: [.../* @__PURE__ */ new Set([...result.warnings ?? [], ...additional])] };
+}
 function selectCaseConditionsNeedFieldMetadata(stmt) {
   const visit = (value) => {
     if (value === null || typeof value !== "object") return false;
@@ -17461,11 +17685,6 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
   }
   return (field) => field.tableAlias === null && aliases.has(field.field) ? aliases.get(field.field) : rowResolver(field);
 }
-async function resolveSelectWhereCapability(stmt, client, cacheContext, materializedTables) {
-  if (stmt.where === null) return classifyWhereCapability(null, () => void 0);
-  const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, materializedTables);
-  return classifyWhereCapability(stmt.where, resolver);
-}
 function formatWhereCapabilityFailure(result) {
   const reason = result.reasons.find(
     (candidate) => candidate.code === "WHERE_FIELD_UNRESOLVED" || candidate.code === "WHERE_OPERATOR_UNSUPPORTED" || candidate.code === "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE"
@@ -17510,7 +17729,7 @@ async function assertDmlWhereCapability(stmt, client, cacheContext) {
     );
   }
 }
-async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false, forLibraryCapture = false) {
+async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false, forLibraryCapture = false, windowWarningContext = "DIRECT") {
   let result;
   await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
   if (isNoFromSelect(stmt)) {
@@ -17523,6 +17742,18 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     }
     return result;
   }
+  const { resolver: fieldSemanticsResolver } = await normalizeSelectChoiceEquality(
+    stmt,
+    client,
+    cacheContext,
+    cteCache,
+    hasDefaultRangeAggregateWindow(stmt)
+  );
+  const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
+    stmt,
+    fieldSemanticsResolver,
+    windowWarningContext
+  );
   const plainGroupByPlan = await buildRuntimePlainGroupByPlan(
     stmt,
     client,
@@ -17530,7 +17761,10 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     cteCache
   );
   await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
-  const whereCapability = rememberSelectWhereCapability(stmt, await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache));
+  const whereCapability = rememberSelectWhereCapability(
+    stmt,
+    classifyWhereCapability(stmt.where, fieldSemanticsResolver)
+  );
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
@@ -17617,7 +17851,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache, forLibraryCapture)
     );
   }
-  return result;
+  return mergeSelectWarnings(result, defaultRangeWarnings);
 }
 async function buildRuntimePlainGroupByPlan(stmt, client, cacheContext, materializedTables) {
   if (stmt.groupBy.length === 0) return void 0;
@@ -17853,6 +18087,8 @@ function arithHasFieldRef(node) {
   return false;
 }
 function stringFuncArgHasFieldRef(arg) {
+  if (arg.type === "AGG_GROUP_KEY") return true;
+  if (arg.type === "VARIABLE") return false;
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
   return scalarValueHasFieldRef(arg);
 }
@@ -18410,7 +18646,11 @@ function collectAggregateArgFieldRefs(arg, out) {
   }
   if (arg.type === "STRING_FUNC") {
     for (const child of arg.args) {
-      if (child.type !== "AGG_REF" && child.type !== "AGG_ARITH") collectAggregateArgFieldRefs(child, out);
+      if (child.type === "AGG_GROUP_KEY") {
+        out.push({ type: "FIELD", tableAlias: child.tableAlias ?? null, field: child.field });
+      } else if (child.type !== "AGG_REF" && child.type !== "AGG_ARITH" && child.type !== "VARIABLE") {
+        collectAggregateArgFieldRefs(child, out);
+      }
     }
     return;
   }
@@ -18430,11 +18670,16 @@ function collectAggregateOperandRefs(node, out) {
     collectAggregateOperandRefs(node.left, out);
     collectAggregateOperandRefs(node.right, out);
   }
+  if (node.type === "AGG_GROUP_KEY") out.push({ type: "FIELD", tableAlias: node.tableAlias ?? null, field: node.field });
 }
 function collectStringFuncAggregateRefs(expr, out) {
   for (const arg of expr.args) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
       collectAggregateOperandRefs(arg, out);
+    } else if (arg.type === "AGG_GROUP_KEY") {
+      out.push({ type: "FIELD", tableAlias: arg.tableAlias ?? null, field: arg.field });
+    } else if (arg.type === "VARIABLE") {
+      continue;
     } else {
       collectScalarAggregateRefs(arg, out);
     }
@@ -19117,7 +19362,8 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
         cacheContext,
         void 0,
         captureColumnMeta,
-        forLibraryCapture
+        forLibraryCapture,
+        "DERIVED"
       ),
       executeSelect(
         markCountTotalCountRoot(stmt.right),
@@ -19126,7 +19372,8 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
         cacheContext,
         void 0,
         captureColumnMeta,
-        forLibraryCapture
+        forLibraryCapture,
+        "DERIVED"
       )
     ]);
     const leftCols = leftResult.columns;
@@ -19140,7 +19387,17 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
     });
     const combined = [...leftResult.rows, ...remappedRight];
     const rows = stmt.all ? combined : deduplicateRows(combined, leftCols);
-    const result = { type: "SELECT", rows, columns: leftCols, rowCount: rows.length };
+    const warnings = [.../* @__PURE__ */ new Set([
+      ...leftResult.warnings ?? [],
+      ...rightResult.warnings ?? []
+    ])];
+    const result = {
+      type: "SELECT",
+      rows,
+      columns: leftCols,
+      rowCount: rows.length,
+      warnings
+    };
     if (captureColumnMeta) {
       materializedMetaBySelectResult.set(result, mergeUnionColumnMeta(leftResult, rightResult));
     }
@@ -19158,25 +19415,44 @@ function deduplicateRows(rows, columns) {
 }
 async function executeWith(stmt, client, options, cacheContext, seed, captureColumnMeta = false) {
   if ((seed == null || seed.size === 0) && canInlineSingleCte(stmt)) {
-    return executeSelect(buildInlinedQuery(stmt), client, options, cacheContext, void 0, captureColumnMeta, false);
+    return executeSelect(
+      buildInlinedQuery(stmt),
+      client,
+      options,
+      cacheContext,
+      void 0,
+      captureColumnMeta,
+      false,
+      "DERIVED"
+    );
   }
   const cteCache = new Map(seed ?? []);
+  const warnings = /* @__PURE__ */ new Set();
   for (const cte of stmt.ctes) {
-    let result;
+    let result2;
     if (cte.query.type === "SHOW_APPS") {
-      result = await executeShowApps(client);
+      result2 = await executeShowApps(client);
     } else if (cte.query.type === "DESCRIBE") {
-      result = await executeDescribe(cte.query, client, cacheContext);
+      result2 = await executeDescribe(cte.query, client, cacheContext);
     } else {
-      result = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext, true);
+      result2 = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext, true);
     }
+    for (const warning of result2.warnings ?? []) warnings.add(warning);
     cteCache.set(cte.name, {
-      rows: result.rows,
-      columns: result.columns,
-      columnMeta: materializedMetaBySelectResult.get(result)
+      rows: result2.rows,
+      columns: result2.columns,
+      columnMeta: materializedMetaBySelectResult.get(result2)
     });
   }
-  return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext, captureColumnMeta);
+  const result = await executeQueryWithCte(
+    stmt.query,
+    client,
+    options,
+    cteCache,
+    cacheContext,
+    captureColumnMeta
+  );
+  return mergeSelectWarnings(result, [...warnings]);
 }
 async function executeQueryWithCte(query, client, options, cteCache, cacheContext, captureColumnMeta = false, b86PreflightComplete = false) {
   if (!b86PreflightComplete) {
@@ -19198,7 +19474,17 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
     });
     const combined = [...leftResult.rows, ...remapped];
     const rows = query.all ? combined : deduplicateRows(combined, leftCols);
-    const result2 = { type: "SELECT", rows, columns: leftCols, rowCount: rows.length };
+    const warnings = [.../* @__PURE__ */ new Set([
+      ...leftResult.warnings ?? [],
+      ...rightResult.warnings ?? []
+    ])];
+    const result2 = {
+      type: "SELECT",
+      rows,
+      columns: leftCols,
+      rowCount: rows.length,
+      warnings
+    };
     if (captureColumnMeta) {
       materializedMetaBySelectResult.set(result2, mergeUnionColumnMeta(leftResult, rightResult));
     }
@@ -19206,7 +19492,16 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
   }
   const hasCteRef = query.from.cteName != null && query.from.cteName !== NO_FROM_CTE_NAME || query.joins.some((j) => j.table.cteName != null);
   if (!hasCteRef) {
-    return executeSelect(query, client, options, cacheContext, cteCache, captureColumnMeta, false);
+    return executeSelect(
+      query,
+      client,
+      options,
+      cacheContext,
+      cteCache,
+      captureColumnMeta,
+      false,
+      "DERIVED"
+    );
   }
   const result = await executeFullScanWithCte(query, client, options, cteCache, cacheContext);
   if (captureColumnMeta) {
@@ -19254,6 +19549,18 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   for (const table of [stmt.from, ...stmt.joins.map((join2) => join2.table)]) {
     if (table.cteName !== null) requireMaterializedTable(table.cteName);
   }
+  const { resolver: choiceAndWindowResolver } = await normalizeSelectChoiceEquality(
+    stmt,
+    client,
+    cacheContext,
+    cteCache,
+    hasDefaultRangeAggregateWindow(stmt)
+  );
+  const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
+    stmt,
+    choiceAndWindowResolver,
+    "DERIVED"
+  );
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -19262,7 +19569,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     resolveSubqueries(stmt.having, client, options, cacheContext, cteCache),
     resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache)
   ]);
-  const whereCapability = await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache);
+  const whereCapability = classifyWhereCapability(stmt.where, choiceAndWindowResolver);
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
@@ -19391,7 +19698,10 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     client,
     cacheContext
   );
-  return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
+  return mergeSelectWarnings(
+    { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] },
+    defaultRangeWarnings
+  );
 }
 async function restoreEmptyWildcardColumns(stmt, rows, columns, client, cacheContext) {
   if (rows.length !== 0 || columns.length !== 0 || stmt.columns.length !== 1 || stmt.columns[0].type !== "WILDCARD" || stmt.joins.length !== 0 || stmt.from.cteName !== null) {
@@ -22805,6 +23115,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
+var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan) {
@@ -22860,7 +23171,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       if (needsWhereSchema || select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
         physicalApps.forEach((appId) => fieldApps.add(appId));
       }
-      const capability = await resolveSelectWhereCapability(select, tracedClient, cacheContext);
+      const { resolver, rewrites } = await normalizeSelectChoiceEquality(
+        select,
+        tracedClient,
+        cacheContext
+      );
+      if (rewrites.length > 0) explainChoiceEqualityRewrites.set(select, rewrites);
+      const capability = classifyWhereCapability(select.where, resolver);
       const relativeNode = relativeNodeFor(select);
       if (capability.capability === "UNSUPPORTED" && !relativeNode) {
         throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
@@ -22972,7 +23289,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   await visit(query);
   if (typeof query === "object" && query !== null && query.type === "WITH" && canInlineSingleCte(query)) {
     const inlined = buildInlinedQuery(query);
-    const capability = await resolveSelectWhereCapability(inlined, tracedClient, cacheContext);
+    const { resolver, rewrites } = await normalizeSelectChoiceEquality(
+      inlined,
+      tracedClient,
+      cacheContext
+    );
+    if (rewrites.length > 0) explainChoiceEqualityRewrites.set(inlined, rewrites);
+    const capability = classifyWhereCapability(inlined.where, resolver);
     const relativeNode = relativeNodeFor(inlined);
     if (capability.capability === "UNSUPPORTED" && !relativeNode) {
       throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
@@ -23744,6 +24067,13 @@ function buildValidatePlan(stmt, label) {
   lines.push("  records/mutation API during EXPLAIN: none; violation count unavailable");
   return lines;
 }
+function formatChoiceEqualityRewrite(rewrite) {
+  const field = rewrite.field.tableAlias ? `${rewrite.field.tableAlias}.${rewrite.field.field}` : rewrite.field.field;
+  const originalValue = rewrite.value.replace(/'/g, "''");
+  const normalizedValue = rewrite.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const normalizedOperator = rewrite.normalizedOperator === "IN" ? "in" : "not in";
+  return `  pushdown normalized: ${field} ${rewrite.originalOperator} '${originalValue}' -> ${field} ${normalizedOperator} ("${normalizedValue}")`;
+}
 function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlans, allowTotalCountPlan = true, emitFetch = true, collector = { sources: [] }, sourceRole = "main") {
   const whereCapability = capabilities?.get(stmt) ?? (capabilities ? [...capabilities].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
   const orderPlan = orderPlans?.get(stmt) ?? (orderPlans ? [...orderPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
@@ -23761,6 +24091,9 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
   );
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
+  for (const rewrite of explainChoiceEqualityRewrites.get(stmt) ?? choiceEqualityRewritesBySelect.get(stmt) ?? []) {
+    lines.push(formatChoiceEqualityRewrite(rewrite));
+  }
   if (groupingMetadata) {
     lines.push(`  grouping source: ${groupingMetadata.source}`);
     lines.push(
@@ -24416,7 +24749,8 @@ function collectArithNodeRefs(node, out) {
   }
   if (node.type === "STRING_FUNC") {
     for (const arg of node.args) {
-      if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") collectScalarNodeRefs(arg, out);
+      if (arg.type === "AGG_GROUP_KEY") out.add(arg.tableAlias ? `${arg.tableAlias}.${arg.field}` : arg.field);
+      else if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH" && arg.type !== "VARIABLE") collectScalarNodeRefs(arg, out);
     }
   }
 }
@@ -24478,7 +24812,10 @@ function collectScalarNodeRefs(node, out) {
     return;
   }
   if (node.type === "STRING_FUNC") {
-    for (const arg of node.args) if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") collectScalarNodeRefs(arg, out);
+    for (const arg of node.args) {
+      if (arg.type === "AGG_GROUP_KEY") out.add(arg.tableAlias ? `${arg.tableAlias}.${arg.field}` : arg.field);
+      else if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH" && arg.type !== "VARIABLE") collectScalarNodeRefs(arg, out);
+    }
     return;
   }
   if (node.type === "SCALAR_ARITH" || node.type === "CONCAT_OP") {