@rex0220/kintone-sql-tools 2.4.0 → 2.6.0

package/dist-cli/ksql.js

@@ -3508,52 +3508,93 @@ function resolveFieldRef(row, field) {
 }
 
 // src/engine/evalWhere.ts
-function evalWhere(expr, row) {
+function evalWhere(expr, row, resolveFieldType) {
   switch (expr.type) {
     case "BINARY":
-      return evalBinary(expr, row);
+      return evalBinary(expr, row, resolveFieldType);
     case "NULL_CHECK":
       return evalNullCheck(expr, row);
     case "LOGICAL":
-      return evalLogical(expr, row);
+      return evalLogical(expr, row, resolveFieldType);
     case "NOT":
-      return !evalWhere(expr.expr, row);
+      return !evalWhere(expr.expr, row, resolveFieldType);
     case "GROUP":
-      return evalWhere(expr.expr, row);
+      return evalWhere(expr.expr, row, resolveFieldType);
     case "EXISTS": {
       const exists = expr.resolved;
       return expr.not ? !exists : exists;
     }
   }
 }
-function evalBinary(expr, row) {
-  const left = resolveField(expr.left, row);
-  return evalOp(expr.op, left, expr.right, row);
+function evalBinary(expr, row, resolveFieldType) {
+  const left = resolveField(expr.left, row, resolveFieldType);
+  const fieldType = expr.left.type === "FIELD" ? resolveFieldType?.(expr.left) : void 0;
+  return evalOp(expr.op, left, expr.right, row, fieldType, resolveFieldType);
 }
-function evalOp(op, leftStr, right, row) {
+function evalOp(op, leftStr, right, row, fieldType, resolveFieldType) {
   if (op === "IN" || op === "NOT_IN") {
+    let values = null;
     if (right.type === "IN_LIST") {
       assertResolvedInListValues2(right.values);
-      const contains = right.values.some((v) => leftStr === String(v.value));
-      return op === "IN" ? contains : !contains;
+      values = new Set(right.values.map((v) => String(v.value)));
     }
     if (right.type === "SUBQUERY_IN_LIST") {
-      const contains = right.resolved.has(leftStr);
-      return op === "IN" ? contains : !contains;
+      values = right.resolved;
     }
-    return op === "NOT_IN";
+    if (values === null) return op === "NOT_IN";
+    const contains = typedInContains(leftStr, values, fieldType);
+    return op === "IN" ? contains : !contains;
   }
   if (op === "LIKE") {
-    const pattern = resolveValue(right, row);
+    const pattern = resolveValue(right, row, resolveFieldType);
     return matchLike(leftStr, pattern);
   }
   if (op === "NOT_LIKE") {
-    const pattern = resolveValue(right, row);
+    const pattern = resolveValue(right, row, resolveFieldType);
     return !matchLike(leftStr, pattern);
   }
-  const rightStr = resolveValue(right, row);
+  const rightStr = resolveValue(right, row, resolveFieldType);
   return compareScalarValues(op, leftStr, rightStr);
 }
+var STRING_ARRAY_FIELD_TYPES = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
+var OBJECT_ARRAY_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "STATUS_ASSIGNEE"
+]);
+var SINGLE_OBJECT_FIELD_TYPES = /* @__PURE__ */ new Set(["CREATOR", "MODIFIER"]);
+function typedInContains(leftStr, values, fieldType) {
+  const fallback = () => values.has(leftStr);
+  if (fieldType === void 0) return fallback();
+  let parsed;
+  if (STRING_ARRAY_FIELD_TYPES.has(fieldType) || OBJECT_ARRAY_FIELD_TYPES.has(fieldType) || SINGLE_OBJECT_FIELD_TYPES.has(fieldType)) {
+    try {
+      parsed = JSON.parse(leftStr);
+    } catch {
+      return fallback();
+    }
+  } else {
+    return fallback();
+  }
+  if (STRING_ARRAY_FIELD_TYPES.has(fieldType)) {
+    if (!Array.isArray(parsed) || !parsed.every((item) => typeof item === "string")) {
+      return fallback();
+    }
+    if (parsed.length === 0 && values.has("")) return true;
+    return parsed.some((item) => values.has(item));
+  }
+  if (OBJECT_ARRAY_FIELD_TYPES.has(fieldType)) {
+    if (!Array.isArray(parsed) || !parsed.every(hasStringCode)) return fallback();
+    if (parsed.length === 0 && values.has("")) return true;
+    return parsed.some((item) => values.has(item.code));
+  }
+  if (!hasStringCode(parsed)) return fallback();
+  return values.has(parsed.code);
+}
+function hasStringCode(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && typeof value.code === "string";
+}
 function assertResolvedInListValues2(values) {
   const unresolved = values.find((item) => item.type === "VARIABLE");
   if (unresolved?.type === "VARIABLE") {
@@ -3564,20 +3605,20 @@ function evalNullCheck(expr, row) {
   const val = resolveField(expr.field, row);
   return expr.not ? val !== "" : val === "";
 }
-function evalLogical(expr, row) {
+function evalLogical(expr, row, resolveFieldType) {
   if (expr.op === "AND") {
-    return evalWhere(expr.left, row) && evalWhere(expr.right, row);
+    return evalWhere(expr.left, row, resolveFieldType) && evalWhere(expr.right, row, resolveFieldType);
   }
-  return evalWhere(expr.left, row) || evalWhere(expr.right, row);
+  return evalWhere(expr.left, row, resolveFieldType) || evalWhere(expr.right, row, resolveFieldType);
 }
-function resolveField(field, row) {
+function resolveField(field, row, resolveFieldType) {
   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);
+  if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType);
   const key = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
   return resolveFieldRef(row, key);
 }
-function resolveValue(value, row) {
+function resolveValue(value, row, resolveFieldType) {
   switch (value.type) {
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${value.name}.`);
@@ -3600,14 +3641,14 @@ function resolveValue(value, row) {
       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);
+      return evalCaseWhen(value.expr, row, resolveFieldType);
     case "ARRAY":
       return value.elements.map((e) => e.value).join(",");
   }
 }
-function evalCaseWhen(expr, row) {
+function evalCaseWhen(expr, row, resolveFieldType) {
   for (const branch of expr.branches) {
-    if (evalWhere(branch.condition, row)) {
+    if (evalWhere(branch.condition, row, resolveFieldType)) {
       return evalCaseResult(branch.result, row);
     }
   }
@@ -4158,8 +4199,11 @@ async function resolveDmlTargetIds(getRecords, app, query, options) {
 function extractSafePushdownLeaves(where, options = {}) {
   return extractAndLeaves(where, (expr) => isSafeComparison(expr, options));
 }
-function extractNumericPushdownCandidates(where, options = {}) {
-  return extractAndLeaves(where, (expr) => isNumericCandidate(expr, options));
+function extractTypedPushdownCandidates(where, options = {}) {
+  return extractAndLeaves(
+    where,
+    (expr) => isNumericCandidate(expr, options) || isSelectionInCandidate(expr, options)
+  );
 }
 function extractAndLeaves(where, accept) {
   switch (where.type) {
@@ -4183,8 +4227,27 @@ function extractAndLeaves(where, accept) {
 }
 function isSafeComparison(expr, options) {
   if (isSafeIdComparison(expr, options)) return true;
-  if (!isNumericCandidate(expr, options)) return false;
-  return options.fieldTypes?.get(expr.left.field) === "NUMBER";
+  if (isNumericCandidate(expr, options)) {
+    return options.fieldTypes?.get(expr.left.field) === "NUMBER";
+  }
+  return isSelectionInComparison(expr, options);
+}
+var SELECTION_IN_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "DROP_DOWN",
+  "RADIO_BUTTON",
+  "CHECK_BOX",
+  "MULTI_SELECT"
+]);
+function isSelectionInComparison(expr, options) {
+  if (!isSelectionInCandidate(expr, options)) return false;
+  if (expr.left.type !== "FIELD" || expr.right.type !== "IN_LIST") return false;
+  const fieldType = options.fieldTypes?.get(expr.left.field);
+  if (fieldType === void 0 || !SELECTION_IN_FIELD_TYPES.has(fieldType)) return false;
+  const validOptions = options.fieldOptions?.get(expr.left.field);
+  if (validOptions === void 0) return false;
+  return expr.right.values.every(
+    (value) => value.type === "STRING" && value.value !== "" && validOptions.has(value.value)
+  );
 }
 function isSafeIdComparison(expr, options) {
   if (!isTargetIdField(expr.left, options)) return false;
@@ -4204,6 +4267,13 @@ function isNumericCandidate(expr, options) {
   if (expr.op === "=") return true;
   return (expr.op === "<" || expr.op === ">") && Number.isSafeInteger(expr.right.value);
 }
+function isSelectionInCandidate(expr, options) {
+  if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
+  if (!isTargetField(expr.left, options)) return false;
+  if (expr.op !== "IN" && expr.op !== "NOT_IN") return false;
+  if (expr.right.type !== "IN_LIST" || expr.right.values.length === 0) return false;
+  return expr.right.values.every((value) => value.type === "STRING" && value.value !== "");
+}
 function isTargetField(field, options) {
   const targetAlias = options.tableAlias ?? null;
   if (field.tableAlias === targetAlias) return true;
@@ -4215,7 +4285,7 @@ function flatten(record, alias) {
   const row = {};
   for (const [field, fv] of Object.entries(record)) {
     const val = fv.value;
-    const strVal = typeof val === "string" ? val : JSON.stringify(val ?? "");
+    const strVal = val == null ? "" : typeof val === "string" ? val : JSON.stringify(val);
     if (alias) {
       row[`${alias}.${field}`] = strVal;
       row[field] = strVal;
@@ -4274,9 +4344,9 @@ function applyJoin(leftRows, rightRows, join2) {
   }
   return result;
 }
-function applyFilter(rows, where) {
+function applyFilter(rows, where, resolveFieldType) {
   if (where === null) return rows;
-  return rows.filter((row) => evalWhere(where, row));
+  return rows.filter((row) => evalWhere(where, row, resolveFieldType));
 }
 function hasAggregateColumns(columns) {
   return columns.some(
@@ -4402,9 +4472,9 @@ function aggregateSyntheticName2(func, distinct, arg) {
   const argStr = aggregateArgLabel(arg);
   return distinct ? `${func}(DISTINCT ${argStr})` : `${func}(${argStr})`;
 }
-function applyHaving(rows, having) {
+function applyHaving(rows, having, resolveFieldType) {
   if (having === null) return rows;
-  return rows.filter((row) => evalWhere(having, row));
+  return rows.filter((row) => evalWhere(having, row, resolveFieldType));
 }
 function applyDistinct(rows, columns) {
   if (rows.length === 0) return rows;
@@ -4529,7 +4599,7 @@ function applyLimit(rows, limit, offset) {
   if (limit === null) return rows.slice(start);
   return rows.slice(start, start + limit);
 }
-function project(rows, columns, scalarCache) {
+function project(rows, columns, scalarCache, resolveFieldType) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
     const projected2 = rows.map((row) => stripParentShortcutColumns(row));
     const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [];
@@ -4590,7 +4660,7 @@ function project(rows, columns, scalarCache) {
         }
         case "CASE_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? "case";
-          out[key] = evalCaseWhen(col.expr, row);
+          out[key] = evalCaseWhen(col.expr, row, resolveFieldType);
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
@@ -4726,7 +4796,15 @@ function resolveAggInStringFuncExpr(expr, rows) {
   };
 }
 function runFullScan(input) {
-  const { stmt, tables, scalarCache, optionOrders, sortKinds } = input;
+  const {
+    stmt,
+    tables,
+    scalarCache,
+    optionOrders,
+    sortKinds,
+    fieldTypeResolver,
+    havingFieldTypeResolver
+  } = input;
   let rows = [];
   const mainAlias = stmt.from.alias;
   const mainRecords = tables.get(mainAlias) ?? tables.get(null) ?? [];
@@ -4737,17 +4815,17 @@ function runFullScan(input) {
     const rightRows = rightRecords.map((r) => flatten(r, rightAlias));
     rows = applyJoin(rows, rightRows, join2);
   }
-  rows = applyFilter(rows, stmt.where);
+  rows = applyFilter(rows, stmt.where, fieldTypeResolver);
   if (stmt.groupBy.length > 0 || hasAggregateColumns(stmt.columns)) {
     rows = applyGroupBy(rows, stmt.groupBy, stmt.columns);
   }
-  rows = applyHaving(rows, stmt.having);
+  rows = applyHaving(rows, stmt.having, havingFieldTypeResolver);
   if (stmt.distinct) {
     rows = applyDistinct(rows, stmt.columns);
   }
   rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds);
   rows = applyLimit(rows, stmt.limit, stmt.offset);
-  return project(rows, stmt.columns, scalarCache);
+  return project(rows, stmt.columns, scalarCache, fieldTypeResolver);
 }
 
 // src/converter/subtableAdapter.ts
@@ -5280,6 +5358,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache) {
   if (isNoFromSelect(stmt)) {
     return executeNoFromSelect(stmt);
   }
+  await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
   const mode = resolveSelectMode(stmt);
   await validateSelectFieldCodes(stmt, mode, client, cacheContext);
   if (mode === "SIMPLE") {
@@ -5338,6 +5417,8 @@ function executeNoFromSelect(stmt) {
 }
 async function executeSimpleSelect(stmt, client, options, cacheContext) {
   const params = selectToKintoneParams(stmt);
+  const typedInFieldTypes = await loadTypedInFieldTypes(stmt, client, cacheContext);
+  const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const onLimit = options.onLimitReached ?? "error";
@@ -5374,7 +5455,12 @@ async function executeSimpleSelect(stmt, client, options, cacheContext) {
     rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds);
     rows = applyLimit(rows, stmt.limit, stmt.offset);
   }
-  const { rows: projected, columns } = project(rows, stmt.columns);
+  const { rows: projected, columns } = project(
+    rows,
+    stmt.columns,
+    void 0,
+    fieldTypeResolvers.row
+  );
   return { type: "SELECT", rows: projected, columns, rowCount: projected.length, warnings: [...warnings] };
 }
 async function validateSelectFieldCodes(stmt, mode, client, cacheContext) {
@@ -5409,44 +5495,160 @@ async function validateSelectFieldCodes(stmt, mode, client, cacheContext) {
     }
   }
 }
-function extractMainSafePushdown(stmt, fieldTypes) {
+function extractMainSafePushdown(stmt, fieldTypes, fieldOptions) {
   if (stmt.where === null || stmt.from.subtableCode || stmt.from.cteName !== null) return null;
   if (stmt.joins.length === 0) {
     return extractSafePushdownLeaves(stmt.where, {
       tableAlias: stmt.from.alias ?? void 0,
       allowUnqualifiedFields: true,
-      fieldTypes
+      fieldTypes,
+      fieldOptions
     });
   }
   if (!stmt.from.alias) return null;
-  return extractSafePushdownLeaves(stmt.where, { tableAlias: stmt.from.alias, fieldTypes });
+  return extractSafePushdownLeaves(stmt.where, {
+    tableAlias: stmt.from.alias,
+    fieldTypes,
+    fieldOptions
+  });
 }
-function extractMainNumericPushdownCandidate(stmt) {
+function extractMainTypedPushdownCandidate(stmt) {
   if (stmt.where === null || stmt.from.subtableCode || stmt.from.cteName !== null) return null;
   if (stmt.joins.length === 0) {
-    return extractNumericPushdownCandidates(stmt.where, {
+    return extractTypedPushdownCandidates(stmt.where, {
       tableAlias: stmt.from.alias ?? void 0,
       allowUnqualifiedFields: true
     });
   }
   if (!stmt.from.alias) return null;
-  return extractNumericPushdownCandidates(stmt.where, { tableAlias: stmt.from.alias });
+  return extractTypedPushdownCandidates(stmt.where, { tableAlias: stmt.from.alias });
 }
-async function loadNumericPushdownFieldTypes(stmt, client, cacheContext) {
+async function loadTypedPushdownMeta(stmt, client, cacheContext) {
   const appIds = /* @__PURE__ */ new Set();
-  if (extractMainNumericPushdownCandidate(stmt) !== null) appIds.add(stmt.from.appId);
+  if (extractMainTypedPushdownCandidate(stmt) !== null) appIds.add(stmt.from.appId);
   if (stmt.where !== null) {
     for (const join2 of stmt.joins) {
       if (!join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
-      const candidate = extractNumericPushdownCandidates(stmt.where, {
+      const candidate = extractTypedPushdownCandidates(stmt.where, {
         tableAlias: join2.table.alias
       });
       if (candidate !== null) appIds.add(join2.table.appId);
     }
   }
+  const entries = await Promise.all([...appIds].map(async (appId) => {
+    const [fieldTypes, fieldOptions] = await Promise.all([
+      getFieldTypeMap(appId, client, cacheContext),
+      getFieldOptionSetMapByApp(appId, client, cacheContext)
+    ]);
+    return [appId, fieldTypes, fieldOptions];
+  }));
+  return {
+    fieldTypesByApp: new Map(entries.map(([appId, fieldTypes]) => [appId, fieldTypes])),
+    fieldOptionsByApp: new Map(entries.map(([appId, , fieldOptions]) => [appId, fieldOptions]))
+  };
+}
+function collectTypedInFieldRefs(expr, out) {
+  if (expr === null) return;
+  switch (expr.type) {
+    case "BINARY":
+      if ((expr.op === "IN" || expr.op === "NOT_IN") && expr.left.type === "FIELD") {
+        out.push(expr.left);
+      }
+      if (expr.left.type === "CASE_FIELD") collectCaseTypedInFieldRefs(expr.left.expr, out);
+      if (expr.right.type === "CASE_VALUE") collectCaseTypedInFieldRefs(expr.right.expr, out);
+      return;
+    case "LOGICAL":
+      collectTypedInFieldRefs(expr.left, out);
+      collectTypedInFieldRefs(expr.right, out);
+      return;
+    case "NOT":
+    case "GROUP":
+      collectTypedInFieldRefs(expr.expr, out);
+      return;
+    case "NULL_CHECK":
+    case "EXISTS":
+      return;
+  }
+}
+function collectCaseTypedInFieldRefs(expr, out) {
+  for (const branch of expr.branches) collectTypedInFieldRefs(branch.condition, out);
+}
+function collectSelectTypedInFieldRefs(stmt) {
+  const refs = [];
+  collectTypedInFieldRefs(stmt.where, refs);
+  collectTypedInFieldRefs(stmt.having, refs);
+  for (const column of stmt.columns) {
+    if (column.type === "CASE_COL") collectCaseTypedInFieldRefs(column.expr, refs);
+  }
+  return refs;
+}
+function findTableForAlias(stmt, alias) {
+  return [stmt.from, ...stmt.joins.map((join2) => join2.table)].find((table) => table.alias === alias);
+}
+function physicalSelectTables(stmt) {
+  return [stmt.from, ...stmt.joins.map((join2) => join2.table)].filter((table) => table.cteName === null);
+}
+async function loadTypedInFieldTypes(stmt, client, cacheContext) {
+  const refs = collectSelectTypedInFieldRefs(stmt);
+  if (refs.length === 0) return /* @__PURE__ */ new Map();
+  const appIds = /* @__PURE__ */ new Set();
+  const physicalTables = physicalSelectTables(stmt);
+  for (const ref of refs) {
+    if (ref.tableAlias !== null) {
+      if (ref.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
+        appIds.add(stmt.from.appId);
+        continue;
+      }
+      const table = findTableForAlias(stmt, ref.tableAlias);
+      if (table && table.cteName === null) appIds.add(table.appId);
+      continue;
+    }
+    if (stmt.joins.length === 0) {
+      if (stmt.from.cteName === null) appIds.add(stmt.from.appId);
+      continue;
+    }
+    for (const table of physicalTables) appIds.add(table.appId);
+  }
   const entries = await Promise.all([...appIds].map(async (appId) => [appId, await getFieldTypeMap(appId, client, cacheContext)]));
   return new Map(entries);
 }
+function fieldCodeForTypeLookup(table, field) {
+  if (table.subtableCode && field.startsWith("_p.")) return field.slice(3);
+  return field;
+}
+function buildSelectFieldTypeResolvers(stmt, fieldTypesByApp) {
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const physicalTables = tables.filter((table) => table.cteName === null);
+  const outputAliases = new Set(
+    stmt.columns.map((column) => "alias" in column ? column.alias : null).filter((alias) => alias !== null)
+  );
+  const row = (field) => {
+    if (field.tableAlias !== null) {
+      if (field.tableAlias === "_p" && stmt.from.subtableCode && stmt.from.cteName === null) {
+        return fieldTypesByApp.get(stmt.from.appId)?.get(field.field);
+      }
+      const table2 = tables.find((candidate) => candidate.alias === field.tableAlias);
+      if (!table2 || table2.cteName !== null) return void 0;
+      return fieldTypesByApp.get(table2.appId)?.get(fieldCodeForTypeLookup(table2, field.field));
+    }
+    if (stmt.joins.length === 0) {
+      if (stmt.from.cteName !== null) return void 0;
+      return fieldTypesByApp.get(stmt.from.appId)?.get(fieldCodeForTypeLookup(stmt.from, field.field));
+    }
+    if (tables.some((table2) => table2.cteName !== null)) return void 0;
+    const matches = physicalTables.filter(
+      (table2) => fieldTypesByApp.get(table2.appId)?.has(fieldCodeForTypeLookup(table2, field.field))
+    );
+    if (matches.length !== 1) return void 0;
+    const table = matches[0];
+    return fieldTypesByApp.get(table.appId)?.get(fieldCodeForTypeLookup(table, field.field));
+  };
+  const having = (field) => {
+    if (field.tableAlias === null && outputAliases.has(field.field)) return void 0;
+    return row(field);
+  };
+  return { row, having };
+}
 async function executeFullScanSelect(stmt, client, options, cacheContext, cteCache) {
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
@@ -5455,10 +5657,15 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     resolveSubqueries(stmt.where, client, options, cacheContext, cteCache),
     resolveSubqueries(stmt.having, client, options, cacheContext, cteCache)
   ]);
-  const pushdownFieldTypes = await loadNumericPushdownFieldTypes(stmt, client, cacheContext);
+  const [pushdownMeta, typedInFieldTypes] = await Promise.all([
+    loadTypedPushdownMeta(stmt, client, cacheContext),
+    loadTypedInFieldTypes(stmt, client, cacheContext)
+  ]);
+  const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
   const mainPushDown = extractMainSafePushdown(
     stmt,
-    pushdownFieldTypes.get(stmt.from.appId)
+    pushdownMeta.fieldTypesByApp.get(stmt.from.appId),
+    pushdownMeta.fieldOptionsByApp.get(stmt.from.appId)
   );
   const tableConditions = /* @__PURE__ */ new Map();
   if (stmt.where !== null) {
@@ -5466,7 +5673,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
       if (!join2.table.alias || join2.table.subtableCode || join2.table.cteName !== null) continue;
       const cond = extractSafePushdownLeaves(stmt.where, {
         tableAlias: join2.table.alias,
-        fieldTypes: pushdownFieldTypes.get(join2.table.appId)
+        fieldTypes: pushdownMeta.fieldTypesByApp.get(join2.table.appId),
+        fieldOptions: pushdownMeta.fieldOptionsByApp.get(join2.table.appId)
       });
       if (cond) tableConditions.set(join2.table.alias, cond);
     }
@@ -5544,7 +5752,15 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   }));
   const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds } = await orderByMetaPromise;
-  const { rows, columns } = runFullScan({ tables, stmt, scalarCache, optionOrders, sortKinds });
+  const { rows, columns } = runFullScan({
+    tables,
+    stmt,
+    scalarCache,
+    optionOrders,
+    sortKinds,
+    fieldTypeResolver: fieldTypeResolvers.row,
+    havingFieldTypeResolver: fieldTypeResolvers.having
+  });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
 async function executeUnion(stmt, client, options, cacheContext) {
@@ -5700,8 +5916,11 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const parallel = options.fetchParallel ?? 1;
   await Promise.all([
     resolveSubqueries(stmt.where, client, options, cacheContext, cteCache),
-    resolveSubqueries(stmt.having, client, options, cacheContext, cteCache)
+    resolveSubqueries(stmt.having, client, options, cacheContext, cteCache),
+    resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache)
   ]);
+  const typedInFieldTypes = await loadTypedInFieldTypes(stmt, client, cacheContext);
+  const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
   const scalarCachePromise = resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
   const orderByMetaPromise = buildOrderByMetaForSelect(stmt, client, cacheContext);
   scalarCachePromise.catch(() => {
@@ -5756,7 +5975,15 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   await Promise.all(joinFetches);
   const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds } = await orderByMetaPromise;
-  const { rows, columns } = runFullScan({ tables, stmt, scalarCache, optionOrders, sortKinds });
+  const { rows, columns } = runFullScan({
+    tables,
+    stmt,
+    scalarCache,
+    optionOrders,
+    sortKinds,
+    fieldTypeResolver: fieldTypeResolvers.row,
+    havingFieldTypeResolver: fieldTypeResolvers.having
+  });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
 function processRowToKintoneRecord(row) {
@@ -5988,6 +6215,15 @@ async function getOptionOrderMapByApp(appId, client, cacheContext) {
   setScopedCacheValue(optionOrderCache, cacheContext, appId, map);
   return map;
 }
+async function getFieldOptionSetMapByApp(appId, client, cacheContext) {
+  const optionOrders = await getOptionOrderMapByApp(appId, client, cacheContext);
+  return new Map(
+    [...optionOrders.entries()].map(([fieldCode, order]) => [
+      fieldCode,
+      new Set(order.keys())
+    ])
+  );
+}
 async function getSortKindMapByApp(appId, client, cacheContext) {
   const cached = getScopedCacheValue(sortKindCache, cacheContext, appId);
   if (cached) return cached;
@@ -6253,6 +6489,16 @@ async function executeUpsert(stmt, client, options, cacheContext) {
     updatedCount: toUpdate.length
   };
 }
+async function buildSubtableFieldTypeResolver(appId, typedInRefs, client, cacheContext) {
+  if (typedInRefs.length === 0) return void 0;
+  const fieldTypes = await getFieldTypeMap(appId, client, cacheContext);
+  return (field) => {
+    if (field.tableAlias !== null && field.tableAlias !== "_p") return void 0;
+    if (field.tableAlias === "_p") return fieldTypes.get(field.field);
+    const code = field.field.startsWith("_p.") ? field.field.slice(3) : field.field;
+    return fieldTypes.get(code);
+  };
+}
 async function executeInsertSubtable(stmt, client, options, _cacheContext) {
   const subtableCode = stmt.subtableCode;
   const pidIndex = stmt.fields.indexOf("_pid");
@@ -6293,11 +6539,24 @@ async function executeInsertSubtable(stmt, client, options, _cacheContext) {
   }
   return { type: "INSERT", createdIds: [], insertedCount: stmt.values.length };
 }
-async function executeUpdateSubtable(stmt, client, options, _cacheContext) {
+async function executeUpdateSubtable(stmt, client, options, cacheContext) {
   const subtableCode = stmt.subtableCode;
   if (!hasRidCondition(stmt.where)) {
     throw new Error("\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306B\u306F _rid \u6761\u4EF6\u304C\u5FC5\u9808\u3067\u3059");
   }
+  const typedInRefs = [];
+  collectTypedInFieldRefs(stmt.where, typedInRefs);
+  for (const assignment of stmt.assignments) {
+    if (assignment.value.type === "CASE_VALUE") {
+      collectCaseTypedInFieldRefs(assignment.value.expr, typedInRefs);
+    }
+  }
+  const resolveFieldType = await buildSubtableFieldTypeResolver(
+    stmt.appId,
+    typedInRefs,
+    client,
+    cacheContext
+  );
   const parents = await fetchAll(
     client.getRecords,
     stmt.appId,
@@ -6306,7 +6565,7 @@ async function executeUpdateSubtable(stmt, client, options, _cacheContext) {
     { maxRecords: options.maxRecords ?? 1e4, parallel: options.fetchParallel ?? 1 }
   );
   const expanded = expandRowsForSubtableDml(parents, subtableCode);
-  const targets = expanded.filter((r) => evalWhere(stmt.where, r.flat));
+  const targets = expanded.filter((r) => evalWhere(stmt.where, r.flat, resolveFieldType));
   if (options.confirm) {
     const ok = await options.confirm(targets.length, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", targets.length);
@@ -6326,7 +6585,7 @@ async function executeUpdateSubtable(stmt, client, options, _cacheContext) {
       if (a.field.startsWith("_")) {
         throw new Error(`\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u3067\u30B7\u30B9\u30C6\u30E0\u5217\u300C${a.field}\u300D\u306F\u66F4\u65B0\u3067\u304D\u307E\u305B\u3093`);
       }
-      updates[a.field] = { value: evalAssignmentValueForSubtable(a.value, t.flat) };
+      updates[a.field] = { value: evalAssignmentValueForSubtable(a.value, t.flat, resolveFieldType) };
     }
     byRid.set(t.rowId, updates);
   }
@@ -6348,11 +6607,19 @@ async function executeUpdateSubtable(stmt, client, options, _cacheContext) {
   }
   return { type: "UPDATE", updatedCount: targets.length };
 }
-async function executeDeleteSubtable(stmt, client, options, _cacheContext) {
+async function executeDeleteSubtable(stmt, client, options, cacheContext) {
   const subtableCode = stmt.subtableCode;
   if (!hasRidCondition(stmt.where)) {
     throw new Error("\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB DELETE \u306B\u306F _rid \u6761\u4EF6\u304C\u5FC5\u9808\u3067\u3059");
   }
+  const typedInRefs = [];
+  collectTypedInFieldRefs(stmt.where, typedInRefs);
+  const resolveFieldType = await buildSubtableFieldTypeResolver(
+    stmt.appId,
+    typedInRefs,
+    client,
+    cacheContext
+  );
   const parents = await fetchAll(
     client.getRecords,
     stmt.appId,
@@ -6361,7 +6628,7 @@ async function executeDeleteSubtable(stmt, client, options, _cacheContext) {
     { maxRecords: options.maxRecords ?? 1e4, parallel: options.fetchParallel ?? 1 }
   );
   const expanded = expandRowsForSubtableDml(parents, subtableCode);
-  const targets = expanded.filter((r) => evalWhere(stmt.where, r.flat));
+  const targets = expanded.filter((r) => evalWhere(stmt.where, r.flat, resolveFieldType));
   if (options.confirm) {
     const ok = await options.confirm(targets.length, "DELETE");
     if (!ok) throw new OperationCancelledError("DELETE", targets.length);
@@ -6476,11 +6743,11 @@ function buildSubtableReorderPutParams(appId, parentId, revision, subtableCode,
     ]
   };
 }
-function evalAssignmentValueForSubtable(value, row) {
+function evalAssignmentValueForSubtable(value, row, resolveFieldType) {
   if (value.type === "STRING") return value.value;
   if (value.type === "NUMBER") return String(value.value);
   if (value.type === "ARITH") return String(evalArithExpr(value, row));
-  if (value.type === "CASE_VALUE") return evalCaseWhen(value.expr, row);
+  if (value.type === "CASE_VALUE") return evalCaseWhen(value.expr, row, resolveFieldType);
   throw new Error(`${value.type} \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306E\u5024\u3068\u3057\u3066\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
 }
 function valueToString(value) {
@@ -6512,7 +6779,15 @@ function hasRidCondition(where) {
       return false;
   }
 }
-async function executeReorder(stmt, client, options, _cacheContext) {
+async function executeReorder(stmt, client, options, cacheContext) {
+  const typedInRefs = [];
+  collectTypedInFieldRefs(stmt.where, typedInRefs);
+  const resolveFieldType = await buildSubtableFieldTypeResolver(
+    stmt.appId,
+    typedInRefs,
+    client,
+    cacheContext
+  );
   const parents = await fetchAll(
     client.getRecords,
     stmt.appId,
@@ -6521,7 +6796,7 @@ 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)).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)).map((r) => r.parentId));
   if (options.confirm) {
     const ok = await options.confirm(targetParentIds.size, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", targetParentIds.size);
@@ -6666,6 +6941,16 @@ async function resolveSubqueries(where, client, options, cacheContext, cteCache)
   collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCache);
   await Promise.all(tasks);
 }
+async function resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache) {
+  const tasks = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "CASE_COL") continue;
+    for (const branch of column.expr.branches) {
+      tasks.push(resolveSubqueries(branch.condition, client, options, cacheContext, cteCache));
+    }
+  }
+  await Promise.all(tasks);
+}
 function runSubquery(query, client, options, cacheContext, cteCache) {
   if (cteCache !== void 0 && cteCache.size > 0) {
     return executeQueryWithCte(query, client, options, cteCache, cacheContext);
@@ -6898,12 +7183,12 @@ function buildSelectPlan(stmt, label) {
     const mainFields = selectToFetchAllFields(stmt, stmt.from);
     const mainAliasStr = stmt.from.alias ? ` AS ${stmt.from.alias}` : "";
     const mainPushDown = extractMainSafePushdown(stmt);
-    const mainCandidate = extractMainNumericPushdownCandidate(stmt);
+    const mainCandidate = extractMainTypedPushdownCandidate(stmt);
     const mainQ = mainPushDown !== null ? whereToKintone(mainPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
     lines.push(`  app:           APP${stmt.from.appId}${mainAliasStr} (${stmt.from.appId})`);
     lines.push(`  kintone query: ${mainQ}`);
     if (mainCandidate !== null) {
-      lines.push(`  pushdown candidate: ${whereToKintone(mainCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u78BA\u8A8D\u5F85\u3061\uFF09`);
+      lines.push(`  pushdown candidate: ${whereToKintone(mainCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
     }
     lines.push(`  fields:        ${mainFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : mainFields.join(", ")}`);
     for (const join2 of stmt.joins) {
@@ -6911,12 +7196,12 @@ function buildSelectPlan(stmt, label) {
       const joinAliasStr = join2.table.alias ? ` AS ${join2.table.alias}` : "";
       const joinType = join2.type === "INNER" ? "JOIN" : `${join2.type} JOIN`;
       const joinPushDown = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractSafePushdownLeaves(stmt.where, { tableAlias: join2.table.alias }) : null;
-      const joinCandidate = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractNumericPushdownCandidates(stmt.where, { tableAlias: join2.table.alias }) : null;
+      const joinCandidate = join2.table.alias && !join2.table.subtableCode && join2.table.cteName === null && stmt.where ? extractTypedPushdownCandidates(stmt.where, { tableAlias: join2.table.alias }) : null;
       const joinQ = joinPushDown !== null ? whereToKintone(joinPushDown) : "(\u5168\u4EF6\u53D6\u5F97)";
       lines.push(`  ${joinType}:        APP${join2.table.appId}${joinAliasStr} (${join2.table.appId})`);
       lines.push(`  kintone query: ${joinQ}`);
       if (joinCandidate !== null) {
-        lines.push(`  pushdown candidate: ${whereToKintone(joinCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u78BA\u8A8D\u5F85\u3061\uFF09`);
+        lines.push(`  pushdown candidate: ${whereToKintone(joinCandidate)}\uFF08\u5B9F\u884C\u6642\u306E\u578B\u30FB\u5B9F\u5728\u78BA\u8A8D\u5F85\u3061\uFF09`);
       }
       lines.push(`  fields:        ${joinFields.length === 0 ? "(\u5168\u30D5\u30A3\u30FC\u30EB\u30C9)" : joinFields.join(", ")}`);
     }
@@ -7595,6 +7880,42 @@ function clampInt(v, min, max) {
   return Math.max(min, Math.min(max, Math.trunc(v)));
 }
 
+// src/core/formFieldInfo.ts
+function flattenFormFieldProperties(properties) {
+  const out = [];
+  for (const field of Object.values(properties)) {
+    out.push({
+      code: field.code,
+      label: field.label,
+      fieldType: field.type,
+      optionOrder: toOptionOrderMap(field.options),
+      sortKind: detectSortKind(field.type, field.format)
+    });
+    if (field.fields) out.push(...flattenFormFieldProperties(field.fields));
+  }
+  return out;
+}
+function toOptionOrderMap(options) {
+  if (!options || typeof options !== "object") return void 0;
+  const order = {};
+  let hasAny = false;
+  for (const [label, meta] of Object.entries(options)) {
+    const n = Number(meta?.index);
+    if (!Number.isFinite(n)) continue;
+    order[label] = n;
+    hasAny = true;
+  }
+  return hasAny ? order : void 0;
+}
+function detectSortKind(fieldType, calcFormat) {
+  if (fieldType === "NUMBER" || fieldType === "RECORD_NUMBER") return "number";
+  if (fieldType === "CALC") {
+    if (calcFormat === "NUMBER" || calcFormat === "NUMBER_DIGIT") return "number";
+    return "string";
+  }
+  return void 0;
+}
+
 // src/cli/nodeKintoneClient.ts
 function createNodeKintoneClient(baseUrl, tokenResolver) {
   const normalizedBaseUrl = baseUrl.replace(/\/+$/, "");
@@ -7773,36 +8094,10 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
         { method: "GET" },
         appId
       );
-      return Object.values(res.properties).map((f) => ({
-        code: f.code,
-        label: f.label,
-        fieldType: f.type,
-        optionOrder: toOptionOrderMap(f.options),
-        sortKind: detectSortKind(f.type, f.format)
-      }));
+      return flattenFormFieldProperties(res.properties);
     }
   };
 }
-function toOptionOrderMap(options) {
-  if (!options || typeof options !== "object") return void 0;
-  const order = {};
-  let hasAny = false;
-  for (const [label, meta] of Object.entries(options)) {
-    const n = Number(meta?.index);
-    if (!Number.isFinite(n)) continue;
-    order[label] = n;
-    hasAny = true;
-  }
-  return hasAny ? order : void 0;
-}
-function detectSortKind(fieldType, calcFormat) {
-  if (fieldType === "NUMBER" || fieldType === "RECORD_NUMBER") return "number";
-  if (fieldType === "CALC") {
-    if (calcFormat === "NUMBER" || calcFormat === "NUMBER_DIGIT") return "number";
-    return "string";
-  }
-  return void 0;
-}
 
 // src/node/appProfiles.ts
 var import_fs = require("fs");