@rex0220/kintone-sql-tools 3.11.0 → 3.13.0

package/dist-cli/ksql.js

@@ -93,6 +93,12 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["MAX", "MAX" /* MAX */],
   ["MIN", "MIN" /* MIN */],
   ["GROUP_CONCAT", "GROUP_CONCAT" /* GROUP_CONCAT */],
+  ["STDDEV_POP", "STDDEV_POP" /* STDDEV_POP */],
+  ["STDDEV_SAMP", "STDDEV_SAMP" /* STDDEV_SAMP */],
+  ["VAR_POP", "VAR_POP" /* VAR_POP */],
+  ["VAR_SAMP", "VAR_SAMP" /* VAR_SAMP */],
+  ["MEDIAN", "MEDIAN" /* MEDIAN */],
+  ["MODE", "MODE" /* MODE */],
   ["ROW_NUMBER", "ROW_NUMBER" /* ROW_NUMBER */],
   ["RANK", "RANK" /* RANK */],
   ["DENSE_RANK", "DENSE_RANK" /* DENSE_RANK */],
@@ -155,6 +161,9 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["YEAR", "YEAR" /* YEAR */],
   ["MONTH", "MONTH" /* MONTH */],
   ["DAY", "DAY" /* DAY */],
+  ["DAYOFWEEK", "DAYOFWEEK" /* DAYOFWEEK */],
+  ["QUARTER", "QUARTER" /* QUARTER */],
+  ["WEEK", "WEEK" /* WEEK */],
   ["DATE_FORMAT", "DATE_FORMAT" /* DATE_FORMAT */],
   ["DATEDIFF", "DATEDIFF" /* DATEDIFF */],
   ["DATE_ADD", "DATE_ADD" /* DATE_ADD */],
@@ -577,6 +586,112 @@ function numberLiteralText(node) {
 
 // src/parser/parser.ts
 var MAX_BATCH_STATEMENTS = 20;
+var PARSER_SCALAR_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["UPPER" /* UPPER */]: "UPPER",
+  ["LOWER" /* LOWER */]: "LOWER",
+  ["TRIM" /* TRIM */]: "TRIM",
+  ["LTRIM" /* LTRIM */]: "LTRIM",
+  ["RTRIM" /* RTRIM */]: "RTRIM",
+  ["LENGTH" /* LENGTH */]: "LENGTH",
+  ["LENGTH_CHAR" /* LENGTH_CHAR */]: "LENGTH_CHAR",
+  ["SUBSTRING" /* SUBSTRING */]: "SUBSTRING",
+  ["SUBSTR" /* SUBSTR */]: "SUBSTRING",
+  ["LEFT" /* LEFT */]: "LEFT",
+  ["RIGHT" /* RIGHT */]: "RIGHT",
+  ["INSTR" /* INSTR */]: "INSTR",
+  ["CONCAT" /* CONCAT */]: "CONCAT",
+  ["REPLACE" /* REPLACE */]: "REPLACE",
+  ["REGEXP_LIKE" /* REGEXP_LIKE */]: "REGEXP_LIKE",
+  ["REGEXP_REPLACE" /* REGEXP_REPLACE */]: "REGEXP_REPLACE",
+  ["REGEXP_SUBSTR" /* REGEXP_SUBSTR */]: "REGEXP_SUBSTR",
+  ["TRANSLATE" /* TRANSLATE */]: "TRANSLATE",
+  ["COALESCE" /* COALESCE */]: "COALESCE",
+  ["ISNULL" /* ISNULL */]: "ISNULL",
+  ["NULLIF" /* NULLIF */]: "NULLIF",
+  ["GREATEST" /* GREATEST */]: "GREATEST",
+  ["LEAST" /* LEAST */]: "LEAST",
+  ["LPAD" /* LPAD */]: "LPAD",
+  ["RPAD" /* RPAD */]: "RPAD",
+  ["ROUND" /* ROUND */]: "ROUND",
+  ["FLOOR" /* FLOOR */]: "FLOOR",
+  ["CEIL" /* CEIL */]: "CEIL",
+  ["CEILING" /* CEILING */]: "CEIL",
+  ["TRUNCATE" /* TRUNCATE */]: "TRUNCATE",
+  ["TRUNC" /* TRUNC */]: "TRUNCATE",
+  ["ABS" /* ABS */]: "ABS",
+  ["MOD" /* MOD */]: "MOD",
+  ["POWER" /* POWER */]: "POWER",
+  ["POW" /* POW */]: "POWER",
+  ["SQRT" /* SQRT */]: "SQRT",
+  ["FORMAT" /* FORMAT */]: "FORMAT",
+  ["CAST" /* CAST */]: "CAST",
+  ["CONVERT" /* CONVERT */]: "CAST",
+  ["YEAR" /* YEAR */]: "YEAR",
+  ["MONTH" /* MONTH */]: "MONTH",
+  ["DAY" /* DAY */]: "DAY",
+  ["DAYOFWEEK" /* DAYOFWEEK */]: "DAYOFWEEK",
+  ["QUARTER" /* QUARTER */]: "QUARTER",
+  ["WEEK" /* WEEK */]: "WEEK",
+  ["DATE_FORMAT" /* DATE_FORMAT */]: "DATE_FORMAT",
+  ["DATEDIFF" /* DATEDIFF */]: "DATEDIFF",
+  ["DATE_ADD" /* DATE_ADD */]: "DATE_ADD",
+  ["LAST_DAY" /* LAST_DAY */]: "LAST_DAY"
+});
+var PARSER_IDENT_SCALAR_FUNCTIONS = Object.freeze([
+  "CURRENT_DATE",
+  "CURRENT_TIMESTAMP"
+]);
+var PARSER_AGGREGATE_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["COUNT" /* COUNT */]: "COUNT",
+  ["SUM" /* SUM */]: "SUM",
+  ["AVG" /* AVG */]: "AVG",
+  ["MAX" /* MAX */]: "MAX",
+  ["MIN" /* MIN */]: "MIN",
+  ["GROUP_CONCAT" /* GROUP_CONCAT */]: "GROUP_CONCAT",
+  ["STDDEV_POP" /* STDDEV_POP */]: "STDDEV_POP",
+  ["STDDEV_SAMP" /* STDDEV_SAMP */]: "STDDEV_SAMP",
+  ["VAR_POP" /* VAR_POP */]: "VAR_POP",
+  ["VAR_SAMP" /* VAR_SAMP */]: "VAR_SAMP",
+  ["MEDIAN" /* MEDIAN */]: "MEDIAN",
+  ["MODE" /* MODE */]: "MODE"
+});
+var PARSER_AGGREGATE_FUNCTIONS = Object.freeze(
+  Object.values(PARSER_AGGREGATE_FUNCTION_TOKEN_MAP).filter(
+    (func) => func !== void 0
+  )
+);
+var PARSER_AGGREGATE_WILDCARD_FUNCTIONS = Object.freeze([
+  "COUNT",
+  "SUM",
+  "AVG",
+  "MAX",
+  "MIN"
+]);
+var PARSER_AGGREGATE_WILDCARD_FUNCTION_SET = new Set(PARSER_AGGREGATE_WILDCARD_FUNCTIONS);
+function aggregateAcceptsWildcard(func) {
+  return PARSER_AGGREGATE_WILDCARD_FUNCTION_SET.has(func);
+}
+var PARSER_WINDOW_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["ROW_NUMBER" /* ROW_NUMBER */]: "ROW_NUMBER",
+  ["RANK" /* RANK */]: "RANK",
+  ["DENSE_RANK" /* DENSE_RANK */]: "DENSE_RANK"
+});
+var PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP = Object.freeze({
+  ["TODAY" /* TODAY */]: "TODAY",
+  ["NOW" /* NOW */]: "NOW",
+  ["LOGINUSER" /* LOGINUSER */]: "LOGINUSER"
+});
+function isContextualFunctionToken(kind) {
+  return PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[kind] !== void 0;
+}
+var PARSER_FUNCTION_SPELLINGS = Object.freeze(Array.from(/* @__PURE__ */ new Set([
+  ...Object.keys(PARSER_SCALAR_FUNCTION_TOKEN_MAP),
+  ...PARSER_IDENT_SCALAR_FUNCTIONS,
+  ...Object.keys(PARSER_AGGREGATE_FUNCTION_TOKEN_MAP),
+  ...Object.keys(PARSER_WINDOW_FUNCTION_TOKEN_MAP),
+  ...Object.keys(PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP),
+  "IF"
+])));
 var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "IDENT" /* IDENT */,
   "BIDENT" /* BIDENT */,
