@rex0220/kintone-sql-tools 2.17.0 → 3.0.0

package/dist-cli/ksql.js

@@ -78,6 +78,7 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["BY", "BY" /* BY */],
   ["HAVING", "HAVING" /* HAVING */],
   ["ORDER", "ORDER" /* ORDER */],
+  ["KORDER", "KORDER" /* KORDER */],
   ["ASC", "ASC" /* ASC */],
   ["DESC", "DESC" /* DESC */],
   ["LIMIT", "LIMIT" /* LIMIT */],
@@ -603,7 +604,7 @@ var Parser = class {
       case "WITH" /* WITH */:
         return this.parseWith();
       case "SELECT" /* SELECT */:
-        return this.tryParseUnionChain(this.parseSelect());
+        return this.tryParseUnionChain(this.parseSelect(true));
       case "INSERT" /* INSERT */:
         return this.parseInsert();
       case "UPDATE" /* UPDATE */:
@@ -793,7 +794,7 @@ var Parser = class {
       }
       query = w;
     } else if (tok.kind === "SELECT" /* SELECT */) {
-      const sel = this.parseSelect();
+      const sel = this.parseSelect(true);
       const chained = this.tryParseUnionChain(sel);
       query = chained;
     } else if (tok.kind === "INSERT" /* INSERT */) {
@@ -986,7 +987,7 @@ var Parser = class {
   // ----------------------------------------------------------
   // SELECT
   // ----------------------------------------------------------
-  parseSelect() {
+  parseSelect(allowKorder = false) {
     this.expect("SELECT" /* SELECT */);
     const distinct = this.consume("DISTINCT" /* DISTINCT */);
     const columns = this.parseSelectColumns();
@@ -1003,7 +1004,19 @@ var Parser = class {
         having = this.parseWhereExpr();
       }
     }
-    const orderBy = this.consume("ORDER" /* ORDER */) ? (this.expect("BY" /* BY */), this.parseOrderBy()) : [];
+    let orderMode = "CANONICAL";
+    let orderBy = [];
+    if (this.consume("ORDER" /* ORDER */)) {
+      this.expect("BY" /* BY */);
+      orderBy = this.parseOrderBy();
+    } else if (this.consume("KORDER" /* KORDER */)) {
+      if (!allowKorder) {
+        throw new ParseError("KORDER BY \u306F\u5229\u7528\u8005\u3078\u7D50\u679C\u3092\u8FD4\u3059\u30C8\u30C3\u30D7\u30EC\u30D9\u30EB SELECT \u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059", this.prev());
+      }
+      orderMode = "KINTONE_NATIVE";
+      this.expect("BY" /* BY */);
+      orderBy = 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");
@@ -1020,6 +1033,7 @@ var Parser = class {
       where,
       groupBy,
       having,
+      orderMode,
       orderBy,
       limit,
       offset
@@ -1057,6 +1071,9 @@ var Parser = class {
   // ----------------------------------------------------------
   tryParseUnionChain(left) {
     if (this.peek().kind !== "UNION" /* UNION */) return left;
+    if (left.type === "SELECT" && left.orderMode === "KINTONE_NATIVE") {
+      throw new ParseError("KORDER BY \u306F UNION \u5206\u5C90\u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
+    }
     this.advance();
     const all = this.consume("ALL" /* ALL */);
     const right = this.parseSelect();
@@ -2710,7 +2727,50 @@ function isReadOnlyStatement(stmt) {
   return !writesKintone(stmt) && (isReadOnlyType(stmt.type) || isDmlType(stmt.type));
 }
 function requiresCompleteInput(stmt) {
-  return isDmlType(stmt.type);
+  if (isDmlType(stmt.type)) return true;
+  switch (stmt.type) {
+    case "SELECT":
+      return selectRequiresCompleteInput(stmt);
+    case "UNION":
+      return unionRequiresCompleteInput(stmt);
+    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));
+    case "CREATE_TEMP_TABLE":
+      return stmt.query.type === "SELECT" ? selectRequiresCompleteInput(stmt.query) : stmt.query.type === "UNION" ? unionRequiresCompleteInput(stmt.query) : requiresCompleteInput(stmt.query);
+    default:
+      return false;
+  }
+}
+function unionRequiresCompleteInput(stmt) {
+  const left = stmt.left.type === "SELECT" ? selectRequiresCompleteInput(stmt.left) : unionRequiresCompleteInput(stmt.left);
+  return left || selectRequiresCompleteInput(stmt.right);
+}
+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 whereRequiresCompleteInput(where) {
+  if (where === null) return false;
+  switch (where.type) {
+    case "BINARY":
+      return (where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY") && selectRequiresCompleteInput(where.right.query);
+    case "LOGICAL":
+      return whereRequiresCompleteInput(where.left) || whereRequiresCompleteInput(where.right);
+    case "NOT":
+    case "GROUP":
+      return whereRequiresCompleteInput(where.expr);
+    case "EXISTS":
+      return selectRequiresCompleteInput(where.query);
+    case "NULL_CHECK":
+      return false;
+  }
 }
 function hasWhereClause(stmt) {
   if (!stmt || typeof stmt !== "object") return false;
@@ -3525,6 +3585,7 @@ function buildInlinedQuery(stmt) {
     where,
     groupBy: [],
     having: null,
+    orderMode: "CANONICAL",
     orderBy: final.orderBy.length > 0 ? final.orderBy : cteBody.orderBy,
     limit: final.limit ?? cteBody.limit,
     offset: final.offset ?? cteBody.offset,
@@ -4119,6 +4180,72 @@ function analyzeBatch(statements) {
   };
 }
 
+// src/core/fieldSemantics.ts
+var STRING_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "SINGLE_LINE_TEXT",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "LINK",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "CREATOR",
+  "MODIFIER"
+]);
+var OPTION_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "STATUS"
+]);
+function resolveFieldSemantics(source) {
+  let compareMode;
+  if (source.fieldType === "RECORD_NUMBER" || source.fieldType === "__ID__") {
+    compareMode = "recordNumber";
+  } else if (source.fieldType === "NUMBER") {
+    compareMode = "number";
+  } else if (source.fieldType === "CALC") {
+    compareMode = source.sortKind === "number" ? "number" : "string";
+  } else if (OPTION_FIELD_TYPES.has(source.fieldType)) {
+    compareMode = "option";
+  } else if (STRING_FIELD_TYPES.has(source.fieldType)) {
+    compareMode = "string";
+  } else {
+    compareMode = "unsupported";
+  }
+  const optionOrder = source.optionOrder ? new Map(Object.entries(source.optionOrder)) : void 0;
+  return {
+    fieldType: source.fieldType,
+    compareMode,
+    inSubtable: source.inSubtable === true,
+    requiresCollectionOperators: source.inSubtable === true || source.requiresCollectionOperators === true,
+    ...optionOrder && optionOrder.size > 0 ? { optionOrder } : {}
+  };
+}
+function syntheticSemantics(compareMode, fieldType = compareMode === "number" ? "KSQL_NUMBER" : "KSQL_STRING") {
+  return { fieldType, compareMode, inSubtable: false, requiresCollectionOperators: false };
+}
+function withFieldSemanticSource(semantics, appId, fieldCode) {
+  return { ...semantics, source: { appId, fieldCode } };
+}
+function fieldSemanticsEqual(left, right) {
+  if (left === right) return true;
+  if (!left || !right) return false;
+  if (left.fieldType !== right.fieldType || left.compareMode !== right.compareMode || left.inSubtable !== right.inSubtable || left.requiresCollectionOperators !== right.requiresCollectionOperators) return false;
+  if (left.source?.appId !== right.source?.appId || left.source?.fieldCode !== right.source?.fieldCode) return false;
+  const a = left.optionOrder;
+  const b = right.optionOrder;
+  if (a === b) return true;
+  if (!a || !b || a.size !== b.size) return false;
+  for (const [key, value] of a) {
+    if (b.get(key) !== value) return false;
+  }
+  return true;
+}
+
 // src/core/batchVariables.ts
 var VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
 function normalizeBatchVariableName(name) {
@@ -4154,24 +4281,129 @@ function validateDeclaredBatchVariables(statements, input) {
 }
 
 // src/core/scalarCompare.ts
-function compareScalarValues(op, leftStr, rightStr) {
-  if (op === "=") return leftStr === rightStr;
-  if (op === "!=" || op === "<>") return leftStr !== rightStr;
-  const rightNum = Number(rightStr);
-  if (leftStr === "" && rightStr !== "" && Number.isFinite(rightNum)) {
-    return op === "<" || op === "<=";
-  }
-  const leftNum = Number(leftStr);
-  const numeric = !Number.isNaN(leftNum) && !Number.isNaN(rightNum);
+function compareCodePointStrings(left, right) {
+  const a = left[Symbol.iterator]();
+  const b = right[Symbol.iterator]();
+  while (true) {
+    const av = a.next();
+    const bv = b.next();
+    if (av.done || bv.done) {
+      if (av.done && bv.done) return 0;
+      return av.done ? -1 : 1;
+    }
+    const ac = av.value.codePointAt(0) ?? 0;
+    const bc = bv.value.codePointAt(0) ?? 0;
+    if (ac < bc) return -1;
+    if (ac > bc) return 1;
+  }
+}
+function triCompare(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function numberKey(value) {
+  if (value === "") return { band: 0 };
+  const numeric = Number(value);
+  if (numeric === Number.NEGATIVE_INFINITY) return { band: 1 };
+  if (Number.isFinite(numeric)) return { band: 2, value: numeric };
+  if (numeric === Number.POSITIVE_INFINITY) return { band: 3 };
+  if (value === "NaN") return { band: 4 };
+  return { band: 5, value };
+}
+function compareNumbers(left, right) {
+  const a = numberKey(left);
+  const b = numberKey(right);
+  if (a.band !== b.band) return a.band < b.band ? -1 : 1;
+  if (a.band === 2 && b.band === 2) return triCompare(a.value, b.value);
+  if (a.band === 5 && b.band === 5) return compareCodePointStrings(a.value, b.value);
+  return 0;
+}
+function recordNumberKey(value, allowPrefix) {
+  if (value === "") return { empty: true, normalizedId: "", display: value };
+  const match = /^\d+$/.test(value) ? value : allowPrefix ? /-(\d+)$/.exec(value)?.[1] : void 0;
+  if (match === void 0) {
+    throw new Error(`ArgumentError: invalid ${allowPrefix ? "RECORD_NUMBER" : "$id"} value: ${value}`);
+  }
+  return {
+    empty: false,
+    normalizedId: match.replace(/^0+(?=\d)/, ""),
+    display: value
+  };
+}
+function compareRecordNumbers(left, right, allowPrefix) {
+  const a = recordNumberKey(left, allowPrefix);
+  const b = recordNumberKey(right, allowPrefix);
+  if (a.empty || b.empty) return a.empty === b.empty ? 0 : a.empty ? -1 : 1;
+  if (a.normalizedId.length !== b.normalizedId.length) {
+    return a.normalizedId.length < b.normalizedId.length ? -1 : 1;
+  }
+  const idCmp = compareCodePointStrings(a.normalizedId, b.normalizedId);
+  return idCmp !== 0 ? idCmp : compareCodePointStrings(a.display, b.display);
+}
+function parseOptionValues(value, fieldType) {
+  if (value === "") return [];
+  if (fieldType !== "CHECK_BOX" && fieldType !== "MULTI_SELECT") return [value];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.map((item) => String(item ?? "")) : [value];
+  } catch {
+    return [value];
+  }
+}
+function optionVector(value, semantics) {
+  const order = semantics.optionOrder ?? /* @__PURE__ */ new Map();
+  const unique = [...new Set(parseOptionValues(value, semantics.fieldType))];
+  const vector = unique.map((label) => {
+    const rank = order.get(label);
+    return rank === void 0 ? { knownBand: 1, rank: 0, label } : { knownBand: 0, rank, label };
+  });
+  vector.sort(compareOptionElement);
+  return vector;
+}
+function compareOptionElement(left, right) {
+  if (left.knownBand !== right.knownBand) return left.knownBand < right.knownBand ? -1 : 1;
+  if (left.rank !== right.rank) return left.rank < right.rank ? -1 : 1;
+  return compareCodePointStrings(left.label, right.label);
+}
+function compareOptions(left, right, semantics) {
+  const a = optionVector(left, semantics);
+  const b = optionVector(right, semantics);
+  const length = Math.min(a.length, b.length);
+  for (let index = 0; index < length; index++) {
+    const cmp = compareOptionElement(a[index], b[index]);
+    if (cmp !== 0) return cmp;
+  }
+  return a.length < b.length ? -1 : a.length > b.length ? 1 : 0;
+}
+function compareCanonicalValues(left, right, semantics) {
+  switch (semantics.compareMode) {
+    case "string":
+      return compareCodePointStrings(left, right);
+    case "number":
+      return compareNumbers(left, right);
+    case "recordNumber":
+      return compareRecordNumbers(left, right, semantics.fieldType === "RECORD_NUMBER");
+    case "option":
+      return compareOptions(left, right, semantics);
+    case "unsupported":
+      throw new Error(`ArgumentError: values of type ${semantics.fieldType} cannot be compared.`);
+  }
+}
+function compareScalarValues(op, left, right, semantics = syntheticSemantics("string")) {
+  const cmp = compareCanonicalValues(left, right, semantics);
   switch (op) {
+    case "=":
+      return cmp === 0;
+    case "!=":
+    case "<>":
+      return cmp !== 0;
     case ">":
-      return numeric ? leftNum > rightNum : leftStr > rightStr;
+      return cmp > 0;
     case "<":
-      return numeric ? leftNum < rightNum : leftStr < rightStr;
+      return cmp < 0;
     case ">=":
-      return numeric ? leftNum >= rightNum : leftStr >= rightStr;
+      return cmp >= 0;
     case "<=":
-      return numeric ? leftNum <= rightNum : leftStr <= rightStr;
+      return cmp <= 0;
   }
 }
 function selectScalarExtreme(values, extreme) {
@@ -4181,12 +4413,10 @@ function selectScalarExtreme(values, extreme) {
   const numeric = candidates.every((value) => !Number.isNaN(Number(value)));
   const compare = (left, right) => {
     if (numeric) {
-      const leftNum = Number(left);
-      const rightNum = Number(right);
-      if (leftNum < rightNum) return -1;
-      if (leftNum > rightNum) return 1;
+      const numericCmp = triCompare(Number(left), Number(right));
+      if (numericCmp !== 0) return numericCmp;
     }
-    return left < right ? -1 : left > right ? 1 : 0;
+    return compareCodePointStrings(left, right);
   };
   return candidates.reduce((best, candidate) => {
     const cmp = compare(candidate, best);
@@ -4194,6 +4424,55 @@ function selectScalarExtreme(values, extreme) {
   });
 }
 
+// src/core/explainMetadata.ts
+function whereNeedsFieldMetadata(where) {
+  if (where === null) return false;
+  switch (where.type) {
+    case "BINARY":
+      return valueNeedsFieldMetadata(where.left);
+    case "NULL_CHECK":
+      return valueNeedsFieldMetadata(where.field);
+    case "LOGICAL":
+      return whereNeedsFieldMetadata(where.left) || whereNeedsFieldMetadata(where.right);
+    case "NOT":
+    case "GROUP":
+      return whereNeedsFieldMetadata(where.expr);
+    case "EXISTS":
+      return false;
+  }
+}
+function valueNeedsFieldMetadata(value) {
+  if (Array.isArray(value)) return value.some(valueNeedsFieldMetadata);
+  if (value === null || typeof value !== "object") return false;
+  const item = value;
+  if (item["type"] === "FIELD") return item["field"] !== "$id";
+  if (item["type"] === "SELECT") return false;
+  return Object.values(item).some(valueNeedsFieldMetadata);
+}
+function selectNeedsOwnMetadata(statement) {
+  return whereNeedsFieldMetadata(statement.where) || statement.orderBy.length > 0 || statement.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
+  );
+}
+function explainNeedsAppMetadata(statement) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (node === null || typeof node !== "object") return false;
+    if (seen.has(node)) return false;
+    seen.add(node);
+    if (Array.isArray(node)) return node.some(visit);
+    const item = node;
+    if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
+      return true;
+    }
+    if ((item["type"] === "UPDATE" || item["type"] === "DELETE") && whereNeedsFieldMetadata(node.where)) {
+      return true;
+    }
+    return Object.values(item).some(visit);
+  };
+  return visit(statement);
+}
+
 // src/engine/evalFunc.ts
 function evalArithExpr(expr, row) {
   if (expr.type === "NUMBER") return expr.value;
@@ -4458,34 +4737,35 @@ function resolveFieldRef(row, field) {
 }
 
 // src/engine/evalWhere.ts
-function evalWhere(expr, row, resolveFieldType, appliedKlikes) {
+function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   switch (expr.type) {
     case "BINARY":
-      return evalBinary(expr, row, resolveFieldType, appliedKlikes);
+      return evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
     case "NULL_CHECK":
       return evalNullCheck(expr, row);
     case "LOGICAL":
-      return evalLogical(expr, row, resolveFieldType, appliedKlikes);
+      return evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
     case "NOT":
-      return !evalWhere(expr.expr, row, resolveFieldType, appliedKlikes);
+      return !evalWhere(expr.expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
     case "GROUP":
-      return evalWhere(expr.expr, row, resolveFieldType, appliedKlikes);
+      return evalWhere(expr.expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
     case "EXISTS": {
       const exists = expr.resolved;
       return expr.not ? !exists : exists;
     }
   }
 }
-function evalBinary(expr, row, resolveFieldType, appliedKlikes) {
+function evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   if (expr.op === "KLIKE" || expr.op === "NOT_KLIKE") {
     if (appliedKlikes?.has(expr)) return true;
     throw new Error("KLIKE / NOT KLIKE \u306F\u62BC\u3057\u4E0B\u3052\u6E08\u307F\u96C6\u5408\u306B\u542B\u307E\u308C\u306A\u3044\u305F\u3081 JavaScript \u5074\u3067\u306F\u8A55\u4FA1\u3067\u304D\u307E\u305B\u3093");
   }
-  const left = resolveField(expr.left, row, resolveFieldType);
+  const left = resolveField(expr.left, row, resolveFieldType, resolveFieldSemantics2);
   const fieldType = expr.left.type === "FIELD" ? resolveFieldType?.(expr.left) : void 0;
-  return evalOp(expr.op, left, expr.right, row, fieldType, resolveFieldType);
+  const semantics = semanticsForLeft(expr.left, fieldType, resolveFieldSemantics2);
+  return evalOp(expr.op, left, expr.right, row, fieldType, resolveFieldType, semantics, resolveFieldSemantics2);
 }
-function evalOp(op, leftStr, right, row, fieldType, resolveFieldType) {
+function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics = syntheticSemantics("string"), resolveFieldSemantics2) {
   if (op === "IN" || op === "NOT_IN") {
     let values = null;
     if (right.type === "IN_LIST") {
@@ -4510,8 +4790,53 @@ function evalOp(op, leftStr, right, row, fieldType, resolveFieldType) {
   if (op === "KLIKE" || op === "NOT_KLIKE") {
     throw new Error("KLIKE / NOT KLIKE \u306F JavaScript \u5074\u3067\u306F\u8A55\u4FA1\u3067\u304D\u307E\u305B\u3093\uFF08SIMPLE SELECT \u3067\u306E\u307F\u4F7F\u7528\u3067\u304D\u307E\u3059\uFF09");
   }
-  const rightStr = resolveValue(right, row, resolveFieldType);
-  return compareScalarValues(op, leftStr, rightStr);
+  const rightStr = resolveValue(right, row, resolveFieldType, resolveFieldSemantics2);
+  return compareScalarValues(op, leftStr, rightStr, semantics);
+}
+var NUMERIC_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
+  "LENGTH",
+  "INSTR",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "TRUNCATE",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "DATEDIFF",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT"
+]);
+function semanticsForLeft(left, fieldType, resolveSemantics) {
+  if (left.type === "FIELD") {
+    return resolveSemantics?.(left) ?? (fieldType ? resolveFieldSemantics({ fieldType }) : syntheticSemantics("string"));
+  }
+  if (left.type === "ARITH_FIELD") return syntheticSemantics("number");
+  if (left.type === "FUNC_FIELD") {
+    return syntheticSemantics(NUMERIC_STRING_FUNCTIONS.has(left.expr.func) ? "number" : "string");
+  }
+  if (left.type === "CASE_FIELD") {
+    const results = [
+      ...left.expr.branches.map((branch) => branch.result),
+      ...left.expr.elseResult ? [left.expr.elseResult] : []
+    ];
+    const modes = results.map((result) => {
+      if (result.type === "NUMBER" || result.type === "ARITH") return syntheticSemantics("number");
+      if (result.type === "STRING_FUNC") {
+        return syntheticSemantics(NUMERIC_STRING_FUNCTIONS.has(result.func) ? "number" : "string");
+      }
+      if (result.type === "FIELD_REF") {
+        const dot = result.field.indexOf(".");
+        const ref = dot > 0 ? { type: "FIELD", tableAlias: result.field.slice(0, dot), field: result.field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field: result.field };
+        return resolveSemantics?.(ref) ?? syntheticSemantics("string");
+      }
+      return syntheticSemantics("string");
+    });
+    if (modes.length > 0 && modes.every((mode) => mode.compareMode === modes[0].compareMode)) return modes[0];
+  }
+  return syntheticSemantics("string");
 }
 var STRING_ARRAY_FIELD_TYPES = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
 var OBJECT_ARRAY_FIELD_TYPES = /* @__PURE__ */ new Set([
@@ -4562,20 +4887,20 @@ function evalNullCheck(expr, row) {
   const val = resolveField(expr.field, row);
   return expr.not ? val !== "" : val === "";
 }
-function evalLogical(expr, row, resolveFieldType, appliedKlikes) {
+function evalLogical(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   if (expr.op === "AND") {
-    return evalWhere(expr.left, row, resolveFieldType, appliedKlikes) && evalWhere(expr.right, row, resolveFieldType, appliedKlikes);
+    return evalWhere(expr.left, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) && evalWhere(expr.right, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
   }
-  return evalWhere(expr.left, row, resolveFieldType, appliedKlikes) || evalWhere(expr.right, row, resolveFieldType, appliedKlikes);
+  return evalWhere(expr.left, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) || evalWhere(expr.right, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
 }
-function resolveField(field, row, resolveFieldType) {
+function resolveField(field, row, resolveFieldType, resolveFieldSemantics2) {
   if (field.type === "FUNC_FIELD") return evalStringFunc(field.expr, row);
   if (field.type === "ARITH_FIELD") return String(evalArithExpr(field.expr, row));
-  if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType);
+  if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType, resolveFieldSemantics2);
   const key = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
   return resolveFieldRef(row, key);
 }
-function resolveValue(value, row, resolveFieldType) {
+function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
   switch (value.type) {
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${value.name}.`);
@@ -4598,14 +4923,14 @@ function resolveValue(value, row, resolveFieldType) {
       if (value.expr.type === "STRING_FUNC") return evalStringFunc(value.expr, row);
       return String(evalArithExpr(value.expr, row));
     case "CASE_VALUE":
-      return evalCaseWhen(value.expr, row, resolveFieldType);
+      return evalCaseWhen(value.expr, row, resolveFieldType, resolveFieldSemantics2);
     case "ARRAY":
       return value.elements.map((e) => e.value).join(",");
   }
 }
-function evalCaseWhen(expr, row, resolveFieldType) {
+function evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2) {
   for (const branch of expr.branches) {
-    if (evalWhere(branch.condition, row, resolveFieldType)) {
+    if (evalWhere(branch.condition, row, resolveFieldType, void 0, resolveFieldSemantics2)) {
       return evalCaseResult(branch.result, row);
     }
   }
@@ -5236,6 +5561,141 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
   };
 }
 
+// src/core/optimization/canonicalOrderPlanner.ts
+var REST_OFFSET_MAX = 1e4;
+var REST_LIMIT_MAX = 500;
+function fieldSemantics(item, semantics) {
+  return item.key.type === "FIELD_NAME" ? semantics.get(item.key.name) : void 0;
+}
+function planCanonicalOrder(input) {
+  const { stmt } = input;
+  const reasons = [];
+  const windowOrderBy = stmt.columns.flatMap(
+    (column) => column.type === "WINDOW_COL" ? column.orderBy : []
+  );
+  const allOrderBy = [...stmt.orderBy, ...windowOrderBy];
+  for (const item of allOrderBy) {
+    if (item.key.type !== "FIELD_NAME") continue;
+    const semantics = fieldSemantics(item, input.orderSemantics);
+    if (!semantics) {
+      reasons.push("ORDER_KEY_UNRESOLVED");
+      continue;
+    }
+    if (semantics.fieldType === "KSQL_AMBIGUOUS") reasons.push("ORDER_KEY_AMBIGUOUS");
+    else if (semantics.compareMode === "unsupported") reasons.push("ORDER_KEY_UNSUPPORTED");
+  }
+  if (reasons.includes("ORDER_KEY_AMBIGUOUS")) {
+    throw new Error(
+      "ArgumentError: ORDER BY key is an ambiguous column reference (reason=ORDER_KEY_AMBIGUOUS). Qualify the key with its table alias."
+    );
+  }
+  if (reasons.includes("ORDER_KEY_UNSUPPORTED") || reasons.includes("ORDER_KEY_UNRESOLVED")) {
+    const reason = reasons.includes("ORDER_KEY_UNSUPPORTED") ? "ORDER_KEY_UNSUPPORTED" : "ORDER_KEY_UNRESOLVED";
+    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"
+  );
+  if (!allRestEquivalent) reasons.push("ORDER_KEY_NOT_REST_EQUIVALENT");
+  if (input.whereCapability !== "EXACT_PUSHDOWN") reasons.push("WHERE_NOT_EXACT");
+  if (input.staticMode !== "SIMPLE") reasons.push("QUERY_SHAPE_LOCAL");
+  if (stmt.limit === null || stmt.limit < 0 || stmt.limit > REST_LIMIT_MAX) {
+    reasons.push("LIMIT_NOT_REST_WINDOW");
+  }
+  if ((stmt.offset ?? 0) < 0 || (stmt.offset ?? 0) > REST_OFFSET_MAX) {
+    reasons.push("OFFSET_NOT_REST_WINDOW");
+  }
+  if (stmt.limit !== null && stmt.limit > input.maxRecords) reasons.push("MAX_RECORDS_WINDOW");
+  if (input.hasKlike) reasons.push("KLIKE_NOT_REST_WINDOW");
+  if (reasons.length === 0) {
+    return {
+      kind: "CANONICAL_REST_TOP_N",
+      requiresCompleteInput: false,
+      localOrderBy: false,
+      applyLocalOffsetLimit: false,
+      reasonCodes: []
+    };
+  }
+  return {
+    kind: "CANONICAL_LOCAL",
+    requiresCompleteInput: allOrderBy.length > 0,
+    localOrderBy: stmt.orderBy.length > 0,
+    applyLocalOffsetLimit: stmt.orderBy.length > 0,
+    reasonCodes: [...new Set(reasons)]
+  };
+}
+
+// src/core/optimization/korderPlanner.ts
+var KORDER_NATIVE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "RECORD_NUMBER",
+  "SINGLE_LINE_TEXT",
+  "NUMBER",
+  "CALC",
+  "DATE",
+  "DATETIME",
+  "TIME",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "STATUS",
+  "LINK",
+  "CREATOR",
+  "MODIFIER"
+]);
+function planKorderNative(input) {
+  const { stmt } = input;
+  const reasons = [];
+  if (stmt.orderMode !== "KINTONE_NATIVE") reasons.push("KORDER_MODE_REQUIRED");
+  if (stmt.from.cteName !== null || stmt.from.subtableCode || input.staticMode !== "SIMPLE") {
+    reasons.push("KORDER_QUERY_SHAPE_UNSUPPORTED");
+  }
+  if (input.whereCapability !== "EXACT_PUSHDOWN") reasons.push("KORDER_WHERE_NOT_EXACT");
+  if (input.hasKlike) reasons.push("KORDER_KLIKE_UNSUPPORTED");
+  if (stmt.orderBy.length === 0) reasons.push("KORDER_KEY_REQUIRED");
+  for (const item of stmt.orderBy) {
+    if (item.key.type !== "FIELD_NAME") {
+      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(key=${item.key.type})`);
+      continue;
+    }
+    const name = item.key.name;
+    const semantics = input.orderSemantics.get(name);
+    if (!semantics) {
+      reasons.push(`KORDER_KEY_UNRESOLVED(field=${name})`);
+      continue;
+    }
+    if (name === "$id") continue;
+    if (!semantics.source || semantics.source.fieldCode !== name) {
+      reasons.push(`KORDER_KEY_NOT_DIRECT_FIELD(field=${name})`);
+      continue;
+    }
+    if (!KORDER_NATIVE_FIELD_TYPES.has(semantics.fieldType)) {
+      reasons.push(`KORDER_TYPE_UNSUPPORTED(field=${name}, type=${semantics.fieldType})`);
+    }
+  }
+  if (stmt.limit === null || stmt.limit < 0 || stmt.limit > 500) {
+    reasons.push(`KORDER_LIMIT_INVALID(limit=${String(stmt.limit)})`);
+  }
+  if (stmt.limit !== null && stmt.limit > input.maxRecords) {
+    reasons.push(`KORDER_LIMIT_EXCEEDS_MAX_RECORDS(limit=${stmt.limit}, maxRecords=${input.maxRecords})`);
+  }
+  const offset = stmt.offset ?? 0;
+  if (offset < 0 || offset > 1e4) reasons.push(`KORDER_OFFSET_INVALID(offset=${offset})`);
+  const unique = [...new Set(reasons)];
+  if (unique.length > 0) {
+    throw new Error(
+      `ArgumentError: KORDER BY cannot be executed (mode=KINTONE_NATIVE; ${unique.join(", ")}). Use ORDER BY for canonical local ordering or simplify the query.`
+    );
+  }
+  return {
+    kind: "KORDER_NATIVE",
+    requiresCompleteInput: false,
+    localOrderBy: false,
+    applyLocalOffsetLimit: false,
+    reasonCodes: []
+  };
+}
+
 // src/engine/process.ts
 function flatten(record, alias) {
   const row = {};
@@ -5300,9 +5760,9 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   return result;
 }
-function applyFilter(rows, where, resolveFieldType, appliedKlikes) {
+function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   if (where === null) return rows;
-  return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes));
+  return rows.filter((row) => evalWhere(where, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2));
 }
 function hasAggregateColumns(columns) {
   return columns.some(
@@ -5363,7 +5823,7 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
     let strVal;
     if (arg.type === "FIELD_REF") {
       const raw = row[arg.field];
-      if (raw === void 0 || raw === "") continue;
+      if (raw === void 0 || raw === "" && func !== "MIN" && func !== "MAX") continue;
       strVal = raw;
     } else {
       const n = evalArithExpr(arg, row);
@@ -5375,10 +5835,16 @@ function evalAggregate(func, distinct, arg, separator, 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 "";
-    return func === "MAX" ? maxStringOf(eff) : minStringOf(eff);
+  const comparison = (func === "MIN" || func === "MAX") && arg.type === "FIELD_REF" ? resolveAggSortKind?.(toAggregateFieldRef(arg.field)) : void 0;
+  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 cmp = compareCanonicalValues(candidate, result, semantics);
+      if (func === "MAX" && cmp > 0 || func === "MIN" && cmp < 0) result = candidate;
+    }
+    return result;
   }
   const nums = eff.map(Number);
   switch (func) {
@@ -5386,37 +5852,12 @@ function evalAggregate(func, distinct, arg, separator, rows, resolveAggSortKind)
       return nums.reduce((a, b) => a + b, 0);
     case "AVG":
       return nums.length === 0 ? 0 : nums.reduce((a, b) => a + b, 0) / nums.length;
-    // Math.max(...nums) は要素数が多いと RangeError になるためループで求める
-    case "MAX":
-      return nums.length === 0 ? 0 : maxOf(nums);
-    case "MIN":
-      return nums.length === 0 ? 0 : minOf(nums);
   }
 }
 function toAggregateFieldRef(field) {
   const dot = field.indexOf(".");
   return dot > 0 ? { type: "FIELD", tableAlias: field.slice(0, dot), field: field.slice(dot + 1) } : { type: "FIELD", tableAlias: null, field };
 }
-function maxStringOf(values) {
-  let value = values[0];
-  for (const candidate of values) if (candidate > value) value = candidate;
-  return value;
-}
-function minStringOf(values) {
-  let value = values[0];
-  for (const candidate of values) if (candidate < value) value = candidate;
-  return value;
-}
-function maxOf(nums) {
-  let m = nums[0];
-  for (const n of nums) if (n > m) m = n;
-  return m;
-}
-function minOf(nums) {
-  let m = nums[0];
-  for (const n of nums) if (n < m) m = n;
-  return m;
-}
 function evalAggArithExpr(node, rows, resolveAggSortKind) {
   if (node.type === "NUMBER") return node.value;
   if (node.type === "AGG_REF") return Number(evalAggregate(node.func, node.distinct, node.arg, node.separator, rows, resolveAggSortKind));
@@ -5448,9 +5889,9 @@ function aggregateSyntheticName2(func, distinct, arg) {
   const argStr = aggregateArgLabel(arg);
   return distinct ? `${func}(DISTINCT ${argStr})` : `${func}(${argStr})`;
 }
-function applyHaving(rows, having, resolveFieldType) {
+function applyHaving(rows, having, resolveFieldType, resolveFieldSemantics2) {
   if (having === null) return rows;
-  return rows.filter((row) => evalWhere(having, row, resolveFieldType));
+  return rows.filter((row) => evalWhere(having, row, resolveFieldType, void 0, resolveFieldSemantics2));
 }
 function applyDistinct(rows, columns) {
   if (rows.length === 0) return rows;
@@ -5502,27 +5943,37 @@ function buildDistinctKeyBuilder(rows, columns) {
     return JSON.stringify(values);
   };
 }
-function applyOrderBy(rows, orderBy, optionOrders, sortKinds) {
+function applyOrderBy(rows, orderBy, optionOrders, sortKinds, fieldSemantics2) {
   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
-  }));
+  return sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2).rows.map((item) => item.row);
+}
+function sortDecoratedRows(rows, orderBy, optionOrders, sortKinds, fieldSemantics2) {
+  const keyMeta = orderBy.map(({ key }) => {
+    if (key.type === "ARITH_KEY") return { semantics: syntheticSemantics("number") };
+    if (key.type === "FUNC_KEY") {
+      return { semantics: syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(key.expr.func) ? "number" : "string") };
+    }
+    const semantics = fieldSemantics2?.get(key.name);
+    if (semantics) return { semantics };
+    const orderMap = optionOrders?.get(key.name);
+    if (orderMap) {
+      return {
+        semantics: {
+          fieldType: "MULTI_SELECT",
+          compareMode: "option",
+          inSubtable: false,
+          requiresCollectionOperators: false,
+          optionOrder: orderMap
+        }
+      };
+    }
+    return { semantics: syntheticSemantics(sortKinds?.get(key.name) ?? "string") };
+  });
   const decorated = rows.map((row) => ({
     row,
     keys: orderBy.map(({ key }, i) => {
       const s = evalOrderKey(key, row);
-      const n = Number(s);
-      const orderMap = keyMeta[i].orderMap;
-      return {
-        s,
-        n,
-        isNum: !Number.isNaN(n),
-        rank: orderMap ? minChoiceIndex(parseChoiceValues(s), orderMap) : 0
-      };
+      return { s };
     })
   }));
   const compare = (a, b) => compareDecoratedRows(a, b, orderBy, keyMeta);
@@ -5537,15 +5988,24 @@ function compareDecoratedRows(a, b, orderBy, keyMeta) {
   return 0;
 }
 function compareSortKeys(a, b, meta) {
-  if (meta.orderMap) {
-    if (a.rank !== b.rank) return a.rank - b.rank;
-    return a.s.localeCompare(b.s, "ja");
-  }
-  if (meta.sortKind === "string") {
-    return a.s.localeCompare(b.s, "ja");
-  }
-  return a.isNum && b.isNum ? a.n - b.n : a.s.localeCompare(b.s, "ja");
-}
+  return compareCanonicalValues(a.s, b.s, meta.semantics);
+}
+var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
+  "LENGTH",
+  "INSTR",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "TRUNCATE",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "DATEDIFF",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT"
+]);
 function evalOrderKey(key, row) {
   switch (key.type) {
     case "FIELD_NAME":
@@ -5556,30 +6016,7 @@ function evalOrderKey(key, row) {
       return evalStringFunc(key.expr, row);
   }
 }
-function parseChoiceValues(raw) {
-  const trimmed = raw.trim();
-  if (trimmed === "") return [""];
-  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-    try {
-      const arr = JSON.parse(trimmed);
-      if (Array.isArray(arr)) {
-        return arr.map((v) => String(v ?? ""));
-      }
-    } catch {
-    }
-  }
-  return [trimmed];
-}
-function minChoiceIndex(values, orderMap) {
-  let min = Number.MAX_SAFE_INTEGER;
-  for (const value of values) {
-    const idx = orderMap.get(value);
-    const rank = idx ?? Number.MAX_SAFE_INTEGER;
-    if (rank < min) min = rank;
-  }
-  return min;
-}
-function applyWindow(rows, columns, optionOrders, sortKinds) {
+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;
   for (const window of windows) {
@@ -5591,7 +6028,7 @@ function applyWindow(rows, columns, optionOrders, sortKinds) {
       else partitions.set(key, [row]);
     }
     for (const partition of partitions.values()) {
-      const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds);
+      const sortedResult = sortDecoratedRows(partition, window.orderBy, optionOrders, sortKinds, fieldSemantics2);
       const sorted = sortedResult.rows;
       let rank = 1;
       let denseRank = 1;
@@ -5616,7 +6053,7 @@ function applyLimit(rows, limit, offset) {
   if (limit === null) return rows.slice(start);
   return rows.slice(start, start + limit);
 }
-function project(rows, columns, scalarCache, resolveFieldType, sourceColumns) {
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, resolveFieldSemantics2) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
     const projected2 = rows.map((row) => stripParentShortcutColumns(row));
     const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns ?? []];
@@ -5680,7 +6117,7 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns) {
         }
         case "CASE_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? "case";
-          out[key] = evalCaseWhen(col.expr, row, resolveFieldType);
+          out[key] = evalCaseWhen(col.expr, row, resolveFieldType, resolveFieldSemantics2);
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
@@ -5835,6 +6272,26 @@ function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
     args: expr.args.map((arg) => resolveAggInStringFuncArg(arg, rows, resolveAggSortKind))
   };
 }
+function deriveOutputOrderSemantics(columns) {
+  const result = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!("alias" in column) || !column.alias) continue;
+    if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+      result.set(column.alias, syntheticSemantics("number"));
+    } else if (column.type === "AGGREGATE") {
+      if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG") {
+        result.set(column.alias, syntheticSemantics("number"));
+      } else if (column.func === "GROUP_CONCAT") {
+        result.set(column.alias, syntheticSemantics("string"));
+      }
+    } else if (column.type === "LITERAL_COL" || column.type === "CASE_COL" || column.type === "SCALAR_SUBQUERY_COL") {
+      result.set(column.alias, syntheticSemantics("string"));
+    } else if (column.type === "STRFUNC_COL") {
+      result.set(column.alias, syntheticSemantics(NUMERIC_ORDER_FUNCTIONS.has(column.expr.func) ? "number" : "string"));
+    }
+  }
+  return result;
+}
 function runFullScan(input) {
   const {
     stmt,
@@ -5842,12 +6299,17 @@ function runFullScan(input) {
     scalarCache,
     optionOrders,
     sortKinds,
+    orderSemantics,
     fieldTypeResolver,
+    fieldSemanticsResolver,
     havingFieldTypeResolver,
+    havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes,
     sourceColumns
   } = input;
+  const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns);
+  for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
   let rows = [];
   const mainAlias = stmt.from.alias;
   const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
@@ -5858,18 +6320,18 @@ function runFullScan(input) {
     const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
     rows = applyJoin(rows, rightRows, join2);
   }
-  rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes);
+  rows = applyFilter(rows, stmt.where, fieldTypeResolver, appliedKlikes, fieldSemanticsResolver);
   if (stmt.groupBy.length > 0 || hasAggregateColumns(stmt.columns)) {
     rows = applyGroupBy(rows, stmt.groupBy, stmt.columns, aggregateSortKindResolver);
   }
