@rex0220/kintone-sql-tools 2.3.0 → 2.5.0

package/dist-cli/ksql.js

@@ -599,13 +599,14 @@ var Parser = class {
         const upper = tok.value.toUpperCase();
         if (upper === "CREATE") return this.parseCreateTempTable();
         if (upper === "DROP") return this.parseDropTempTable();
+        if (upper === "DECLARE") return this.parseDeclareVariable();
         break;
       }
       default:
         break;
     }
     throw new ParseError(
-      "SELECT / INSERT / UPDATE / DELETE / REORDER / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / SET / ASSERT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
+      "SELECT / INSERT / UPDATE / DELETE / REORDER / WITH / SHOW / DESCRIBE / EXPLAIN / CREATE TEMP TABLE / DROP TEMP TABLE / SET / DECLARE / ASSERT \u306E\u3044\u305A\u308C\u304B\u3067\u59CB\u307E\u308B SQL \u6587\u304C\u5FC5\u8981\u3067\u3059",
       tok
     );
   }
@@ -616,19 +617,32 @@ var Parser = class {
     this.expect("SET" /* SET */);
     const variable = this.expect("VARIABLE" /* VARIABLE */, "SET \u306E\u5F8C\u306B\u306F\u5909\u6570\u540D\uFF08\u4F8B: @name\uFF09\u304C\u5FC5\u8981\u3067\u3059");
     this.expect("=" /* EQ */);
-    const expr = this.parseScalarExpr();
+    const expr = this.parseScalarExpr("SET", true);
     return { type: "SET_VARIABLE", name: variable.value.slice(1).toLowerCase(), expr };
   }