@@ -585,6 +700,13 @@ var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "AVG" /* AVG */,
   "MAX" /* MAX */,
   "MIN" /* MIN */,
+  "GROUP_CONCAT" /* GROUP_CONCAT */,
+  "STDDEV_POP" /* STDDEV_POP */,
+  "STDDEV_SAMP" /* STDDEV_SAMP */,
+  "VAR_POP" /* VAR_POP */,
+  "VAR_SAMP" /* VAR_SAMP */,
+  "MEDIAN" /* MEDIAN */,
+  "MODE" /* MODE */,
   "ROW_NUMBER" /* ROW_NUMBER */,
   "RANK" /* RANK */,
   "DENSE_RANK" /* DENSE_RANK */,
@@ -633,6 +755,9 @@ var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "YEAR" /* YEAR */,
   "MONTH" /* MONTH */,
   "DAY" /* DAY */,
+  "DAYOFWEEK" /* DAYOFWEEK */,
+  "QUARTER" /* QUARTER */,
+  "WEEK" /* WEEK */,
   "DATE_FORMAT" /* DATE_FORMAT */,
   "DATEDIFF" /* DATEDIFF */,
   "DATE_ADD" /* DATE_ADD */,
@@ -820,13 +945,14 @@ var Parser = class {
       this.advance();
       return { type: "STRING", value: tok.value };
     }