-  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver);
-  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds);
+  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, havingFieldSemanticsResolver);
+  rows = applyWindow(rows, stmt.columns, optionOrders, sortKinds, effectiveOrderSemantics);
   if (stmt.distinct) {
     rows = applyDistinct(rows, stmt.columns);
   }
-  rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds);
+  rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds, effectiveOrderSemantics);
   rows = applyLimit(rows, stmt.limit, stmt.offset);
-  return project(rows, stmt.columns, scalarCache, fieldTypeResolver, sourceColumns);
+  return project(rows, stmt.columns, scalarCache, fieldTypeResolver, sourceColumns, fieldSemanticsResolver);
 }
 
 // src/converter/subtableAdapter.ts
@@ -6137,6 +6599,192 @@ function renderValidationValue(value) {
   return String(value);
 }
 
+// src/core/optimization/whereCapability.ts
+var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
+var EQUALITY_IN = ["=", "!=", "in", "not in"];
+var NATIVE_OPERATORS = /* @__PURE__ */ new Map([
+  ["RECORD_NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["__ID__", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["CREATOR", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MODIFIER", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["CREATED_TIME", new Set(RANGE_AND_EQUALITY)],
+  ["UPDATED_TIME", new Set(RANGE_AND_EQUALITY)],
+  ["DATE", new Set(RANGE_AND_EQUALITY)],
+  ["TIME", new Set(RANGE_AND_EQUALITY)],
+  ["DATETIME", new Set(RANGE_AND_EQUALITY)],
+  ["SINGLE_LINE_TEXT", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
+  ["LINK", /* @__PURE__ */ new Set(["=", "!=", "in", "not in", "like", "not like"])],
+  ["NUMBER", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["CALC", /* @__PURE__ */ new Set([...RANGE_AND_EQUALITY, "in", "not in"])],
+  ["MULTI_LINE_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["RICH_TEXT", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["CHECK_BOX", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["RADIO_BUTTON", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["DROP_DOWN", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["MULTI_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["FILE", /* @__PURE__ */ new Set(["like", "not like"])],
+  ["USER_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["ORGANIZATION_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["GROUP_SELECT", /* @__PURE__ */ new Set(["in", "not in"])],
+  ["STATUS", new Set(EQUALITY_IN)]
+]);
+var LOCAL_SCALAR_TYPES = /* @__PURE__ */ new Set([
+  "RECORD_NUMBER",
+  "__ID__",
+  "CREATOR",
+  "MODIFIER",
+  "CREATED_TIME",
+  "UPDATED_TIME",
+  "DATE",
+  "TIME",
+  "DATETIME",
+  "SINGLE_LINE_TEXT",
+  "LINK",
+  "NUMBER",
+  "CALC",
+  "MULTI_LINE_TEXT",
+  "RICH_TEXT",
+  "RADIO_BUTTON",
+  "DROP_DOWN",
+  "STATUS",
+  // 一時表・CTE・式列は kintone REST へは送らず、共有ローカル評価器で扱う。
+  "KSQL_STRING",
+  "KSQL_NUMBER",
+  "KSQL_BOOLEAN"
+]);
+var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "FILE",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "STATUS_ASSIGNEE",
+  "CATEGORY"
+]);
+function nativeWhereOperatorsForType(fieldType) {
+  return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
+}
+function classifyWhereCapability(where, resolveField2) {
+  if (where === null) {
+    return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
+  }
+  return classifyNode(where, resolveField2);
+}
+function classifyNode(where, resolveField2) {
+  switch (where.type) {
+    case "BINARY":
+      return classifyBinary(where.op, where.left, where.right.type, resolveField2);
+    case "NULL_CHECK":
+      if (where.field.type !== "FIELD") return localExpression();
+      return classifyLocalOnlyField(where.field, where.not ? "IS NOT NULL" : "IS NULL", resolveField2);
+    case "EXISTS":
+      return localExpression();
+    case "GROUP":
+      return classifyNode(where.expr, resolveField2);
+    case "NOT": {
+      const inner = classifyNode(where.expr, resolveField2);
+      return inner.capability === "SUPERSET_PREFILTER" ? { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] } : inner;
+    }
+    case "LOGICAL": {
+      const left = classifyNode(where.left, resolveField2);
+      const right = classifyNode(where.right, resolveField2);
+      return combineLogical(where.op, left, right);
+    }
+  }
+}
+function classifyBinary(op, left, rightType, resolveField2) {
+  if (left.type !== "FIELD") return localExpression();
+  const semantics = resolveField2(left);
+  if (!semantics) {
+    return unsupported("WHERE_FIELD_UNRESOLVED", left.field, void 0, normalizeOperator(op));
+  }
+  if (!hasLocalContract(semantics.fieldType, op)) {
+    return unsupported("WHERE_OPERATOR_UNSUPPORTED", left.field, semantics.fieldType, normalizeOperator(op));
+  }
+  const nativeOp = normalizeOperator(op);
+  const native = nativeWhereOperatorsForType(semantics.fieldType);
+  const rightCanPush = rightType === "STRING" || rightType === "NUMBER" || rightType === "IN_LIST" || rightType === "KINTONE_FUNC";
+  const structureAllows = !semantics.requiresCollectionOperators || nativeOp !== "=" && nativeOp !== "!=";
+  const sqlLikeIsResidual = op === "LIKE" || op === "NOT_LIKE";
+  if (rightCanPush && structureAllows && native.has(nativeOp) && !sqlLikeIsResidual) {
+    return {
+      capability: "EXACT_PUSHDOWN",
+      reasons: [{
+        code: "WHERE_EXACT",
+        field: left.field,
+        fieldType: semantics.fieldType,
+        operator: nativeOp
+      }]
+    };
+  }
+  return {
+    capability: "LOCAL_ONLY",
+    reasons: [{
+      code: "WHERE_RESIDUAL",
+      field: left.field,
+      fieldType: semantics.fieldType,
+      operator: nativeOp
+    }]
+  };
+}
+function classifyLocalOnlyField(field, operator, resolveField2) {
+  const semantics = resolveField2(field);
+  if (!semantics) return unsupported("WHERE_FIELD_UNRESOLVED", field.field, void 0, operator);
+  if (!LOCAL_SCALAR_TYPES.has(semantics.fieldType) && !LOCAL_COLLECTION_TYPES.has(semantics.fieldType)) {
+    return unsupported("WHERE_OPERATOR_UNSUPPORTED", field.field, semantics.fieldType, operator);
+  }
+  return {
+    capability: "LOCAL_ONLY",
+    reasons: [{ code: "WHERE_RESIDUAL", field: field.field, fieldType: semantics.fieldType, operator }]
+  };
+}
+function hasLocalContract(fieldType, op) {
+  if (LOCAL_SCALAR_TYPES.has(fieldType)) return true;
+  if (!LOCAL_COLLECTION_TYPES.has(fieldType)) return false;
+  return op === "=" || op === "!=" || op === "<>" || op === "IN" || op === "NOT_IN" || op === "LIKE" || op === "NOT_LIKE" || op === "KLIKE" || op === "NOT_KLIKE";
+}
+function normalizeOperator(op) {
+  switch (op) {
+    case "<>":
+      return "!=";
+    case "IN":
+      return "in";
+    case "NOT_IN":
+      return "not in";
+    case "LIKE":
+    case "KLIKE":
+      return "like";
+    case "NOT_LIKE":
+    case "NOT_KLIKE":
+      return "not like";
+    default:
+      return op;
+  }
+}
+function combineLogical(op, left, right) {
+  const reasons = [...left.reasons, ...right.reasons];
+  if (left.capability === "UNSUPPORTED" || right.capability === "UNSUPPORTED") {
+    return { capability: "UNSUPPORTED", reasons };
+  }
+  if (left.capability === "EXACT_PUSHDOWN" && right.capability === "EXACT_PUSHDOWN") {
+    return { capability: "EXACT_PUSHDOWN", reasons };
+  }
+  if (op === "AND" && (left.capability === "EXACT_PUSHDOWN" || right.capability === "EXACT_PUSHDOWN" || left.capability === "SUPERSET_PREFILTER" || right.capability === "SUPERSET_PREFILTER")) {
+    return {
+      capability: "SUPERSET_PREFILTER",
+      reasons: [{ code: "WHERE_SUPERSET_PREFILTER" }, ...reasons]
+    };
+  }
+  return { capability: "LOCAL_ONLY", reasons };
+}
+function localExpression() {
+  return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
+}
+function unsupported(code, field, fieldType, operator) {
+  return { capability: "UNSUPPORTED", reasons: [{ code, field, fieldType, operator }] };
+}
+
 // src/execute.ts
 var SEARCH_ABORTED_WARNING = "\u691C\u7D22\u304C 10 \u4E07\u4EF6\u3067\u6253\u3061\u5207\u3089\u308C\u3001\u7D50\u679C\u304C\u6B20\u843D\u3057\u305F\u53EF\u80FD\u6027\u304C\u3042\u308A\u307E\u3059\u3002";
 var SearchAbortedError = class extends Error {
@@ -6147,8 +6795,20 @@ var SearchAbortedError = class extends Error {
 };
 var materializedMetaBySelectResult = /* @__PURE__ */ new WeakMap();
 var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
+var defaultCacheContextByClient = /* @__PURE__ */ new WeakMap();
+var nextDefaultCacheContextId = 1;
+function resolveCacheContext(client, explicit) {
+  if (explicit) return explicit;
+  let context = defaultCacheContextByClient.get(client);
+  if (!context) {
+    context = `client:${nextDefaultCacheContextId++}`;
+    defaultCacheContextByClient.set(client, context);
+  }
+  return context;
+}
 async function execute(sql, client, options = {}) {
   const startedAt = Date.now();
+  const cacheContext = resolveCacheContext(client, options.cacheContext);
   const stmt = parseSql(sql);
   const metrics = createEmptyMetrics();
   const countedClient = wrapClientWithMetrics(client, metrics);
@@ -6162,7 +6822,7 @@ async function execute(sql, client, options = {}) {
     stmt,
     guardedClient,
     options,
-    options.cacheContext ?? "default"
+    cacheContext
   );
   metrics.elapsedMs = Date.now() - startedAt;
   return { ...attachSearchAbortWarning(result, collector), metrics };
@@ -6277,7 +6937,7 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
     case "DESCRIBE":
       return executeDescribe(stmt, client, cacheContext);
     case "EXPLAIN":
-      return executeExplain(stmt);
+      return executeExplain(stmt, client, cacheContext, options.maxRecords ?? 1e4);
     // 一時テーブルはバッチスコープのため単文実行では拒否する（executeBatch を使う）
     case "CREATE_TEMP_TABLE":
       throw new Error("ArgumentError: CREATE TEMP TABLE requires a batch (temp tables are batch-scoped).");
@@ -6308,7 +6968,7 @@ function materializedColumnMetaEqual(left, right) {
   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;
+    if (!candidate || candidate.sortKind !== meta.sortKind || candidate.fieldType !== meta.fieldType || !fieldSemanticsEqual(candidate.semantics, meta.semantics)) return false;
   }
   return true;
 }
@@ -6339,7 +6999,7 @@ async function executeBatch(sql, client, options = {}) {
   const countedClient = wrapClientWithMetrics(client, metrics);
   const startedAt = Date.now();
   const deadline = options.timeoutMs != null ? startedAt + options.timeoutMs : null;
-  const cacheContext = options.cacheContext ?? "default";
+  const cacheContext = resolveCacheContext(client, options.cacheContext);
   const tempTables = /* @__PURE__ */ new Map();
   const variables = /* @__PURE__ */ new Map();
   const results = [];
@@ -6433,7 +7093,10 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
           cacheContext,
           tempTables
         );
-        variables.set(stmt.name, { type: "string", value });
+        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");
+        const numberValue = numeric ? Number(value) : Number.NaN;
+        variables.set(stmt.name, numeric && Number.isFinite(numberValue) ? { type: "number", value: numberValue } : { type: "string", value });
       } catch (e) {
         if (e instanceof ScalarSubqueryError) {
           throw new Error(`ArgumentError: ${e.message}`);
@@ -6664,13 +7327,14 @@ var ScalarSubqueryError = class extends Error {
 };
 async function executeAssert(stmt, client, options, cacheContext, tempTables) {
   const left = await evalAssertOperand(stmt.left, client, options, cacheContext, tempTables);
+  const semantics = stmt.left.type === "NUMBER" || stmt.left.type === "ARITH" ? syntheticSemantics("number") : syntheticSemantics("string");
   if (stmt.op === "BETWEEN") {
     if (stmt.low === null || stmt.high === null) {
       throw new Error("ArgumentError: malformed ASSERT statement.");
     }
     const low = await evalAssertOperand(stmt.low, client, options, cacheContext, tempTables);
     const high = await evalAssertOperand(stmt.high, client, options, cacheContext, tempTables);
-    if (!compareScalarValues(">=", left, low) || !compareScalarValues("<=", left, high)) {
+    if (!compareScalarValues(">=", left, low, semantics) || !compareScalarValues("<=", left, high, semantics)) {
       throw new AssertError(`assertion failed: ${stmt.text} (actual: ${left}).`);
     }
     return { type: "ASSERT", condition: stmt.text };
@@ -6679,7 +7343,7 @@ async function executeAssert(stmt, client, options, cacheContext, tempTables) {
     throw new Error("ArgumentError: malformed ASSERT statement.");
   }
   const right = await evalAssertOperand(stmt.right, client, options, cacheContext, tempTables);
-  if (!compareScalarValues(stmt.op, left, right)) {
+  if (!compareScalarValues(stmt.op, left, right, semantics)) {
     throw new AssertError(`assertion failed: ${stmt.text} (actual: ${left}).`);
   }
   return { type: "ASSERT", condition: stmt.text };
@@ -6752,6 +7416,149 @@ function evalAssertArith(node) {
   }
   throw new Error(`ArgumentError: unsupported operand in ASSERT expression: ${node.type}`);
 }
+async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, materializedTables, forcePhysicalMetadata = false) {
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const physicalAppIds = forcePhysicalMetadata || whereNeedsFieldMetadata(stmt.where) ? [...new Set(tables.filter((table) => table.cteName === null).map((table) => table.appId))] : [];
+  const infosByApp = new Map(
+    await Promise.all(physicalAppIds.map(async (appId) => {
+      const infos = await getFieldsCached(appId, client, cacheContext);
+      return [appId, new Map(infos.map((info) => [info.code, info]))];
+    }))
+  );
+  const orderedFields = /* @__PURE__ */ new Set();
+  const collectOrderedFields = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(collectOrderedFields);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (value["type"] === "SELECT") return;
+    if (value["type"] === "BINARY" && [">", "<", ">=", "<="].includes(String(value["op"]))) {
+      const left = value["left"];
+      if (left?.["type"] === "FIELD" && typeof left["field"] === "string") {
+        orderedFields.add(left["field"]);
+      }
+    }
+    Object.values(value).forEach(collectOrderedFields);
+  };
+  collectOrderedFields(stmt.where);
+  collectOrderedFields(stmt.having);
+  for (const column of stmt.columns) {
+    if (column.type === "CASE_COL") collectOrderedFields(column.expr);
+  }
+  const statusOrdersByApp = /* @__PURE__ */ new Map();
+  await Promise.all([...infosByApp].map(async ([appId, infos]) => {
+    const needsStatus = [...orderedFields].some((field) => infos.get(field)?.fieldType === "STATUS");
+    if (!needsStatus) return;
+    const order = await loadProcessStatusOrder(appId, client, cacheContext);
+    if (order) statusOrdersByApp.set(appId, order);
+  }));
+  const fromPhysical = (table, field) => {
+    if (field === "$id") return withFieldSemanticSource(
+      resolveFieldSemantics({ fieldType: "__ID__" }),
+      table.appId,
+      "$id"
+    );
+    const info = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, field));
+    if (!info) return void 0;
+    const base = info.semantics ?? resolveFieldSemantics(info);
+    const semantics = info.fieldType === "STATUS" && statusOrdersByApp.has(table.appId) ? { ...base, optionOrder: statusOrdersByApp.get(table.appId) } : base;
+    return withFieldSemanticSource(
+      semantics,
+      table.appId,
+      info.code
+    );
+  };
+  return (field) => {
+    if (field.tableAlias !== null) {
+      if (field.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
+        return fromPhysical(stmt.from, field.field);
+      }
+      const table = tables.find((candidate) => candidate.alias === field.tableAlias);
+      if (!table) return void 0;
+      if (table.cteName !== null) {
+        return materializedTables?.get(table.cteName)?.columnMeta?.get(field.field)?.semantics ?? syntheticSemantics("string");
+      }
+      return fromPhysical(table, field.field);
+    }
+    if (stmt.joins.length === 0) {
+      if (stmt.from.cteName !== null) {
+        return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(field.field)?.semantics ?? syntheticSemantics("string");
+      }
+      return fromPhysical(stmt.from, field.field);
+    }
+    const matches = tables.flatMap((table) => {
+      const semantics = table.cteName !== null ? materializedTables?.get(table.cteName)?.columnMeta?.get(field.field)?.semantics : fromPhysical(table, field.field);
+      return semantics ? [semantics] : [];
+    });
+    if (matches.length === 1) return matches[0];
+    return matches.length > 1 ? syntheticSemantics("string") : void 0;
+  };
+}
+function selectCaseConditionsNeedFieldMetadata(stmt) {
+  return stmt.columns.some((column) => column.type === "CASE_COL" && column.expr.branches.some((branch) => whereNeedsFieldMetadata(branch.condition)));
+}
+function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
+  const aliases = /* @__PURE__ */ new Map();
+  for (const column of stmt.columns) {
+    if (!("alias" in column) || !column.alias) continue;
+    let semantics;
+    if (column.type === "FIELD") semantics = rowResolver(aggregateFieldRef(column.field));
+    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+      semantics = syntheticSemantics("number");
+    } else if (column.type === "AGGREGATE") {
+      if (column.func === "MIN" || column.func === "MAX") {
+        semantics = column.arg.type === "FIELD_REF" ? rowResolver(aggregateFieldRef(column.arg.field)) : syntheticSemantics("number");
+      } else {
+        semantics = column.func === "GROUP_CONCAT" ? syntheticSemantics("string") : syntheticSemantics("number");
+      }
+    } else if (column.type === "STRFUNC_COL") {
+      semantics = stringFunctionColumnMeta(column.expr).semantics;
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "CASE_COL") {
+      semantics = syntheticSemantics("string");
+    }
+    if (semantics) aliases.set(column.alias, semantics);
+  }
+  return (field) => field.tableAlias === null && aliases.has(field.field) ? aliases.get(field.field) : rowResolver(field);
+}
+async function resolveSelectWhereCapability(stmt, client, cacheContext, materializedTables) {
+  if (stmt.where === null) return classifyWhereCapability(null, () => void 0);
+  const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, materializedTables);
+  return classifyWhereCapability(stmt.where, resolver);
+}
+function formatWhereCapabilityFailure(result) {
+  const reason = result.reasons.find(
+    (candidate) => candidate.code === "WHERE_FIELD_UNRESOLVED" || candidate.code === "WHERE_OPERATOR_UNSUPPORTED"
+  ) ?? result.reasons[0];
+  const details = [
+    reason?.field ? `field=${reason.field}` : null,
+    reason?.fieldType ? `type=${reason.fieldType}` : null,
+    reason?.operator ? `operator=${reason.operator}` : null,
+    reason?.code ? `reason=${reason.code}` : null
+  ].filter((value) => value !== null).join(", ");
+  return details || "reason=WHERE_UNSUPPORTED";
+}
+function hasCanonicalOrder(stmt) {
+  return stmt.orderBy.length > 0 || stmt.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.orderBy.length > 0
+  );
+}
+async function assertDmlWhereCapability(stmt, client, cacheContext) {
+  if (stmt.subtableCode || stmt.type === "UPDATE" && stmt.from != null) return;
+  const fields = whereNeedsFieldMetadata(stmt.where) ? await getFieldsCached(stmt.appId, client, cacheContext) : [];
+  const byCode = new Map(fields.map((field) => [field.code, field]));
+  const result = classifyWhereCapability(stmt.where, (field) => {
+    if (field.field === "$id") return resolveFieldSemantics({ fieldType: "__ID__" });
+    const info = byCode.get(field.field);
+    return info?.semantics ?? (info ? resolveFieldSemantics(info) : void 0);
+  });
+  if (result.capability !== "EXACT_PUSHDOWN") {
+    throw new DmlConvertError(
+      `WHERE predicate cannot be represented by kintone REST (${formatWhereCapabilityFailure(result)})`
+    );
+  }
+}
 async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false) {
   let result;
   if (isNoFromSelect(stmt)) {
@@ -6762,12 +7569,51 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     return result;
   }
   await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
-  const mode = resolveSelectMode(stmt);
-  await validateSelectFieldCodes(stmt, mode, client, cacheContext);
-  if (mode === "SIMPLE") {
-    result = await executeSimpleSelect(stmt, client, options, cacheContext);
-  } else {
-    result = await executeFullScanSelect(stmt, client, options, cacheContext, cteCache);
+  const whereCapability = await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache);
+  if (whereCapability.capability === "UNSUPPORTED") {
+    throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
+  }
+  const staticMode = resolveSelectMode(stmt);
+  const mode = whereCapability.capability === "EXACT_PUSHDOWN" ? staticMode : "FULL_SCAN";
+  const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
+  const orderPlan = hasCanonicalOrder(stmt) ? (stmt.orderMode === "KINTONE_NATIVE" ? planKorderNative : planCanonicalOrder)({
+    stmt,
+    staticMode: mode,
+    whereCapability: whereCapability.capability,
+    orderSemantics: orderMeta.semantics,
+    maxRecords: options.maxRecords ?? 1e4,
+    hasKlike: whereHasKlike(stmt.where)
+  }) : null;
+  await validateSelectFieldCodes(
+    stmt,
+    orderPlan?.kind === "CANONICAL_LOCAL" ? "FULL_SCAN" : mode,
+    client,
+    cacheContext
+  );
+  const completeInputRequired = orderPlan?.kind === "CANONICAL_REST_TOP_N" || orderPlan?.kind === "KORDER_NATIVE" ? requiresCompleteInput({ ...stmt, orderBy: [] }) : requiresCompleteInput(stmt);
+  const truncateWasDisabled = completeInputRequired && options.onLimitReached === "truncate";
+  const effectiveOptions = truncateWasDisabled ? { ...options, onLimitReached: "error" } : options;
+  try {
+    if (mode === "SIMPLE") {
+      result = await executeSimpleSelect(stmt, client, effectiveOptions, cacheContext, orderPlan, orderMeta);
+    } else {
+      result = await executeFullScanSelect(
+        stmt,
+        client,
+        effectiveOptions,
+        cacheContext,
+        cteCache,
+        whereCapability.capability === "EXACT_PUSHDOWN",
+        orderMeta
+      );
+    }
+  } 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
+      );
+    }
+    throw error;
   }
   if (captureColumnMeta) {
     materializedMetaBySelectResult.set(result, await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache));
