@rex0220/kintone-sql-tools 3.49.0 → 3.51.0

package/dist-cli/ksql.js

@@ -578,7 +578,13 @@ function compareDecimal(left, right) {
 // src/types/ast.ts
 var NO_FROM_CTE_NAME = "__NO_FROM__";
 function isRankingWindow(column) {
-  return column.windowKind !== "AGGREGATE";
+  return column.windowKind === void 0 || column.windowKind === "RANKING";
+}
+function isAggregateWindow(column) {
+  return column.windowKind === "AGGREGATE";
+}
+function isValueWindow(column) {
+  return column.windowKind === "VALUE";
 }
 function makeNumberLiteral(raw) {
   return { type: "NUMBER", value: Number(raw), raw };
@@ -1976,6 +1982,10 @@ var Parser = class {
       const parsedAlias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return this.withAliasDisplay({ type: "GROUPING_COL", ref, alias: parsedAlias2?.alias ?? null }, parsedAlias2);
     }
+    const valueWindowFunc = this.tryValueWindowFunc();
+    if (valueWindowFunc !== null) {
+      return this.parseValueWindowColumn(valueWindowFunc);
+    }
     if (this.tryAggregateFunc() === null && this.hasNestedAggregateWindowInSelectColumn()) {
       throw new ParseError(
         WINDOW_RESULT_IN_EXPRESSION_MESSAGE,
@@ -2086,6 +2096,22 @@ var Parser = class {
   tryWindowFunc() {
     return PARSER_WINDOW_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
+  tryValueWindowFunc(index = this.pos) {
+    const token = this.tokens[index];
+    if (token?.kind !== "IDENT" /* IDENT */ || this.tokens[index + 1]?.kind !== "(" /* LPAREN */) return null;
+    const name = token.value.toUpperCase();
+    if (name !== "LAG" && name !== "LEAD") return null;
+    let depth = 0;
+    for (let cursor = index + 1; cursor < this.tokens.length; cursor++) {
+      const candidate = this.tokens[cursor];
+      if (candidate.kind === "(" /* LPAREN */) depth++;
+      else if (candidate.kind === ")" /* RPAREN */ && --depth === 0) {
+        const next = this.tokens[cursor + 1];
+        return next?.kind === "IDENT" /* IDENT */ && next.value.toUpperCase() === "OVER" ? name : null;
+      }
+    }
+    return null;
+  }
   hasNestedAggregateWindowInSelectColumn() {
     let depth = 0;
     for (let index = this.pos; index < this.tokens.length; index++) {
@@ -2103,6 +2129,7 @@ var Parser = class {
           }
         }
       }
+      if (this.tryValueWindowFunc(index) !== null) return true;
       if (token.kind === "(" /* LPAREN */) depth++;
       else if (token.kind === ")" /* RPAREN */) depth--;
     }
@@ -2134,6 +2161,54 @@ var Parser = class {
     const parsedAlias = this.parseAliasName();
     return this.withAliasDisplay({ type: "WINDOW_COL", func, partitionBy, orderBy, alias: parsedAlias.alias }, parsedAlias);
   }
+  parseValueWindowColumn(valueFunc) {
+    this.advance();
+    this.expect("(" /* LPAREN */);
+    const arg = this.parseScalarValueExpr({ allowCase: true, allowAggregateArgs: false });
+    let offset = 1;
+    if (this.consume("," /* COMMA */)) {
+      const token = this.expect("NUMBER" /* NUMBER */, `${valueFunc} \u306E offset \u306F\u975E\u8CA0\u306E\u6574\u6570\u30EA\u30C6\u30E9\u30EB\u3060\u3051\u3067\u3059`);
+      offset = Number(token.value);
+      if (!Number.isSafeInteger(offset) || offset < 0) {
+        throw new ParseError(`${valueFunc} \u306E offset \u306F\u975E\u8CA0\u306E safe integer \u30EA\u30C6\u30E9\u30EB\u3060\u3051\u3067\u3059`, token);
+      }
+    }
+    this.expect(")" /* RPAREN */, `${valueFunc} \u306F expr \u3068\u7701\u7565\u53EF\u80FD\u306A offset \u306E 2 \u5F15\u6570\u307E\u3067\u3067\u3059`);
+    this.expectSoftKeyword("OVER", `${valueFunc} \u306B\u306F OVER (...) \u304C\u5FC5\u8981\u3067\u3059`);
+    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 */));
+    }
+    if (!this.consume("ORDER" /* ORDER */)) {
+      throw new ParseError(`${valueFunc} \u306E OVER \u306B\u306F ORDER BY \u304C\u5FC5\u8981\u3067\u3059`, this.peek());
+    }
+    this.expect("BY" /* BY */);
+    const orderBy = this.parseOrderBy(false);
+    this.expect(")" /* RPAREN */);
+    if (this.isArithOp(this.peek().kind) || this.peek().kind === "||" /* CONCAT_OP */) {
+      throw new ParseError(WINDOW_RESULT_IN_EXPRESSION_MESSAGE, 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: "VALUE",
+      valueFunc,
+      arg,
+      offset,
+      partitionBy,
+      orderBy,
+      alias: parsedAlias.alias
+    }, parsedAlias);
+  }
   parseAggregateWindowColumn(ref) {
     const supported = /* @__PURE__ */ new Set(["SUM", "COUNT", "AVG", "MIN", "MAX"]);
     if (!supported.has(ref.func)) {
@@ -6343,7 +6418,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
       case "SCALAR_SUBQUERY_COL":
         break;
       case "WINDOW_COL":
-        if (col.windowKind === "AGGREGATE" && col.arg.type !== "WILDCARD") {
+        if ((col.windowKind === "AGGREGATE" || col.windowKind === "VALUE") && col.arg.type !== "WILDCARD") {
           walkAggregateArg(col.arg, "select");
         }
         for (const ref of col.partitionBy) addFieldRef(ref.field, ref.tableAlias, "select");
@@ -13835,10 +13910,17 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
     for (const partition of partitions.values()) {
       const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
-      if (!isRankingWindow(window)) {
+      if (isAggregateWindow(window)) {
         applyAggregateWindow(window, sortedResult, resolveAggSortKind);
         continue;
       }
+      if (isValueWindow(window)) {
+        applyValueWindow(window, sorted);
+        continue;
+      }
+      if (!isRankingWindow(window)) {
+        throw new Error(`InternalError: unknown window kind ${window.windowKind ?? "undefined"}`);
+      }
       let rank = 1;
       let denseRank = 1;
       for (let index = 0; index < sorted.length; index++) {
@@ -13853,6 +13935,20 @@ function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2, re
   }
   return rows;
 }
+function evaluateValueWindowArg(arg, row) {
+  const value = evalScalarValueExprNullable(arg, row);
+  if (value === null || value === void 0) return "";
+  if (typeof value === "number" && !Number.isFinite(value)) return "";
+  return String(value);
+}
+function applyValueWindow(window, sorted) {
+  const values = sorted.map((item) => evaluateValueWindowArg(window.arg, item.row));
+  const direction = window.valueFunc === "LAG" ? -1 : 1;
+  for (let index = 0; index < sorted.length; index++) {
+    const target = index + direction * window.offset;
+    sorted[index].row[window.alias] = target >= 0 && target < values.length ? values[target] : "";
+  }
+}
 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));
@@ -14382,9 +14478,9 @@ function deriveOutputOrderSemantics(columns, resolveAggSortKind) {
     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") {
+      if (isRankingWindow(column) || isAggregateWindow(column) && (column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG")) {
         result.set(column.alias, syntheticSemantics("number"));
-      } else if (column.arg.type !== "WILDCARD") {
+      } else if ((isAggregateWindow(column) || isValueWindow(column)) && column.arg.type !== "WILDCARD") {
         const semantics = resolveAggregateArgSemantics(column.arg, resolveAggSortKind) ?? "string";
         result.set(column.alias, typeof semantics === "string" ? syntheticSemantics(semantics) : semantics);
       }
@@ -16970,8 +17066,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.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")) {
+        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" && (first.windowKind === void 0 || first.windowKind === "RANKING" || 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 === "VALUE" || first?.type === "WINDOW_COL" && first.windowKind === "AGGREGATE" && (first.aggFunc === "MIN" || first.aggFunc === "MAX")) {
           const meta = (await inferSelectColumnMeta(
             resolvedStmt2.expr.query,
             ["__scalar__"],
@@ -17614,26 +17710,43 @@ function hasDefaultRangeAggregateWindow(stmt) {
     (column) => column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && column.orderBy.length > 0 && column.frame?.source === "DEFAULT"
   );
 }
+function hasWindowNeedingOrderProof(stmt) {
+  return hasDefaultRangeAggregateWindow(stmt) || stmt.columns.some((column) => column.type === "WINDOW_COL" && column.windowKind === "VALUE");
+}
+function canProveTotalWindowOrder(stmt, orderBy, resolveField2, context) {
+  if (context !== "DIRECT" || stmt.joins.length > 0 || stmt.from.cteName !== null || stmt.from.subtableCode != null) {
+    return false;
+  }
+  return 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";
+  });
+}
 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;
+    if (canProveTotalWindowOrder(stmt, column.orderBy, resolveField2, context)) 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`
     );
   }
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL" || column.windowKind !== "VALUE") continue;
+    if (canProveTotalWindowOrder(stmt, column.orderBy, resolveField2, context)) continue;
+    warnings.push(
+      `${column.alias} \u306E ORDER BY \u306F\u5168\u9806\u5E8F\u3067\u306A\u3044\u305F\u3081\u3001\u540C\u9806\u5185\u306E\u524D\u5F8C\u95A2\u4FC2\u306F\u672A\u898F\u5B9A\u3067\u3059\u3002\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u7B49\u3092 ORDER BY \u306B\u8FFD\u52A0\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])] };
+  const merged = { ...result, warnings: [.../* @__PURE__ */ new Set([...result.warnings ?? [], ...additional])] };
+  const meta = materializedMetaBySelectResult.get(result);
+  if (meta) materializedMetaBySelectResult.set(merged, meta);
+  return merged;
 }
 function selectCaseConditionsNeedFieldMetadata(stmt) {
   const visit = (value) => {
@@ -17654,9 +17767,9 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
     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") {
+      if (column.windowKind === void 0 || column.windowKind === "RANKING" || column.windowKind === "AGGREGATE" && (column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG")) {
         semantics = syntheticSemantics("number");
-      } else if (column.arg.type !== "WILDCARD") {
+      } else if ((column.windowKind === "AGGREGATE" || column.windowKind === "VALUE") && column.arg.type !== "WILDCARD") {
         semantics = inferAggregateArgMeta(column.arg, (ref) => {
           const resolved = rowResolver(ref);
           return resolved ? {
@@ -17753,7 +17866,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     client,
     cacheContext,
     cteCache,
-    hasDefaultRangeAggregateWindow(stmt)
+    hasWindowNeedingOrderProof(stmt)
   );
   const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
     stmt,
@@ -18963,17 +19076,23 @@ function inferAggregateArgMeta(arg, resolveField2) {
   return mergeExpressionColumnMeta(results);
 }
 function inferWindowColumnMeta(column, resolveField2) {
-  if (column.windowKind !== "AGGREGATE" || column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
-    return syntheticColumnMeta("number");
+  if (column.windowKind === "VALUE") {
+    return inferAggregateArgMeta(column.arg, resolveField2);
   }
-  return column.arg.type === "WILDCARD" ? unknownStringColumnMeta() : inferAggregateArgMeta(column.arg, resolveField2);
+  if (column.windowKind === "AGGREGATE") {
+    if (column.aggFunc === "COUNT" || column.aggFunc === "SUM" || column.aggFunc === "AVG") {
+      return syntheticColumnMeta("number");
+    }
+    return column.arg.type === "WILDCARD" ? unknownStringColumnMeta() : inferAggregateArgMeta(column.arg, resolveField2);
+  }
+  return syntheticColumnMeta("number");
 }
 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.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && (column.aggFunc === "MIN" || column.aggFunc === "MAX")
+    (column) => column.type === "FIELD" || column.type === "WILDCARD" || column.type === "PARENT_WILDCARD" || column.type === "CASE_COL" || column.type === "AGGREGATE" && (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") || column.type === "WINDOW_COL" && (column.windowKind === "VALUE" || column.windowKind === "AGGREGATE" && (column.aggFunc === "MIN" || column.aggFunc === "MAX"))
   );
 }
 async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext, materializedTables, forLibraryCapture = false) {
@@ -19349,6 +19468,13 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   );
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
+function assertUnionColumnCount(leftColumns, rightColumns) {
+  if (leftColumns.length === rightColumns.length) return;
+  throw new Error(
+    `ArgumentError: UNION \u306E\u5DE6\u53F3\u3067\u5217\u6570\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093\uFF08\u5DE6 ${leftColumns.length} \u5217 / \u53F3 ${rightColumns.length} \u5217\uFF09\u3002
+UNION \u306F\u5217\u3092\u4F4D\u7F6E\u3067\u5BFE\u5FDC\u3055\u305B\u308B\u305F\u3081\u3001\u4E21\u8FBA\u306E\u5217\u6570\u3092\u63C3\u3048\u3066\u304F\u3060\u3055\u3044`
+  );
+}
 async function executeUnion(stmt, client, options, cacheContext, captureColumnMeta = false, forLibraryCapture = false) {
   const completePolicy = buildCompleteInputPolicy(stmt, options, null);
   return withCompleteInputPolicy(completePolicy, async () => {
@@ -19384,6 +19510,7 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
     ]);
     const leftCols = leftResult.columns;
     const rightCols = rightResult.columns;
+    assertUnionColumnCount(leftCols, rightCols);
     const remappedRight = rightResult.rows.map((row) => {
       const mapped = {};
       leftCols.forEach((col, i) => {
@@ -19471,6 +19598,7 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
     ]);
     const leftCols = leftResult.columns;
     const rightCols = rightResult.columns;
+    assertUnionColumnCount(leftCols, rightCols);
     const remapped = rightResult.rows.map((row) => {
       const mapped = {};
       leftCols.forEach((col, i) => {
@@ -19560,7 +19688,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     client,
     cacheContext,
     cteCache,
-    hasDefaultRangeAggregateWindow(stmt)
+    hasWindowNeedingOrderProof(stmt)
   );
   const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
     stmt,
@@ -22990,9 +23118,23 @@ async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache
     updatedCount: toUpdate.length
   };
 }
+var SHOW_APPS_COLUMNS = Object.freeze([
+  "\u30A2\u30D7\u30EAID",
+  "\u30A2\u30D7\u30EA\u540D",
+  "\u8AAC\u660E"
+]);
+var DESCRIBE_COLUMNS = Object.freeze([
+  "\u30D5\u30A3\u30FC\u30EB\u30C9\u30B3\u30FC\u30C9",
+  "\u30E9\u30D9\u30EB",
+  "\u30BF\u30A4\u30D7",
+  "\u30EB\u30C3\u30AF\u30A2\u30C3\u30D7",
+  "\u30B3\u30D4\u30FC\u5143",
+  "\u91CD\u8907\u7981\u6B62",
+  "\u8A08\u7B97\u5F0F"
+]);
 async function executeShowApps(client) {
   const apps = await client.getApps();
-  const columns = ["\u30A2\u30D7\u30EAID", "\u30A2\u30D7\u30EA\u540D", "\u8AAC\u660E"];
+  const columns = [...SHOW_APPS_COLUMNS];
   const rows = apps.map((a) => ({
     "\u30A2\u30D7\u30EAID": String(a.appId),
     "\u30A2\u30D7\u30EA\u540D": a.name,
@@ -23002,15 +23144,7 @@ async function executeShowApps(client) {
 }
 async function executeDescribe(stmt, client, cacheContext) {
   const fields = await getFieldsCached(stmt.appId, client, cacheContext);
-  const columns = [
-    "\u30D5\u30A3\u30FC\u30EB\u30C9\u30B3\u30FC\u30C9",
-    "\u30E9\u30D9\u30EB",
-    "\u30BF\u30A4\u30D7",
-    "\u30EB\u30C3\u30AF\u30A2\u30C3\u30D7",
-    "\u30B3\u30D4\u30FC\u5143",
-    "\u91CD\u8907\u7981\u6B62",
-    "\u8A08\u7B97\u5F0F"
-  ];
+  const columns = [...DESCRIBE_COLUMNS];
   const rows = fields.map((f) => ({
     "\u30D5\u30A3\u30FC\u30EB\u30C9\u30B3\u30FC\u30C9": f.code,
     "\u30E9\u30D9\u30EB": f.label,
@@ -24148,7 +24282,7 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     }
   }
   for (const column of stmt.columns) {
-    if (column.type !== "WINDOW_COL" || column.windowKind !== "AGGREGATE") continue;
+    if (column.type !== "WINDOW_COL" || column.windowKind === void 0 || column.windowKind === "RANKING") continue;
     const clauses = [];
     if (column.partitionBy.length > 0) {
       clauses.push(`PARTITION BY ${column.partitionBy.map(
@@ -24158,8 +24292,12 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
     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 (column.windowKind === "VALUE") {
+      lines.push(`  window ${column.alias}: ${column.valueFunc}(offset=${column.offset}) OVER (${clauses.join(" ")})`);
+    } else if (column.windowKind === "AGGREGATE") {
+      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);