-    if (tok.kind === "LOGINUSER" /* LOGINUSER */) {
+    const contextualFunction = PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[tok.kind];
+    if (contextualFunction === "LOGINUSER") {
       throw new ParseError(
         `${context} \u306E\u53F3\u8FBA\u3067 LOGINUSER() \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08\u5B9F\u884C\u74B0\u5883\u5171\u901A\u306E\u30ED\u30B0\u30A4\u30F3\u30E6\u30FC\u30B6\u30FC\u89E3\u6C7A\u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF09`,
         tok
       );
     }
-    if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */) {
+    if (contextualFunction !== void 0) {
       return this.parseSqlValue();
     }
     const expr = this.parseArithAddSub();
@@ -1581,16 +1707,7 @@ var Parser = class {
     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;
-    }
+    return PARSER_WINDOW_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
   parseWindowColumn(func) {
     this.advance();
@@ -1947,64 +2064,14 @@ var Parser = class {
   // ──────────────────────────────────────────────────
   tryStringFuncName() {
     if (this.peekAt(1).kind === "(" /* LPAREN */) {
-      if (this.peek().kind === "LEFT" /* LEFT */) return "LEFT";
-      if (this.peek().kind === "RIGHT" /* RIGHT */) return "RIGHT";
-    }
-    const map = {
-      ["UPPER" /* UPPER */]: "UPPER",
-      ["LOWER" /* LOWER */]: "LOWER",
-      ["TRIM" /* TRIM */]: "TRIM",
-      ["LTRIM" /* LTRIM */]: "LTRIM",
-      ["RTRIM" /* RTRIM */]: "RTRIM",
-      ["LENGTH" /* LENGTH */]: "LENGTH",
-      ["LENGTH_CHAR" /* LENGTH_CHAR */]: "LENGTH_CHAR",
-      ["SUBSTRING" /* SUBSTRING */]: "SUBSTRING",
-      ["SUBSTR" /* SUBSTR */]: "SUBSTRING",
-      ["CONCAT" /* CONCAT */]: "CONCAT",
-      ["REPLACE" /* REPLACE */]: "REPLACE",
-      ["REGEXP_LIKE" /* REGEXP_LIKE */]: "REGEXP_LIKE",
-      ["REGEXP_REPLACE" /* REGEXP_REPLACE */]: "REGEXP_REPLACE",
-      ["REGEXP_SUBSTR" /* REGEXP_SUBSTR */]: "REGEXP_SUBSTR",
-      ["TRANSLATE" /* TRANSLATE */]: "TRANSLATE",
-      ["COALESCE" /* COALESCE */]: "COALESCE",
-      ["NULLIF" /* NULLIF */]: "NULLIF",
-      ["ISNULL" /* ISNULL */]: "ISNULL",
-      ["INSTR" /* INSTR */]: "INSTR",
-      ["GREATEST" /* GREATEST */]: "GREATEST",
-      ["LEAST" /* LEAST */]: "LEAST",
-      ["LPAD" /* LPAD */]: "LPAD",
-      ["RPAD" /* RPAD */]: "RPAD",
-      ["CAST" /* CAST */]: "CAST",
-      ["CONVERT" /* CONVERT */]: "CAST",
-      // CONVERT → CAST に正規化
-      ["FORMAT" /* FORMAT */]: "FORMAT",
-      ["ROUND" /* ROUND */]: "ROUND",
-      ["FLOOR" /* FLOOR */]: "FLOOR",
-      ["CEIL" /* CEIL */]: "CEIL",
-      ["CEILING" /* CEILING */]: "CEIL",
-      // CEILING → CEIL に正規化
-      ["TRUNCATE" /* TRUNCATE */]: "TRUNCATE",
-      ["TRUNC" /* TRUNC */]: "TRUNCATE",
-      // TRUNC → TRUNCATE に正規化
-      ["YEAR" /* YEAR */]: "YEAR",
-      ["MONTH" /* MONTH */]: "MONTH",
-      ["DAY" /* DAY */]: "DAY",
-      ["DATE_FORMAT" /* DATE_FORMAT */]: "DATE_FORMAT",
-      ["DATEDIFF" /* DATEDIFF */]: "DATEDIFF",
-      ["DATE_ADD" /* DATE_ADD */]: "DATE_ADD",
-      ["LAST_DAY" /* LAST_DAY */]: "LAST_DAY",
-      ["ABS" /* ABS */]: "ABS",
-      ["MOD" /* MOD */]: "MOD",
-      ["POWER" /* POWER */]: "POWER",
-      ["POW" /* POW */]: "POWER",
-      // POW → POWER に正規化
-      ["SQRT" /* SQRT */]: "SQRT"
-    };
-    const byKind = map[this.peek().kind] ?? null;
-    if (byKind !== null) return byKind;
+      const conditional = PARSER_SCALAR_FUNCTION_TOKEN_MAP[this.peek().kind];
+      if (conditional === "LEFT" || conditional === "RIGHT") return conditional;
+    }
+    const byKind = PARSER_SCALAR_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
+    if (byKind !== null && byKind !== "LEFT" && byKind !== "RIGHT") return byKind;
     if (this.peek().kind === "IDENT" /* IDENT */) {
       const name = this.peek().value.toUpperCase();
-      if (name === "CURRENT_DATE" || name === "CURRENT_TIMESTAMP") {
+      if (PARSER_IDENT_SCALAR_FUNCTIONS.includes(name)) {
         if (this.peekAt(1).kind === "(" /* LPAREN */) {
           return name;
         }
@@ -2094,26 +2161,21 @@ var Parser = class {
     return false;
   }
   tryAggregateFunc() {
-    const map = {
-      ["COUNT" /* COUNT */]: "COUNT",
-      ["SUM" /* SUM */]: "SUM",
-      ["AVG" /* AVG */]: "AVG",
-      ["MAX" /* MAX */]: "MAX",
-      ["MIN" /* MIN */]: "MIN",
-      ["GROUP_CONCAT" /* GROUP_CONCAT */]: "GROUP_CONCAT"
-    };
-    const kind = this.peek().kind;
-    return map[kind] ?? null;
+    return PARSER_AGGREGATE_FUNCTION_TOKEN_MAP[this.peek().kind] ?? null;
   }
   /** 集計関数参照を読む。SELECT 列の alias は呼び出し側で式全体の後に処理する。 */
   parseAggregateRef(func) {
     this.advance();
     this.expect("(" /* LPAREN */);
     const distinct = this.consume("DISTINCT" /* DISTINCT */);
+    const distinctToken = distinct ? this.prev() : null;
+    if (func === "MODE" && distinctToken) {
+      throw new ParseError("MODE \u3067\u306F DISTINCT \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", distinctToken);
+    }
     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());
+      if (!aggregateAcceptsWildcard(func)) {
+        throw new ParseError(`${func}(*) \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002\u30D5\u30A3\u30FC\u30EB\u30C9\u307E\u305F\u306F\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044`, this.prev());
       }
       arg = { type: "WILDCARD" };
     } else {
@@ -2407,10 +2469,14 @@ var Parser = class {
       this.advance();
       this.expect("(" /* LPAREN */);
       const distinct = this.consume("DISTINCT" /* DISTINCT */);
+      const distinctToken = distinct ? this.prev() : null;
+      if (aggFunc === "MODE" && distinctToken) {
+        throw new ParseError("MODE \u3067\u306F DISTINCT \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", distinctToken);
+      }
       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());
+        if (!aggregateAcceptsWildcard(aggFunc)) {
+          throw new ParseError(`${aggFunc}(*) \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 {
@@ -2464,13 +2530,13 @@ var Parser = class {
       this.advance();
       return { type: "STRING", value: tok.value };
     }
-    if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */ || tok.kind === "LOGINUSER" /* LOGINUSER */) {
+    if (isContextualFunctionToken(tok.kind)) {
       this.advance();
       this.expect("(" /* LPAREN */);
       this.expect(")" /* RPAREN */);
       return {
         type: "KINTONE_FUNC",
-        name: tok.value
+        name: PARSER_CONTEXTUAL_FUNCTION_TOKEN_MAP[tok.kind]
       };
     }
     if (tok.kind === "CASE" /* CASE */) {
@@ -3267,7 +3333,7 @@ var Parser = class {
     }
     if (tok.kind === "VARIABLE" /* VARIABLE */) return this.parseSqlValue();
     if (tok.kind === "STRING" /* STRING */) return this.parseSqlValue();
-    if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */ || tok.kind === "LOGINUSER" /* LOGINUSER */) return this.parseSqlValue();
+    if (isContextualFunctionToken(tok.kind)) return this.parseSqlValue();
     if (tok.kind === "IN" /* IN */) return this.parseSqlValue();
     if (tok.kind === "CASE" /* CASE */ || tok.kind === "IF" /* IF */) {
       return this.parseSqlValue();
@@ -3549,54 +3615,105 @@ function writesKintone(stmt) {
 function isReadOnlyStatement(stmt) {
   return !writesKintone(stmt) && (isReadOnlyType(stmt.type) || isDmlType(stmt.type));
 }
-function requiresCompleteInput(stmt) {
-  if (isDmlType(stmt.type)) return true;
+var STATISTICAL_AGGREGATES = /* @__PURE__ */ new Set([
+  "STDDEV_POP",
+  "STDDEV_SAMP",
+  "VAR_POP",
+  "VAR_SAMP",
+  "MEDIAN",
+  "MODE"
+]);
+function addReasons(target, source) {
+  for (const reason of source) target.add(reason);
+}
+function containsStatisticalAggregate(value, seen = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value !== "object") return false;
+  if (seen.has(value)) return false;
+  seen.add(value);
+  const record = value;
+  if ((record.type === "AGGREGATE" || record.type === "AGG_REF") && typeof record.func === "string" && STATISTICAL_AGGREGATES.has(record.func)) return true;
+  if (record.type === "FIELD" && typeof record.field === "string" && /^(STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/i.test(record.field)) return true;
+  return Object.values(record).some((child) => Array.isArray(child) ? child.some((entry) => containsStatisticalAggregate(entry, seen)) : containsStatisticalAggregate(child, seen));
+}
+function completeInputReasons(stmt) {
+  const reasons = /* @__PURE__ */ new Set();
+  if (isDmlType(stmt.type)) {
+    reasons.add("DML");
+    return reasons;
+  }
   switch (stmt.type) {
     case "VALIDATE":
-      return true;
+      reasons.add("VALIDATE");
+      break;
     case "SELECT":
-      return selectRequiresCompleteInput(stmt);
+      addReasons(reasons, selectCompleteInputReasons(stmt));
+      break;
     case "UNION":
-      return unionRequiresCompleteInput(stmt);
+      addReasons(reasons, unionCompleteInputReasons(stmt));
+      break;
     case "WITH":
-      return stmt.ctes.some(
-        (cte) => cte.query.type === "SELECT" && selectRequiresCompleteInput(cte.query) || cte.query.type === "UNION" && unionRequiresCompleteInput(cte.query)
-      ) || (stmt.query.type === "SELECT" ? selectRequiresCompleteInput(stmt.query) : unionRequiresCompleteInput(stmt.query));
+      for (const cte of stmt.ctes) {
+        addReasons(reasons, completeInputReasons(cte.query));
+      }
+      addReasons(reasons, completeInputReasons(stmt.query));
+      break;
     case "CREATE_TEMP_TABLE":
-      return stmt.query.type === "SELECT" ? selectRequiresCompleteInput(stmt.query) : stmt.query.type === "UNION" ? unionRequiresCompleteInput(stmt.query) : requiresCompleteInput(stmt.query);
+      addReasons(reasons, completeInputReasons(stmt.query));
+      break;
     default:
-      return false;
+      break;
   }
+  if (containsStatisticalAggregate(stmt)) reasons.add("STATISTICAL_AGGREGATE");
+  return reasons;
 }
-function unionRequiresCompleteInput(stmt) {
-  const left = stmt.left.type === "SELECT" ? selectRequiresCompleteInput(stmt.left) : unionRequiresCompleteInput(stmt.left);
-  return left || selectRequiresCompleteInput(stmt.right);
+function requiresCompleteInput(stmt) {
+  return completeInputReasons(stmt).size > 0;
 }
-function selectRequiresCompleteInput(stmt) {
-  if (stmt.orderBy.length > 0) return true;
-  if (stmt.columns.some(
-    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0 || column.type === "SCALAR_SUBQUERY_COL" && selectRequiresCompleteInput(column.query) || column.type === "CASE_COL" && column.expr.branches.some(
-      (branch) => whereRequiresCompleteInput(branch.condition)
-    )
-  )) return true;
-  return whereRequiresCompleteInput(stmt.where) || whereRequiresCompleteInput(stmt.having);
+function unionCompleteInputReasons(stmt) {
+  const reasons = stmt.left.type === "SELECT" ? selectCompleteInputReasons(stmt.left) : unionCompleteInputReasons(stmt.left);
+  addReasons(reasons, selectCompleteInputReasons(stmt.right));
+  return reasons;
 }
-function whereRequiresCompleteInput(where) {
-  if (where === null) return false;
+function selectCompleteInputReasons(stmt) {
+  const reasons = /* @__PURE__ */ new Set();
+  if (stmt.orderBy.length > 0) reasons.add("LOCAL_ORDER");
+  for (const column of stmt.columns) {
+    if (column.type === "WINDOW_COL" && column.orderBy.length > 0) reasons.add("WINDOW_ORDER");
+    if (column.type === "SCALAR_SUBQUERY_COL") addReasons(reasons, selectCompleteInputReasons(column.query));
+    if (column.type === "CASE_COL") {
+      for (const branch of column.expr.branches) addReasons(reasons, whereCompleteInputReasons(branch.condition));
+    }
+  }
+  addReasons(reasons, whereCompleteInputReasons(stmt.where));
+  addReasons(reasons, whereCompleteInputReasons(stmt.having));
+  if (containsStatisticalAggregate(stmt)) reasons.add("STATISTICAL_AGGREGATE");
+  return reasons;
+}
+function whereCompleteInputReasons(where) {
+  const reasons = /* @__PURE__ */ new Set();
+  if (where === null) return reasons;
   switch (where.type) {
     case "BINARY":
-      return (where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY") && selectRequiresCompleteInput(where.right.query);
+      if (where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY") {
+        addReasons(reasons, selectCompleteInputReasons(where.right.query));
+      }
+      break;
     case "LOGICAL":
-      return whereRequiresCompleteInput(where.left) || whereRequiresCompleteInput(where.right);
+      addReasons(reasons, whereCompleteInputReasons(where.left));
+      addReasons(reasons, whereCompleteInputReasons(where.right));
+      break;
     case "NOT":
     case "GROUP":
-      return whereRequiresCompleteInput(where.expr);
+      addReasons(reasons, whereCompleteInputReasons(where.expr));
+      break;
     case "EXISTS":
-      return selectRequiresCompleteInput(where.query);
+      addReasons(reasons, selectCompleteInputReasons(where.query));
+      break;
     case "NULL_CHECK":
     case "BOOLEAN":
-      return false;
+      break;
   }
+  return reasons;
 }
 function hasWhereClause(stmt) {
   if (!stmt || typeof stmt !== "object") return false;
@@ -4922,7 +5039,7 @@ function scalarValueLabel(expr) {
   }
 }
 function isAggregateSyntheticName(name) {
-  return /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT)\(/i.test(name);
+  return /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/i.test(name);
 }
 
 // src/core/cteInlining.ts
@@ -5903,7 +6020,7 @@ function evalArithExpr(expr, row) {
       return r !== 0 ? l % r : NaN;
   }
 }
-function evalScalarValueExpr(expr, row) {
+function evalScalarValueExpr(expr, row, resolveFieldType, resolveFieldSemantics2) {
   switch (expr.type) {
     case "STRING":
       return expr.value;
@@ -5914,19 +6031,19 @@ function evalScalarValueExpr(expr, row) {
     case "VARIABLE":
       throw new Error(`ArgumentError: unresolved variable @${expr.name} reached scalar evaluator.`);
     case "STRING_FUNC":
-      return evalStringFunc(expr, row);
+      return evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2);
     case "CASE_WHEN":
-      return evalCaseWhen(expr, row);
+      return evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2);
     case "CONCAT_OP": {
       return evalStringFunc({
         type: "STRING_FUNC",
         func: "CONCAT",
         args: [expr.left, expr.right]
-      }, row);
+      }, row, resolveFieldType, resolveFieldSemantics2);
     }
     case "SCALAR_ARITH": {
-      const left = Number(evalScalarValueExpr(expr.left, row));
-      const right = Number(evalScalarValueExpr(expr.right, row));
+      const left = Number(evalScalarValueExpr(expr.left, row, resolveFieldType, resolveFieldSemantics2));
+      const right = Number(evalScalarValueExpr(expr.right, row, resolveFieldType, resolveFieldSemantics2));
       switch (expr.op) {
         case "+":
           return left + right;
@@ -6091,8 +6208,8 @@ function replaceNthMatch(input, globalRe, replacement, n) {
     return expandRegexpReplacement(replacement, match, captures, namedGroups);
   });
 }
-function evalStringFunc(expr, row) {
-  const args = expr.args.map((a) => evalStringFuncArg(a, row));
+function evalStringFunc(expr, row, resolveFieldType, resolveFieldSemantics2) {
+  const args = expr.args.map((a) => evalStringFuncArg(a, row, resolveFieldType, resolveFieldSemantics2));
   switch (expr.func) {
     case "UPPER":
       return (args[0] ?? "").toUpperCase();
@@ -6225,6 +6342,15 @@ function evalStringFunc(expr, row) {
       const d = args[0] ?? "";
       return d.length >= 10 ? String(parseInt(d.slice(8, 10), 10)) : "";
     }
+    case "DAYOFWEEK":
+      assertArity(expr.func, args, 1, 1);
+      return isValidYmd(args[0]) ? String(dayOfWeekIndex(args[0]) + 1) : "";
+    case "QUARTER":
+      assertArity(expr.func, args, 1, 1);
+      return isValidYmd(args[0]) ? String(Math.ceil(Number(args[0].slice(5, 7)) / 3)) : "";
+    case "WEEK":
+      assertArity(expr.func, args, 1, 1);
+      return isValidYmd(args[0]) ? String(isoWeekNumber(args[0])) : "";
     case "DATE_FORMAT":
       return applyDateFormat(args[0] ?? "", args[1] ?? "");
     case "DATEDIFF":
@@ -6271,10 +6397,78 @@ function parseDateParts(s) {
     sec: s.length >= 19 ? s.slice(17, 19) : "00"
   };
 }
+function ymdUtcDate(dateStr) {
+  const date = /* @__PURE__ */ new Date(0);
+  date.setUTCHours(0, 0, 0, 0);
+  date.setUTCFullYear(
+    Number(dateStr.slice(0, 4)),
+    Number(dateStr.slice(5, 7)) - 1,
+    Number(dateStr.slice(8, 10))
+  );
+  return date;
+}
+function isValidYmd(dateStr) {
+  const ymd = dateStr.slice(0, 10);
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(ymd)) return false;
+  const date = ymdUtcDate(ymd);
+  return date.getUTCFullYear() === Number(ymd.slice(0, 4)) && date.getUTCMonth() + 1 === Number(ymd.slice(5, 7)) && date.getUTCDate() === Number(ymd.slice(8, 10));
+}
+function dayOfWeekIndex(dateStr) {
+  return ymdUtcDate(dateStr).getUTCDay();
+}
+function isoWeekThursday(dateStr) {
+  const date = ymdUtcDate(dateStr);
+  const isoDay = date.getUTCDay() || 7;
+  date.setUTCDate(date.getUTCDate() + 4 - isoDay);
+  return date;
+}
+function isoWeekYear(dateStr) {
+  return isoWeekThursday(dateStr).getUTCFullYear();
+}
+function isoWeekNumber(dateStr) {
+  const thursday = isoWeekThursday(dateStr);
+  const year = thursday.getUTCFullYear();
+  const jan4 = ymdUtcDate(`${String(year).padStart(4, "0")}-01-04`);
+  const jan4IsoDay = jan4.getUTCDay() || 7;
+  jan4.setUTCDate(jan4.getUTCDate() + 4 - jan4IsoDay);
+  return 1 + Math.round((thursday.getTime() - jan4.getTime()) / (7 * 864e5));
+}
 function applyDateFormat(dateStr, pattern) {
   if (!dateStr || dateStr.length < 10) return "";
   const { y, mo, d, h, mi, sec } = parseDateParts(dateStr);
-  return pattern.replace(/%Y/g, y).replace(/%y/g, y.slice(2)).replace(/%m/g, mo).replace(/%c/g, String(parseInt(mo, 10))).replace(/%d/g, d).replace(/%e/g, String(parseInt(d, 10))).replace(/%H/g, h).replace(/%i/g, mi).replace(/%s/g, sec);
+  const validYmd = isValidYmd(dateStr);
+  return pattern.replace(/%[YymcdeHiswavG]/g, (specifier) => {
+    switch (specifier) {
+      case "%Y":
+        return y;
+      case "%y":
+        return y.slice(2);
+      case "%m":
+        return mo;
+      case "%c":
+        return String(parseInt(mo, 10));
+      case "%d":
+        return d;
+      case "%e":
+        return String(parseInt(d, 10));
+      case "%H":
+        return h;
+      case "%i":
+        return mi;
+      case "%s":
+        return sec;
+      case "%w":
+        return validYmd ? String(dayOfWeekIndex(dateStr)) : "";
+      case "%a":
+        return validYmd ? ["\u65E5", "\u6708", "\u706B", "\u6C34", "\u6728", "\u91D1", "\u571F"][dayOfWeekIndex(dateStr)] : "";
+      case "%v":
+        return validYmd ? String(isoWeekNumber(dateStr)).padStart(2, "0") : "";
+      case "%G":
+        return validYmd ? String(isoWeekYear(dateStr)).padStart(4, "0") : "";
+      default:
+        return specifier;
+    }
+  });
 }
 function applyDateDiff(date1, date2) {
   if (date1.length < 10 || date2.length < 10) return "0";
@@ -6343,10 +6537,10 @@ function formatWithComma(num, digits) {
   const intFmt = intStr.replace(/\B(?=(\d{3})+(?!\d))/g, ",");
   return decStr ? `${intFmt}.${decStr}` : intFmt;
 }
-function evalStringFuncArg(arg, row) {
+function evalStringFuncArg(arg, row, resolveFieldType, resolveFieldSemantics2) {
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return "";
   if (arg.type === "NUMBER") return numberLiteralText(arg);
-  return String(evalScalarValueExpr(arg, row));
+  return String(evalScalarValueExpr(arg, row, resolveFieldType, resolveFieldSemantics2));
 }
 function resolveFieldRef(row, field) {
   const direct = row[field];
@@ -6433,7 +6627,10 @@ var NUMERIC_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
   "ABS",
   "MOD",
   "POWER",
-  "SQRT"
+  "SQRT",
+  "DAYOFWEEK",
+  "QUARTER",
+  "WEEK"
 ]);
 function semanticsForLeft(left, fieldType, resolveSemantics) {
   if (left.type === "FIELD") {
@@ -6563,15 +6760,15 @@ function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
 function evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2) {
   for (const branch of expr.branches) {
     if (evalWhere(branch.condition, row, resolveFieldType, void 0, resolveFieldSemantics2)) {
-      return evalCaseResult(branch.result, row);
+      return evalCaseResult(branch.result, row, resolveFieldType, resolveFieldSemantics2);
     }
   }
   if (expr.elseResult !== null) {
-    return evalCaseResult(expr.elseResult, row);
+    return evalCaseResult(expr.elseResult, row, resolveFieldType, resolveFieldSemantics2);
   }
   return "";
 }
-function evalCaseResult(result, row) {
+function evalCaseResult(result, row, resolveFieldType, resolveFieldSemantics2) {
   if (result.type === "ARRAY") return result.elements.map((e) => e.value).join(",");
   if (result.type === "FIELD_REF") {
     return row[result.field] ?? "";
@@ -6579,7 +6776,7 @@ function evalCaseResult(result, row) {
   if (result.type === "ARITH") {
     return String(evalArithExpr(result, row));
   }
-  return String(evalScalarValueExpr(result, row));
+  return String(evalScalarValueExpr(result, row, resolveFieldType, resolveFieldSemantics2));
 }
 function resolveKintoneFunc(name) {
   const now = /* @__PURE__ */ new Date();
@@ -6652,7 +6849,7 @@ function collectRefs2(root) {
     for (const value of Object.values(obj)) visit(value);
   };
   const add = (tableAlias, field) => {
-    if (/^(COUNT|SUM|AVG|MIN|MAX|GROUP_CONCAT)\(/i.test(field)) {
+    if (/^(COUNT|SUM|AVG|MIN|MAX|GROUP_CONCAT|STDDEV_POP|STDDEV_SAMP|VAR_POP|VAR_SAMP|MEDIAN|MODE)\(/i.test(field)) {
       throw customCheckParseError("CHECK \u306B\u96C6\u7D04\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
     }
     const key = `${tableAlias ?? ""}\0${field}`;
@@ -9468,6 +9665,9 @@ var REST_LIMIT_MAX = 500;
 function fieldSemantics(item, semantics) {
   return item.key.type === "FIELD_NAME" ? semantics.get(item.key.name) : void 0;
 }
+function hasSelectOutputAlias(stmt, name) {
+  return stmt.columns.some((column) => "alias" in column && column.alias === name);
+}
 function planCanonicalOrder(input) {
   const { stmt } = input;
   const reasons = [];
@@ -9495,7 +9695,7 @@ function planCanonicalOrder(input) {
     throw new Error(`ArgumentError: ORDER BY key has no canonical comparison contract (reason=${reason}).`);
   }
   const allRestEquivalent = stmt.orderBy.length > 0 && windowOrderBy.length === 0 && stmt.orderBy.every(
-    (item) => item.key.type === "FIELD_NAME" && item.key.name === "$id"
+    (item) => item.key.type === "FIELD_NAME" && item.key.name === "$id" && !hasSelectOutputAlias(stmt, item.key.name)
   );
   if (!allRestEquivalent) reasons.push("ORDER_KEY_NOT_REST_EQUIVALENT");
   if (input.whereCapability !== "EXACT_PUSHDOWN") reasons.push("WHERE_NOT_EXACT");
@@ -9544,6 +9744,9 @@ var KORDER_NATIVE_FIELD_TYPES = /* @__PURE__ */ new Set([
   "CREATOR",
   "MODIFIER"
 ]);
+function hasSelectOutputAlias2(stmt, name) {
+  return stmt.columns.some((column) => "alias" in column && column.alias === name);
+}
 function planKorder(input) {
   const { stmt } = input;
   const reasons = [];
@@ -9565,6 +9768,10 @@ function planKorder(input) {
       reasons.push(`KORDER_KEY_UNRESOLVED(field=${name})`);
       continue;
     }
+    if (hasSelectOutputAlias2(stmt, name)) {
+      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
+      continue;
+    }
     if (name === "$id") continue;
     if (!semantics.source || semantics.source.fieldCode !== name) {
       reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
@@ -9836,26 +10043,81 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
     }
     strValues.push(strVal);
   }
-  const eff = distinct ? [...new Set(strValues)] : strValues;
+  const statistical = func === "STDDEV_POP" || func === "STDDEV_SAMP" || func === "VAR_POP" || func === "VAR_SAMP" || func === "MEDIAN";
+  const numericValues = statistical ? strValues.map((value) => {
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric)) {
+      throw new Error(`ArgumentError: ${func} \u306E\u5F15\u6570\u306B\u975E\u6570\u5024\u307E\u305F\u306F\u975E\u6709\u9650\u306E\u5024\u304C\u3042\u308A\u307E\u3059: ${value}`);
+    }
+    return numeric;
+  }) : null;
+  const eff = distinct ? statistical ? [...new Set(numericValues)] : [...new Set(strValues)] : statistical ? numericValues : strValues;
   if (func === "COUNT") return eff.length;
   if (func === "GROUP_CONCAT") return eff.join(separator ?? ",");
-  const comparison = (func === "MIN" || func === "MAX") && arg.type === "FIELD_REF" ? resolveAggSortKind?.(toAggregateFieldRef(arg.field)) : void 0;
+  const comparison = (func === "MIN" || func === "MAX" || func === "MODE") && arg.type === "FIELD_REF" ? resolveAggSortKind?.(toAggregateFieldRef(arg.field)) : void 0;
+  const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? (arg.type === "FIELD_REF" ? syntheticSemantics("string") : syntheticSemantics("number"));
+  if (func === "MODE") {
+    if (strValues.length === 0) return "";
+    const frequencies = /* @__PURE__ */ new Map();
+    for (const value of strValues) frequencies.set(value, (frequencies.get(value) ?? 0) + 1);
+    let result = "";
+    let maxFrequency = 0;
+    for (const [candidate, frequency] of frequencies) {
+      if (frequency > maxFrequency) {
+        result = candidate;
+        maxFrequency = frequency;
+        continue;
+      }
+      if (frequency !== maxFrequency) continue;
+      const canonical = compareCanonicalValues(candidate, result, semantics);
+      if (canonical < 0 || canonical === 0 && compareCodePointStrings(candidate, result) < 0) {
+        result = candidate;
+      }
+    }
+    return result;
+  }
   if (func === "MIN" || func === "MAX") {
-    if (eff.length === 0) return 0;
-    const semantics = typeof comparison === "string" ? syntheticSemantics(comparison) : comparison ?? (arg.type === "FIELD_REF" ? syntheticSemantics("string") : syntheticSemantics("number"));
-    let result = eff[0];
-    for (const candidate of eff.slice(1)) {
+    const comparableValues = eff;
+    if (comparableValues.length === 0) return 0;
+    let result = comparableValues[0];
+    for (const candidate of comparableValues.slice(1)) {
       const cmp = compareCanonicalValues(candidate, result, semantics);
       if (func === "MAX" && cmp > 0 || func === "MIN" && cmp < 0) result = candidate;
     }
     return result;
   }
-  const nums = eff.map(Number);
+  const nums = statistical ? eff : eff.map(Number);
   switch (func) {
     case "SUM":
       return nums.reduce((a, b) => a + b, 0);
     case "AVG":
       return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
+    case "MEDIAN": {
+      if (nums.length === 0) return "";
+      const sorted = [...nums].sort((a, b) => a - b);
+      const middle = Math.floor(sorted.length / 2);
+      return sorted.length % 2 === 1 ? sorted[middle] : (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+    case "VAR_POP":
+    case "VAR_SAMP":
+    case "STDDEV_POP":
+    case "STDDEV_SAMP": {
+      const sample = func === "VAR_SAMP" || func === "STDDEV_SAMP";
+      if (nums.length === 0 || sample && nums.length < 2) return "";
+      const origin = nums[0];
+      let count = 0;
+      let mean = 0;
+      let m2 = 0;
+      for (const rawValue of nums) {
+        const value = rawValue - origin;
+        count++;
+        const delta = value - mean;
+        mean += delta / count;
+        m2 += delta * (value - mean);
+      }
+      const variance = Math.max(0, m2 / (sample ? count - 1 : count));
+      return func === "STDDEV_POP" || func === "STDDEV_SAMP" ? Math.sqrt(variance) : variance;
+    }
   }
 }
 function toAggregateFieldRef(field) {
@@ -9947,11 +10209,11 @@ function buildDistinctKeyBuilder(rows, columns) {
     return JSON.stringify(values);
   };
 }
-function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2) {
+function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
   if (orderBy.length === 0) return rows;
-  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2).rows.map((item) => item.row);
+  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator).rows.map((item) => item.row);
 }
-function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2) {
+function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2, aliasEvaluator) {
   const keyMeta = orderBy.map(({ key }) => {
     if (key.type === "ARITH_KEY") return { semantics: syntheticSemantics("number") };
     if (key.type === "FUNC_KEY") {
@@ -9976,7 +10238,7 @@ function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantic
   const decorated = rows.map((row) => ({
     row,
     keys: orderBy.map(({ key }, i) => {
-      const s = evalOrderKey(key, row);
+      const s = evalOrderKey(key, row, aliasEvaluator);
       return { s };
     })
   }));
@@ -10009,18 +10271,71 @@ var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
   "ABS",
   "MOD",
   "POWER",
-  "SQRT"
+  "SQRT",
+  "DAYOFWEEK",
+  "QUARTER",
+  "WEEK"
 ]);
-function evalOrderKey(key, row) {
+function evalOrderKey(key, row, aliasEvaluator) {
   switch (key.type) {
     case "FIELD_NAME":
-      return row[key.name] ?? "";
+      return aliasEvaluator?.(key.name, row) ?? row[key.name] ?? "";
     case "ARITH_KEY":
       return String(evalArithExpr(key.expr, row));
     case "FUNC_KEY":
       return evalStringFunc(key.expr, row);
   }
 }
+function buildOrderByAliasEvaluator(columns, scalarCache, resolveFieldType, resolveFieldSemantics2) {
+  const evaluators = /* @__PURE__ */ new Map();
+  for (const [columnIndex, column] of columns.entries()) {
+    if (!("alias" in column) || column.alias === null) continue;
+    const alias = column.alias;
+    switch (column.type) {
+      case "FIELD":
+        evaluators.set(alias, (row) => resolveFieldRef(row, column.field));
+        break;
+      case "LITERAL_COL":
+        evaluators.set(alias, () => column.value);
+        break;
+      case "AGGREGATE": {
+        const source = aggregateSyntheticName2(column.func, column.distinct, column.arg);
+        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        break;
+      }
+      case "ARITH_AGG_COL": {
+        const source = aggArithDefaultKey(column.expr);
+        evaluators.set(alias, (row) => row[alias] ?? row[source] ?? "0");
+        break;
+      }
+      case "WINDOW_COL":
+        evaluators.set(alias, (row) => row[alias] ?? "");
+        break;
+      case "ARITH_COL":
+        evaluators.set(alias, (row) => String(evalArithExpr(column.expr, row)));
+        break;
+      case "STRFUNC_COL": {
+        const source = stringFuncDefaultKey(column.expr);
+        evaluators.set(alias, (row) => hasAggregateInStringFuncExpr2(column.expr) ? row[alias] ?? row[source] ?? evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2) : evalStringFunc(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        break;
+      }
+      case "CASE_COL":
+        evaluators.set(alias, (row) => evalCaseWhen(column.expr, row, resolveFieldType, resolveFieldSemantics2));
+        break;
+      case "SCALAR_VALUE_COL": {
+        const source = scalarValueDefaultKey(column.expr);
+        evaluators.set(alias, (row) => scalarValueHasAggregate2(column.expr) ? row[alias] ?? row[source] ?? "" : String(evalScalarValueExpr(column.expr, row, resolveFieldType, resolveFieldSemantics2)));
+        break;
+      }
+      case "SCALAR_SUBQUERY_COL":
+        evaluators.set(alias, () => scalarCache?.get(columnIndex) ?? "");
+        break;
+      case "VARIABLE_COL":
+        break;
+    }
+  }
+  return (name, row) => evaluators.get(name)?.(row);
+}
 function applyWindow(rows, columns, optionOrders, sortKinds, fieldSemantics2) {
   const windows = columns.filter((column) => column.type === "WINDOW_COL");
   if (rows.length === 0 || windows.length === 0) return rows;
@@ -10138,9 +10453,9 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
           const key = outputKeys?.[colIdx] ?? col.alias ?? stringFuncDefaultKey(col.expr);
           if (hasAggregateInStringFuncExpr2(col.expr)) {
             const srcKey = stringFuncDefaultKey(col.expr);
-            out[key] = row[col.alias ?? srcKey] ?? row[srcKey] ?? evalStringFunc(col.expr, row);
+            out[key] = row[col.alias ?? srcKey] ?? row[srcKey] ?? evalStringFunc(col.expr, row, resolveFieldType, resolveFieldSemantics2);
           } else {
-            out[key] = evalStringFunc(col.expr, row);
+            out[key] = evalStringFunc(col.expr, row, resolveFieldType, resolveFieldSemantics2);
           }
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
@@ -10148,7 +10463,7 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
         case "SCALAR_VALUE_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? scalarValueDefaultKey(col.expr);
           const srcKey = scalarValueDefaultKey(col.expr);
-          out[key] = scalarValueHasAggregate2(col.expr) ? row[col.alias ?? srcKey] ?? row[srcKey] ?? "" : String(evalScalarValueExpr(col.expr, row));
+          out[key] = scalarValueHasAggregate2(col.expr) ? row[col.alias ?? srcKey] ?? row[srcKey] ?? "" : String(evalScalarValueExpr(col.expr, row, resolveFieldType, resolveFieldSemantics2));
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
@@ -10367,7 +10682,7 @@ function deriveOutputOrderSemantics(columns) {
     if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
       result.set(column.alias, syntheticSemantics("number"));
     } else if (column.type === "AGGREGATE") {
-      if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG") {
+      if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG" || column.func === "STDDEV_POP" || column.func === "STDDEV_SAMP" || column.func === "VAR_POP" || column.func === "VAR_SAMP" || column.func === "MEDIAN") {
         result.set(column.alias, syntheticSemantics("number"));
       } else if (column.func === "GROUP_CONCAT") {
         result.set(column.alias, syntheticSemantics("string"));
@@ -10433,7 +10748,14 @@ function runFullScan(input) {
   if (stmt.distinct) {
     rows = applyDistinct(rows, stmt.columns);
   }
-  rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds, effectiveOrderSemantics);
+  rows = applyOrderBy(
+    rows,
+    stmt.orderBy,
+    optionOrders,
+    sortKinds,
+    effectiveOrderSemantics,
+    buildOrderByAliasEvaluator(stmt.columns, scalarCache, fieldTypeResolver, fieldSemanticsResolver)
+  );
   rows = applyLimit(rows, stmt.limit, stmt.offset);
   return project(
     rows,
@@ -12254,7 +12576,17 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
           tempTables
         );
         const first = resolvedStmt2.expr.query.columns[0];
-        const numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG");
+        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
+        if (first?.type === "AGGREGATE" && first.func === "MODE") {
+          const meta = (await inferSelectColumnMeta(
+            resolvedStmt2.expr.query,
+            ["__scalar__"],
+            client,
+            cacheContext,
+            tempTables
+          )).get("__scalar__");
+          numeric = meta?.semantics?.compareMode === "number" || meta?.sortKind === "number";
+        }
         const numberValue = numeric ? Number(value) : Number.NaN;
         variables.set(stmt.name, numeric && Number.isFinite(numberValue) ? { type: "number", value: numberValue, raw: value } : { type: "string", value });
       } catch (e) {
@@ -12789,7 +13121,7 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
     else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
       semantics = syntheticSemantics("number");
     } else if (column.type === "AGGREGATE") {
-      if (column.func === "MIN" || column.func === "MAX") {
+      if (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") {
         semantics = column.arg.type === "FIELD_REF" ? rowResolver(aggregateFieldRef(column.arg.field)) : syntheticSemantics("number");
       } else {
         semantics = column.func === "GROUP_CONCAT" ? syntheticSemantics("string") : syntheticSemantics("number");
@@ -12872,7 +13204,8 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     client,
     cacheContext
   );
-  const completeInputRequired = orderPlan?.kind === "CANONICAL_REST_TOP_N" || orderPlan?.kind === "KORDER_NATIVE" || orderPlan?.kind === "KORDER_CURSOR" ? requiresCompleteInput({ ...stmt, orderBy: [] }) : requiresCompleteInput(stmt);
+  const completeReasons = orderPlan?.kind === "CANONICAL_REST_TOP_N" || orderPlan?.kind === "KORDER_NATIVE" || orderPlan?.kind === "KORDER_CURSOR" ? completeInputReasons({ ...stmt, orderBy: [] }) : completeInputReasons(stmt);
+  const completeInputRequired = completeReasons.size > 0;
   const truncateWasDisabled = completeInputRequired && options.onLimitReached === "truncate";
   const effectiveOptions = truncateWasDisabled ? { ...options, onLimitReached: "error" } : options;
   try {
@@ -12892,7 +13225,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   } catch (error) {
     if (completeInputRequired && error instanceof FetchAllLimitError) {
       throw new FetchAllLimitError(
-        "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C\u306B\u306F\u5B8C\u5168\u306A\u5019\u88DC\u96C6\u5408\u304C\u5FC5\u8981\u3067\u3059\u3002" + (truncateWasDisabled ? "onLimit=truncate\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002" : "") + error.message
+        completeInputErrorPrefix(completeReasons) + (truncateWasDisabled ? "onLimit=truncate\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\u3002" : "") + error.message
       );
     }
     throw error;
@@ -12902,6 +13235,11 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   }
   return result;
 }
+function completeInputErrorPrefix(reasons) {
+  const reasonList = [...reasons].join(", ");
+  const subject = reasons.size === 1 && reasons.has("STATISTICAL_AGGREGATE") ? "\u7D71\u8A08\u96C6\u7D04\u306E\u6B63\u3057\u3044\u7D50\u679C" : "ORDER BY\u306E\u6B63\u3057\u3044\u7D50\u679C";
+  return `${subject}\u306B\u306F\u5B8C\u5168\u306A\u5019\u88DC\u96C6\u5408\u304C\u5FC5\u8981\u3067\u3059\u3002complete input reason: ${reasonList}\u3002`;
+}
 function isConstantFalseWhere(where) {
   return where?.type === "BOOLEAN" && where.value === false;
 }
@@ -13041,7 +13379,13 @@ async function executeSimpleSelect(stmt, client, options, cacheContext, orderPla
       stmt.orderBy,
       orderMeta.optionOrders,
       orderMeta.sortKinds,
-      orderMeta.semantics
+      orderMeta.semantics,
+      buildOrderByAliasEvaluator(
+        stmt.columns,
+        void 0,
+        fieldTypeResolvers.row,
+        projectionSemanticsResolver
+      )
     );
     rows = applyLimit(rows, stmt.limit, stmt.offset);
   }
@@ -13227,7 +13571,7 @@ function aggregateFieldRef(field) {
   return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
 }
 function collectAggregateRef(func, arg, out) {
-  if ((func === "MIN" || func === "MAX") && arg.type === "FIELD_REF" && arg.field) {
+  if ((func === "MIN" || func === "MAX" || func === "MODE") && arg.type === "FIELD_REF" && arg.field) {
     out.push(aggregateFieldRef(arg.field));
   }
 }
@@ -13440,7 +13784,10 @@ var NUMBER_RETURNING_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
   "ABS",
   "MOD",
   "POWER",
-  "SQRT"
+  "SQRT",
+  "DAYOFWEEK",
+  "QUARTER",
+  "WEEK"
 ]);
 function stringFunctionColumnMeta(expr) {
   if (expr.func === "CAST") {
@@ -13481,7 +13828,7 @@ function mergeExpressionColumnMeta(candidates) {
 }
 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.arg.type === "FIELD_REF"
+    (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.arg.type === "FIELD_REF"
   );
 }
 async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext, materializedTables) {
@@ -13550,11 +13897,13 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
     } else if (column.type === "AGGREGATE") {
       if (column.func === "GROUP_CONCAT") {
         meta = syntheticColumnMeta("string");
-      } else if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG") {
+      } else if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG" || column.func === "STDDEV_POP" || column.func === "STDDEV_SAMP" || column.func === "VAR_POP" || column.func === "VAR_SAMP" || column.func === "MEDIAN") {
         meta = syntheticColumnMeta("number");
-      } else if ((column.func === "MIN" || column.func === "MAX") && column.arg.type === "FIELD_REF") {
+      } else if ((column.func === "MIN" || column.func === "MAX" || column.func === "MODE") && column.arg.type === "FIELD_REF") {
         const source = resolveField2(aggregateFieldRef(column.arg.field));
         if (source) meta = source;
+      } else if (column.func === "MODE") {
+        meta = syntheticColumnMeta("number");
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
       meta = syntheticColumnMeta("number");
@@ -14319,7 +14668,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
       if (column.expr.elseResult) candidates.push(caseResultColumnMeta(column.expr.elseResult, resolveField2));
       meta = mergeExpressionColumnMeta(candidates);
     } else if (column.type === "AGGREGATE") {
-      if (column.func === "MIN" || column.func === "MAX") {
+      if (column.func === "MIN" || column.func === "MAX" || column.func === "MODE") {
         meta = column.arg.type === "FIELD_REF" ? resolveField2(aggregateFieldRef(column.arg.field)) : syntheticColumnMeta("number");
       } else {
         meta = column.func === "GROUP_CONCAT" ? syntheticColumnMeta("string") : syntheticColumnMeta("number");
@@ -17834,8 +18183,13 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
       lines.push(`  scan rows:     ${orderPlan.scanRows}`);
     }
   }
-  if (orderPlan?.requiresCompleteInput ?? requiresCompleteInput(stmt)) {
-    lines.push("  complete input: required (ORDER BY / window ORDER BY; onLimit=truncate disabled)");
+  const explainedStmt = orderPlan && !orderPlan.requiresCompleteInput ? { ...stmt, orderBy: [] } : stmt;
+  const completeReasons = completeInputReasons(explainedStmt);
+  if (orderPlan?.requiresCompleteInput) completeReasons.add("LOCAL_ORDER");
+  if (completeReasons.size > 0) {
+    lines.push("  complete input: required (onLimit=truncate disabled)");
+    lines.push(`  complete input reason: ${[...completeReasons].join(", ")}`);
+    lines.push("  onLimit=truncate: disabled");
   }
   if (mode === "FULL_SCAN" && reasons.length > 0) {
     lines.push(`  reason:        ${reasons.join(", ")}`);