@rex0220/kintone-sql-tools 2.14.1 → 2.16.0

package/dist-cli/ksql.js

@@ -87,6 +87,10 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["AVG", "AVG" /* AVG */],
   ["MAX", "MAX" /* MAX */],
   ["MIN", "MIN" /* MIN */],
+  ["GROUP_CONCAT", "GROUP_CONCAT" /* GROUP_CONCAT */],
+  ["ROW_NUMBER", "ROW_NUMBER" /* ROW_NUMBER */],
+  ["RANK", "RANK" /* RANK */],
+  ["DENSE_RANK", "DENSE_RANK" /* DENSE_RANK */],
   ["ASSERT", "ASSERT" /* ASSERT */],
   ["AND", "AND" /* AND */],
   ["OR", "OR" /* OR */],
@@ -463,6 +467,9 @@ var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "AVG" /* AVG */,
   "MAX" /* MAX */,
   "MIN" /* MIN */,
+  "ROW_NUMBER" /* ROW_NUMBER */,
+  "RANK" /* RANK */,
+  "DENSE_RANK" /* DENSE_RANK */,
   "TODAY" /* TODAY */,
   "NOW" /* NOW */,
   "LOGINUSER" /* LOGINUSER */,
@@ -981,6 +988,11 @@ var Parser = class {
     const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy()) : [];
     const limit = this.consume("LIMIT" /* LIMIT */) ? this.parseUnsignedInt() : null;
     const offset = this.consume("OFFSET" /* OFFSET */) ? this.parseUnsignedInt() : null;