@@ -6828,19 +7674,30 @@ function executeNoFromSelect(stmt) {
   const rows = applyLimit(projected, stmt.limit, stmt.offset);
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [] };
 }
-async function executeSimpleSelect(stmt, client, options, cacheContext) {
-  const params = selectToKintoneParams(stmt);
+async function executeSimpleSelect(stmt, client, options, cacheContext, orderPlan, orderMeta) {
+  const restStmt = orderPlan?.kind === "CANONICAL_REST_TOP_N" ? withCanonicalRestTie(stmt) : stmt;
+  const params = selectToKintoneParams(restStmt);
+  const fetchFields = orderPlan?.kind === "CANONICAL_LOCAL" ? selectToFetchAllFields(stmt, stmt.from) : params.fields;
   const typedInFieldTypes = await loadTypedInFieldTypes(stmt, client, cacheContext);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
+  const projectionSemanticsResolver = stmt.columns.some((column) => column.type === "CASE_COL") ? await buildWhereFieldSemanticsResolver(
+    stmt,
+    client,
+    cacheContext,
+    void 0,
+    selectCaseConditionsNeedFieldMetadata(stmt)
+  ) : void 0;
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const onLimit = options.onLimitReached ?? "error";
   const parallel = options.fetchParallel ?? 1;
-  const useSingleGet = stmt.limit !== null && stmt.limit <= 500;
+  const useRestWindow = stmt.orderBy.length > 0 ? orderPlan?.kind === "CANONICAL_REST_TOP_N" || orderPlan?.kind === "KORDER_NATIVE" : stmt.limit !== null && stmt.limit <= 500;
   const needed = stmt.limit === null ? null : (stmt.offset ?? 0) + stmt.limit;
   const stopAfter = stmt.orderBy.length === 0 && needed !== null && needed <= maxRecords && !whereHasKlike(stmt.where) ? needed : void 0;
   let records;
-  if (useSingleGet) {
+  if (orderPlan?.kind === "KORDER_NATIVE" && stmt.limit === 0) {
+    records = [];
+  } else if (useRestWindow) {
     const res = await client.getRecords({
       app: params.app,
       query: params.query,
@@ -6853,7 +7710,7 @@ async function executeSimpleSelect(stmt, client, options, cacheContext) {
       client.getRecords,
       params.app,
       baseQuery,
-      params.fields,
+      fetchFields,
       {
         parallel,
         maxRecords,
@@ -6866,16 +7723,23 @@ async function executeSimpleSelect(stmt, client, options, cacheContext) {
     );
   }
   let rows = records.map((r) => flatten(r, null));
-  if (!useSingleGet) {
-    const { optionOrders, sortKinds } = await buildOrderByMetaForSelect(stmt, client, cacheContext);
-    rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds);
+  if (!useRestWindow) {
+    rows = applyOrderBy(
+      rows,
+      stmt.orderBy,
+      orderMeta.optionOrders,
+      orderMeta.sortKinds,
+      orderMeta.semantics
+    );
     rows = applyLimit(rows, stmt.limit, stmt.offset);
   }
   const { rows: projected, columns } = project(
     rows,
     stmt.columns,
     void 0,
-    fieldTypeResolvers.row
+    fieldTypeResolvers.row,
+    void 0,
+    projectionSemanticsResolver
   );
   return { type: "SELECT", rows: projected, columns, rowCount: projected.length, warnings: [...warnings] };
 }
@@ -6948,8 +7812,8 @@ async function loadTypedPushdownMeta(stmt, client, cacheContext) {
     const statusFields = collectCandidateFieldCodes(candidates).filter((fieldCode) => fieldTypes.get(fieldCode) === "STATUS");
     if (statusFields.length > 0) {
       const process2 = await getProcessStatusesCached(appId, client, cacheContext);
-      if (process2.enable && process2.states.length > 0) {
-        const states = new Set(process2.states);
+      if (process2.enable && process2.states && process2.states.length > 0) {
+        const states = new Set(process2.states.map((state) => state.name));
         for (const fieldCode of statusFields) fieldOptions.set(fieldCode, states);
       }
     }
@@ -7127,7 +7991,18 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
       return [appId, new Map(infos.map((info) => [info.code, info]))];
     }))
   );
+  const statusOrdersByApp = /* @__PURE__ */ new Map();
+  const aggregateFieldNames = new Set(refs.map((ref) => ref.field));
+  await Promise.all([...fieldInfosByApp].map(async ([appId, infos]) => {
+    if (![...aggregateFieldNames].some((field) => infos.get(field)?.fieldType === "STATUS")) return;
+    const order = await loadProcessStatusOrder(appId, client, cacheContext);
+    if (order) statusOrdersByApp.set(appId, order);
+  }));
   const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const semanticsForInfo = (info, appId) => {
+    const base = info.semantics ?? resolveFieldSemantics(info);
+    return info.fieldType === "STATUS" && statusOrdersByApp.has(appId) ? { ...base, optionOrder: statusOrdersByApp.get(appId) } : base;
+  };
   return (ref) => {
     let info;
     if (ref.tableAlias !== null) {
@@ -7137,40 +8012,130 @@ async function loadAggregateSortKindResolver(stmt, client, cacheContext, materia
         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)?.sortKind;
+          return materializedTables?.get(table.cteName)?.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string");
         }
         info = fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
       }
     } else if (stmt.joins.length === 0) {
       if (stmt.from.cteName !== null) {
-        return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field)?.sortKind;
+        return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string");
       }
       info = fieldInfosByApp.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
     } else {
       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] : [];
+          return materialized?.columns.includes(ref.field) ? [materialized.columnMeta?.get(ref.field)?.semantics ?? syntheticSemantics("string")] : [];
         }
         const candidate = fieldInfosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
-        return candidate ? [aggregateSortKind(candidate)] : [];
+        return candidate ? [semanticsForInfo(candidate, table.appId)] : [];
       });
       if (matches.length !== 1) return void 0;
       return matches[0];
     }