-  /** SET RHS 専用。既存式パーサーで構文を読み、フィールド参照を明示的に拒否する。 */
-  parseScalarExpr() {
+  parseDeclareVariable() {
+    this.advance();
+    const variable = this.expect("VARIABLE" /* VARIABLE */, "DECLARE \u306E\u5F8C\u306B\u306F\u5909\u6570\u540D\uFF08\u4F8B: @name\uFF09\u304C\u5FC5\u8981\u3067\u3059");
+    this.expect("=" /* EQ */);
+    const expr = this.parseScalarExpr("DECLARE", false);
+    if (expr.type === "SCALAR_SUBQUERY") {
+      throw new ParseError("DECLARE \u306E\u65E2\u5B9A\u5024\u306B\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", this.peek());
+    }
+    return { type: "DECLARE_VARIABLE", name: variable.value.slice(1).toLowerCase(), default: expr };
+  }
+  /** SET / DECLARE RHS 専用。既存式パーサーで構文を読み、フィールド参照を明示的に拒否する。 */
+  parseScalarExpr(context, allowScalarSubquery) {
     const tok = this.peek();
     if (tok.kind === "VARIABLE" /* VARIABLE */) {
-      throw new ParseError("SET \u306E\u53F3\u8FBA\u3067\u306F\u4ED6\u306E\u5909\u6570\u3092\u53C2\u7167\u3067\u304D\u307E\u305B\u3093\uFF08Phase 1a\uFF09", tok);
+      throw new ParseError(`${context} \u306E\u53F3\u8FBA\u3067\u306F\u4ED6\u306E\u5909\u6570\u3092\u53C2\u7167\u3067\u304D\u307E\u305B\u3093`, tok);
     }
     if (tok.kind === "NULL" /* NULL */) {
-      throw new ParseError("SET \u306E\u53F3\u8FBA\u3067 NULL \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08Phase 1a\uFF09", tok);
+      throw new ParseError(`${context} \u306E\u53F3\u8FBA\u3067 NULL \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`, tok);
     }
     if (tok.kind === "(" /* LPAREN */ && this.peekAt(1).kind === "SELECT" /* SELECT */) {
+      if (!allowScalarSubquery) {
+        throw new ParseError("DECLARE \u306E\u65E2\u5B9A\u5024\u306B\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
       this.advance();
       const query = this.parseSelect();
       this.expect(")" /* RPAREN */);
@@ -652,7 +666,7 @@ var Parser = class {
     }
     if (tok.kind === "LOGINUSER" /* LOGINUSER */) {
       throw new ParseError(
-        "SET \u306E\u53F3\u8FBA\u3067 LOGINUSER() \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08\u5B9F\u884C\u74B0\u5883\u5171\u901A\u306E\u30ED\u30B0\u30A4\u30F3\u30E6\u30FC\u30B6\u30FC\u89E3\u6C7A\u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF09",
+        `${context} \u306E\u53F3\u8FBA\u3067 LOGINUSER() \u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093\uFF08\u5B9F\u884C\u74B0\u5883\u5171\u901A\u306E\u30ED\u30B0\u30A4\u30F3\u30E6\u30FC\u30B6\u30FC\u89E3\u6C7A\u306F\u672A\u5BFE\u5FDC\u3067\u3059\uFF09`,
         tok
       );
     }
@@ -660,22 +674,22 @@ var Parser = class {
       return this.parseSqlValue();
     }
     const expr = this.parseArithAddSub();
-    this.rejectNonScalarExpr(expr, tok);
+    this.rejectNonScalarExpr(expr, tok, context);
     if (expr.type === "NUMBER" || expr.type === "STRING_FUNC" || expr.type === "ARITH") return expr;
-    throw new ParseError("SET \u306E\u53F3\u8FBA\u306B\u306F\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u542B\u307E\u306A\u3044\u30B9\u30AB\u30E9\u30FC\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044", tok);
+    throw new ParseError(`${context} \u306E\u53F3\u8FBA\u306B\u306F\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u542B\u307E\u306A\u3044\u30B9\u30AB\u30E9\u30FC\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044`, tok);
   }
-  rejectNonScalarExpr(node, tok) {
+  rejectNonScalarExpr(node, tok, context) {
     if (node.type === "STRING" || node.type === "NUMBER") return;
     if (node.type === "FIELD_REF" || node.type === "AGG_REF") {
-      throw new ParseError("SET \u306E\u53F3\u8FBA\u3067\u306F\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u30FB\u96C6\u8A08\u95A2\u6570\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      throw new ParseError(`${context} \u306E\u53F3\u8FBA\u3067\u306F\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u30FB\u96C6\u8A08\u95A2\u6570\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`, tok);
     }
     if (node.type === "ARITH" || node.type === "AGG_ARITH") {
-      this.rejectNonScalarExpr(node.left, tok);
-      this.rejectNonScalarExpr(node.right, tok);
+      this.rejectNonScalarExpr(node.left, tok, context);
+      this.rejectNonScalarExpr(node.right, tok, context);
       return;
     }
     if (node.type === "STRING_FUNC") {
-      for (const arg of node.args) this.rejectNonScalarExpr(arg, tok);
+      for (const arg of node.args) this.rejectNonScalarExpr(arg, tok, context);
     }
   }
   // ----------------------------------------------------------
@@ -2301,7 +2315,7 @@ function isDmlType(type) {
   return type === "INSERT" || type === "INSERT_SELECT" || type === "UPDATE" || type === "DELETE" || type === "UPSERT" || type === "UPSERT_SELECT" || type === "REORDER";
 }
 function isReadOnlyType(type) {
-  return type === "SELECT" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "SET_VARIABLE" || type === "ASSERT";
+  return type === "SELECT" || type === "UNION" || type === "WITH" || type === "EXPLAIN" || type === "SHOW_APPS" || type === "DESCRIBE" || type === "CREATE_TEMP_TABLE" || type === "DROP_TEMP_TABLE" || type === "SET_VARIABLE" || type === "DECLARE_VARIABLE" || type === "ASSERT";
 }
 function hasWhereClause(stmt) {
   if (!stmt || typeof stmt !== "object") return false;
@@ -2375,8 +2389,9 @@ function analyzeBatch(statements) {
   }
   if (statements.length === 1) {
     const t = statements[0].type;
-    if (t === "SET_VARIABLE") {
-      throw new BatchAnalysisError("ArgumentError: SET variable requires a batch.", 0);
+    if (t === "SET_VARIABLE" || t === "DECLARE_VARIABLE") {
+      const verb = t === "SET_VARIABLE" ? "SET" : "DECLARE";
+      throw new BatchAnalysisError(`ArgumentError: ${verb} variable requires a batch.`, 0);
     }
     if (t === "CREATE_TEMP_TABLE" || t === "DROP_TEMP_TABLE") {
       const verb = t === "CREATE_TEMP_TABLE" ? "CREATE TEMP TABLE" : "DROP TEMP TABLE";
@@ -2410,7 +2425,7 @@ function analyzeBatch(statements) {
       }
       def.referencedBy.push(index);
     }
-    if (stmt.type === "SET_VARIABLE") {
+    if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
       if (variableDefs.has(stmt.name)) {
         throw new BatchAnalysisError(`ParseError: variable @${stmt.name} is already defined.`, index);
       }
@@ -2507,6 +2522,40 @@ function analyzeBatch(statements) {
   };
 }
 
+// src/core/batchVariables.ts
+var VARIABLE_NAME_RE = /^[A-Za-z_][A-Za-z0-9_]{0,63}$/;
+function normalizeBatchVariableName(name) {
+  if (!VARIABLE_NAME_RE.test(name)) {
+    throw new Error(
+      `ArgumentError: invalid variable name "${name}". Use a name without @ matching [A-Za-z_][A-Za-z0-9_]{0,63}.`
+    );
+  }
+  return name.toLowerCase();
+}
+function normalizeBatchVariables(input) {
+  const normalized = /* @__PURE__ */ Object.create(null);
+  for (const [rawName, value] of Object.entries(input ?? {})) {
+    const name = normalizeBatchVariableName(rawName);
+    if (Object.prototype.hasOwnProperty.call(normalized, name)) {
+      throw new Error(`ArgumentError: variable "${rawName}" is specified more than once.`);
+    }
+    normalized[name] = value;
+  }
+  return normalized;
+}
+function validateDeclaredBatchVariables(statements, input) {
+  const normalized = normalizeBatchVariables(input);
+  const declared = new Set(
+    statements.filter((stmt) => stmt.type === "DECLARE_VARIABLE").map((stmt) => stmt.name)
+  );
+  for (const name of Object.keys(normalized)) {
+    if (!declared.has(name)) {
+      throw new Error(`ArgumentError: injected variable @${name} is not declared.`);
+    }
+  }
+  return normalized;
+}
+
 // src/core/scalarCompare.ts
 function compareScalarValues(op, leftStr, rightStr) {
   if (op === "=") return leftStr === rightStr;
@@ -3459,52 +3508,91 @@ 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();
+    }
+    return parsed.some((item) => values.has(item));
+  }
+  if (OBJECT_ARRAY_FIELD_TYPES.has(fieldType)) {
+    if (!Array.isArray(parsed) || !parsed.every(hasStringCode)) return fallback();
+    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") {
@@ -3515,20 +3603,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}.`);
@@ -3551,14 +3639,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);
     }
   }
@@ -4225,9 +4313,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(
@@ -4353,9 +4441,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;
@@ -4480,7 +4568,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]) : [];
@@ -4541,7 +4629,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;
         }
@@ -4677,7 +4765,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) ?? [];
@@ -4688,17 +4784,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
@@ -4838,6 +4934,8 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
       throw new Error("ArgumentError: DROP TEMP TABLE requires a batch (temp tables are batch-scoped).");
     case "SET_VARIABLE":
       throw new Error("ArgumentError: SET variable requires a batch.");
+    case "DECLARE_VARIABLE":
+      throw new Error("ArgumentError: DECLARE variable requires a batch.");
     case "ASSERT":
       return executeAssert(stmt, client, options, cacheContext);
   }
@@ -4851,6 +4949,8 @@ var BatchTimeoutError = class extends Error {
 async function executeBatch(sql, client, options = {}) {
   const statements = parseSqlBatch(sql);
   const analysis = analyzeBatch(statements);
+  const injectedVariables = validateDeclaredBatchVariables(statements, options.variables);
+  const batchOptions = { ...options, variables: injectedVariables };
   if (options.continueOnError && analysis.containsDml) {
     throw new Error("ArgumentError: continueOnError is not allowed for batches containing DML.");
   }
@@ -4895,16 +4995,16 @@ async function executeBatch(sql, client, options = {}) {
     }
     try {
       const remaining = deadline !== null ? deadline - Date.now() : null;
-      const userConfirm = options.confirm;
+      const userConfirm = batchOptions.confirm;
       const stmtOptions = userConfirm ? {
-        ...options,
+        ...batchOptions,
         confirm: (count, operation) => userConfirm(count, operation, {
           statementIndex: i,
           statementCount: statements.length,
           statementType: info.statementType,
           targetAppId: info.targetAppId
         })
-      } : options;
+      } : batchOptions;
       const outcome = await runWithDeadline(
         executeBatchStatement(statements[i], info, countedClient, stmtOptions, cacheContext, tempTables, variables),
         remaining
@@ -4917,7 +5017,7 @@ async function executeBatch(sql, client, options = {}) {
         aborted = "timeout";
       } else if (e instanceof AssertError) {
         aborted = "assertion";
-      } else if (info.statementType === "SET_VARIABLE") {
+      } else if (info.statementType === "SET_VARIABLE" || info.statementType === "DECLARE_VARIABLE") {
         aborted = "fail-fast";
       } else if (!options.continueOnError) {
         aborted = "fail-fast";
@@ -4957,6 +5057,16 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     }
     return {};
   }
+  if (stmt.type === "DECLARE_VARIABLE") {
+    const injected = options.variables ?? {};
+    if (Object.prototype.hasOwnProperty.call(injected, stmt.name)) {
+      variables.set(stmt.name, { type: "string", value: injected[stmt.name] });
+    } else {
+      const value = evaluateScalarExpr(stmt.default);
+      variables.set(stmt.name, { type: "string", value: String(value.value) });
+    }
+    return {};
+  }
   const resolvedStmt = resolveVariableRefs(stmt, variables);
   if (resolvedStmt.type === "CREATE_TEMP_TABLE") {
     const materializeOptions = {
@@ -5217,6 +5327,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") {
@@ -5275,6 +5386,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";
@@ -5311,7 +5424,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) {
@@ -5384,6 +5502,108 @@ async function loadNumericPushdownFieldTypes(stmt, client, cacheContext) {
   const entries = await Promise.all([...appIds].map(async (appId) => [appId, await getFieldTypeMap(appId, client, cacheContext)]));
   return new Map(entries);
 }
+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();
@@ -5392,7 +5612,11 @@ 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 [pushdownFieldTypes, typedInFieldTypes] = await Promise.all([
+    loadNumericPushdownFieldTypes(stmt, client, cacheContext),
+    loadTypedInFieldTypes(stmt, client, cacheContext)
+  ]);
+  const fieldTypeResolvers = buildSelectFieldTypeResolvers(stmt, typedInFieldTypes);
   const mainPushDown = extractMainSafePushdown(
     stmt,
     pushdownFieldTypes.get(stmt.from.appId)
@@ -5481,7 +5705,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) {
@@ -5637,8 +5869,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(() => {
@@ -5693,7 +5928,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) {
@@ -6190,6 +6433,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");
@@ -6230,11 +6483,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,
@@ -6243,7 +6509,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);
@@ -6263,7 +6529,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);
   }
@@ -6285,11 +6551,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,
@@ -6298,7 +6572,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);
@@ -6413,11 +6687,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) {
@@ -6449,7 +6723,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,
@@ -6458,7 +6740,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);
@@ -6603,6 +6885,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);
@@ -6682,9 +6974,10 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   pending.forEach(([i], idx) => cache.set(i, values[idx]));
   return cache;
 }
-function buildBatchExplainPlans(sql) {
+function buildBatchExplainPlans(sql, injectedVariables) {
   const statements = parseSqlBatch(sql);
   const analysis = analyzeBatch(statements);
+  validateDeclaredBatchVariables(statements, injectedVariables);
   const variables = /* @__PURE__ */ new Map();
   return {
     statementCount: statements.length,
@@ -6695,7 +6988,7 @@ function buildBatchExplainPlans(sql) {
         type: analysis.statements[i].statementType,
         plan: buildBatchStatementPlan(planStmt, analysis.statements[i])
       };
-      if (stmt.type === "SET_VARIABLE") {
+      if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
         variables.set(stmt.name, { type: "string", value: `@${stmt.name}` });
       }
       return result;
@@ -6732,6 +7025,12 @@ function buildBatchStatementPlan(stmt, info) {
       "  value:         \u5B9F\u884C\u6642\u306B1\u56DE\u8A55\u4FA1\uFF08\u30D0\u30C3\u30C1\u5185\u5B9A\u6570\u30FB\u7D50\u679C\u30E1\u30BF\u30C7\u30FC\u30BF\u306B\u306F\u975E\u516C\u958B\uFF09"
     ];
   }
+  if (stmt.type === "DECLARE_VARIABLE") {
+    return [
+      `DECLARE @${stmt.name} = <default scalar expression>`,
+      "  value:         \u5916\u90E8\u6CE8\u5165\u304C\u3042\u308C\u3070\u63A1\u7528\u3001\u306A\u3051\u308C\u3070\u65E2\u5B9A\u5024\u3092\u5B9F\u884C\u6642\u306B1\u56DE\u8A55\u4FA1\uFF08\u5024\u306F\u975E\u516C\u958B\uFF09"
+    ];
+  }
   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);
@@ -7525,6 +7824,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(/\/+$/, "");
@@ -7703,36 +8038,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");
@@ -8193,6 +8502,7 @@ Options:
   -f, --file <path>          Execute SQL file
   --console                  Start interactive console mode
   --dry-run                  Parse and show execution plan only
+  --var <name=value>         Override a DECLARE variable (repeatable; not for secrets)
   --format <type>            Output format: table | json | jsonl | csv | markdown | md
                              (batch + json: prints one JSON envelope for the whole batch)
   --max-records <n>          Max records to fetch (default: 500)
@@ -8262,6 +8572,8 @@ function parseArgs(argv) {
     password: null,
     token: null,
     tokenMap: {},
+    // `__proto__` も有効な変数名なので prototype のない辞書で保持する。
+    variables: /* @__PURE__ */ Object.create(null),
     tokenFile: null,
     app: null,
     diagRecordId: null,
@@ -8356,6 +8668,19 @@ function parseArgs(argv) {
       continue;
     }
     const v = argv[i + 1];
+    if (a === "--var") {
+      const raw = v ?? "";
+      const eq = raw.indexOf("=");
+      if (eq < 0) throw new Error("ArgumentError: --var must use name=value.");
+      const rawName = raw.slice(0, eq);
+      const name = normalizeBatchVariableName(rawName);
+      if (Object.prototype.hasOwnProperty.call(out.variables, name)) {
+        throw new Error(`ArgumentError: variable "${rawName}" is specified more than once.`);
+      }
+      out.variables[name] = raw.slice(eq + 1);
+      i++;
+      continue;
+    }
     if (a === "-e" || a === "--execute") {
       out.executeSql = v ?? "";
       i++;
@@ -8912,6 +9237,7 @@ function buildReplExecArgv(base, sql, dryRun, format) {
   const argv = ["-e", sql];
   if (dryRun) argv.push("--dry-run");
   if (format) argv.push("--format", format);
+  for (const [name, value] of Object.entries(base.variables)) argv.push("--var", `${name}=${value}`);
   pushOpt(argv, "--config", base.configPath);
   pushOpt(argv, "--profile", base.profile);
   pushOpt(argv, "--base-url", base.baseUrl);
@@ -9535,6 +9861,10 @@ async function run() {
     attachmentFormat: args.attachmentFormat ?? profile.output?.attachmentFormat ?? "full"
   };
   const appIds = sql ? extractAppIds(sql) : [];
+  if (!isBatchSql && Object.keys(args.variables).length > 0) {
+    process.stderr.write("ArgumentError: --var requires a batch containing DECLARE.\n");
+    return 2;
+  }
   const defaultApp = args.app ?? envInt2("KSQL_APP") ?? profile.app ?? null;
   if (appIds.length === 0 && defaultApp !== null) appIds.push(defaultApp);
   const allowNoFromSelect = isNoFromSelectStatement(parsedStmt) || stmtType === "SHOW_APPS";
@@ -9550,7 +9880,7 @@ async function run() {
     if (args.dryRun) {
       let plans;
       try {
-        plans = buildBatchExplainPlans(sql);
+        plans = buildBatchExplainPlans(sql, args.variables);
       } catch (err) {
         const restored = sourceSql && sqlDiagnosticContext ? restoreSqlContextError(err, sourceSql, {
           bindings: sqlDiagnosticContext.appBindingByMappedApp,
@@ -9867,6 +10197,7 @@ query=${label}`);
         continueOnError: args.continueOnError,
         tempTableMaxRows,
         timeoutMs: timeout,
+        variables: args.variables,
         confirm: batchContainsDml ? async (count, operation) => {
           if (count > dmlMaxRows) {
             throw new Error(`ArgumentError: ${operation} affected rows (${count}) exceed --dml-max-rows (${dmlMaxRows}).`);