+    const hasWindow = columns.some((column) => column.type === "WINDOW_COL");
+    const hasAggregate = columns.some((column) => this.selectColumnHasAggregate(column));
+    if (hasWindow && (groupBy.length > 0 || hasAggregate)) {
+      throw new ParseError("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u306F GROUP BY / \u96C6\u8A08\u95A2\u6570\u3068\u540C\u3058 SELECT \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
+    }
     return {
       type: "SELECT",
       distinct,
@@ -1045,6 +1057,10 @@ var Parser = class {
     if (this.consume("*" /* STAR */)) {
       return { type: "WILDCARD" };
     }
+    const windowFunc = this.tryWindowFunc();
+    if (windowFunc !== null) {
+      return this.parseWindowColumn(windowFunc);
+    }
     if (this.peek().kind === "CASE" /* CASE */) {
       const expr = this.parseCaseWhenExpr();
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
@@ -1079,6 +1095,7 @@ var Parser = class {
         func: ref.func,
         distinct: ref.distinct,
         arg: ref.arg,
+        ...ref.separator !== void 0 ? { separator: ref.separator } : {},
         alias: alias2
       };
     }
@@ -1115,6 +1132,56 @@ var Parser = class {
     const alias = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
     return { type: "FIELD", field, alias };
   }
+  tryWindowFunc() {
+    switch (this.peek().kind) {
+      case "ROW_NUMBER" /* ROW_NUMBER */:
+        return "ROW_NUMBER";
+      case "RANK" /* RANK */:
+        return "RANK";
+      case "DENSE_RANK" /* DENSE_RANK */:
+        return "DENSE_RANK";
+      default:
+        return null;
+    }
+  }
+  parseWindowColumn(func) {
+    this.advance();
+    this.expect("(" /* LPAREN */);
+    if (this.peek().kind !== ")" /* RPAREN */) {
+      throw new ParseError(`${func} \u306F\u5F15\u6570\u3092\u53D7\u3051\u4ED8\u3051\u307E\u305B\u3093`, this.peek());
+    }
+    this.expect(")" /* RPAREN */);
+    this.expectSoftKeyword("OVER", `${func} \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 ref = this.parseQualifiedIdent();
+        partitionBy.push({ type: "FIELD", tableAlias: ref.tableAlias, field: ref.field });
+      } while (this.consume("," /* COMMA */));
+    }
+    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy()) : [];
+    this.expect(")" /* RPAREN */);
+    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 alias = this.parseAliasName();
+    return { type: "WINDOW_COL", func, partitionBy, orderBy, alias };
+  }
+  selectColumnHasAggregate(column) {
+    if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
+    if (column.type !== "STRFUNC_COL") return false;
+    return column.expr.args.some((arg) => this.stringFuncArgHasAggregate(arg));
+  }
+  stringFuncArgHasAggregate(arg) {
+    if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+    if (arg.type === "STRING_FUNC") {
+      return arg.args.some((nested) => this.stringFuncArgHasAggregate(nested));
+    }
+    return false;
+  }
   isArithOp(kind) {
     return kind === "+" /* PLUS */ || kind === "-" /* MINUS */ || kind === "*" /* STAR */ || kind === "/" /* SLASH */ || kind === "%" /* PERCENT */;
   }
@@ -1450,7 +1517,8 @@ var Parser = class {
       ["SUM" /* SUM */]: "SUM",
       ["AVG" /* AVG */]: "AVG",
       ["MAX" /* MAX */]: "MAX",
-      ["MIN" /* MIN */]: "MIN"
+      ["MIN" /* MIN */]: "MIN",
+      ["GROUP_CONCAT" /* GROUP_CONCAT */]: "GROUP_CONCAT"
     };
     const kind = this.peek().kind;
     return map[kind] ?? null;
@@ -1462,12 +1530,29 @@ var Parser = class {
     const distinct = this.consume("DISTINCT" /* DISTINCT */);
     let arg;
     if (this.consume("*" /* STAR */)) {
+      if (func === "GROUP_CONCAT") {
+        throw new ParseError("GROUP_CONCAT(*) \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u30D5\u30A3\u30FC\u30EB\u30C9\u307E\u305F\u306F\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", this.prev());
+      }
       arg = { type: "WILDCARD" };
     } else {
       arg = this.parseArithAddSub();
     }
+    let separator;
+    if (this.isSoftKeyword("SEPARATOR")) {
+      const separatorToken = this.advance();
+      if (func !== "GROUP_CONCAT") {
+        throw new ParseError("SEPARATOR \u306F GROUP_CONCAT \u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059", separatorToken);
+      }
+      separator = this.expect("STRING" /* STRING */, "SEPARATOR \u306E\u5F8C\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059").value;
+    }
     this.expect(")" /* RPAREN */);
-    return { type: "AGG_REF", func, distinct, arg };
+    return {
+      type: "AGG_REF",
+      func,
+      distinct,
+      arg,
+      ...separator !== void 0 ? { separator } : {}
+    };
   }
   // ----------------------------------------------------------
   // FROM / JOIN
@@ -1745,10 +1830,20 @@ var Parser = class {
       const distinct = this.consume("DISTINCT" /* DISTINCT */);
       let argStr;
       if (this.consume("*" /* STAR */)) {
+        if (aggFunc === "GROUP_CONCAT") {
+          throw new ParseError("GROUP_CONCAT(*) \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u30D5\u30A3\u30FC\u30EB\u30C9\u307E\u305F\u306F\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", this.prev());
+        }
         argStr = "*";
       } else {
         argStr = this.parseIdentifier();
       }
+      if (this.isSoftKeyword("SEPARATOR")) {
+        const separatorToken = this.advance();
+        if (aggFunc !== "GROUP_CONCAT") {
+          throw new ParseError("SEPARATOR \u306F GROUP_CONCAT \u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059", separatorToken);
+        }
+        this.expect("STRING" /* STRING */, "SEPARATOR \u306E\u5F8C\u306B\u306F\u6587\u5B57\u5217\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
+      }
       this.expect(")" /* RPAREN */);
       const syntheticName = distinct ? `${aggFunc}(DISTINCT ${argStr})` : `${aggFunc}(${argStr})`;
       return { type: "FIELD", tableAlias: null, field: syntheticName };
@@ -2868,12 +2963,16 @@ 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 (stmt.groupBy.length > 0) 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)
   )) return "FULL_SCAN";
@@ -3245,16 +3344,16 @@ function collectRequiredFieldsByTable(stmt) {
     }
     walkStringFunc(k.expr, "groupBy");
   };
-  const walkOrderByKey = (k) => {
+  const walkOrderByKey = (k, phase = "orderBy") => {
     if (k.type === "FIELD_NAME") {
-      addFieldName(k.name, "orderBy");
+      addFieldName(k.name, phase);
       return;
     }
     if (k.type === "ARITH_KEY") {
-      walkArith(k.expr, "orderBy");
+      walkArith(k.expr, phase);
       return;
     }
-    walkStringFunc(k.expr, "orderBy");
+    walkStringFunc(k.expr, phase);
   };
   for (const col of stmt.columns) {
     switch (col.type) {
@@ -3286,6 +3385,10 @@ function collectRequiredFieldsByTable(stmt) {
         break;
       case "SCALAR_SUBQUERY_COL":
         break;
+      case "WINDOW_COL":
+        for (const ref of col.partitionBy) addFieldRef(ref.field, ref.tableAlias, "select");
+        for (const item of col.orderBy) walkOrderByKey(item.key, "select");
+        break;
     }
   }
   for (const join2 of stmt.joins) {
@@ -3332,6 +3435,10 @@ function collectSelectOutputNames(columns) {
     }
     if (col.type === "SCALAR_SUBQUERY_COL") {
       names.add(col.alias ?? "(subquery)");
+      continue;
+    }
+    if (col.type === "WINDOW_COL") {
+      names.add(col.alias);
     }
   }
   return names;
@@ -3357,7 +3464,7 @@ function stringFuncLabel(expr) {
   return `${expr.func}(${args.join(",")})`;
 }
 function isAggregateSyntheticName(name) {
-  return /^(COUNT|SUM|AVG|MAX|MIN)\(/i.test(name);
+  return /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT)\(/i.test(name);
 }
 
 // src/core/cteInlining.ts
@@ -5123,7 +5230,7 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind) {
     for (const col of columns) {
       if (col.type === "AGGREGATE") {
         const syntheticKey = aggregateSyntheticName2(col.func, col.distinct, col.arg);
-        const value = String(evalAggregate(col.func, col.distinct, col.arg, groupRows, resolveAggSortKind));
+        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") {
@@ -5144,7 +5251,7 @@ function evalGroupByKey(key, row) {
   if (key.type === "FUNC_KEY") return evalStringFunc(key.expr, row);
   return String(evalArithExpr(key.expr, row));
 }
-function evalAggregate(func, distinct, arg, rows, resolveAggSortKind) {
+function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind) {
   if (arg.type === "WILDCARD") {
     return func === "COUNT" ? rows.length : 0;
   }
@@ -5164,6 +5271,7 @@ function evalAggregate(func, distinct, arg, rows, resolveAggSortKind) {
   }
   const eff = distinct ? [...new Set(strValues)] : strValues;
   if (func === "COUNT") return eff.length;
+  if (func === "GROUP_CONCAT") return eff.join(separator ?? ",");
   const sortKind = (func === "MIN" || func === "MAX") && arg.type === "FIELD_REF" ? resolveAggSortKind?.(toAggregateFieldRef(arg.field)) : void 0;
   if (sortKind === "string") {
     if (eff.length === 0) return "";
@@ -5208,7 +5316,7 @@ function minOf(nums) {
 }
 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, rows, resolveAggSortKind));
+  if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
   const l = evalAggArithExpr(node.left, rows, resolveAggSortKind);
   const r = evalAggArithExpr(node.right, rows, resolveAggSortKind);
   switch (node.op) {
@@ -5278,6 +5386,10 @@ function buildDistinctKeyBuilder(rows, columns) {
         values.push(row[col.field] ?? "");
         continue;
       }
+      if (col.type === "WINDOW_COL") {
+        values.push(row[col.alias] ?? "");
+        continue;
+      }
       if (col.type === "PARENT_WILDCARD") {
         for (const k of sortedParentKeys) {
           values.push(row[k] !== void 0 ? row[k] : null);
@@ -5289,6 +5401,9 @@ function buildDistinctKeyBuilder(rows, columns) {
 }
 function applyOrderBy(rows, orderBy, optionOrders, sortKinds) {
   if (orderBy.length === 0) return rows;
+  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds).rows.map((item) => item.row);
+}
+function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds) {
   const keyMeta = orderBy.map(({ key }) => ({
     orderMap: key.type === "FIELD_NAME" ? optionOrders?.get(key.name) : void 0,
     sortKind: key.type === "FIELD_NAME" ? sortKinds?.get(key.name) : void 0
@@ -5307,14 +5422,16 @@ function applyOrderBy(rows, orderBy, optionOrders, sortKinds) {
       };
     })
   }));
-  decorated.sort((a, b) => {
-    for (let i = 0; i < orderBy.length; i++) {
-      const cmp = compareSortKeys(a.keys[i], b.keys[i], keyMeta[i]);
-      if (cmp !== 0) return orderBy[i].direction === "ASC" ? cmp : -cmp;
-    }
-    return 0;
-  });
-  return decorated.map((d) => d.row);
+  const compare = (a, b) => compareDecoratedRows(a, b, orderBy, keyMeta);
+  decorated.sort(compare);
+  return { rows: decorated, compare };
+}
+function compareDecoratedRows(a, b, orderBy, keyMeta) {
+  for (let i = 0; i < orderBy.length; i++) {
+    const cmp = compareSortKeys(a.keys[i], b.keys[i], keyMeta[i]);
+    if (cmp !== 0) return orderBy[i].direction === "ASC" ? cmp : -cmp;
+  }
+  return 0;
 }
 function compareSortKeys(a, b, meta) {
   if (meta.orderMap) {
@@ -5359,6 +5476,38 @@ function minChoiceIndex(values, orderMap) {
   }
   return min;
 }
+function applyWindow(rows, columns, optionOrders, sortKinds) {
+  const windows = columns.filter((column) => column.type === "WINDOW_COL");
+  if (rows.length === 0 || windows.length === 0) return rows;
+  for (const window of windows) {
+    const partitions = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const key = JSON.stringify(window.partitionBy.map((ref) => resolveWindowField(row, ref)));
+      const partition = partitions.get(key);
+      if (partition) partition.push(row);
+      else partitions.set(key, [row]);
+    }
+    for (const partition of partitions.values()) {
+      const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds);
+      const sorted = sortedResult.rows;
+      let rank = 1;
+      let denseRank = 1;
+      for (let index = 0; index < sorted.length; index++) {
+        if (index > 0 && sortedResult.compare(sorted[index - 1], sorted[index]) !== 0) {
+          rank = index + 1;
+          denseRank++;
+        }
+        const value = window.func === "ROW_NUMBER" ? index + 1 : window.func === "RANK" ? rank : denseRank;
+        sorted[index].row[window.alias] = String(value);
+      }
+    }
+  }
+  return rows;
+}
+function resolveWindowField(row, ref) {
+  const name = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+  return resolveFieldRef(row, name);
+}
 function applyLimit(rows, limit, offset) {
   const start = offset ?? 0;
   if (limit === null) return rows.slice(start);
@@ -5449,6 +5598,12 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns) {
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
+        case "WINDOW_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias;
+          out[key] = row[col.alias] ?? "";
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
       }
     }
     return out;
@@ -5489,6 +5644,8 @@ function computeOutputKey(col, colIdx, defaultFieldKeys) {
       return col.alias ?? stringFuncDefaultKey(col.expr);
     case "SCALAR_SUBQUERY_COL":
       return col.alias ?? "(subquery)";
+    case "WINDOW_COL":
+      return col.alias;
     case "WILDCARD":
     case "PARENT_WILDCARD":
       throw new Error("internal: computeOutputKey received a wildcard column");
@@ -5557,7 +5714,7 @@ function hasAggregateInStringFuncExpr2(expr) {
 }
 function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
   if (arg.type === "AGG_REF") {
-    const value = evalAggregate(arg.func, arg.distinct, arg.arg, rows, resolveAggSortKind);
+    const value = evalAggregate(arg.func, arg.distinct, arg.arg, arg.separator, rows, resolveAggSortKind);
     return typeof value === "number" ? { type: "NUMBER", value } : { type: "STRING", value };
   }
   if (arg.type === "AGG_ARITH") {
@@ -5603,6 +5760,7 @@ function runFullScan(input) {
     rows = applyGroupBy(rows, stmt.groupBy, stmt.columns, aggregateSortKindResolver);
   }
   rows = applyHaving(rows, stmt.having, havingFieldTypeResolver);
+  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds);
   if (stmt.distinct) {
     rows = applyDistinct(rows, stmt.columns);
   }
@@ -5803,7 +5961,8 @@ function isValidTemporal(value, type) {
   const date = new Date(Date.UTC(year, month - 1, day));
   if (date.getUTCFullYear() !== year || date.getUTCMonth() !== month - 1 || date.getUTCDate() !== day) return false;
   if (type === "DATE") return true;
-  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && isValidTemporal(value.slice(11, value.endsWith("Z") ? -1 : value.length - 6), "TIME");
+  const timePart = value.slice(11, value.endsWith("Z") ? -1 : value.length - 6).replace(/\.\d+$/, "");
+  return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(value) && isValidTemporal(timePart, "TIME");
 }
 
 // src/core/dmlValidationCandidates.ts
@@ -5883,6 +6042,8 @@ var SearchAbortedError = class extends Error {
     this.name = "SearchAbortedError";
   }
 };
+var materializedMetaBySelectResult = /* @__PURE__ */ new WeakMap();
+var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
 async function execute(sql, client, options = {}) {
   const startedAt = Date.now();
   const stmt = parseSql(sql);
@@ -6028,16 +6189,25 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
   }
 }
 var TEMP_TABLE_MAX_ROWS = 1e4;
-function appendValidationErrors(tempTables, name, columns, rows, maxRows) {
+function appendValidationErrors(tempTables, name, columns, rows, maxRows, columnMeta) {
   const current = tempTables.get(name);
-  if (current && (current.columns.length !== columns.length || current.columns.some((c, i) => c !== columns[i]))) {
+  if (current && (current.columns.length !== columns.length || current.columns.some((c, i) => c !== columns[i]) || !materializedColumnMetaEqual(current.columnMeta, columnMeta))) {
     throw new Error(`ArgumentError: validation error table ${name} has a different schema.`);
   }
   const existingRows = current?.rows ?? [];
   if (existingRows.length + rows.length > maxRows) {
     throw new Error(`ArgumentError: temp table ${name} exceeds max rows (${maxRows}).`);
   }
-  tempTables.set(name, { columns: [...columns], rows: [...existingRows, ...rows] });
+  tempTables.set(name, { columns: [...columns], rows: [...existingRows, ...rows], columnMeta });
+}
+function materializedColumnMetaEqual(left, right) {
+  if (left === right) return true;
+  if (!left || !right || left.size !== right.size) return false;
+  for (const [column, meta] of left) {
+    const candidate = right.get(column);
+    if (!candidate || candidate.sortKind !== meta.sortKind || candidate.fieldType !== meta.fieldType) return false;
+  }
+  return true;
 }
 var BatchTimeoutError = class extends Error {
   constructor() {
@@ -6199,7 +6369,8 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
         resolvedStmt.validationErrorTable,
         result.columns,
         result.errors,
-        options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS
+        options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+        materializedMetaByValidationResult.get(result) ?? /* @__PURE__ */ new Map()
       );
     }
     return { result };
@@ -6223,7 +6394,11 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
       onLimitReached: "error"
     };
     const result = await runSelectLike(resolvedStmt.query, client, materializeOptions, cacheContext, tempTables);
-    tempTables.set(resolvedStmt.name, { rows: result.rows, columns: result.columns });
+    tempTables.set(resolvedStmt.name, {
+      rows: result.rows,
+      columns: result.columns,
+      columnMeta: materializedMetaBySelectResult.get(result)
+    });
     return { tempTable: resolvedStmt.name, rowCount: result.rows.length };
   }
   if (stmt.type === "DROP_TEMP_TABLE") {
@@ -6259,9 +6434,9 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
 }
 async function runSelectLike(query, client, options, cacheContext, tempTables) {
   if (query.type === "WITH") {
-    return executeWith(query, client, options, cacheContext, tempTables);
+    return executeWith(query, client, options, cacheContext, tempTables, true);
   }
-  return executeQueryWithCte(query, client, options, tempTables, cacheContext);
+  return executeQueryWithCte(query, client, options, tempTables, cacheContext, true);
 }
 async function runWithDeadline(work, remainingMs) {
   if (remainingMs === null) return work;
@@ -6474,18 +6649,27 @@ function evalAssertArith(node) {
   }
   throw new Error(`ArgumentError: unsupported operand in ASSERT expression: ${node.type}`);
 }
-async function executeSelect(stmt, client, options, cacheContext, cteCache) {
+async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false) {
+  let result;
   if (isNoFromSelect(stmt)) {
-    return executeNoFromSelect(stmt);
+    result = executeNoFromSelect(stmt);
+    if (captureColumnMeta) {
+      materializedMetaBySelectResult.set(result, await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache));
+    }
+    return result;
   }
   await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
   const mode = resolveSelectMode(stmt);
   await validateSelectFieldCodes(stmt, mode, client, cacheContext);
   if (mode === "SIMPLE") {
-    return executeSimpleSelect(stmt, client, options, cacheContext);
+    result = await executeSimpleSelect(stmt, client, options, cacheContext);
   } else {
-    return executeFullScanSelect(stmt, client, options, cacheContext, cteCache);
+    result = await executeFullScanSelect(stmt, client, options, cacheContext, cteCache);
+  }
+  if (captureColumnMeta) {
+    materializedMetaBySelectResult.set(result, await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache));
   }
+  return result;
 }
 function isNoFromSelect(stmt) {
   return stmt.from.appId === 0 && stmt.from.cteName === NO_FROM_CTE_NAME;
@@ -6521,6 +6705,11 @@ function validateNoFromColumns(stmt) {
           throw new Error("ArgumentError: field reference is not allowed without FROM.");
         }
         break;
+      case "WINDOW_COL":
+        if (col.partitionBy.length > 0 || col.orderBy.length > 0) {
+          throw new Error("ArgumentError: field reference is not allowed without FROM.");
+        }
+        break;
       default:
         throw new Error(`ArgumentError: ${col.type} is not supported without FROM.`);
     }
@@ -6531,7 +6720,8 @@ function executeNoFromSelect(stmt) {
     throw new Error("ArgumentError: JOIN/WHERE/GROUP BY/HAVING/ORDER BY/DISTINCT are not supported without FROM.");
   }
   validateNoFromColumns(stmt);
-  const { rows: projected, columns } = project([{}], stmt.columns);
+  const windowed = applyWindow([{}], stmt.columns);
+  const { rows: projected, columns } = project(windowed, stmt.columns);
   const rows = applyLimit(projected, stmt.limit, stmt.offset);
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [] };
 }
@@ -6809,7 +6999,7 @@ function aggregateSortKind(info) {
   if (info.fieldType === "NUMBER" || info.fieldType === "RECORD_NUMBER") return "number";
   return AGGREGATE_STRING_FIELD_TYPES.has(info.fieldType) ? "string" : void 0;
 }
-async function loadAggregateSortKindResolver(stmt, client, cacheContext) {
+async function loadAggregateSortKindResolver(stmt, client, cacheContext, materializedTables) {
   const refs = collectSelectAggregateSortRefs(stmt.columns);
   if (refs.length === 0) return void 0;
   const appIds = /* @__PURE__ */ new Set();
@@ -6825,11 +7015,9 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext) {
     } else if (stmt.joins.length === 0) {
       if (stmt.from.cteName === null) appIds.add(stmt.from.appId);
     } else {
-      if ([stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) continue;
       for (const table of physicalTables) appIds.add(table.appId);
     }
   }
-  if (appIds.size === 0) return void 0;
   const fieldInfosByApp = new Map(
     await Promise.all([...appIds].map(async (appId) => {
       const infos = await getFieldsCached(appId, client, cacheContext);
@@ -6844,17 +7032,28 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext) {
         info = fieldInfosByApp.get(stmt.from.appId)?.get(ref.field);
       } else {
         const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
-        if (!table || table.cteName !== null) return void 0;
+        if (!table) return void 0;
+        if (table.cteName !== null) {
+          return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field)?.sortKind;
+        }
         info = fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
       }
     } else if (stmt.joins.length === 0) {
-      if (stmt.from.cteName !== null) return void 0;
+      if (stmt.from.cteName !== null) {
+        return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field)?.sortKind;
+      }
       info = fieldInfosByApp.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
     } else {
-      if (tables.some((table) => table.cteName !== null)) return void 0;
-      const matches = physicalTables.map((table) => fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field))).filter((candidate) => candidate !== void 0);
+      const matches = tables.flatMap((table) => {
+        if (table.cteName !== null) {
+          const materialized = materializedTables?.get(table.cteName);
+          return materialized?.columns.includes(ref.field) ? [materialized.columnMeta?.get(ref.field)?.sortKind] : [];
+        }
+        const candidate = fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
+        return candidate ? [aggregateSortKind(candidate)] : [];
+      });
       if (matches.length !== 1) return void 0;
-      info = matches[0];
+      return matches[0];
     }
     return info ? aggregateSortKind(info) : void 0;
   };
@@ -6863,6 +7062,108 @@ function fieldCodeForTypeLookup(table, field) {
   if (table.subtableCode && field.startsWith("_p.")) return field.slice(3);
   return field;
 }
+function materializedMetaFromFieldInfo(info) {
+  return { sortKind: aggregateSortKind(info), fieldType: info.fieldType };
+}
+function selectNeedsSourceColumnMeta(stmt) {
+  return stmt.columns.some(
+    (column) => column.type === "FIELD" || column.type === "WILDCARD" || column.type === "PARENT_WILDCARD" || column.type === "AGGREGATE" && (column.func === "MIN" || column.func === "MAX") && column.arg.type === "FIELD_REF"
+  );
+}
+async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext, materializedTables) {
+  const physicalInfos = /* @__PURE__ */ new Map();
+  if (selectNeedsSourceColumnMeta(stmt)) {
+    await Promise.all(physicalSelectTables(stmt).map(async (table) => {
+      if (physicalInfos.has(table.appId)) return;
+      const infos = await getFieldsCached(table.appId, client, cacheContext);
+      physicalInfos.set(table.appId, new Map(infos.map((info) => [info.code, info])));
+    }));
+  }
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const resolveField2 = (ref) => {
+    if (ref.tableAlias !== null) {
+      if (ref.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
+        const info2 = physicalInfos.get(stmt.from.appId)?.get(ref.field);
+        return info2 ? materializedMetaFromFieldInfo(info2) : void 0;
+      }
+      const table = tables.find((candidate) => candidate.alias === ref.tableAlias);
+      if (!table) return void 0;
+      if (table.cteName !== null) return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field);
+      const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
+      return info ? materializedMetaFromFieldInfo(info) : void 0;
+    }
+    if (stmt.joins.length === 0) {
+      if (stmt.from.cteName !== null) return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field);
+      const info = physicalInfos.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
+      return info ? materializedMetaFromFieldInfo(info) : void 0;
+    }
+    const matches = tables.flatMap((table) => {
+      if (table.cteName !== null) {
+        const materialized = materializedTables?.get(table.cteName);
+        if (!materialized?.columns.includes(ref.field)) return [];
+        return [materialized.columnMeta?.get(ref.field)];
+      }
+      const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
+      return info ? [materializedMetaFromFieldInfo(info)] : [];
+    });
+    return matches.length === 1 ? matches[0] : void 0;
+  };
+  const inferred = /* @__PURE__ */ new Map();
+  const hasWildcard = stmt.columns.some((column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD");
+  if (stmt.columns.length === 1 && (stmt.columns[0].type === "WILDCARD" || stmt.columns[0].type === "PARENT_WILDCARD")) {
+    for (const output of outputColumns) {
+      const meta = resolveField2(aggregateFieldRef(output));
+      if (meta) inferred.set(output, meta);
+    }
+    return inferred;
+  }
+  if (hasWildcard) {
+    for (const output of outputColumns) {
+      const meta = resolveField2(aggregateFieldRef(output));
+      if (meta) inferred.set(output, meta);
+    }
+  }
+  const explicitColumns = stmt.columns.filter(
+    (column) => column.type !== "WILDCARD" && column.type !== "PARENT_WILDCARD"
+  );
+  explicitColumns.forEach((column, index) => {
+    const output = hasWildcard ? "alias" in column && column.alias ? column.alias : void 0 : outputColumns[index];
+    if (!output) return;
+    let meta;
+    if (column.type === "FIELD") {
+      meta = resolveField2(aggregateFieldRef(column.field));
+    } else if (column.type === "AGGREGATE") {
+      if (column.func === "GROUP_CONCAT") {
+        meta = { sortKind: "string" };
+      } else if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG") {
+        meta = { sortKind: "number" };
+      } else if ((column.func === "MIN" || column.func === "MAX") && column.arg.type === "FIELD_REF") {
+        const source = resolveField2(aggregateFieldRef(column.arg.field));
+        if (source?.sortKind) meta = { sortKind: source.sortKind };
+      }
+    } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
+      meta = { sortKind: "number" };
+    } else if (column.type === "LITERAL_COL") {
+      meta = { sortKind: "string" };
+    } else if (column.type === "WINDOW_COL") {
+      meta = { sortKind: "number" };
+    }
+    if (meta) inferred.set(output, meta);
+  });
+  return inferred;
+}
+function mergeUnionColumnMeta(left, right) {
+  const leftMeta = materializedMetaBySelectResult.get(left);
+  const rightMeta = materializedMetaBySelectResult.get(right);
+  const merged = /* @__PURE__ */ new Map();
+  left.columns.forEach((column, index) => {
+    const a = leftMeta?.get(column);
+    const rightColumn = right.columns[index];
+    const b = rightColumn === void 0 ? void 0 : rightMeta?.get(rightColumn);
+    if (a && b && a.sortKind === b.sortKind && a.fieldType === b.fieldType) merged.set(column, a);
+  });
+  return merged;
+}
 function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
   const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
   const physicalTables = tables.filter((table) => table.cteName === null);
@@ -6907,7 +7208,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const [pushdownMeta, typedInFieldTypes, aggregateSortKindResolver] = await Promise.all([
     loadTypedPushdownMeta(stmt, client, cacheContext),
     loadTypedInFieldTypes(stmt, client, cacheContext),
-    loadAggregateSortKindResolver(stmt, client, cacheContext)
+    loadAggregateSortKindResolver(stmt, client, cacheContext, cteCache)
   ]);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
   const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
@@ -7027,9 +7328,9 @@ function deduplicateRows(rows, columns) {
     return true;
   });
 }
-async function executeWith(stmt, client, options, cacheContext, seed) {
+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);
+    return executeSelect(buildInlinedQuery(stmt), client, options, cacheContext, void 0, captureColumnMeta);
   }
   const cteCache = new Map(seed ?? []);
   for (const cte of stmt.ctes) {
@@ -7039,17 +7340,21 @@ async function executeWith(stmt, client, options, cacheContext, seed) {
     } else if (cte.query.type === "DESCRIBE") {
       result = await executeDescribe(cte.query, client, cacheContext);
     } else {
-      result = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext);
+      result = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext, true);
     }
-    cteCache.set(cte.name, { rows: result.rows, columns: result.columns });
+    cteCache.set(cte.name, {
+      rows: result.rows,
+      columns: result.columns,
+      columnMeta: materializedMetaBySelectResult.get(result)
+    });
   }
-  return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext);
+  return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext, captureColumnMeta);
 }
-async function executeQueryWithCte(query, client, options, cteCache, cacheContext) {
+async function executeQueryWithCte(query, client, options, cteCache, cacheContext, captureColumnMeta = false) {
   if (query.type === "UNION") {
     const [leftResult, rightResult] = await Promise.all([
-      executeQueryWithCte(query.left, client, options, cteCache, cacheContext),
-      executeQueryWithCte(query.right, client, options, cteCache, cacheContext)
+      executeQueryWithCte(query.left, client, options, cteCache, cacheContext, captureColumnMeta),
+      executeQueryWithCte(query.right, client, options, cteCache, cacheContext, captureColumnMeta)
     ]);
     const leftCols = leftResult.columns;
     const rightCols = rightResult.columns;
@@ -7062,13 +7367,21 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
     });
     const combined = [...leftResult.rows, ...remapped];
     const rows = query.all ? combined : deduplicateRows(combined, leftCols);
-    return { type: "SELECT", rows, columns: leftCols, rowCount: rows.length };
+    const result2 = { type: "SELECT", rows, columns: leftCols, rowCount: rows.length };
+    if (captureColumnMeta) {
+      materializedMetaBySelectResult.set(result2, mergeUnionColumnMeta(leftResult, rightResult));
+    }
+    return result2;
   }
   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);
+    return executeSelect(query, client, options, cacheContext, cteCache, captureColumnMeta);
   }
-  return executeFullScanWithCte(query, client, options, cteCache, cacheContext);
+  const result = await executeFullScanWithCte(query, client, options, cteCache, cacheContext);
+  if (captureColumnMeta) {
+    materializedMetaBySelectResult.set(result, await inferSelectColumnMeta(query, result.columns, client, cacheContext, cteCache));
+  }
+  return result;
 }
 async function executeFullScanWithCte(stmt, client, options, cteCache, cacheContext) {
   const maxRecords = options.maxRecords ?? 1e4;
@@ -7082,7 +7395,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const [pushdownMeta, typedInFieldTypes, aggregateSortKindResolver] = await Promise.all([
     loadTypedPushdownMeta(stmt, client, cacheContext),
     loadTypedInFieldTypes(stmt, client, cacheContext),
-    loadAggregateSortKindResolver(stmt, client, cacheContext)
+    loadAggregateSortKindResolver(stmt, client, cacheContext, cteCache)
   ]);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
   const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
@@ -7419,7 +7732,10 @@ async function getSortKindMapByApp(appId, client, cacheContext) {
   return map;
 }
 async function buildOrderByMetaForSelect(stmt, client, cacheContext) {
-  if (stmt.orderBy.length === 0) {
+  const hasWindowOrderBy = stmt.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
+  );
+  if (stmt.orderBy.length === 0 && !hasWindowOrderBy) {
     return { optionOrders: /* @__PURE__ */ new Map(), sortKinds: /* @__PURE__ */ new Map() };
   }
   const [optionOrders, sortKinds] = await Promise.all([
@@ -7560,7 +7876,23 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     errors,
     ...stmt.validationErrorTable ? { errTable: stmt.validationErrorTable } : stmt.onErrorSkip && stmt.errorTable ? { errTable: stmt.errorTable } : {}
   };
-  return { result, candidates, invalidRowNumbers };
+  const columnMeta = /* @__PURE__ */ new Map();
+  for (const column of payloadFields) {
+    if (column === "$id") {
+      columnMeta.set(column, { sortKind: "number", fieldType: "RECORD_NUMBER" });
+      continue;
+    }
+    const info = infoByCode.get(column);
+    if (info) columnMeta.set(column, materializedMetaFromFieldInfo(info));
+  }
+  columnMeta.set("$err_statement", { sortKind: "number" });
+  columnMeta.set("$err_operation", { sortKind: "string" });
+  columnMeta.set("$err_row", { sortKind: "number" });
+  columnMeta.set("$err_field", { sortKind: "string" });
+  columnMeta.set("$err_code", { sortKind: "string" });
+  columnMeta.set("$err_message", { sortKind: "string" });
+  materializedMetaByValidationResult.set(result, columnMeta);
+  return { result, candidates, invalidRowNumbers, columnMeta };
 }
 async function executeOnErrorSkip(stmt, client, options, cacheContext, tempTables, statementNumber) {
   const prepared = await prepareDmlValidation(
@@ -7578,7 +7910,8 @@ async function executeOnErrorSkip(stmt, client, options, cacheContext, tempTable
     errTable,
     prepared.result.columns,
     prepared.result.errors,
-    options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS
+    options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+    prepared.columnMeta
   );
   const rejectLimit = stmt.rejectLimit ?? null;
   if (rejectLimit !== null && prepared.result.invalidRows > rejectLimit) {
@@ -8864,6 +9197,8 @@ function collectFullScanReasons(stmt) {
     r.push("DISTINCT \u3042\u308A");
   if (stmt.columns.some((c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL"))
     r.push("\u96C6\u8A08\u95A2\u6570\uFF08COUNT / SUM \u7B49\uFF09\u3042\u308A");
+  if (stmt.columns.some((c) => c.type === "WINDOW_COL"))
+    r.push("\u30A6\u30A3\u30F3\u30C9\u30A6\u95A2\u6570\u3042\u308A");
   if (stmt.columns.some((c) => c.type === "SCALAR_SUBQUERY_COL"))
     r.push("SELECT \u5217\u306B\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA");
   if (whereRequiresJsEval(stmt.where))