-    return info ? aggregateSortKind(info) : void 0;
+    if (!info) return void 0;
+    const sourceTable = ref.tableAlias !== null ? tables.find((table) => table.alias === ref.tableAlias) : stmt.joins.length === 0 ? stmt.from : void 0;
+    return semanticsForInfo(info, sourceTable?.appId ?? stmt.from.appId);
   };
 }
 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 materializedMetaFromFieldInfo(info, sourceAppId) {
+  const semantics = info.semantics ?? resolveFieldSemantics(info);
+  return {
+    sortKind: aggregateSortKind(info),
+    fieldType: info.fieldType,
+    semantics: sourceAppId === void 0 ? semantics : withFieldSemanticSource(semantics, sourceAppId, info.code)
+  };
+}
+function withCanonicalRestTie(stmt) {
+  const hasId = stmt.orderBy.some(
+    (item) => item.key.type === "FIELD_NAME" && item.key.name === "$id"
+  );
+  return hasId ? stmt : {
+    ...stmt,
+    orderBy: [...stmt.orderBy, { key: { type: "FIELD_NAME", name: "$id" }, direction: "ASC" }]
+  };
+}
+function syntheticColumnMeta(compareMode) {
+  return { sortKind: compareMode, semantics: syntheticSemantics(compareMode) };
+}
+function unknownStringColumnMeta() {
+  return { semantics: syntheticSemantics("string", "KSQL_UNKNOWN") };
+}
+function unsupportedColumnMeta(fieldType = "KSQL_ARRAY") {
+  return {
+    semantics: { fieldType, compareMode: "unsupported", inSubtable: false, requiresCollectionOperators: false }
+  };
+}
+function systemColumnMeta(field) {
+  if (field === "$id" || field === "_rid" || field === "_pid") {
+    return {
+      sortKind: "number",
+      fieldType: "__ID__",
+      semantics: resolveFieldSemantics({ fieldType: "__ID__" })
+    };
+  }
+  if (field === "$revision") return syntheticColumnMeta("number");
+  return void 0;
+}
+var NUMBER_RETURNING_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
+  "LENGTH",
+  "INSTR",
+  "ROUND",
+  "FLOOR",
+  "CEIL",
+  "TRUNCATE",
+  "YEAR",
+  "MONTH",
+  "DAY",
+  "DATEDIFF",
+  "ABS",
+  "MOD",
+  "POWER",
+  "SQRT"
+]);
+function stringFunctionColumnMeta(expr) {
+  if (expr.func === "CAST") {
+    const target = expr.args[1];
+    return target?.type === "STRING" && target.value === "NUMBER" ? syntheticColumnMeta("number") : syntheticColumnMeta("string");
+  }
+  return NUMBER_RETURNING_STRING_FUNCTIONS.has(expr.func) ? syntheticColumnMeta("number") : syntheticColumnMeta("string");
+}
+function caseResultColumnMeta(result, resolveField2) {
+  if (result.type === "STRING") return syntheticColumnMeta("string");
+  if (result.type === "ARRAY") return unsupportedColumnMeta();
+  if (result.type === "NUMBER" || result.type === "ARITH") return syntheticColumnMeta("number");
+  if (result.type === "STRING_FUNC") return stringFunctionColumnMeta(result);
+  const source = resolveField2(aggregateFieldRef(result.field));
+  return source ?? unknownStringColumnMeta();
+}
+function mergeExpressionColumnMeta(candidates) {
+  if (candidates.length === 0) return unknownStringColumnMeta();
+  const first = candidates[0];
+  const withoutSource = (semantics) => {
+    if (!semantics) return void 0;
+    const { source: _source, ...rest } = semantics;
+    return rest;
+  };
+  if (candidates.every(
+    (candidate) => candidate.sortKind === first.sortKind && candidate.fieldType === first.fieldType && fieldSemanticsEqual(withoutSource(candidate.semantics), withoutSource(first.semantics))
+  )) {
+    const sameSource = candidates.every(
+      (candidate) => fieldSemanticsEqual(candidate.semantics, first.semantics)
+    );
+    return sameSource ? first : { ...first, semantics: withoutSource(first.semantics) };
+  }
+  if (candidates.some((candidate) => candidate.semantics?.compareMode === "unsupported")) {
+    return unsupportedColumnMeta("KSQL_MIXED_UNSUPPORTED");
+  }
+  return unknownStringColumnMeta();
 }
 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"
+    (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"
   );
 }
 async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext, materializedTables) {
@@ -7187,18 +8152,18 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
     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;
+        return info2 ? materializedMetaFromFieldInfo(info2, stmt.from.appId) : 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;
+      return info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
     }
     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;
+      return info ? materializedMetaFromFieldInfo(info, stmt.from.appId) : systemColumnMeta(ref.field);
     }
     const matches = tables.flatMap((table) => {
       if (table.cteName !== null) {
@@ -7207,7 +8172,8 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
         return [materialized.columnMeta?.get(ref.field)];
       }
       const info = physicalInfos.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
-      return info ? [materializedMetaFromFieldInfo(info)] : [];
+      const meta = info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
+      return meta ? [meta] : [];
     });
     return matches.length === 1 ? matches[0] : void 0;
   };
@@ -7237,19 +8203,27 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       meta = resolveField2(aggregateFieldRef(column.field));
     } else if (column.type === "AGGREGATE") {
       if (column.func === "GROUP_CONCAT") {
-        meta = { sortKind: "string" };
+        meta = syntheticColumnMeta("string");
       } else if (column.func === "COUNT" || column.func === "SUM" || column.func === "AVG") {
-        meta = { sortKind: "number" };
+        meta = syntheticColumnMeta("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 };
+        if (source) meta = source;
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
-      meta = { sortKind: "number" };
+      meta = syntheticColumnMeta("number");
     } else if (column.type === "LITERAL_COL") {
-      meta = { sortKind: "string" };
+      meta = syntheticColumnMeta("string");
+    } else if (column.type === "STRFUNC_COL") {
+      meta = stringFunctionColumnMeta(column.expr);
     } else if (column.type === "WINDOW_COL") {
-      meta = { sortKind: "number" };
+      meta = syntheticColumnMeta("number");
+    } else if (column.type === "CASE_COL") {
+      const results = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
+      if (column.expr.elseResult) results.push(caseResultColumnMeta(column.expr.elseResult, resolveField2));
+      meta = mergeExpressionColumnMeta(results);
+    } else if (column.type === "SCALAR_SUBQUERY_COL") {
+      meta = unknownStringColumnMeta();
     }
     if (meta) inferred.set(output, meta);
   });
@@ -7263,7 +8237,8 @@ function mergeUnionColumnMeta(left, right) {
     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);
+    if (a && b) merged.set(column, mergeExpressionColumnMeta([a, b]));
+    else if (a || b) merged.set(column, unknownStringColumnMeta());
   });
   return merged;
 }
@@ -7300,7 +8275,7 @@ function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
   };
   return { row, having };
 }
-async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache) {
+async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache, allowOriginalWherePushdown = true, preloadedOrderMeta) {
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -7314,6 +8289,14 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     loadAggregateSortKindResolver(stmt, client, cacheContext, cteCache)
   ]);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
+  const fieldSemanticsResolver = await buildWhereFieldSemanticsResolver(
+    stmt,
+    client,
+    cacheContext,
+    cteCache,
+    whereNeedsFieldMetadata(stmt.having) || selectCaseConditionsNeedFieldMetadata(stmt)
+  );
+  const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
   const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
   const mainPushDown = pushdownPlan.mainCondition;
@@ -7327,7 +8310,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     true,
     options.onLimitReached ?? "error",
     warnings,
-    mainPushDown
+    mainPushDown,
+    allowOriginalWherePushdown
   );
   const parallelJoins = [];
   const onOptJoins = [];
@@ -7353,7 +8337,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     }
   }
   const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
-  const orderByMetaPromise = buildOrderByMetaForSelect(stmt, client, cacheContext);
+  const orderByMetaPromise = preloadedOrderMeta ? Promise.resolve(preloadedOrderMeta) : buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
   scalarCachePromise.catch(() => {
   });
   orderByMetaPromise.catch(() => {
@@ -7390,15 +8374,18 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     tables.set(join2.table.alias, joinRecords);
   }));
   const scalarCache = await scalarCachePromise;
-  const { optionOrders, sortKinds } = await orderByMetaPromise;
+  const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
   const { rows, columns } = runFullScan({
     tables,
     stmt,
     scalarCache,
     optionOrders,
     sortKinds,
+    orderSemantics: semantics,
     fieldTypeResolver: fieldTypeResolvers.row,
+    fieldSemanticsResolver,
     havingFieldTypeResolver: fieldTypeResolvers.having,
+    havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes: pushdownPlan.appliedKlikes
   });
@@ -7495,16 +8482,39 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     resolveSubqueries(stmt.having, client, options, cacheContext, cteCache),
     resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache)
   ]);
+  const whereCapability = await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache);
+  if (whereCapability.capability === "UNSUPPORTED") {
+    throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
+  }
+  const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
+  if (hasCanonicalOrder(stmt)) {
+    (stmt.orderMode === "KINTONE_NATIVE" ? planKorderNative : planCanonicalOrder)({
+      stmt,
+      staticMode: "FULL_SCAN",
+      whereCapability: whereCapability.capability,
+      orderSemantics: orderMeta.semantics,
+      maxRecords,
+      hasKlike: whereHasKlike(stmt.where)
+    });
+  }
   const [pushdownMeta, typedInFieldTypes, aggregateSortKindResolver] = await Promise.all([
     loadTypedPushdownMeta(stmt, client, cacheContext),
     loadTypedInFieldTypes(stmt, client, cacheContext),
     loadAggregateSortKindResolver(stmt, client, cacheContext, cteCache)
   ]);
   const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
+  const fieldSemanticsResolver = await buildWhereFieldSemanticsResolver(
+    stmt,
+    client,
+    cacheContext,
+    cteCache,
+    whereNeedsFieldMetadata(stmt.having) || selectCaseConditionsNeedFieldMetadata(stmt)
+  );
+  const havingFieldSemanticsResolver = buildHavingFieldSemanticsResolver(stmt, fieldSemanticsResolver);
   const pushdownPlan = buildKlikePushdownPlan(stmt, pushdownMeta);
   validateKlikePushdownPlan(pushdownPlan);
   const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
-  const orderByMetaPromise = buildOrderByMetaForSelect(stmt, client, cacheContext);
+  const orderByMetaPromise = Promise.resolve(orderMeta);
   scalarCachePromise.catch(() => {
   });
   orderByMetaPromise.catch(() => {
@@ -7523,7 +8533,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
       true,
       options.onLimitReached ?? "error",
       warnings,
-      pushdownPlan.mainCondition
+      pushdownPlan.mainCondition,
+      whereCapability.capability === "EXACT_PUSHDOWN"
     );
     tables.set(stmt.from.alias, mainRecords);
   }
@@ -7560,7 +8571,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   });
   await Promise.all(joinFetches);
   const scalarCache = await scalarCachePromise;
-  const { optionOrders, sortKinds } = await orderByMetaPromise;
+  const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
   const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? cteCache.get(stmt.from.cteName)?.columns : void 0;
   const { rows, columns } = runFullScan({
     tables,
@@ -7568,8 +8579,11 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     scalarCache,
     optionOrders,
     sortKinds,
+    orderSemantics: semantics,
     fieldTypeResolver: fieldTypeResolvers.row,
+    fieldSemanticsResolver,
     havingFieldTypeResolver: fieldTypeResolvers.having,
+    havingFieldSemanticsResolver,
     aggregateSortKindResolver,
     appliedKlikes: pushdownPlan.appliedKlikes,
     sourceColumns
@@ -7581,13 +8595,13 @@ function processRowToKintoneRecord(row) {
     Object.entries(row).map(([k, v]) => [k, { value: v ?? "" }])
   );
 }
-async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, parallel, isMainTable, onLimit, warnings, pushDownCond = null) {
+async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, parallel, isMainTable, onLimit, warnings, pushDownCond = null, allowOriginalWherePushdown = true) {
   const fields = selectToFetchAllFields(stmt, table);
   const onTruncate = (max) => {
     warnings.add(`\u53D6\u5F97\u4E0A\u9650\uFF08${max} \u4EF6\uFF09\u306B\u9054\u3057\u305F\u305F\u3081\u3001${max} \u4EF6\u3067\u6253\u3061\u5207\u3063\u3066\u8868\u793A\u3057\u3066\u3044\u307E\u3059\u3002`);
   };
   if (!table.subtableCode) {
-    const baseQuery = isMainTable ? selectToFetchAllParams(stmt, table.appId).query : "";
+    const baseQuery = isMainTable && allowOriginalWherePushdown ? selectToFetchAllParams(stmt, table.appId).query : "";
     const pushQuery = pushDownCond !== null ? whereToKintone(pushDownCond) : "";
     const query = baseQuery && pushQuery ? `(${baseQuery}) and (${pushQuery})` : baseQuery || pushQuery;
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, table.appId, query, fields, {
@@ -7791,6 +8805,10 @@ async function getProcessStatusesCached(appId, client, cacheContext) {
   setScopedCacheValue(processStatusCache, cacheContext, appId, loading);
   return loading;
 }
+async function loadProcessStatusOrder(appId, client, cacheContext) {
+  const process2 = await getProcessStatusesCached(appId, client, cacheContext);
+  return process2.enable && process2.states !== null ? new Map(process2.states.map((state) => [state.name, state.index])) : void 0;
+}
 async function getFieldTypeMap(appId, client, cacheContext) {
   const cached = getScopedCacheValue(fieldTypeCache, cacheContext, appId);
   if (cached) return cached;
@@ -7834,18 +8852,118 @@ async function getSortKindMapByApp(appId, client, cacheContext) {
   setScopedCacheValue(sortKindCache, cacheContext, appId, map);
   return map;
 }
-async function buildOrderByMetaForSelect(stmt, client, cacheContext) {
+function orderByFieldNames(stmt) {
+  const items = [
+    ...stmt.orderBy,
+    ...stmt.columns.flatMap((column) => column.type === "WINDOW_COL" ? column.orderBy : [])
+  ];
+  return [...new Set(items.flatMap(
+    (item) => item.key.type === "FIELD_NAME" ? [item.key.name] : []
+  ))];
+}
+async function buildOrderSemanticsForSelect(stmt, client, cacheContext, materializedTables) {
+  const names = orderByFieldNames(stmt);
+  if (names.length === 0) return /* @__PURE__ */ new Map();
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const ambiguousFields = /* @__PURE__ */ new Set();
+  const infosByApp = new Map(
+    await Promise.all([...new Set(
+      tables.filter((table) => table.cteName === null).map((table) => table.appId)
+    )].map(async (appId) => {
+      const infos = await getFieldsCached(appId, client, cacheContext);
+      return [appId, new Map(infos.map((info) => [info.code, info]))];
+    }))
+  );
+  const resolveField2 = (ref) => {
+    if (ref.tableAlias !== null) {
+      if (ref.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
+        const info2 = infosByApp.get(stmt.from.appId)?.get(ref.field);
+        return info2 ? materializedMetaFromFieldInfo(info2, stmt.from.appId) : 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 = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
+      return info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
+    }
+    if (stmt.joins.length === 0) {
+      if (stmt.from.cteName !== null) return materializedTables?.get(stmt.from.cteName)?.columnMeta?.get(ref.field);
+      const info = infosByApp.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, ref.field));
+      return info ? materializedMetaFromFieldInfo(info, stmt.from.appId) : systemColumnMeta(ref.field);
+    }
+    const matches = tables.flatMap((table) => {
+      if (table.cteName !== null) {
+        const materialized = materializedTables?.get(table.cteName);
+        const meta2 = materialized?.columns.includes(ref.field) ? materialized.columnMeta?.get(ref.field) : void 0;
+        return meta2 ? [meta2] : [];
+      }
+      const info = infosByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, ref.field));
+      const meta = info ? materializedMetaFromFieldInfo(info, table.appId) : systemColumnMeta(ref.field);
+      return meta ? [meta] : [];
+    });
+    if (matches.length > 1) ambiguousFields.add(ref.field);
+    return matches.length === 1 ? matches[0] : void 0;
+  };
+  const aliasSemantics = /* @__PURE__ */ new Map();
+  for (const column of stmt.columns) {
+    if (!("alias" in column) || !column.alias) continue;
+    let meta;
+    if (column.type === "FIELD") meta = resolveField2(aggregateFieldRef(column.field));
+    else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
+      meta = syntheticColumnMeta("number");
+    } else if (column.type === "LITERAL_COL") meta = syntheticColumnMeta("string");
+    else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr);
+    else if (column.type === "SCALAR_SUBQUERY_COL") meta = unknownStringColumnMeta();
+    else if (column.type === "CASE_COL") {
+      const candidates = column.expr.branches.map((branch) => caseResultColumnMeta(branch.result, resolveField2));
+      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") {
+        meta = column.arg.type === "FIELD_REF" ? resolveField2(aggregateFieldRef(column.arg.field)) : syntheticColumnMeta("number");
+      } else {
+        meta = column.func === "GROUP_CONCAT" ? syntheticColumnMeta("string") : syntheticColumnMeta("number");
+      }
+    }
+    if (meta?.semantics) aliasSemantics.set(column.alias, meta.semantics);
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const name of names) {
+    const base = aliasSemantics.get(name) ?? resolveField2(aggregateFieldRef(name))?.semantics;
+    if (!base) {
+      const ref = aggregateFieldRef(name);
+      if (ref.tableAlias === null && ambiguousFields.has(ref.field)) {
+        result.set(name, resolveFieldSemantics({ fieldType: "KSQL_AMBIGUOUS" }));
+      }
+      continue;
+    }
+    let semantics = base;
+    if (base.fieldType === "STATUS" && base.source && stmt.orderMode !== "KINTONE_NATIVE") {
+      const process2 = await getProcessStatusesCached(base.source.appId, client, cacheContext);
+      if (process2.enable && process2.states !== null) {
+        semantics = {
+          ...base,
+          optionOrder: new Map(process2.states.map((state) => [state.name, state.index]))
+        };
+      }
+    }
+    result.set(name, semantics);
+  }
+  return result;
+}
+async function buildOrderByMetaForSelect(stmt, client, cacheContext, materializedTables) {
   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() };
+    return { optionOrders: /* @__PURE__ */ new Map(), sortKinds: /* @__PURE__ */ new Map(), semantics: /* @__PURE__ */ new Map() };
   }
-  const [optionOrders, sortKinds] = await Promise.all([
+  const [optionOrders, sortKinds, semantics] = await Promise.all([
     buildOptionOrdersForSelect(stmt, client, cacheContext),
-    buildSortKindsForSelect(stmt, client, cacheContext)
+    buildSortKindsForSelect(stmt, client, cacheContext),
+    buildOrderSemanticsForSelect(stmt, client, cacheContext, materializedTables)
   ]);
-  return { optionOrders, sortKinds };
+  return { optionOrders, sortKinds, semantics };
 }
 async function buildOptionOrdersForSelect(stmt, client, cacheContext) {
   const optionOrders = /* @__PURE__ */ new Map();
@@ -7943,6 +9061,9 @@ var RejectLimitExceededError = class extends Error {
   }
 };
 async function prepareDmlValidation(stmt, client, options, cacheContext, tempTables, statementNumber) {
+  if (stmt.type === "UPDATE") {
+    await assertDmlWhereCapability(stmt, client, cacheContext);
+  }
   const operation = stmt.type === "UPDATE" ? "UPDATE" : stmt.type.startsWith("UPSERT") ? "UPSERT" : "INSERT";
   const payloadFields = stmt.type === "UPDATE" ? ["$id", ...stmt.assignments.map((a) => a.field)] : [...stmt.fields];
   if (new Set(payloadFields).size !== payloadFields.length) {
@@ -7982,18 +9103,22 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
   const columnMeta = /* @__PURE__ */ new Map();
   for (const column of payloadFields) {
     if (column === "$id") {
-      columnMeta.set(column, { sortKind: "number", fieldType: "RECORD_NUMBER" });
+      columnMeta.set(column, {
+        sortKind: "number",
+        fieldType: "RECORD_NUMBER",
+        semantics: resolveFieldSemantics({ 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" });
+    if (info) columnMeta.set(column, materializedMetaFromFieldInfo(info, stmt.appId));
+  }
+  columnMeta.set("$err_statement", syntheticColumnMeta("number"));
+  columnMeta.set("$err_operation", syntheticColumnMeta("string"));
+  columnMeta.set("$err_row", syntheticColumnMeta("number"));
+  columnMeta.set("$err_field", syntheticColumnMeta("string"));
+  columnMeta.set("$err_code", syntheticColumnMeta("string"));
+  columnMeta.set("$err_message", syntheticColumnMeta("string"));
   materializedMetaByValidationResult.set(result, columnMeta);
   return { result, candidates, invalidRowNumbers, columnMeta };
 }
@@ -8379,6 +9504,7 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
   };
 }
 async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
+  await assertDmlWhereCapability(stmt, client, cacheContext);
   if (stmt.subtableCode) {
     return executeUpdateSubtable(stmt, client, options, cacheContext);
   }
@@ -8456,6 +9582,7 @@ function collectUpdateFromTargetFields(stmt) {
   return [...fields];
 }
 async function executeDelete(stmt, client, options, cacheContext) {
+  await assertDmlWhereCapability(stmt, client, cacheContext);
   if (stmt.subtableCode) {
     return executeDeleteSubtable(stmt, client, options, cacheContext);
   }
@@ -8828,6 +9955,18 @@ async function executeReorder(stmt, client, options, cacheContext) {
     client,
     cacheContext
   );
+  const reorderFields = await getFieldsCached(stmt.appId, client, cacheContext);
+  const reorderSemanticsByCode = new Map(reorderFields.map((field) => [
+    field.code,
+    field.semantics ?? resolveFieldSemantics(field)
+  ]));
+  const resolveReorderSemantics = (field) => {
+    if (field.field === "_idx" || field.field === "_pid" || field.field === "_rid") {
+      return syntheticSemantics("number");
+    }
+    const code = field.field.startsWith("_p.") ? field.field.slice(3) : field.field;
+    return reorderSemanticsByCode.get(code) ?? syntheticSemantics("string");
+  };
   const parents = await fetchAll(
     client.getRecords,
     stmt.appId,
@@ -8836,7 +9975,13 @@ async function executeReorder(stmt, client, options, cacheContext) {
     { maxRecords: options.maxRecords ?? 1e4, parallel: options.fetchParallel ?? 1 }
   );
   const expanded = expandRowsForSubtableDml(parents, stmt.subtableCode);
-  const targetParentIds = stmt.all ? new Set(parents.map((p) => String(p["$id"]?.value ?? "")).filter((id) => id !== "")) : new Set(expanded.filter((r) => stmt.where && evalWhere(stmt.where, r.flat, resolveFieldType)).map((r) => r.parentId));
+  const targetParentIds = stmt.all ? new Set(parents.map((p) => String(p["$id"]?.value ?? "")).filter((id) => id !== "")) : new Set(expanded.filter((r) => stmt.where && evalWhere(
+    stmt.where,
+    r.flat,
+    resolveFieldType,
+    void 0,
+    resolveReorderSemantics
+  )).map((r) => r.parentId));
   if (options.confirm) {
     const ok = await options.confirm(targetParentIds.size, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", targetParentIds.size);
@@ -8847,7 +9992,7 @@ async function executeReorder(stmt, client, options, cacheContext) {
     if (!parent) continue;
     const rows = getMutableTableRows(parent, stmt.subtableCode);
     const sortable = rows.map((row, i) => ({ row, i, flat: buildFlatRowForSort(parent, stmt.subtableCode, row, i) }));
-    sortable.sort((a, b) => compareByOrder(a.flat, b.flat, stmt.by));
+    sortable.sort((a, b) => compareByOrder(a.flat, b.flat, stmt.by, resolveReorderSemantics));
     const orderedRowIds = sortable.map((x) => x.row.id ?? "");
     await client.putRecords(buildSubtableReorderPutParams(stmt.appId, pid, getRevision(parent), stmt.subtableCode, orderedRowIds));
   }
@@ -8868,14 +10013,12 @@ function buildFlatRowForSort(parent, subtableCode, row, idx) {
   }
   return flat;
 }
-function compareByOrder(a, b, orderBy) {
+function compareByOrder(a, b, orderBy, resolveSemantics) {
   for (const item of orderBy) {
     const av = evalOrderKeyForRow(item.key, a);
     const bv = evalOrderKeyForRow(item.key, b);
-    const an = Number(av);
-    const bn = Number(bv);
-    const numeric = !Number.isNaN(an) && !Number.isNaN(bn);
-    const cmp = numeric ? an - bn : av.localeCompare(bv, "ja");
+    const semantics = item.key.type === "FIELD_NAME" ? resolveSemantics(aggregateFieldRef(item.key.name)) : item.key.type === "ARITH_KEY" ? syntheticSemantics("number") : stringFunctionColumnMeta(item.key.expr).semantics ?? syntheticSemantics("string");
+    const cmp = compareCanonicalValues(av, bv, semantics ?? syntheticSemantics("string"));
     if (cmp !== 0) return item.direction === "ASC" ? cmp : -cmp;
   }
   return 0;
@@ -9072,35 +10215,140 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   pending.forEach(([i], idx) => cache.set(i, values[idx]));
   return cache;
 }
-function buildBatchExplainPlans(sql, injectedVariables) {
+async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4) {
+  const fieldApps = /* @__PURE__ */ new Set();
+  const processStatusApps = /* @__PURE__ */ new Set();
+  const tracedClient = {
+    ...client,
+    getFields: async (appId) => {
+      fieldApps.add(appId);
+      return client.getFields(appId);
+    },
+    getProcessStatuses: async (appId) => {
+      processStatusApps.add(appId);
+      return client.getProcessStatuses(appId);
+    }
+  };
+  const capabilities = /* @__PURE__ */ new Map();
+  const orderPlans = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Set();
+  const visit = async (node) => {
+    if (node === null || typeof node !== "object") return;
+    if (seen.has(node)) return;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      await Promise.all(node.map(visit));
+      return;
+    }
+    const typed = node;
+    if (typed["type"] === "SELECT") {
+      const select = node;
+      const physicalApps = [select.from, ...select.joins.map((join2) => join2.table)].filter((table) => table.cteName === null).map((table) => table.appId);
+      const needsWhereSchema = whereNeedsFieldMetadata(select.where);
+      if (needsWhereSchema || select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
+        physicalApps.forEach((appId) => fieldApps.add(appId));
+      }
+      const capability = await resolveSelectWhereCapability(select, tracedClient, cacheContext);
+      if (capability.capability === "UNSUPPORTED") {
+        throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
+      }
+      capabilities.set(select, capability);
+      if (select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
+        const meta = await buildOrderByMetaForSelect(select, tracedClient, cacheContext);
+        if (select.orderMode !== "KINTONE_NATIVE") {
+          for (const semantics of meta.semantics.values()) {
+            if (semantics.fieldType === "STATUS" && semantics.source) {
+              processStatusApps.add(semantics.source.appId);
+            }
+          }
+        }
+        const hasUnmaterializedSource = [select.from, ...select.joins.map((join2) => join2.table)].some((table) => table.cteName !== null);
+        if (hasCanonicalOrder(select) && !hasUnmaterializedSource) {
+          const mode = capability.capability === "EXACT_PUSHDOWN" ? resolveSelectMode(select) : "FULL_SCAN";
+          orderPlans.set(select, (select.orderMode === "KINTONE_NATIVE" ? planKorderNative : planCanonicalOrder)({
+            stmt: select,
+            staticMode: mode,
+            whereCapability: capability.capability,
+            orderSemantics: meta.semantics,
+            maxRecords,
+            hasKlike: whereHasKlike(select.where)
+          }));
+        }
+      }
+    } else if (typed["type"] === "UPDATE" || typed["type"] === "DELETE") {
+      fieldApps.add(node.appId);
+      await assertDmlWhereCapability(
+        node,
+        tracedClient,
+        cacheContext
+      );
+    }
+    await Promise.all(Object.values(typed).map(visit));
+  };
+  await visit(query);
+  if (typeof query === "object" && query !== null && query.type === "WITH" && canInlineSingleCte(query)) {
+    const inlined = buildInlinedQuery(query);
+    const capability = await resolveSelectWhereCapability(inlined, tracedClient, cacheContext);
+    if (capability.capability === "UNSUPPORTED") {
+      throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
+    }
+    capabilities.set(inlined, capability);
+    if (hasCanonicalOrder(inlined)) {
+      const meta = await buildOrderByMetaForSelect(inlined, tracedClient, cacheContext);
+      orderPlans.set(inlined, (inlined.orderMode === "KINTONE_NATIVE" ? planKorderNative : planCanonicalOrder)({
+        stmt: inlined,
+        staticMode: capability.capability === "EXACT_PUSHDOWN" ? resolveSelectMode(inlined) : "FULL_SCAN",
+        whereCapability: capability.capability,
+        orderSemantics: meta.semantics,
+        maxRecords,
+        hasKlike: whereHasKlike(inlined.where)
+      }));
+    }
+  }
+  return { capabilities, orderPlans, fieldApps, processStatusApps };
+}
+function explainMetadataLines(analysis) {
+  return [
+    ...[...analysis.fieldApps].sort((a, b) => a - b).map((appId) => `  metadata API: form definition APP${appId}`),
+    ...[...analysis.processStatusApps].sort((a, b) => a - b).map((appId) => `  metadata API: process status APP${appId}`)
+  ];
+}
+async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4) {
   const statements = parseSqlBatch(sql);
   const analysis = analyzeBatch(statements);
   validateDeclaredBatchVariables(statements, injectedVariables);
   const variables = /* @__PURE__ */ new Map();
-  return {
-    statementCount: statements.length,
-    statements: statements.map((stmt, i) => {
-      const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveVariableRefs(stmt.expr, variables) } : stmt : resolveVariableRefs(stmt, variables);
-      validateKlikeStatement(planStmt);
-      const result = {
-        index: i,
-        type: analysis.statements[i].statementType,
-        plan: buildBatchStatementPlan(planStmt, analysis.statements[i])
-      };
-      if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
-        variables.set(stmt.name, { type: "string", value: `@${stmt.name}` });
-      }
-      return result;
-    })
-  };
+  const plans = [];
+  for (let i = 0; i < statements.length; i++) {
+    const stmt = statements[i];
+    const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveVariableRefs(stmt.expr, variables) } : stmt : resolveVariableRefs(stmt, variables);
+    validateKlikeStatement(planStmt);
+    const whereAnalysis = await buildExplainWhereAnalysis(planStmt, client, cacheContext, maxRecords);
+    const statementPlan = buildBatchStatementPlan(
+      planStmt,
+      analysis.statements[i],
+      whereAnalysis.capabilities,
+      whereAnalysis.orderPlans
+    );
+    const metadataPlan = explainMetadataLines(whereAnalysis);
+    plans.push({
+      index: i,
+      type: analysis.statements[i].statementType,
+      plan: statementPlan.length === 0 ? metadataPlan : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1)]
+    });
+    if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
+      variables.set(stmt.name, { type: "string", value: `@${stmt.name}` });
+    }
+  }
+  return { statementCount: statements.length, statements: plans };
 }
-function buildBatchStatementPlan(stmt, info) {
+function buildBatchStatementPlan(stmt, info, capabilities, orderPlans) {
   if (stmt.type === "CREATE_TEMP_TABLE") {
     return [
       `CREATE TEMP TABLE ${stmt.name}`,
       `  scope:         batch\uFF08\u30D0\u30C3\u30C1\u7D42\u4E86\u6642\u306B\u81EA\u52D5\u7834\u68C4\uFF09`,
       `  rows:          \u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u4E0D\u660E\uFF08\u65E2\u5B9A\u4E0A\u9650 ${TEMP_TABLE_MAX_ROWS} \u884C\u3001tempTableMaxRows \u3067\u5909\u66F4\u53EF\u3001\u8D85\u904E\u306F\u30A8\u30E9\u30FC\uFF09`,
-      ...buildPlanForBatchQuery(stmt.query, info).map((l) => `  ${l}`)
+      ...buildPlanForBatchQuery(stmt.query, info, capabilities, orderPlans).map((l) => `  ${l}`)
     ];
   }
   if (stmt.type === "DROP_TEMP_TABLE") {
@@ -9116,7 +10364,7 @@ function buildBatchStatementPlan(stmt, info) {
         `SET @${stmt.name} = (SELECT ...)`,
         "  value:         \u30B5\u30D6\u30AF\u30A8\u30EA\u3092\u5B9F\u884C\u6642\u306B1\u56DE\u8A55\u4FA1\uFF081\u884C1\u5217\u30FB\u30D0\u30C3\u30C1\u5185\u5B9A\u6570\u30FB\u7D50\u679C\u30E1\u30BF\u30C7\u30FC\u30BF\u306B\u306F\u975E\u516C\u958B\uFF09",
         "  subquery:",
-        ...buildPlanForBatchQuery(stmt.expr.query, subInfo).map((l) => `  ${l}`)
+        ...buildPlanForBatchQuery(stmt.expr.query, subInfo, capabilities, orderPlans).map((l) => `  ${l}`)
       ];
     }
     return [
@@ -9132,7 +10380,7 @@ function buildBatchStatementPlan(stmt, info) {
   }
   if (stmt.type === "SHOW_APPS") return ["SHOW APPS\uFF08\u30A2\u30D7\u30EA\u4E00\u89A7\u306E\u53D6\u5F97\uFF09"];
   if (stmt.type === "DESCRIBE") return [`DESCRIBE APP${stmt.appId}\uFF08\u30D5\u30A3\u30FC\u30EB\u30C9\u5B9A\u7FA9\u306E\u53D6\u5F97\uFF09`];
-  if (stmt.type === "EXPLAIN") return buildPlanForBatchQuery(stmt.query, info);
+  if (stmt.type === "EXPLAIN") return buildPlanForBatchQuery(stmt.query, info, capabilities, orderPlans);
   if (stmt.type === "ASSERT") {
     const lines = [
       `ASSERT ${stmt.text}`,
@@ -9144,11 +10392,11 @@ function buildBatchStatementPlan(stmt, info) {
     subqueries.forEach((sq, i) => {
       lines.push(subqueries.length > 1 ? `  subquery[${i + 1}]:` : "  subquery:");
       const subInfo = hasTempTableRef(sq.query) ? info : { ...info, tempTablesReferenced: [] };
-      lines.push(...buildPlanForBatchQuery(sq.query, subInfo).map((l) => `  ${l}`));
+      lines.push(...buildPlanForBatchQuery(sq.query, subInfo, capabilities, orderPlans).map((l) => `  ${l}`));
     });
     return lines;
   }
-  return buildPlanForBatchQuery(stmt, info);
+  return buildPlanForBatchQuery(stmt, info, capabilities, orderPlans);
 }
 function hasTempTableRef(node) {
   if (Array.isArray(node)) return node.some(hasTempTableRef);
@@ -9160,9 +10408,9 @@ function hasTempTableRef(node) {
   }
   return false;
 }
-function buildPlanForBatchQuery(query, info) {
+function buildPlanForBatchQuery(query, info, capabilities, orderPlans) {
   if (info.tempTablesReferenced.length === 0) {
-    return buildExplainPlan(query);
+    return buildExplainPlan(query, void 0, capabilities, orderPlans);
   }
   const lines = [];
   if (query.type === "INSERT_SELECT") {
@@ -9187,8 +10435,12 @@ function buildPlanForBatchQuery(query, info) {
   lines.push("  note:          \u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u3078\u306E WHERE \u30D7\u30C3\u30B7\u30E5\u30C0\u30A6\u30F3\u306F\u884C\u308F\u308C\u306A\u3044");
   return lines;
 }
-function executeExplain(stmt) {
-  const lines = buildExplainPlan(stmt.query);
+async function executeExplain(stmt, client, cacheContext, maxRecords) {
+  const analysis = await buildExplainWhereAnalysis(stmt.query, client, cacheContext, maxRecords);
+  const lines = [
+    ...explainMetadataLines(analysis),
+    ...buildExplainPlan(stmt.query, void 0, analysis.capabilities, analysis.orderPlans)
+  ];
   return {
     type: "SELECT",
     columns: ["plan"],
@@ -9196,29 +10448,45 @@ function executeExplain(stmt) {
     rowCount: lines.length
   };
 }
-function buildExplainPlan(query, label) {
-  if (query.type === "UNION") return buildUnionPlan(query);
-  if (query.type === "WITH") return buildWithPlan(query);
+function buildExplainPlan(query, label, capabilities, orderPlans) {
+  if (query.type === "UNION") return buildUnionPlan(query, capabilities, orderPlans);
+  if (query.type === "WITH") return buildWithPlan(query, capabilities, orderPlans);
   if (query.type === "INSERT") return buildInsertPlan(query, label);
-  if (query.type === "INSERT_SELECT") return buildInsertSelectPlan(query, label);
+  if (query.type === "INSERT_SELECT") return buildInsertSelectPlan(query, label, capabilities, orderPlans);
   if (query.type === "UPSERT") return buildUpsertPlan(query, label);
-  if (query.type === "UPSERT_SELECT") return buildUpsertSelectPlan(query, label);
-  if (query.type === "UPDATE") return buildUpdatePlan(query, label);
+  if (query.type === "UPSERT_SELECT") return buildUpsertSelectPlan(query, label, capabilities, orderPlans);
+  if (query.type === "UPDATE") return buildUpdatePlan(query, label, capabilities, orderPlans);
   if (query.type === "DELETE") return buildDeletePlan(query, label);
   if (query.type === "REORDER") return buildReorderPlan(query, label);
-  return buildSelectPlan(query, label);
+  return buildSelectPlan(query, label, capabilities, orderPlans);
 }
-function buildSelectPlan(stmt, label) {
-  const mode = resolveSelectMode(stmt);
+function buildSelectPlan(stmt, label, capabilities, orderPlans) {
+  const whereCapability = capabilities?.get(stmt) ?? (capabilities ? [...capabilities].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
+  const orderPlan = orderPlans?.get(stmt) ?? (orderPlans ? [...orderPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
+  const mode = orderPlan?.kind === "CANONICAL_LOCAL" ? "FULL_SCAN" : whereCapability && whereCapability.capability !== "EXACT_PUSHDOWN" ? "FULL_SCAN" : resolveSelectMode(stmt);
   const reasons = collectFullScanReasons(stmt);
+  if (whereCapability && whereCapability.capability !== "EXACT_PUSHDOWN") {
+    reasons.push(...whereCapability.reasons.map((reason) => reason.code));
+  }
   const lines = [];
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
+  if (orderPlan) {
+    lines.push(`  order plan:    ${orderPlan.kind}`);
+    if (orderPlan.reasonCodes.length > 0) lines.push(`  order reason:  ${orderPlan.reasonCodes.join(", ")}`);
+    if (orderPlan.kind === "KORDER_NATIVE") {
+      lines.push("  order semantics: kintone native (not kSQL canonical)");
+      lines.push("  REST execution: single GET");
+    }
+  }
+  if (orderPlan?.requiresCompleteInput ?? requiresCompleteInput(stmt)) {
+    lines.push("  complete input: required (ORDER BY / window ORDER BY; onLimit=truncate disabled)");
+  }
   if (mode === "FULL_SCAN" && reasons.length > 0) {
     lines.push(`  reason:        ${reasons.join(", ")}`);
   }
   if (mode === "SIMPLE") {
-    const params = selectToKintoneParams(stmt);
+    const params = selectToKintoneParams(orderPlan?.kind === "CANONICAL_REST_TOP_N" ? withCanonicalRestTie(stmt) : stmt);
     lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);
     lines.push(`  kintone query: ${params.query || "(\u306A\u3057)"}`);
     lines.push(`  fields:        ${params.fields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : params.fields.join(", ")}`);
@@ -9228,7 +10496,8 @@ function buildSelectPlan(stmt, label) {
     const mainAliasStr = stmt.from.alias ? ` AS ${stmt.from.alias}` : "";
     const mainPushDown = pushdownPlan.mainCondition;
     const mainCandidate = extractMainTypedPushdownCandidate(stmt);
-    const mainQ = mainPushDown !== null ? whereToKintone(mainPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
+    const exactOriginalWhere = stmt.joins.length === 0 && whereCapability?.capability === "EXACT_PUSHDOWN" && stmt.where !== null && !whereRequiresJsEval(stmt.where) ? whereToKintone(stmt.where) : "";
+    const mainQ = mainPushDown !== null ? whereToKintone(mainPushDown) : exactOriginalWhere || "(\u5168\u4EF6\u53D6\u5F97)";
     lines.push(`  app:           APP${stmt.from.appId}${mainAliasStr} (${stmt.from.appId})`);
     lines.push(`  kintone query: ${mainQ}`);
     if (mainCandidate !== null) {
@@ -9250,10 +10519,10 @@ function buildSelectPlan(stmt, label) {
       lines.push(`  fields:        ${joinFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : joinFields.join(", ")}`);
     }
   }
-  lines.push(...collectSubqueryPlans(stmt));
+  lines.push(...collectSubqueryPlans(stmt, capabilities, orderPlans));
   return lines;
 }
-function buildUnionPlan(stmt) {
+function buildUnionPlan(stmt, capabilities, orderPlans) {
   const selects = [];
   const collect = (u) => {
     if (u.type === "SELECT") {
@@ -9267,24 +10536,25 @@ function buildUnionPlan(stmt) {
   const lines = [];
   selects.forEach((sel, i) => {
     if (i > 0) lines.push("");
-    lines.push(...buildSelectPlan(sel, `[union:${i + 1}]`));
+    lines.push(...buildSelectPlan(sel, `[union:${i + 1}]`, capabilities, orderPlans));
   });
   return lines;
 }
-function buildWithPlan(stmt) {
+function buildWithPlan(stmt, capabilities, orderPlans) {
   const lines = [];
   for (const cte of stmt.ctes) {
     if (cte.query.type === "SELECT") {
-      lines.push(...buildSelectPlan(cte.query, `[cte: ${cte.name}]`));
+      lines.push(...buildSelectPlan(cte.query, `[cte: ${cte.name}]`, capabilities, orderPlans));
       lines.push("");
     }
   }
   if (stmt.query.type === "SELECT" || stmt.query.type === "UNION") {
-    lines.push(...buildExplainPlan(stmt.query, "[main]"));
+    lines.push(...buildExplainPlan(stmt.query, "[main]", capabilities, orderPlans));
   }
   if (canInlineSingleCte(stmt)) {
     lines.push("");
-    lines.push(...buildSelectPlan(buildInlinedQuery(stmt), "[effective: inlined CTE]"));
+    const inlined = buildInlinedQuery(stmt);
+    lines.push(...buildSelectPlan(inlined, "[effective: inlined CTE]", capabilities, orderPlans));
   }
   return lines;
 }
@@ -9312,7 +10582,7 @@ function collectFullScanReasons(stmt) {
     r.push("ORDER BY \u306B\u5F0F");
   return r;
 }
-function collectSubqueryPlans(stmt) {
+function collectSubqueryPlans(stmt, capabilities, orderPlans) {
   const lines = [];
   let idx = 1;
   const visitWhere = (w) => {
@@ -9321,16 +10591,16 @@ function collectSubqueryPlans(stmt) {
       case "BINARY":
         if (w.right.type === "SCALAR_SUBQUERY") {
           lines.push("");
-          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`));
+          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`, capabilities, orderPlans));
         }
         if (w.right.type === "SUBQUERY_IN_LIST") {
           lines.push("");
-          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`));
+          lines.push(...buildSelectPlan(w.right.query, `[subquery:${idx++}]`, capabilities, orderPlans));
         }
         break;
       case "EXISTS":
         lines.push("");
-        lines.push(...buildSelectPlan(w.query, `[subquery:${idx++}]`));
+        lines.push(...buildSelectPlan(w.query, `[subquery:${idx++}]`, capabilities, orderPlans));
         break;
       case "LOGICAL":
         visitWhere(w.left);
@@ -9348,7 +10618,7 @@ function collectSubqueryPlans(stmt) {
   for (const col of stmt.columns) {
     if (col.type === "SCALAR_SUBQUERY_COL") {
       lines.push("");
-      lines.push(...buildSelectPlan(col.query, `[subquery:${idx++}]`));
+      lines.push(...buildSelectPlan(col.query, `[subquery:${idx++}]`, capabilities, orderPlans));
     }
   }
   if (stmt.having) visitWhere(stmt.having);
@@ -9366,7 +10636,7 @@ function buildInsertPlan(stmt, label) {
   lines.push(`  fields:  ${stmt.fields.join(", ")}`);
   return lines;
 }
-function buildInsertSelectPlan(stmt, label) {
+function buildInsertSelectPlan(stmt, label, capabilities, orderPlans) {
   const lines = [];
   if (label) lines.push(label);
   lines.push(`  [INSERT SELECT]`);
@@ -9374,10 +10644,10 @@ function buildInsertSelectPlan(stmt, label) {
   lines.push(`  fields:  ${stmt.fields.join(", ")}`);
   lines.push(`  api:     POST /k/v1/records.json\uFF08\u4EF6\u6570\u306F SELECT \u7D50\u679C\u306B\u4F9D\u5B58\u3001100 \u4EF6\u3054\u3068\u306B\u30D0\u30C3\u30C1\uFF09`);
   lines.push("");
-  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]"));
+  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans));
   return lines;
 }
-function buildUpdatePlan(stmt, label) {
+function buildUpdatePlan(stmt, label, capabilities, orderPlans) {
   const isArith = hasArithAssignment(stmt);
   const isSubq = stmt.assignments.some((a) => a.value.type === "SCALAR_SUBQUERY");
   const lines = [];
@@ -9411,7 +10681,7 @@ function buildUpdatePlan(stmt, label) {
   for (const a of stmt.assignments) {
     if (a.value.type === "SCALAR_SUBQUERY") {
       lines.push("");
-      lines.push(...buildSelectPlan(a.value.query, `[subquery: ${a.field}]`));
+      lines.push(...buildSelectPlan(a.value.query, `[subquery: ${a.field}]`, capabilities, orderPlans));
     }
   }
   return lines;
@@ -9438,7 +10708,7 @@ function buildUpsertPlan(stmt, label) {
     `  api:        GET /k/v1/records.json\uFF08\u91CD\u8907\u5224\u5B9A\uFF09\u2192 POST \u307E\u305F\u306F PUT /k/v1/records.json \xD7 ${batchCount}`
   ];
 }
-function buildUpsertSelectPlan(stmt, label) {
+function buildUpsertSelectPlan(stmt, label, capabilities, orderPlans) {
   const lines = [
     ...label ? [label] : [],
     `  [UPSERT SELECT]`,
@@ -9448,7 +10718,7 @@ function buildUpsertSelectPlan(stmt, label) {
     `  api:        GET /k/v1/records.json\uFF08\u91CD\u8907\u5224\u5B9A\uFF09\u2192 POST \u307E\u305F\u306F PUT /k/v1/records.json\uFF08100 \u4EF6\u3054\u3068\u306B\u30D0\u30C3\u30C1\uFF09`,
     ``
   ];
-  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]"));
+  lines.push(...buildSelectPlan(stmt.select, "[source SELECT]", capabilities, orderPlans));
   return lines;
 }
 function buildReorderPlan(stmt, label) {
@@ -9990,12 +11260,14 @@ function flattenFormFieldProperties(properties) {
 function flattenFields(properties, lookupCopyFields, inSubtable = false) {
   const out = [];
   for (const field of Object.values(properties)) {
-    out.push({
+    const optionOrder = toOptionOrderMap(field.options);
+    const sortKind = detectSortKind(field.type, field.format);
+    const info = {
       code: field.code,
       label: field.label,
       fieldType: field.type,
-      optionOrder: toOptionOrderMap(field.options),
-      sortKind: detectSortKind(field.type, field.format),
+      optionOrder,
+      sortKind,
       required: field.required,
       minValue: normalizeConstraintValue(field.minValue),
       maxValue: normalizeConstraintValue(field.maxValue),
@@ -10004,7 +11276,9 @@ function flattenFields(properties, lookupCopyFields, inSubtable = false) {
       defaultValue: field.defaultValue,
       inSubtable,
       writable: !lookupCopyFields.has(field.code) && !NON_WRITABLE_FIELD_TYPES2.has(field.type)
-    });
+    };
+    info.semantics = resolveFieldSemantics(info);
+    out.push(info);
     if (field.fields) out.push(...flattenFields(field.fields, lookupCopyFields, true));
   }
   return out;
@@ -10059,6 +11333,18 @@ function detectSortKind(fieldType, calcFormat) {
   return void 0;
 }
 
+// src/core/processStatus.ts
+function normalizeProcessStatusStates(states) {
+  if (states === null) return null;
+  return Object.values(states).map((state) => {
+    const index = Number(state.index);
+    if (!Number.isSafeInteger(index) || index < 0) {
+      throw new Error(`ArgumentError: invalid process status index: ${String(state.index)}`);
+    }
+    return { name: state.name, index };
+  });
+}
+
 // src/cli/nodeKintoneClient.ts
 var SEARCH_ABORTED_HEADER_VALUE = "Filter aborted because of too many search results";
 function createNodeKintoneClient(baseUrl, tokenResolver) {
@@ -10256,7 +11542,7 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
       const res = await requestJson(`${apiBasePath}/app/status.json?${qs.toString()}`, { method: "GET" }, appId);
       return {
         enable: res.enable,
-        states: Object.values(res.states ?? {}).map((state) => state.name)
+        states: normalizeProcessStatusStates(res.states)
       };
     }
   };
@@ -10726,7 +12012,7 @@ Options:
                              (batch + json: prints one JSON envelope for the whole batch)
   --max-records <n>          Max records to fetch (default: 500)
   --fetch-parallel <n>       Parallel page fetches per query: 1-10 (default: 3)
-  --on-limit <mode>          On record limit: error | truncate
+  --on-limit <mode>          On record limit: error | truncate (local ORDER BY needs complete input)
   --temp-table-max-rows <n>  Max rows per temp table (default: 10000, always errors on overflow)
   --timeout <ms>             Request timeout in milliseconds (default: 30000)
   --max-concurrent <n>       Max concurrent kintone requests: 1-50 (default: 10)
@@ -12010,7 +13296,7 @@ async function run() {
   let isBatchSql = false;
   let batchContainsDml = false;
   let batchAnalysis = null;
-  let needsCompleteInput = false;
+  let dryRunNeedsMetadata = false;
   if (args.diagRecordId === null) {
     sql = args.executeSql;
     if (!sql && args.filePath) sql = (0, import_fs2.readFileSync)(args.filePath, "utf-8");
@@ -12037,17 +13323,16 @@ async function run() {
     }
     try {
       const statements = parseSqlStatements(sql);
+      dryRunNeedsMetadata = statements.some(explainNeedsAppMetadata);
       if (statements.length > 1) {
         batchAnalysis = analyzeBatch(statements);
         isBatchSql = true;
         batchContainsDml = batchAnalysis.containsDml;
-        needsCompleteInput = batchAnalysis.requiresCompleteInput;
       } else {
         const stmt = parseSqlStatement(sql);
         parsedStmt = stmt;
         stmtType = getStatementType(stmt);
         isDmlStatement = writesKintone(stmt);
-        needsCompleteInput = requiresCompleteInput(stmt);
         hasWhere = hasWhereClause(stmt);
         insertValuesCount = getInsertValuesCount(stmt);
         const supported = stmtType === "SELECT" || stmtType === "UNION" || stmtType === "WITH" || stmtType === "EXPLAIN" || stmtType === "SHOW_APPS" || stmtType === "DESCRIBE" || stmtType === "ASSERT" || isDmlType(stmtType);
@@ -12094,10 +13379,13 @@ async function run() {
   const yes = args.yes || envBool("KSQL_YES") === true || Boolean(profile.dml?.yes);
   const allowWithoutWhere = args.allowWithoutWhere || envBool("KSQL_ALLOW_WITHOUT_WHERE") === true || Boolean(profile.dml?.allowWithoutWhere);
   const dmlMaxRows = args.dmlMaxRows ?? envInt2("KSQL_DML_MAX_ROWS") ?? profile.dml?.maxRows ?? 100;
-  const dmlForcesOnLimitError = needsCompleteInput;
-  const effectiveOnLimit = dmlForcesOnLimitError ? "error" : onLimit;
-  if (dmlForcesOnLimitError && onLimit === "truncate" && !quiet && !args.dryRun) {
-    process.stderr.write(isDmlStatement || batchContainsDml ? "note: onLimit=truncate is ignored for DML (forced to error)\n" : "note: onLimit=truncate is ignored for VALIDATE ONLY (forced to error)\n");
+  const isValidationOnly = batchAnalysis?.containsValidationOnly === true || parsedStmt !== null && typeof parsedStmt === "object" && "validateOnly" in parsedStmt && parsedStmt.validateOnly === true;
+  const surfaceForcesOnLimitError = isDmlStatement || batchContainsDml || isValidationOnly;
+  const effectiveOnLimit = surfaceForcesOnLimitError ? "error" : onLimit;
+  if (surfaceForcesOnLimitError && onLimit === "truncate" && !quiet && !args.dryRun) {
+    const reason = isDmlStatement || batchContainsDml ? "DML" : "VALIDATE ONLY";
+    process.stderr.write(`note: onLimit=truncate is ignored for ${reason} (forced to error)
+`);
   }
   if (format === "markdown" && noHeader) {
     process.stderr.write("ArgumentError: --no-header cannot be used with --format markdown|md.\n");
@@ -12128,30 +13416,6 @@ async function run() {
       process.stderr.write("ArgumentError: DML is disabled. Use --allow-dml to enable UPDATE/DELETE/INSERT/UPSERT/REORDER.\n");
       return 2;
     }
-    if (args.dryRun) {
-      let plans;
-      try {
-        plans = buildBatchExplainPlans(sql, args.variables);
-      } catch (err) {
-        const restored = sourceSql && sqlDiagnosticContext ? restoreSqlContextError(err, sourceSql, {
-          bindings: sqlDiagnosticContext.appBindingByMappedApp,
-          rewriteSegments: sqlDiagnosticContext.rewriteSegments
-        }) : err;
-        process.stderr.write(`${restored instanceof Error ? restored.message : String(restored)}
-`);
-        return toExitCodeFromError(restored);
-      }
-      const out = [];
-      const restoredStatements = sqlDiagnosticContext ? restoreSqlDiagnosticValue(plans.statements, sqlDiagnosticContext.appBindingByMappedApp) : plans.statements;
-      restoredStatements.forEach((p) => {
-        if (p.index > 0) out.push("");
-        out.push(`[${p.index + 1}] ${p.type}`);
-        out.push(...p.plan);
-      });
-      process.stdout.write(`${out.join("\n")}
-`);
-      return 0;
-    }
   }
   if (isDmlStatement) {
     if (hasProfileSyntax && stmtType === "DELETE") {
@@ -12178,7 +13442,7 @@ async function run() {
     appProfileByApp.set(appId, appBindingByMappedApp.get(appId)?.profile ?? profileName.toLowerCase());
   }
   const cacheContext = buildCacheContext(profileName, appBindingByMappedApp);
-  if (args.dryRun) {
+  if (args.dryRun && !dryRunNeedsMetadata) {
     client = createDryRunClient();
   } else {
     for (const explicitProfile of appProfileByApp.values()) {
@@ -12412,6 +13676,29 @@ async function run() {
       maxDelayMs: args.retryMaxDelay ?? profile.query?.retryMaxDelayMs
     })));
   }
+  if (isBatchSql && args.dryRun) {
+    try {
+      const plans = await buildBatchExplainPlans(sql, client, args.variables, cacheContext, maxRecords);
+      const out = [];
+      const restoredStatements = sqlDiagnosticContext ? restoreSqlDiagnosticValue(plans.statements, sqlDiagnosticContext.appBindingByMappedApp) : plans.statements;
+      restoredStatements.forEach((p) => {
+        if (p.index > 0) out.push("");
+        out.push(`[${p.index + 1}] ${p.type}`);
+        out.push(...p.plan);
+      });
+      process.stdout.write(`${out.join("\n")}
+`);
+      return 0;
+    } catch (err) {
+      const restored = sourceSql && sqlDiagnosticContext ? restoreSqlContextError(err, sourceSql, {
+        bindings: sqlDiagnosticContext.appBindingByMappedApp,
+        rewriteSegments: sqlDiagnosticContext.rewriteSegments
+      }) : err;
+      process.stderr.write(`${restored instanceof Error ? restored.message : String(restored)}
+`);
+      return toExitCodeFromError(restored);
+    }
+  }
   try {
     if (isDmlStatement && !args.dryRun) {
       const stmtAppId = parsedStmt && typeof parsedStmt === "object" && typeof parsedStmt.appId === "number" ? parsedStmt.appId : appIds[0];