@rex0220/kintone-sql-tools 3.3.0 → 3.5.0

package/dist-cli/ksql.js

@@ -307,6 +307,10 @@ var Lexer = class {
       this.pos += 2;
       return this.makeToken("<=" /* LTE */, "<=", start);
     }
+    if (ch === "|" && ch2 === "|") {
+      this.pos += 2;
+      return this.makeToken("||" /* CONCAT_OP */, "||", start);
+    }
     switch (ch) {
       case "=":
         this.pos++;
@@ -650,6 +654,8 @@ var Parser = class {
   constructor(tokens) {
     this.tokens = tokens;
     this.allowUnaryPlusNumber = false;
+    this.scalarAllowsAggregateArgs = true;
+    this.scalarAllowsCase = true;
     this.pos = 0;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
@@ -738,13 +744,14 @@ var Parser = class {
         if (upper === "CREATE") return this.parseCreateTempTable();
         if (upper === "DROP") return this.parseDropTempTable();
         if (upper === "DECLARE") return this.parseDeclareVariable();
+        if (upper === "VALIDATE") return this.parseValidate();
         break;
       }
       default:
         break;
     }
     throw new ParseError(
-      "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",
+      "SELECT / INSERT / UPDATE / DELETE / REORDER / VALIDATE / 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
     );
   }
@@ -755,7 +762,7 @@ 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("SET", true);
+    const expr = this.peek().kind === "[" /* LBRACKET */ ? this.parseArrayLiteral() : this.parseScalarExpr("SET", true);
     return { type: "SET_VARIABLE", name: variable.value.slice(1).toLowerCase(), expr };
   }
   parseDeclareVariable() {
@@ -818,17 +825,19 @@ var Parser = class {
   }
   rejectNonScalarExpr(node, tok, context) {
     if (node.type === "STRING" || node.type === "NUMBER") return;
-    if (node.type === "FIELD_REF" || node.type === "AGG_REF") {
+    if (node.type === "FIELD_REF" || node.type === "FIELD" || node.type === "VARIABLE" || node.type === "AGG_REF") {
       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") {
+    if (node.type === "ARITH" || node.type === "SCALAR_ARITH" || node.type === "CONCAT_OP" || node.type === "AGG_ARITH") {
       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, context);
+      return;
     }
+    throw new ParseError(`${context} \u306E\u53F3\u8FBA\u3067\u306F CASE \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`, tok);
   }
   // ----------------------------------------------------------
   // CREATE TEMP TABLE / DROP TEMP TABLE（バッチ内一時テーブル）
@@ -914,11 +923,63 @@ var Parser = class {
       query = this.parseDelete();
     } else if (tok.kind === "REORDER" /* REORDER */) {
       query = this.parseReorder();
+    } else if (tok.kind === "IDENT" /* IDENT */ && tok.value.toUpperCase() === "VALIDATE") {
+      query = this.parseValidate();
     } else {
-      throw new ParseError("EXPLAIN \u306E\u5F8C\u306B\u306F SELECT / WITH / INSERT / UPSERT / UPDATE / DELETE / REORDER \u304C\u5FC5\u8981\u3067\u3059", tok);
+      throw new ParseError("EXPLAIN \u306E\u5F8C\u306B\u306F SELECT / WITH / INSERT / UPSERT / UPDATE / DELETE / REORDER / VALIDATE \u304C\u5FC5\u8981\u3067\u3059", tok);
     }
     return { type: "EXPLAIN", query };
   }
+  /** VALIDATE APP100 [(fields)] [WHERE ...] [CHECK ...] [INTO #err]. */
+  parseValidate() {
+    const validateTok = this.advance();
+    const name = this.parseIdentifier();
+    const { appId, subtableCode } = extractTableRef(name, this.prev());
+    if (subtableCode) {
+      throw new ParseError("VALIDATE \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB\u3092\u5BFE\u8C61\u306B\u3067\u304D\u307E\u305B\u3093", this.prev());
+    }
+    let fields;
+    if (this.consume("(" /* LPAREN */)) {
+      fields = this.parseIdentList();
+      this.expect(")" /* RPAREN */);
+    }
+    const where = this.consume("WHERE" /* WHERE */) ? this.parseWhereExpr() : null;
+    const checks = this.parseCheckGroups();
+    let errorTable;
+    if (this.consume("INTO" /* INTO */)) {
+      const tableTok = this.peek();
+      if (tableTok.kind !== "IDENT" /* IDENT */ || !tableTok.value.startsWith("#")) {
+        throw new ParseError("VALIDATE INTO \u306B\u306F # \u3067\u59CB\u307E\u308B\u4E00\u6642\u30C6\u30FC\u30D6\u30EB\u540D\u304C\u5FC5\u8981\u3067\u3059", tableTok);
+      }
+      errorTable = this.parseTableName();
+    }
+    const stmt = { type: "VALIDATE", appId, fields, where, ...checks, ...errorTable ? { errorTable } : {} };
+    this.assertValidateExpressions(stmt, validateTok);
+    return stmt;
+  }
+  /** v1 VALIDATE is single-app/local: subqueries and qualified references are rejected. */
+  assertValidateExpressions(stmt, tok) {
+    const visit = (node) => {
+      if (Array.isArray(node)) {
+        node.forEach(visit);
+        return;
+      }
+      if (node === null || typeof node !== "object") return;
+      const obj = node;
+      if (obj.type === "EXISTS" || obj.type === "SUBQUERY_IN_LIST" || obj.type === "SCALAR_SUBQUERY") {
+        throw new ParseError("VALIDATE \u306E WHERE / CHECK \u306B\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      if (obj.type === "FIELD" && obj.tableAlias !== null && obj.tableAlias !== void 0) {
+        throw new ParseError("VALIDATE \u306E WHERE / CHECK \u3067\u306F\u4FEE\u98FE\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      if (obj.type === "FIELD_REF" && typeof obj.field === "string" && obj.field.includes(".")) {
+        throw new ParseError("VALIDATE \u306E WHERE / CHECK \u3067\u306F\u4FEE\u98FE\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      Object.values(obj).forEach(visit);
+    };
+    visit(stmt.where);
+    visit(stmt.checkGroups);
+  }
   // ----------------------------------------------------------
   // ASSERT
   //
@@ -1199,6 +1260,22 @@ var Parser = class {
     if (this.consume("*" /* STAR */)) {
       return { type: "WILDCARD" };
     }
+    if (this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
+      const expr = this.parseScalarValueExpr({ allowAggregateArgs: true });
+      const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
+      return { type: "SCALAR_VALUE_COL", expr, alias: alias2 };
+    }
+    if (this.peek().kind === "VARIABLE" /* VARIABLE */) {
+      const variable = this.advance();
+      if (!this.consume("AS" /* AS */)) {
+        throw new ParseError("SELECT \u5217\u306E\u30D0\u30C3\u30C1\u5909\u6570\u306B\u306F AS alias \u304C\u5FC5\u8981\u3067\u3059", this.peek());
+      }
+      return {
+        type: "VARIABLE_COL",
+        name: variable.value.slice(1).toLowerCase(),
+        alias: this.parseAliasName()
+      };
+    }
     const windowFunc = this.tryWindowFunc();
     if (windowFunc !== null) {
       return this.parseWindowColumn(windowFunc);
@@ -1314,13 +1391,25 @@ var Parser = class {
   }
   selectColumnHasAggregate(column) {
     if (column.type === "AGGREGATE" || column.type === "ARITH_AGG_COL") return true;
-    if (column.type !== "STRFUNC_COL") return false;
-    return column.expr.args.some((arg) => this.stringFuncArgHasAggregate(arg));
+    if (column.type === "STRFUNC_COL") return column.expr.args.some((arg) => this.stringFuncArgHasAggregate(arg));
+    if (column.type === "SCALAR_VALUE_COL") return this.scalarValueHasAggregate(column.expr);
+    return false;
   }
   stringFuncArgHasAggregate(arg) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
-    if (arg.type === "STRING_FUNC") {
-      return arg.args.some((nested) => this.stringFuncArgHasAggregate(nested));
+    return this.scalarValueHasAggregate(arg);
+  }
+  scalarValueHasAggregate(expr) {
+    if (expr.type === "STRING_FUNC") return expr.args.some((arg) => this.stringFuncArgHasAggregate(arg));
+    if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+      return this.scalarValueHasAggregate(expr.left) || this.scalarValueHasAggregate(expr.right);
+    }
+    if (expr.type === "CASE_WHEN") {
+      const results = [...expr.branches.map((b) => b.result), ...expr.elseResult ? [expr.elseResult] : []];
+      return results.some((result) => {
+        if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
+        return this.scalarValueHasAggregate(result);
+      });
     }
     return false;
   }
@@ -1378,6 +1467,105 @@ var Parser = class {
     throw new ParseError("\u96C6\u8A08\u7B97\u8853\u5F0F\u306B\u306F\u96C6\u8A08\u95A2\u6570\u307E\u305F\u306F\u6570\u5024\u304C\u5FC5\u8981\u3067\u3059", this.peek());
   }
   // ──────────────────────────────────────────────────
+  // 汎用スカラー値式パーサー（B38）
+  // ──────────────────────────────────────────────────
+  /** 比較・述語・集約・サブクエリを含まない値式の公開入口。 */
+  parseScalarValueExpr(options = {}) {
+    const previousAggregateArgs = this.scalarAllowsAggregateArgs;
+    const previousCase = this.scalarAllowsCase;
+    this.scalarAllowsAggregateArgs = options.allowAggregateArgs === true;
+    this.scalarAllowsCase = options.allowCase !== false;
+    let expr;
+    try {
+      expr = this.parseScalarAddSubConcat(this.scalarAllowsCase);
+    } finally {
+      this.scalarAllowsAggregateArgs = previousAggregateArgs;
+      this.scalarAllowsCase = previousCase;
+    }
+    const next = this.peek();
+    if (next.kind === "IS" /* IS */ || next.kind === "=" /* EQ */ || next.kind === "!=" /* NEQ */ || next.kind === "<>" /* LT_GT */ || next.kind === ">" /* GT */ || next.kind === "<" /* LT */ || next.kind === ">=" /* GTE */ || next.kind === "<=" /* LTE */ || next.kind === "LIKE" /* LIKE */ || next.kind === "KLIKE" /* KLIKE */ || next.kind === "IN" /* IN */ || next.kind === "BETWEEN" /* BETWEEN */) throw new ParseError("\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u306B\u6BD4\u8F03\u30FB\u8FF0\u8A9E\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", next);
+    return expr;
+  }
+  parseScalarAddSubConcat(allowCase) {
+    let left = this.parseScalarMulDiv(allowCase);
+    while (this.peek().kind === "+" /* PLUS */ || this.peek().kind === "-" /* MINUS */ || this.peek().kind === "||" /* CONCAT_OP */) {
+      const token = this.advance();
+      const right = this.parseScalarMulDiv(allowCase);
+      left = token.kind === "||" /* CONCAT_OP */ ? { type: "CONCAT_OP", left, right } : { type: "SCALAR_ARITH", left, op: token.kind === "+" /* PLUS */ ? "+" : "-", right };
+    }
+    return left;
+  }
+  parseScalarMulDiv(allowCase) {
+    let left = this.parseScalarPrimary(allowCase);
+    while (this.peek().kind === "*" /* STAR */ || this.peek().kind === "/" /* SLASH */ || this.peek().kind === "%" /* PERCENT */) {
+      const token = this.advance();
+      const op = token.kind === "*" /* STAR */ ? "*" : token.kind === "/" /* SLASH */ ? "/" : "%";
+      left = { type: "SCALAR_ARITH", left, op, right: this.parseScalarPrimary(allowCase) };
+    }
+    return left;
+  }
+  parseScalarPrimary(allowCase) {
+    const tok = this.peek();
+    if (tok.kind === "(" /* LPAREN */) {
+      if (this.peekAt(1).kind === "SELECT" /* SELECT */) throw new ParseError("\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u306B\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      this.advance();
+      const expr = this.parseScalarAddSubConcat(allowCase);
+      this.expect(")" /* RPAREN */);
+      return expr;
+    }
+    if (tok.kind === "+" /* PLUS */ || tok.kind === "-" /* MINUS */) {
+      this.advance();
+      if (this.peek().kind === "+" /* PLUS */ || this.peek().kind === "-" /* MINUS */) {
+        throw new ParseError("\u5358\u9805\u7B26\u53F7\u3092\u91CD\u306D\u3066\u6307\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093", this.peek());
+      }
+      const operand = this.parseScalarPrimary(allowCase);
+      if (operand.type === "NUMBER") {
+        return makeNumberLiteral(`${tok.kind === "-" /* MINUS */ ? "-" : "+"}${numberLiteralText(operand)}`);
+      }
+      if (tok.kind === "+" /* PLUS */) throw new ParseError("\u5358\u9805 + \u306E\u76F4\u5F8C\u306B\u306F\u6570\u5024\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059", tok);
+      return { type: "SCALAR_ARITH", left: makeNumberLiteral("0"), op: "-", right: operand };
+    }
+    if (tok.kind === "STRING" /* STRING */) {
+      this.advance();
+      return { type: "STRING", value: tok.value };
+    }
+    if (tok.kind === "NUMBER" /* NUMBER */) {
+      this.advance();
+      return makeNumberLiteral(tok.value);
+    }
+    if (tok.kind === "VARIABLE" /* VARIABLE */) {
+      this.advance();
+      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+    }
+    if (tok.kind === "CASE" /* CASE */) {
+      if (!allowCase) throw new ParseError("\u3053\u306E\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u3067\u306F CASE \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      return this.parseCaseWhenExpr();
+    }
+    if (this.tryAggregateFunc() !== null) throw new ParseError("\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u306B\u96C6\u7D04\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+    if (this.tryStringFuncName() !== null) return this.parseStringFuncExpr();
+    if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) {
+      this.advance();
+      if (this.consume("." /* DOT */)) return { type: "FIELD", tableAlias: tok.value, field: this.parseIdentifier() };
+      return { type: "FIELD", tableAlias: null, field: tok.value };
+    }
+    throw new ParseError("\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u306E\u30AA\u30DA\u30E9\u30F3\u30C9\u304C\u5FC5\u8981\u3067\u3059", tok);
+  }
+  /** 現在の値の終端までに指定トークンがあるか（括弧内も対象）。 */
+  hasTopLevelTokenBeforeValueEnd(target) {
+    let depth = 0;
+    for (let i = this.pos; i < this.tokens.length; i++) {
+      const kind = this.tokens[i].kind;
+      if (kind === "(" /* LPAREN */ || kind === "[" /* LBRACKET */) depth++;
+      else if (kind === ")" /* RPAREN */ || kind === "]" /* RBRACKET */) {
+        if (depth === 0) break;
+        depth--;
+      }
+      if (kind === target) return true;
+      if (depth === 0 && (kind === "," /* COMMA */ || kind === "AS" /* AS */ || kind === "FROM" /* FROM */ || kind === "WHERE" /* WHERE */ || kind === "WHEN" /* WHEN */ || kind === "THEN" /* THEN */ || kind === "ELSE" /* ELSE */ || kind === "END" /* END */ || kind === ";" /* SEMICOLON */ || kind === "EOF" /* EOF */)) break;
+    }
+    return false;
+  }
+  // ──────────────────────────────────────────────────
   // 算術式パーサー（演算子優先順位: * / > + -）
   //
   //   parseArithAddSub   : + -（左結合・低優先度）
@@ -1499,12 +1687,15 @@ var Parser = class {
     this.expect("END" /* END */);
     return { type: "CASE_WHEN", branches, elseResult };
   }
-  /** THEN / ELSE の結果値: 文字列リテラル / 配列リテラル / 文字列関数 / 算術式 */
+  /** THEN / ELSE の結果値。`||` を含む場合だけ新スカラー文法へ渡す。 */
   parseCaseResult() {
     const tok = this.peek();
     if (tok.kind === "[" /* LBRACKET */) {
       return this.parseArrayLiteral();
     }
+    if (this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
+      return this.parseScalarValueExpr({ allowAggregateArgs: true });
+    }
     if (tok.kind === "STRING" /* STRING */) {
       this.advance();
       return { type: "STRING", value: tok.value };
@@ -1652,25 +1843,19 @@ var Parser = class {
     }
     return { type: "STRING", value: normalized };
   }
-  /** 文字列関数の引数: 文字列リテラル / ネスト文字列関数 / 算術式 / 集計算術式 */
+  /** 文字列関数の引数: ScalarValueExpr / 集計算術式 */
   parseStringFuncArg() {
-    const tok = this.peek();
-    if (tok.kind === "STRING" /* STRING */) {
-      this.advance();
-      return { type: "STRING", value: tok.value };
-    }
-    if (this.tryStringFuncName() !== null) {
-      return this.parseStringFuncExpr();
-    }
-    const startPos = this.pos;
-    try {
-      const left = this.parseAggPrimary();
-      const expr = this.continueAggArith(left);
-      if (this.hasAggregateOperand(expr)) return expr;
-    } catch {
+    if (this.scalarAllowsAggregateArgs) {
+      const startPos = this.pos;
+      try {
+        const left = this.parseAggPrimary();
+        const expr = this.continueAggArith(left);
+        if (this.hasAggregateOperand(expr)) return expr;
+      } catch {
+      }
+      this.pos = startPos;
     }
-    this.pos = startPos;
-    return this.parseArithAddSub();
+    return this.parseScalarAddSubConcat(this.scalarAllowsCase);
   }
   hasAggregateOperand(node) {
     if (node.type === "AGG_REF") return true;
@@ -1758,6 +1943,7 @@ var Parser = class {
     const k = this.peek().kind;
     if (k === "IDENT" /* IDENT */ || k === "BIDENT" /* BIDENT */) {
       if (k === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === "VALIDATE" && this.peekAt(1).kind === "IDENT" /* IDENT */ && this.peekAt(1).value.toUpperCase() === "ONLY") return null;
+      if (k === "IDENT" /* IDENT */ && this.peek().value.toUpperCase() === "CHECK" && this.peekAt(1).kind === "WHEN" /* WHEN */) return null;
       return this.parseTableAliasName();
     }
     return null;
@@ -1905,9 +2091,7 @@ var Parser = class {
     }
     if (this.consume("NOT" /* NOT */)) {
       if (this.consume("IN" /* IN */)) {
-        this.expect("(" /* LPAREN */);
-        const right2 = this.parseInListOrSubquery();
-        this.expect(")" /* RPAREN */);
+        const right2 = this.parseInRight();
         return { type: "BINARY", op: "NOT_IN", left: field, right: right2 };
       }
       if (this.consume("LIKE" /* LIKE */)) {
@@ -1924,9 +2108,7 @@ var Parser = class {
       );
     }
     if (this.consume("IN" /* IN */)) {
-      this.expect("(" /* LPAREN */);
-      const right2 = this.parseInListOrSubquery();
-      this.expect(")" /* RPAREN */);
+      const right2 = this.parseInRight();
       return { type: "BINARY", op: "IN", left: field, right: right2 };
     }
     if (this.consume("KLIKE" /* KLIKE */)) {
@@ -2093,6 +2275,18 @@ var Parser = class {
     );
   }
   // IN (...) — 値リストまたはサブクエリ
+  parseInRight() {
+    if (this.consume("(" /* LPAREN */)) {
+      const right = this.parseInListOrSubquery();
+      this.expect(")" /* RPAREN */);
+      return right;
+    }
+    const variable = this.expect(
+      "VARIABLE" /* VARIABLE */,
+      "IN / NOT IN \u306E\u5F8C\u306B\u306F (\u5024\u30EA\u30B9\u30C8\u307E\u305F\u306F SELECT) \u304B\u914D\u5217\u5909\u6570\u304C\u5FC5\u8981\u3067\u3059"
+    );
+    return { type: "VARIABLE_IN_LIST", name: variable.value.slice(1).toLowerCase() };
+  }
   parseInListOrSubquery() {
     if (this.peek().kind === "SELECT" /* SELECT */) {
       const query = this.parseSelect();
@@ -2223,8 +2417,9 @@ var Parser = class {
       if (subtableCode) {
         throw new ParseError("INSERT INTO ... SELECT \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u4EEE\u60F3\u30C6\u30FC\u30D6\u30EB\u3067\u306F\u672A\u5BFE\u5FDC\u3067\u3059", this.prev());
       }
+      const checkGroups2 = this.parseCheckGroups();
       const validation2 = this.parseDmlControlSuffix();
-      return { type: "INSERT_SELECT", appId, fields, select, ...validation2 };
+      return { type: "INSERT_SELECT", appId, fields, select, ...checkGroups2, ...validation2 };
     }
     this.expect("VALUES" /* VALUES */);
     const values = [];
@@ -2234,11 +2429,15 @@ var Parser = class {
       this.expect(")" /* RPAREN */);
       values.push(row);
     } while (this.consume("," /* COMMA */));
+    const checkGroups = this.parseCheckGroups();
     const validation = this.parseDmlControlSuffix();
+    if (subtableCode && checkGroups.checkGroups) {
+      throw new ParseError("CHECK \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB INSERT \u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
+    }
     if (subtableCode && (validation.validateOnly || validation.onErrorSkip)) {
       throw new ParseError("VALIDATE ONLY / ON ERROR SKIP \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB INSERT \u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
     }
-    return subtableCode ? { type: "INSERT", appId, subtableCode, fields, values, ...validation } : { type: "INSERT", appId, fields, values, ...validation };
+    return subtableCode ? { type: "INSERT", appId, subtableCode, fields, values, ...checkGroups, ...validation } : { type: "INSERT", appId, fields, values, ...checkGroups, ...validation };
   }
   parseUpsert() {
     this.expect("UPSERT" /* UPSERT */);
@@ -2255,8 +2454,9 @@ var Parser = class {
     if (this.peek().kind === "SELECT" /* SELECT */) {
       const select = this.parseSelect();
       const keyFields2 = this.parseOnDuplicate();
+      const checkGroups2 = this.parseCheckGroups();
       const validation2 = this.parseDmlControlSuffix();
-      return { type: "UPSERT_SELECT", appId, fields, select, keyFields: keyFields2, ...validation2 };
+      return { type: "UPSERT_SELECT", appId, fields, select, keyFields: keyFields2, ...checkGroups2, ...validation2 };
     }
     this.expect("VALUES" /* VALUES */);
     const values = [];
@@ -2266,8 +2466,9 @@ var Parser = class {
       this.expect(")" /* RPAREN */);
     } while (this.consume("," /* COMMA */));
     const keyFields = this.parseOnDuplicate();
+    const checkGroups = this.parseCheckGroups();
     const validation = this.parseDmlControlSuffix();
-    return { type: "UPSERT", appId, fields, values, keyFields, ...validation };
+    return { type: "UPSERT", appId, fields, values, keyFields, ...checkGroups, ...validation };
   }
   parseOnDuplicate() {
     this.expectKeyword("ON" /* ON */, "UPSERT \u306B\u306F ON DUPLICATE (\u30AD\u30FC\u30D5\u30A3\u30FC\u30EB\u30C9) \u304C\u5FC5\u8981\u3067\u3059");
@@ -2399,12 +2600,33 @@ var Parser = class {
         whereTok
       );
     }
+    const checkGroups = this.parseCheckGroups();
     const validation = this.parseDmlControlSuffix();
+    if (subtableCode && checkGroups.checkGroups) {
+      throw new ParseError("CHECK \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
+    }
     if (subtableCode && (validation.validateOnly || validation.onErrorSkip)) {
       throw new ParseError("VALIDATE ONLY / ON ERROR SKIP \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
     }
-    if (from !== null) return { type: "UPDATE", appId, assignments, where, from, ...validation };
-    return subtableCode ? { type: "UPDATE", appId, subtableCode, assignments, where, ...validation } : { type: "UPDATE", appId, assignments, where, ...validation };
+    if (from !== null) return { type: "UPDATE", appId, assignments, where, from, ...checkGroups, ...validation };
+    return subtableCode ? { type: "UPDATE", appId, subtableCode, assignments, where, ...checkGroups, ...validation } : { type: "UPDATE", appId, assignments, where, ...checkGroups, ...validation };
+  }
+  /** CHECK WHEN ... THEN ... blocks. CHECK is a soft keyword. */
+  parseCheckGroups() {
+    const groups = [];
+    while (this.isSoftKeyword("CHECK") && this.peekAt(1).kind === "WHEN" /* WHEN */) {
+      const check = this.advance();
+      const rules = [];
+      while (this.consume("WHEN" /* WHEN */)) {
+        const condition = this.parseWhereExpr();
+        this.expect("THEN" /* THEN */, "CHECK WHEN \u306E\u6761\u4EF6\u306E\u5F8C\u306B\u306F THEN \u304C\u5FC5\u8981\u3067\u3059");
+        const message = this.parseScalarValueExpr({ allowCase: false });
+        rules.push({ condition, message });
+      }
+      if (rules.length === 0) throw new ParseError("CHECK \u306E\u5F8C\u306B\u306F WHEN \u304C\u6700\u4F4E 1 \u3064\u5FC5\u8981\u3067\u3059", check);
+      groups.push({ rules });
+    }
+    return groups.length > 0 ? { checkGroups: groups } : {};
   }
   /** DML末尾の VALIDATE ONLY または ON ERROR SKIP。各語はsoft keyword。 */
   parseDmlControlSuffix() {
@@ -2593,6 +2815,12 @@ var Parser = class {
    */
   parseAssignmentValue() {
     const tok = this.peek();
+    if (this.hasTopLevelTokenBeforeValueEnd("||" /* CONCAT_OP */)) {
+      const expr = this.parseScalarValueExpr();
+      if (expr.type === "CONCAT_OP" || expr.type === "SCALAR_ARITH" || expr.type === "STRING_FUNC") return expr;
+      if (expr.type === "CASE_WHEN") return { type: "CASE_VALUE", expr };
+      throw new ParseError("SET \u306E\u5024\u306B\u306F\u9023\u7D50\u3092\u542B\u3080\u30B9\u30AB\u30E9\u30FC\u5024\u5F0F\u304C\u5FC5\u8981\u3067\u3059", tok);
+    }
     if (tok.kind === "VARIABLE" /* VARIABLE */) return this.parseSqlValue();
     if (tok.kind === "STRING" /* STRING */) return this.parseSqlValue();
     if (tok.kind === "TODAY" /* TODAY */ || tok.kind === "NOW" /* NOW */ || tok.kind === "LOGINUSER" /* LOGINUSER */) return this.parseSqlValue();
@@ -2869,7 +3097,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 === "DECLARE_VARIABLE" || type === "ASSERT";
+  return type === "SELECT" || type === "VALIDATE" || 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 writesKintone(stmt) {
   return isDmlType(stmt.type) && !("validateOnly" in stmt && stmt.validateOnly === true);
@@ -2880,6 +3108,8 @@ function isReadOnlyStatement(stmt) {
 function requiresCompleteInput(stmt) {
   if (isDmlType(stmt.type)) return true;
   switch (stmt.type) {
+    case "VALIDATE":
+      return true;
     case "SELECT":
       return selectRequiresCompleteInput(stmt);
     case "UNION":
@@ -2920,6 +3150,7 @@ function whereRequiresCompleteInput(where) {
     case "EXISTS":
       return selectRequiresCompleteInput(where.query);
     case "NULL_CHECK":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -2955,6 +3186,8 @@ function collectDmlTargetFields(stmt) {
 // src/engine/pushDownNot.ts
 function pushDownNot(expr) {
   switch (expr.type) {
+    case "BOOLEAN":
+      return { type: "BOOLEAN", value: !expr.value };
     case "BINARY": {
       const negated = negateOp(expr.op);
       if (negated === null) {
@@ -3034,6 +3267,7 @@ function whereHasLike(where) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -3049,6 +3283,7 @@ function whereHasKlike(where) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -3068,6 +3303,8 @@ function whereToKintone(expr) {
       return convertGroup(expr);
     case "EXISTS":
       throw new KintoneQueryError("EXISTS \u306F kintone \u30AF\u30A8\u30EA\u306B\u5909\u63DB\u3067\u304D\u307E\u305B\u3093");
+    case "BOOLEAN":
+      throw new KintoneQueryError("internal error: BOOLEAN predicate reached kintone query conversion");
   }
 }
 function convertBinary(expr) {
@@ -3146,6 +3383,8 @@ function convertValue(value, op) {
   switch (value.type) {
     case "VARIABLE":
       throw new KintoneQueryError(`\u672A\u89E3\u6C7A\u306E\u30D0\u30C3\u30C1\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
+    case "VARIABLE_IN_LIST":
+      throw new KintoneQueryError(`\u672A\u89E3\u6C7A\u306E\u914D\u5217\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
     case "STRING":
       return convertString(value);
     case "NUMBER":
@@ -3216,7 +3455,7 @@ function resolveSelectMode(stmt) {
   if (stmt.distinct) return "FULL_SCAN";
   if (hasWindowColumns(stmt.columns)) return "FULL_SCAN";
   if (stmt.columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "SCALAR_SUBQUERY_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr)
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "SCALAR_SUBQUERY_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate(c.expr)
   )) return "FULL_SCAN";
   if (whereRequiresJsEval(stmt.where)) return "FULL_SCAN";
   if (stmt.orderBy.some((o) => o.key.type !== "FIELD_NAME")) return "FULL_SCAN";
@@ -3225,6 +3464,8 @@ function resolveSelectMode(stmt) {
 function whereRequiresJsEval(where) {
   if (where === null) return false;
   switch (where.type) {
+    case "BOOLEAN":
+      return true;
     case "BINARY":
       return isFunc(where.left) || where.right.type === "ARITH_VALUE" || where.right.type === "CASE_VALUE" || where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY" || isLike(where);
     case "NULL_CHECK":
@@ -3311,6 +3552,8 @@ function extractFields(columns) {
       collectArithNode(col.expr, fields);
     } else if (col.type === "STRFUNC_COL") {
       collectStringFuncFields(col.expr, fields);
+    } else if (col.type === "SCALAR_VALUE_COL") {
+      collectScalarValueFields(col.expr, fields);
     }
   }
   return [...new Set(fields)];
@@ -3336,16 +3579,38 @@ function collectStringFuncFields(expr, out) {
   }
 }
 function collectStringFuncArgFields(arg, out) {
-  if (arg.type === "STRING") return;
-  if (arg.type === "STRING_FUNC") {
-    collectStringFuncFields(arg, out);
-    return;
-  }
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
     collectAggOperandFields(arg, out);
     return;
   }
-  collectArithNode(arg, out);
+  collectScalarValueFields(arg, out);
+}
+function collectScalarValueFields(expr, out) {
+  if (expr.type === "FIELD") {
+    out.push(normalizeSimpleFieldRef(expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field));
+    return;
+  }
+  if (expr.type === "STRING_FUNC") {
+    collectStringFuncFields(expr, out);
+    return;
+  }
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    collectScalarValueFields(expr.left, out);
+    collectScalarValueFields(expr.right, out);
+    return;
+  }
+  if (expr.type === "CASE_WHEN") {
+    for (const branch of expr.branches) collectCaseResultScalarFields(branch.result, out);
+    if (expr.elseResult) collectCaseResultScalarFields(expr.elseResult, out);
+  }
+}
+function collectCaseResultScalarFields(result, out) {
+  if (result.type === "ARRAY") return;
+  if (result.type === "FIELD_REF" || result.type === "ARITH") {
+    collectArithNode(result, out);
+    return;
+  }
+  collectScalarValueFields(result, out);
 }
 function collectAggOperandFields(node, out) {
   if (node.type === "AGG_REF") {
@@ -3360,10 +3625,23 @@ function collectAggOperandFields(node, out) {
 function hasAggregateInStringFuncExpr(expr) {
   return expr.args.some((arg) => {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
-    if (arg.type === "STRING_FUNC") return hasAggregateInStringFuncExpr(arg);
-    return false;
+    return scalarValueHasAggregate(arg);
   });
 }
+function scalarValueHasAggregate(expr) {
+  if (expr.type === "STRING_FUNC") return hasAggregateInStringFuncExpr(expr);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return scalarValueHasAggregate(expr.left) || scalarValueHasAggregate(expr.right);
+  }
+  if (expr.type === "CASE_WHEN") {
+    return expr.branches.some((b) => caseResultHasAggregate(b.result)) || expr.elseResult !== null && caseResultHasAggregate(expr.elseResult);
+  }
+  return false;
+}
+function caseResultHasAggregate(result) {
+  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
+  return scalarValueHasAggregate(result);
+}
 function collectRequiredFieldsByTable(stmt) {
   const physicalTables = [stmt.from, ...stmt.joins.map((j) => j.table)].filter((t) => t.cteName === null);
   const states = /* @__PURE__ */ new Map();
@@ -3498,28 +3776,38 @@ function collectRequiredFieldsByTable(stmt) {
     }
   };
   const walkStringArg = (arg, phase = "select") => {
-    if (arg.type === "STRING") return;
-    if (arg.type === "STRING_FUNC") {
-      walkStringFunc(arg, phase);
-      return;
-    }
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
       walkAgg(arg, phase);
       return;
     }
-    walkArith(arg, phase);
+    walkScalar(arg, phase);
   };
   const walkStringFunc = (expr, phase = "select") => {
     for (const arg of expr.args) walkStringArg(arg, phase);
   };
+  const walkScalar = (expr, phase = "select") => {
+    if (expr.type === "FIELD") {
+      addFieldRef(expr.field, expr.tableAlias, phase);
+      return;
+    }
+    if (expr.type === "STRING_FUNC") {
+      walkStringFunc(expr, phase);
+      return;
+    }
+    if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+      walkScalar(expr.left, phase);
+      walkScalar(expr.right, phase);
+      return;
+    }
+    if (expr.type === "CASE_WHEN") walkCase(expr, phase);
+  };
   const walkCaseResult = (result, phase = "select") => {
-    if (result.type === "STRING") return;
     if (result.type === "ARRAY") return;
-    if (result.type === "STRING_FUNC") {
-      walkStringFunc(result, phase);
+    if (result.type === "FIELD_REF" || result.type === "ARITH") {
+      walkArith(result, phase);
       return;
     }
-    walkArith(result, phase);
+    walkScalar(result, phase);
   };
   const walkCase = (expr, phase = "select") => {
     for (const b of expr.branches) {
@@ -3572,6 +3860,7 @@ function collectRequiredFieldsByTable(stmt) {
         walkWhere(where.expr, phase);
         return;
       case "EXISTS":
+      case "BOOLEAN":
         return;
     }
   };
@@ -3610,6 +3899,8 @@ function collectRequiredFieldsByTable(stmt) {
         break;
       case "LITERAL_COL":
         break;
+      case "VARIABLE_COL":
+        throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
       case "AGGREGATE":
         if (col.arg.type !== "WILDCARD") walkArith(col.arg, "select");
         break;
@@ -3625,6 +3916,9 @@ function collectRequiredFieldsByTable(stmt) {
       case "STRFUNC_COL":
         walkStringFunc(col.expr, "select");
         break;
+      case "SCALAR_VALUE_COL":
+        walkScalar(col.expr, "select");
+        break;
       case "SCALAR_SUBQUERY_COL":
         break;
       case "WINDOW_COL":
@@ -3675,6 +3969,10 @@ function collectSelectOutputNames(columns) {
       if (col.alias) names.add(col.alias);
       continue;
     }
+    if (col.type === "SCALAR_VALUE_COL") {
+      if (col.alias) names.add(col.alias);
+      continue;
+    }
     if (col.type === "SCALAR_SUBQUERY_COL") {
       names.add(col.alias ?? "(subquery)");
       continue;
@@ -3697,14 +3995,32 @@ function arithNodeLabel(node) {
 }
 function stringFuncLabel(expr) {
   const args = expr.args.map((a) => {
-    if (a.type === "STRING") return `'${a.value}'`;
-    if (a.type === "STRING_FUNC") return stringFuncLabel(a);
     if (a.type === "AGG_REF") return aggregateSyntheticName(a.func, a.distinct, a.arg);
     if (a.type === "AGG_ARITH") return "agg_arith";
-    return arithNodeLabel(a);
+    return scalarValueLabel(a);
   });
   return `${expr.func}(${args.join(",")})`;
 }
+function scalarValueLabel(expr) {
+  switch (expr.type) {
+    case "STRING":
+      return `'${expr.value}'`;
+    case "NUMBER":
+      return numberLiteralText(expr);
+    case "VARIABLE":
+      return `@${expr.name}`;
+    case "FIELD":
+      return expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field;
+    case "STRING_FUNC":
+      return stringFuncLabel(expr);
+    case "CASE_WHEN":
+      return "case";
+    case "SCALAR_ARITH":
+      return `(${scalarValueLabel(expr.left)}${expr.op}${scalarValueLabel(expr.right)})`;
+    case "CONCAT_OP":
+      return `(${scalarValueLabel(expr.left)}||${scalarValueLabel(expr.right)})`;
+  }
+}
 function isAggregateSyntheticName(name) {
   return /^(COUNT|SUM|AVG|MAX|MIN|GROUP_CONCAT)\(/i.test(name);
 }
@@ -3760,6 +4076,7 @@ function stripCteAlias(where, alias) {
     case "GROUP":
       return { ...where, expr: stripCteAlias(where.expr, alias) };
     case "EXISTS":
+    case "BOOLEAN":
       return where;
   }
 }
@@ -3797,6 +4114,7 @@ function extractAndLeaves(where, accept) {
     case "NULL_CHECK":
     case "NOT":
     case "EXISTS":
+    case "BOOLEAN":
       return null;
   }
 }
@@ -3935,6 +4253,7 @@ function collectKlikes(where, out) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return;
   }
 }
@@ -3991,6 +4310,11 @@ function validateStatement(stmt) {
         );
       }
       return;
+    case "VALIDATE":
+      if (containsKlike(stmt)) {
+        throw new KlikeValidationError("KLIKE / NOT KLIKE \u306F VALIDATE \u306E WHERE / CHECK \u3067\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
+      }
+      return;
     case "SHOW_APPS":
     case "DESCRIBE":
     case "DROP_TEMP_TABLE":
@@ -4078,6 +4402,8 @@ function isDescendantOf(root, target) {
     case "NULL_CHECK":
     case "EXISTS":
       return false;
+    case "BOOLEAN":
+      return false;
   }
 }
 function walkWithoutNestedSelects(node, visitWhere) {
@@ -4139,8 +4465,12 @@ function collectVariableRefs(node, refs) {
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
-    if (obj["type"] === "VARIABLE" && typeof obj["name"] === "string") {
-      refs.add(obj["name"]);
+    const type = obj["type"];
+    if ((type === "VARIABLE" || type === "VARIABLE_COL" || type === "VARIABLE_IN_LIST") && typeof obj["name"] === "string") {
+      refs.push({
+        name: obj["name"],
+        kind: type === "VARIABLE" ? "scalar" : type === "VARIABLE_COL" ? "select-column" : "array-in-list"
+      });
       return;
     }
     for (const v of Object.values(obj)) collectVariableRefs(v, refs);
@@ -4181,9 +4511,9 @@ function analyzeBatch(statements) {
   const variableDefs = /* @__PURE__ */ new Map();
   const variableOrder = [];
   statements.forEach((stmt, index) => {
-    const validationTable = "validationErrorTable" in stmt && stmt.validationErrorTable ? stmt.validationErrorTable : "onErrorSkip" in stmt && stmt.onErrorSkip ? stmt.errorTable ?? null : null;
+    const validationTable = stmt.type === "VALIDATE" && stmt.errorTable ? stmt.errorTable : "validationErrorTable" in stmt && stmt.validationErrorTable ? stmt.validationErrorTable : "onErrorSkip" in stmt && stmt.onErrorSkip ? stmt.errorTable ?? null : null;
     if (statements.length === 1 && validationTable) {
-      const message = "onErrorSkip" in stmt && stmt.onErrorSkip ? "ArgumentError: ON ERROR SKIP requires a batch." : "ArgumentError: VALIDATE ONLY INTO requires a batch.";
+      const message = stmt.type === "VALIDATE" ? "ArgumentError: VALIDATE INTO requires a batch." : "onErrorSkip" in stmt && stmt.onErrorSkip ? "ArgumentError: ON ERROR SKIP requires a batch." : "ArgumentError: VALIDATE ONLY INTO requires a batch.";
       throw new BatchAnalysisError(message, index);
     }
     const statementType = getStatementType(stmt);
@@ -4192,23 +4522,43 @@ function analyzeBatch(statements) {
     const refs = /* @__PURE__ */ new Set();
     const stmtAppIds = /* @__PURE__ */ new Set();
     const dependsOn = /* @__PURE__ */ new Set();
-    const variableRefs = /* @__PURE__ */ new Set();
+    const variableRefs = [];
     collectVariableRefs(stmt, variableRefs);
-    for (const name of variableRefs) {
-      const def = variableDefs.get(name);
+    const referencedThisStatement = /* @__PURE__ */ new Set();
+    for (const use of variableRefs) {
+      const def = variableDefs.get(use.name);
       if (def === void 0) {
         throw new BatchAnalysisError(
-          `ParseError: variable @${name} is not defined before statement ${index + 1}.`,
+          `ParseError: variable @${use.name} is not defined before statement ${index + 1}.`,
+          index
+        );
+      }
+      if (def.kind === "scalar" && use.kind === "array-in-list") {
+        throw new BatchAnalysisError(
+          `ParseError: scalar variable @${use.name} cannot be used as IN @${use.name}; use IN (@${use.name}) instead.`,
           index
         );
       }
-      def.referencedBy.push(index);
+      if (def.kind === "array" && use.kind !== "array-in-list") {
+        throw new BatchAnalysisError(
+          `ParseError: array variable @${use.name} can only be used as IN @${use.name}.`,
+          index
+        );
+      }
+      if (!referencedThisStatement.has(use.name)) {
+        def.referencedBy.push(index);
+        referencedThisStatement.add(use.name);
+      }
     }
     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);
       }
-      variableDefs.set(stmt.name, { index, referencedBy: [] });
+      variableDefs.set(stmt.name, {
+        index,
+        kind: stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? "array" : "scalar",
+        referencedBy: []
+      });
       variableOrder.push(stmt.name);
       if (variableOrder.length > MAX_BATCH_VARIABLES) {
         throw new BatchAnalysisError(
@@ -4241,7 +4591,7 @@ function analyzeBatch(statements) {
       dependsOn.add(at);
     }
     if (validationTable) {
-      const payloadFields = stmt.type === "UPDATE" ? ["$id", ...stmt.assignments.map((a) => a.field)] : "fields" in stmt ? stmt.fields : [];
+      const payloadFields = stmt.type === "VALIDATE" ? ["$id", "$err_field", "$err_code", "$err_message", "$err_value"] : stmt.type === "UPDATE" ? ["$id", ...stmt.assignments.map((a) => a.field)] : "fields" in stmt ? stmt.fields : [];
       const signature = JSON.stringify(payloadFields);
       const at = defined.get(validationTable);
       if (at === void 0) {
@@ -4316,6 +4666,7 @@ function analyzeBatch(statements) {
   const needsCompleteInput = results.some((r) => r.requiresCompleteInput);
   const variables = variableOrder.map((name) => ({
     name,
+    kind: variableDefs.get(name).kind,
     referencedBy: [...variableDefs.get(name).referencedBy]
   }));
   return {
@@ -4592,6 +4943,7 @@ function whereNeedsFieldMetadata(where) {
     case "GROUP":
       return whereNeedsFieldMetadata(where.expr);
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -4616,6 +4968,7 @@ function explainNeedsAppMetadata(statement) {
     seen.add(node);
     if (Array.isArray(node)) return node.some(visit);
     const item = node;
+    if (item["type"] === "VALIDATE") return true;
     if (item["type"] === "SELECT" && selectNeedsOwnMetadata(node)) {
       return true;
     }
@@ -4647,6 +5000,45 @@ function evalArithExpr(expr, row) {
       return r !== 0 ? l % r : NaN;
   }
 }
+function evalScalarValueExpr(expr, row) {
+  switch (expr.type) {
+    case "STRING":
+      return expr.value;
+    case "NUMBER":
+      return expr.value;
+    case "FIELD":
+      return resolveFieldRef(row, expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field);
+    case "VARIABLE":
+      throw new Error(`ArgumentError: unresolved variable @${expr.name} reached scalar evaluator.`);
+    case "STRING_FUNC":
+      return evalStringFunc(expr, row);
+    case "CASE_WHEN":
+      return evalCaseWhen(expr, row);
+    case "CONCAT_OP": {
+      return evalStringFunc({
+        type: "STRING_FUNC",
+        func: "CONCAT",
+        args: [expr.left, expr.right]
+      }, row);
+    }
+    case "SCALAR_ARITH": {
+      const left = Number(evalScalarValueExpr(expr.left, row));
+      const right = Number(evalScalarValueExpr(expr.right, row));
+      switch (expr.op) {
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return right !== 0 ? left / right : NaN;
+        case "%":
+          return right !== 0 ? left % right : NaN;
+      }
+    }
+  }
+}
 function applyRoundOp(op, num, digits) {
   const factor = Math.pow(10, digits);
   const raw = Math[op](num * factor) / factor;
@@ -5049,12 +5441,9 @@ function formatWithComma(num, digits) {
   return decStr ? `${intFmt}.${decStr}` : intFmt;
 }
 function evalStringFuncArg(arg, row) {
-  if (arg.type === "STRING") return arg.value;
-  if (arg.type === "STRING_FUNC") return evalStringFunc(arg, row);
-  if (arg.type === "FIELD_REF") return resolveFieldRef(row, arg.field);
-  if (arg.type === "NUMBER") return numberLiteralText(arg);
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return "";
-  return String(evalArithExpr(arg, row));
+  if (arg.type === "NUMBER") return numberLiteralText(arg);
+  return String(evalScalarValueExpr(arg, row));
 }
 function resolveFieldRef(row, field) {
   const direct = row[field];
@@ -5070,6 +5459,8 @@ function resolveFieldRef(row, field) {
 // src/engine/evalWhere.ts
 function evalWhere(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2) {
   switch (expr.type) {
+    case "BOOLEAN":
+      return expr.value;
     case "BINARY":
       return evalBinary(expr, row, resolveFieldType, appliedKlikes, resolveFieldSemantics2);
     case "NULL_CHECK":
@@ -5240,6 +5631,8 @@ function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
   switch (value.type) {
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${value.name}.`);
+    case "VARIABLE_IN_LIST":
+      throw new Error(`ParseError: unresolved batch array variable @${value.name}.`);
     case "STRING":
       return value.value;
     case "NUMBER":
@@ -5277,10 +5670,13 @@ function evalCaseWhen(expr, row, resolveFieldType, resolveFieldSemantics2) {
 }
 function evalCaseResult(result, row) {
   if (result.type === "ARRAY") return result.elements.map((e) => e.value).join(",");
-  if (result.type === "STRING") return result.value;
-  if (result.type === "STRING_FUNC") return evalStringFunc(result, row);
-  if (result.type === "FIELD_REF") return row[result.field] ?? "";
-  return String(evalArithExpr(result, row));
+  if (result.type === "FIELD_REF") {
+    return row[result.field] ?? "";
+  }
+  if (result.type === "ARITH") {
+    return String(evalArithExpr(result, row));
+  }
+  return String(evalScalarValueExpr(result, row));
 }
 function resolveKintoneFunc(name) {
   const now = /* @__PURE__ */ new Date();
@@ -5324,6 +5720,63 @@ function matchLike(value, pattern) {
   return regex.test(value);
 }
 
+// src/core/dmlCustomCheck.ts
+function collectCheckFieldRefs(groups) {
+  return collectRefs2(groups);
+}
+function collectCheckComparisonFieldRefs(groups) {
+  return collectRefs2(groups.flatMap((group) => group.rules.map((rule) => rule.condition)));
+}
+function collectRefs2(root) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const obj = node;
+    if (obj.type === "EXISTS" || obj.type === "SUBQUERY_IN_LIST" || obj.type === "SCALAR_SUBQUERY") {
+      throw customCheckParseError("CHECK \u306B\u30B5\u30D6\u30AF\u30A8\u30EA\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
+    }
+    if (obj.type === "FIELD" && typeof obj.field === "string") {
+      add(typeof obj.tableAlias === "string" ? obj.tableAlias : null, obj.field);
+    } else if (obj.type === "FIELD_REF" && typeof obj.field === "string") {
+      const dot = obj.field.indexOf(".");
+      add(dot > 0 ? obj.field.slice(0, dot) : null, dot > 0 ? obj.field.slice(dot + 1) : obj.field);
+    }
+    for (const value of Object.values(obj)) visit(value);
+  };
+  const add = (tableAlias, field) => {
+    if (/^(COUNT|SUM|AVG|MIN|MAX|GROUP_CONCAT)\(/i.test(field)) {
+      throw customCheckParseError("CHECK \u306B\u96C6\u7D04\u95A2\u6570\u306F\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
+    }
+    const key = `${tableAlias ?? ""}\0${field}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      refs.push({ tableAlias, field });
+    }
+  };
+  visit(root);
+  return refs;
+}
+function customCheckParseError(message) {
+  return new ParseError(message, { kind: "EOF" /* EOF */, value: "CHECK", pos: 0 });
+}
+function evaluateCustomChecks(groups, row, resolveFieldType) {
+  const errors = [];
+  groups.forEach((group, groupIndex) => {
+    for (const rule of group.rules) {
+      if (!evalWhere(rule.condition, row, resolveFieldType)) continue;
+      const value = evalScalarValueExpr(rule.message, row);
+      errors.push({ groupIndex, message: value == null ? "" : String(value) });
+      break;
+    }
+  });
+  return errors;
+}
+
 // src/converter/dmlToKintone.ts
 function assertDmlWhereIsSafe(where) {
   if (whereHasKlike(where)) {
@@ -5361,10 +5814,11 @@ function buildInsertRecord(fields, row, fieldTypes) {
 }
 function updateToGetQuery(stmt) {
   assertDmlWhereIsSafe(stmt.where);
+  const checkFields = collectUpdateCheckTargetFields(stmt);
   return {
     app: stmt.appId,
     query: whereToKintone(stmt.where),
-    fields: ["$id"],
+    fields: ["$id", ...checkFields],
     totalCount: false
   };
 }
@@ -5378,19 +5832,19 @@ function updateToPutBatches(stmt, ids, fieldTypes = /* @__PURE__ */ new Map()) {
 function buildUpdateRecord(assignments, fieldTypes) {
   const record = {};
   for (const { field, value } of assignments) {
-    if (value.type === "ARITH" || value.type === "CASE_VALUE" || value.type === "STRING_FUNC" || value.type === "SOURCE_FIELD") continue;
+    if (value.type === "ARITH" || value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP" || value.type === "CASE_VALUE" || value.type === "STRING_FUNC" || value.type === "SOURCE_FIELD") continue;
     record[field] = { value: toKintoneValue(value, fieldTypes.get(field)) };
   }
   return record;
 }
 function hasArithAssignment(stmt) {
   return stmt.assignments.some(
-    (a) => a.value.type === "ARITH" || a.value.type === "CASE_VALUE"
+    (a) => a.value.type === "ARITH" || a.value.type === "SCALAR_ARITH" || a.value.type === "CONCAT_OP" || a.value.type === "CASE_VALUE"
   );
 }
 function hasRowDependentAssignment(stmt) {
   return stmt.assignments.some(
-    (a) => a.value.type === "ARITH" || a.value.type === "CASE_VALUE" || a.value.type === "STRING_FUNC"
+    (a) => a.value.type === "ARITH" || a.value.type === "SCALAR_ARITH" || a.value.type === "CONCAT_OP" || a.value.type === "CASE_VALUE" || a.value.type === "STRING_FUNC"
   );
 }
 function updateToGetQueryForArith(stmt) {
@@ -5399,12 +5853,15 @@ function updateToGetQueryForArith(stmt) {
   for (const { value } of stmt.assignments) {
     if (value.type === "ARITH") {
       collectArithFields2(value, refFields);
+    } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+      collectScalarValueFields2(value, refFields);
     } else if (value.type === "STRING_FUNC") {
       collectStringFuncFields2(value, refFields);
     } else if (value.type === "CASE_VALUE") {
       collectCaseFields(value.expr, refFields);
     }
   }
+  collectUpdateCheckTargetFields(stmt).forEach((field) => refFields.add(field));
   return {
     app: stmt.appId,
     query: whereToKintone(stmt.where),
@@ -5425,16 +5882,27 @@ function collectStringFuncFields2(expr, out) {
   for (const arg of expr.args) collectStringFuncArgFields2(arg, out);
 }
 function collectStringFuncArgFields2(arg, out) {
-  if (arg.type === "STRING") return;
-  if (arg.type === "STRING_FUNC") {
-    collectStringFuncFields2(arg, out);
-    return;
-  }
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
     collectAggOperandFields2(arg, out);
     return;
   }
-  collectArithNode2(arg, out);
+  collectScalarValueFields2(arg, out);
+}
+function collectScalarValueFields2(expr, out) {
+  if (expr.type === "FIELD") {
+    out.add(expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field);
+    return;
+  }
+  if (expr.type === "STRING_FUNC") {
+    collectStringFuncFields2(expr, out);
+    return;
+  }
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    collectScalarValueFields2(expr.left, out);
+    collectScalarValueFields2(expr.right, out);
+    return;
+  }
+  if (expr.type === "CASE_WHEN") collectCaseFields(expr, out);
 }
 function collectAggOperandFields2(node, out) {
   if (node.type === "AGG_REF") {
@@ -5447,9 +5915,12 @@ function collectAggOperandFields2(node, out) {
   }
 }
 function collectCaseResultFields(result, out) {
-  if (result.type === "STRING") return;
   if (result.type === "ARRAY") return;
-  collectArithNode2(result, out);
+  if (result.type === "FIELD_REF" || result.type === "ARITH") {
+    collectArithNode2(result, out);
+    return;
+  }
+  collectScalarValueFields2(result, out);
 }
 function collectCaseFields(expr, out) {
   for (const branch of expr.branches) {
@@ -5477,6 +5948,9 @@ function collectConditionFields(expr, out) {
     case "GROUP":
       collectConditionFields(expr.expr, out);
       break;
+    case "EXISTS":
+    case "BOOLEAN":
+      break;
   }
 }
 function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new Map()) {
@@ -5487,6 +5961,8 @@ function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new
     for (const { field, value } of stmt.assignments) {
       if (value.type === "ARITH") {
         record[field] = { value: String(evalArith(value, raw)) };
+      } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+        record[field] = { value: String(evalScalarValueExpr(value, row)) };
       } else if (value.type === "STRING_FUNC") {
         record[field] = { value: evalStringFunc(value, row) };
       } else if (value.type === "CASE_VALUE") {
@@ -5541,6 +6017,8 @@ function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new
         throw new DmlConvertError("UPDATE ... FROM \u306E SET \u3067\u306F\u6587\u5B57\u5217\u95A2\u6570\u3092\u76F4\u63A5\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
       } else if (value.type === "ARITH") {
         record[field] = { value: String(evalArith(value, target)) };
+      } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+        record[field] = { value: String(evalScalarValueExpr(value, targetRow)) };
       } else if (value.type === "CASE_VALUE") {
         record[field] = { value: evalCaseWhenValue(value.expr, targetRow, fieldType) };
       } else {
@@ -5651,7 +6129,15 @@ function evalCaseResultValue(result, row, fieldType) {
   if (result.type === "STRING_FUNC") {
     return evalStringFunc(result, row);
   }
-  return String(evalArithExpr(result, row));
+  if (result.type === "FIELD_REF" || result.type === "ARITH") {
+    return String(evalArithExpr(result, row));
+  }
+  return String(evalScalarValueExpr(result, row));
+}
+function collectUpdateCheckTargetFields(stmt) {
+  if (!stmt.checkGroups) return [];
+  const targetAlias = `app${stmt.appId}`.toLowerCase();
+  return [...new Set(collectCheckFieldRefs(stmt.checkGroups).filter((ref) => ref.tableAlias === null || ref.tableAlias.toLowerCase() === targetAlias).map((ref) => ref.field).filter((field) => field !== "$id"))];
 }
 function evalCaseWhenValue(expr, row, fieldType) {
   for (const branch of expr.branches) {
@@ -5680,6 +6166,8 @@ function convertDmlSqlValue(value, fieldType) {
   switch (value.type) {
     case "VARIABLE":
       throw new DmlConvertError(`\u672A\u89E3\u6C7A\u306E\u30D0\u30C3\u30C1\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
+    case "VARIABLE_IN_LIST":
+      throw new DmlConvertError(`\u672A\u89E3\u6C7A\u306E\u914D\u5217\u5909\u6570 @${value.name} \u304C\u3042\u308A\u307E\u3059`);
     case "STRING":
       return convertString2(value.value, fieldType);
     case "NUMBER":
@@ -6204,7 +6692,7 @@ function applyFilter(rows, where, resolveFieldType, appliedKlikes, resolveFieldS
 }
 function hasAggregateColumns(columns) {
   return columns.some(
-    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr)
+    (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
   );
 }
 function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind) {
@@ -6241,6 +6729,10 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind) {
         const outputKey = col.alias ?? stringFuncDefaultKey(col.expr);
         const resolvedExpr = resolveAggInStringFuncExpr(col.expr, groupRows, resolveAggSortKind);
         outRow[outputKey] = evalStringFunc(resolvedExpr, outRow);
+      } else if (col.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(col.expr)) {
+        const outputKey = col.alias ?? scalarValueDefaultKey(col.expr);
+        const resolvedExpr = resolveAggInScalarValue(col.expr, groupRows, resolveAggSortKind);
+        outRow[outputKey] = String(evalScalarValueExpr(resolvedExpr, outRow));
       }
     }
     result.push(outRow);
@@ -6511,6 +7003,8 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
     const out = {};
     for (const [colIdx, col] of columns.entries()) {
       switch (col.type) {
+        case "VARIABLE_COL":
+          throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
         case "WILDCARD":
           Object.assign(out, stripParentShortcutColumns(row));
           break;
@@ -6571,6 +7065,13 @@ function project(rows, columns, scalarCache, resolveFieldType, sourceColumns, re
           if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
           break;
         }
+        case "SCALAR_VALUE_COL": {
+          const key = outputKeys?.[colIdx] ?? col.alias ?? scalarValueDefaultKey(col.expr);
+          const srcKey = scalarValueDefaultKey(col.expr);
+          out[key] = scalarValueHasAggregate2(col.expr) ? row[col.alias ?? srcKey] ?? row[srcKey] ?? "" : String(evalScalarValueExpr(col.expr, row));
+          if (outputKeys === null && rowIdx === 0) orderedKeys.push(key);
+          break;
+        }
         case "SCALAR_SUBQUERY_COL": {
           const key = outputKeys?.[colIdx] ?? col.alias ?? "(subquery)";
           out[key] = scalarCache?.get(colIdx) ?? "";
@@ -6607,6 +7108,8 @@ function computeExplicitOutputKeys(columns, defaultFieldKeys) {
 }
 function computeOutputKey(col, colIdx, defaultFieldKeys) {
   switch (col.type) {
+    case "VARIABLE_COL":
+      throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
     case "FIELD":
       return col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
     case "LITERAL_COL":
@@ -6621,6 +7124,8 @@ function computeOutputKey(col, colIdx, defaultFieldKeys) {
       return col.alias ?? "case";
     case "STRFUNC_COL":
       return col.alias ?? stringFuncDefaultKey(col.expr);
+    case "SCALAR_VALUE_COL":
+      return col.alias ?? scalarValueDefaultKey(col.expr);
     case "SCALAR_SUBQUERY_COL":
       return col.alias ?? "(subquery)";
     case "WINDOW_COL":
@@ -6676,18 +7181,49 @@ function arithColDefaultKey(expr) {
 }
 function stringFuncDefaultKey(expr) {
   const argStrs = expr.args.map((a) => {
-    if (a.type === "STRING") return `'${a.value}'`;
-    if (a.type === "STRING_FUNC") return stringFuncDefaultKey(a);
     if (a.type === "AGG_REF" || a.type === "AGG_ARITH") return aggArithDefaultKey(a);
-    return arithColDefaultKey(a);
+    return scalarValueDefaultKey(a);
   });
   return `${expr.func}(${argStrs.join(",")})`;
 }
+function scalarValueDefaultKey(expr) {
+  switch (expr.type) {
+    case "STRING":
+      return `'${expr.value}'`;
+    case "NUMBER":
+      return numberLiteralText(expr);
+    case "VARIABLE":
+      return `@${expr.name}`;
+    case "FIELD":
+      return expr.tableAlias ? `${expr.tableAlias}.${expr.field}` : expr.field;
+    case "STRING_FUNC":
+      return stringFuncDefaultKey(expr);
+    case "CASE_WHEN":
+      return "case";
+    case "SCALAR_ARITH":
+      return `${scalarValueDefaultKey(expr.left)}${expr.op}${scalarValueDefaultKey(expr.right)}`;
+    case "CONCAT_OP":
+      return `${scalarValueDefaultKey(expr.left)}||${scalarValueDefaultKey(expr.right)}`;
+  }
+}
 function hasAggregateInStringFuncArg(arg) {
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
-  if (arg.type === "STRING_FUNC") return hasAggregateInStringFuncExpr2(arg);
+  return scalarValueHasAggregate2(arg);
+}
+function scalarValueHasAggregate2(expr) {
+  if (expr.type === "STRING_FUNC") return hasAggregateInStringFuncExpr2(expr);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return scalarValueHasAggregate2(expr.left) || scalarValueHasAggregate2(expr.right);
+  }
+  if (expr.type === "CASE_WHEN") {
+    return expr.branches.some((branch) => caseResultHasAggregate2(branch.result)) || expr.elseResult !== null && caseResultHasAggregate2(expr.elseResult);
+  }
   return false;
 }
+function caseResultHasAggregate2(result) {
+  if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
+  return scalarValueHasAggregate2(result);
+}
 function hasAggregateInStringFuncExpr2(expr) {
   return expr.args.some((arg) => hasAggregateInStringFuncArg(arg));
 }
@@ -6703,7 +7239,18 @@ function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
   if (arg.type === "STRING_FUNC") {
     return resolveAggInStringFuncExpr(arg, rows, resolveAggSortKind);
   }
-  return arg;
+  return resolveAggInScalarValue(arg, rows, resolveAggSortKind);
+}
+function resolveAggInScalarValue(expr, rows, resolveAggSortKind) {
+  if (expr.type === "STRING_FUNC") return resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return {
+      ...expr,
+      left: resolveAggInScalarValue(expr.left, rows, resolveAggSortKind),
+      right: resolveAggInScalarValue(expr.right, rows, resolveAggSortKind)
+    };
+  }
+  return expr;
 }
 function resolveAggInStringFuncExpr(expr, rows, resolveAggSortKind) {
   return {
@@ -6724,7 +7271,7 @@ function deriveOutputOrderSemantics(columns) {
       } 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") {
+    } else if (column.type === "LITERAL_COL" || column.type === "CASE_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "SCALAR_VALUE_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"));
@@ -6997,19 +7544,20 @@ var VALIDATION_META_COLUMNS = [
   "$err_code",
   "$err_message"
 ];
-function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber, numberPrecision) {
+function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber, numberPrecision, checkGroups = [], validateMissingCreateFields = true, includePreErrors = true) {
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
   const errors = [];
   const invalid = /* @__PURE__ */ new Set();
+  let firstEvaluationError;
   for (const candidate of candidates) {
     candidate.record ??= {};
-    const rowErrors = [...candidate.preErrors];
+    const rowErrors = includePreErrors ? [...candidate.preErrors] : [];
     for (const code of targetFields) {
       const result = validateAndNormalizeDmlValue(candidate.payload.get(code), infoByCode.get(code), numberPrecision);
       if (!result.ok) rowErrors.push({ field: code, code: result.code, message: result.message });
       else candidate.record[code] = { value: result.value };
     }
-    if (candidate.mode === "create") {
+    if (validateMissingCreateFields && candidate.mode === "create") {
       for (const info of fieldInfos) {
         if (info.inSubtable) continue;
         if (candidate.payload.has(info.code)) continue;
@@ -7031,6 +7579,23 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         }
       }
     }
+    if (checkGroups.length > 0) {
+      const row = candidate.evaluationRow ?? Object.fromEntries(
+        [...candidate.payload].map(([field, value]) => [field, renderValidationValue(value)])
+      );
+      const types = candidate.evaluationFieldTypes;
+      const resolveType = (field) => {
+        const qualified = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
+        return types?.get(qualified) ?? types?.get(field.field);
+      };
+      try {
+        for (const custom of evaluateCustomChecks(checkGroups, row, resolveType)) {
+          rowErrors.push({ field: "", code: "ERR_CHECK", message: custom.message });
+        }
+      } catch (error) {
+        firstEvaluationError ??= error;
+      }
+    }
     if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
     for (const error of rowErrors) {
       const row = {};
@@ -7044,6 +7609,7 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
       errors.push(row);
     }
   }
+  if (firstEvaluationError !== void 0) throw firstEvaluationError;
   return { errors, invalidRows: invalid.size, invalidRowNumbers: invalid };
 }
 function renderValidationValue(value) {
@@ -7058,6 +7624,11 @@ function renderValidationValue(value) {
   return String(value);
 }
 
+// src/core/existingRecordValidation.ts
+function renderExistingValidationValue(raw, fieldType) {
+  return isEmptyDmlValue(raw) ? "" : renderValidationValue(normalizeRaw(raw, fieldType));
+}
+
 // src/core/optimization/whereCapability.ts
 var RANGE_AND_EQUALITY = ["=", "!=", ">", "<", ">=", "<="];
 var EQUALITY_IN = ["=", "!=", "in", "not in"];
@@ -7132,6 +7703,8 @@ function classifyWhereCapability(where, resolveField2) {
 }
 function classifyNode(where, resolveField2) {
   switch (where.type) {
+    case "BOOLEAN":
+      return { capability: "LOCAL_ONLY", reasons: [{ code: "WHERE_EXPRESSION_LOCAL_ONLY" }] };
     case "BINARY":
       return classifyBinary(where.op, where.left, where.right.type, resolveField2);
     case "NULL_CHECK":
@@ -7458,6 +8031,8 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
     throw new Error("ArgumentError: ON ERROR SKIP requires a batch.");
   }
   switch (stmt.type) {
+    case "VALIDATE":
+      return executeExistingRecordValidation(stmt, client, options, cacheContext);
     case "SELECT":
       return executeSelect(stmt, client, options, cacheContext);
     case "UNION":
@@ -7503,6 +8078,144 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
       return executeAssert(stmt, client, options, cacheContext);
   }
 }
+var EXISTING_VALIDATION_COLUMNS = ["$id", "$err_field", "$err_code", "$err_message", "$err_value"];
+function hasAuditableConstraint(field) {
+  return field.required === true || field.minValue !== void 0 || field.maxValue !== void 0 || field.minLength !== void 0 || field.maxLength !== void 0 || field.optionOrder !== void 0;
+}
+function resolveExistingValidationTargets(stmt, fieldInfos) {
+  const byCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  const auditable = (field) => !field.inSubtable && (field.fieldType === "NUMBER" || hasAuditableConstraint(field));
+  if (stmt.fields === void 0) return fieldInfos.filter(auditable);
+  const seen = /* @__PURE__ */ new Set();
+  return stmt.fields.map((code) => {
+    if (seen.has(code)) throw new Error(`ArgumentError: VALIDATE field ${code} is duplicated.`);
+    seen.add(code);
+    if (code === "$id") throw new Error("ArgumentError: VALIDATE cannot audit system field $id.");
+    const info = byCode.get(code);
+    if (!info) throw new Error(`ArgumentError: VALIDATE field ${code} does not exist.`);
+    if (info.inSubtable) throw new Error(`ArgumentError: VALIDATE field ${code} is a subtable child field.`);
+    if (!auditable(info)) throw new Error(`ArgumentError: VALIDATE field ${code} has no auditable constraint.`);
+    return info;
+  });
+}
+function collectValidateWhereFields(where) {
+  const fields = [];
+  const seen = /* @__PURE__ */ new Set();
+  const add = (field) => {
+    if (!seen.has(field)) {
+      seen.add(field);
+      fields.push(field);
+    }
+  };
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const obj = node;
+    if (obj.type === "FIELD" && typeof obj.field === "string") add(obj.field);
+    if (obj.type === "FIELD_REF" && typeof obj.field === "string") add(obj.field);
+    Object.values(obj).forEach(visit);
+  };
+  visit(where);
+  return fields;
+}
+function existingValidationColumnMeta() {
+  return new Map(EXISTING_VALIDATION_COLUMNS.map((column) => [column, {
+    fieldType: column === "$id" ? "KSQL_NUMBER" : "KSQL_STRING",
+    sortKind: column === "$id" ? "number" : "string",
+    semantics: syntheticSemantics(column === "$id" ? "number" : "string")
+  }]));
+}
+async function executeExistingRecordValidation(stmt, client, options, cacheContext) {
+  if (stmt.errorTable) throw new Error("ArgumentError: VALIDATE INTO requires a batch.");
+  return executeExistingRecordValidationCore(stmt, client, options, cacheContext);
+}
+async function executeExistingRecordValidationCore(stmt, client, options, cacheContext) {
+  const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  const targets = resolveExistingValidationTargets(stmt, fieldInfos);
+  const checkGroups = stmt.checkGroups ?? [];
+  const checkRefs2 = collectCheckFieldRefs(checkGroups);
+  for (const ref of checkRefs2) {
+    if (ref.field !== "$id" && !infoByCode.has(ref.field)) {
+      throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F APP${stmt.appId} \u306B\u5B58\u5728\u3057\u307E\u305B\u3093`);
+    }
+  }
+  const evaluationTypes = new Map(fieldInfos.map((field) => [field.code, field.fieldType]));
+  evaluationTypes.set("$id", "RECORD_NUMBER");
+  assertCheckComparisonTypes(stmt, evaluationTypes);
+  const whereFields = collectValidateWhereFields(stmt.where);
+  const requiredFields = [.../* @__PURE__ */ new Set([
+    "$id",
+    ...targets.map((field) => field.code),
+    ...whereFields,
+    ...checkRefs2.map((ref) => ref.field)
+  ])];
+  for (const field of whereFields) {
+    if (field !== "$id" && !infoByCode.has(field)) {
+      throw new Error(`ArgumentError: WHERE field ${field} does not exist in APP${stmt.appId}.`);
+    }
+  }
+  const numberPrecision = targets.some((field) => field.fieldType === "NUMBER") ? await getNumberPrecisionCached(stmt.appId, client, cacheContext) : void 0;
+  const semantics = (field) => field.field === "$id" ? resolveFieldSemantics({ fieldType: "__ID__" }) : infoByCode.get(field.field)?.semantics ?? (infoByCode.has(field.field) ? resolveFieldSemantics(infoByCode.get(field.field)) : void 0);
+  const capability = classifyWhereCapability(stmt.where, semantics);
+  if (capability.capability === "UNSUPPORTED") {
+    throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
+  }
+  const fieldTypes = new Map(fieldInfos.map((field) => [field.code, field.fieldType]));
+  const fieldOptions = new Map(fieldInfos.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []));
+  const prefilter = stmt.where === null ? null : capability.capability === "EXACT_PUSHDOWN" ? stmt.where : extractSafePushdownLeaves(stmt.where, {
+    allowUnqualifiedFields: true,
+    fieldTypes,
+    fieldOptions,
+    allowKlike: false
+  });
+  const query = prefilter === null ? "" : whereToKintone(prefilter);
+  const records = await fetchAll(client.getRecords, stmt.appId, query, requiredFields, {
+    maxRecords: options.maxRecords ?? 1e4,
+    parallel: options.fetchParallel ?? 1,
+    onLimit: "error"
+  });
+  const validationRows = records.map((record) => ({
+    id: String(record["$id"]?.value ?? ""),
+    record,
+    flat: flatten(record, null)
+  })).filter((row) => stmt.where === null || evalWhere(stmt.where, row.flat, (field) => evaluationTypes.get(field.field)));
+  const rows = [];
+  for (const row of validationRows) {
+    for (const field of targets) {
+      const raw = row.record[field.code]?.value;
+      const validation = validateAndNormalizeDmlValue(raw, field, numberPrecision);
+      if (validation.ok) continue;
+      rows.push({
+        "$id": row.id,
+        "$err_field": field.code,
+        "$err_code": validation.code,
+        "$err_message": validation.message,
+        "$err_value": renderExistingValidationValue(raw, field.fieldType)
+      });
+    }
+    for (const check of evaluateCustomChecks(checkGroups, row.flat, (field) => evaluationTypes.get(field.field))) {
+      rows.push({
+        "$id": row.id,
+        "$err_field": "",
+        "$err_code": "ERR_CHECK",
+        "$err_message": check.message,
+        "$err_value": ""
+      });
+    }
+  }
+  const result = {
+    type: "SELECT",
+    columns: [...EXISTING_VALIDATION_COLUMNS],
+    rows,
+    rowCount: rows.length
+  };
+  materializedMetaBySelectResult.set(result, existingValidationColumnMeta());
+  return result;
+}
 var TEMP_TABLE_MAX_ROWS = 1e4;
 function appendValidationErrors(tempTables, name, columns, rows, maxRows, columnMeta) {
   const current = tempTables.get(name);
@@ -7636,9 +8349,14 @@ async function executeBatch(sql, client, options = {}) {
 }
 async function executeBatchStatement(stmt, info, client, options, cacheContext, tempTables, variables) {
   if (stmt.type === "SET_VARIABLE") {
-    const resolvedStmt2 = resolveVariableRefs(stmt, variables);
+    const resolvedStmt2 = resolveBatchVariableReferences(stmt, variables);
     validateKlikeStatement(resolvedStmt2);
-    if (resolvedStmt2.expr.type === "SCALAR_SUBQUERY") {
+    if (resolvedStmt2.expr.type === "ARRAY") {
+      variables.set(stmt.name, {
+        type: "array",
+        elements: resolvedStmt2.expr.elements.map((element) => ({ type: "string", value: element.value }))
+      });
+    } else if (resolvedStmt2.expr.type === "SCALAR_SUBQUERY") {
       try {
         const value = await evaluateScalarSubquery(
           resolvedStmt2.expr.query,
@@ -7675,8 +8393,27 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     }
     return {};
   }
-  const resolvedStmt = resolveVariableRefs(stmt, variables);
+  const resolvedStmt = resolveBatchVariableReferences(stmt, variables);
   validateKlikeStatement(resolvedStmt);
+  if (resolvedStmt.type === "VALIDATE") {
+    const result = await executeExistingRecordValidationCore(
+      resolvedStmt,
+      client,
+      { ...options, onLimitReached: "error" },
+      cacheContext
+    );
+    if (resolvedStmt.errorTable) {
+      appendValidationErrors(
+        tempTables,
+        resolvedStmt.errorTable,
+        result.columns,
+        result.rows,
+        options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
+        materializedMetaBySelectResult.get(result) ?? existingValidationColumnMeta()
+      );
+    }
+    return { result };
+  }
   if ("validateOnly" in resolvedStmt && resolvedStmt.validateOnly === true) {
     const result = await executeDmlValidation(
       resolvedStmt,
@@ -7861,9 +8598,9 @@ function evaluateScalarExpr(expr) {
     }
   }
 }
-function resolveVariableRefs(node, variables) {
+function resolveBatchVariableReferences(node, variables) {
   if (Array.isArray(node)) {
-    return node.map((v) => resolveVariableRefs(v, variables));
+    return node.map((v) => resolveBatchVariableReferences(v, variables));
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
@@ -7872,14 +8609,72 @@ function resolveVariableRefs(node, variables) {
       if (value === void 0) {
         throw new Error(`ParseError: variable @${obj["name"]} is not defined in this batch.`);
       }
+      if (value.type === "array") {
+        throw new Error(`ParseError: array variable @${obj["name"]} can only be used as IN @${obj["name"]}.`);
+      }
       return value.type === "number" ? { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) } : { type: "STRING", value: value.value };
     }
-    return Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [key, resolveVariableRefs(value, variables)])
+    if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
+      const value = variables.get(obj["name"]);
+      if (value === void 0) throw new Error(`ParseError: variable @${obj["name"]} is not defined in this batch.`);
+      if (value.type === "array") throw new Error(`ParseError: array variable @${obj["name"]} cannot be used as a SELECT column.`);
+      return value.type === "number" ? { type: "ARITH_COL", expr: { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) }, alias: obj["alias"] } : { type: "LITERAL_COL", value: value.value, alias: obj["alias"] };
+    }
+    if (obj["type"] === "VARIABLE_IN_LIST") return obj;
+    const resolved = Object.fromEntries(
+      Object.entries(obj).map(([key, value]) => [key, resolveBatchVariableReferences(value, variables)])
     );
+    if (resolved["type"] === "BINARY") {
+      const right = resolved["right"];
+      if (right?.["type"] === "VARIABLE_IN_LIST" && typeof right["name"] === "string") {
+        const value = variables.get(right["name"]);
+        if (value === void 0) throw new Error(`ParseError: variable @${right["name"]} is not defined in this batch.`);
+        if (value.type !== "array") {
+          throw new Error(`ParseError: scalar variable @${right["name"]} cannot be used as IN @${right["name"]}; use IN (@${right["name"]}) instead.`);
+        }
+        if (value.elements.length === 0) {
+          return { type: "BOOLEAN", value: resolved["op"] === "NOT_IN" };
+        }
+        resolved["right"] = {
+          type: "IN_LIST",
+          values: value.elements.map((element) => ({ type: "STRING", value: element.value }))
+        };
+      }
+    }
+    const simplified = simplifyBooleanWhere(resolved);
+    if (simplified["type"] === "SELECT" && isBooleanNode(simplified["where"], true)) {
+      simplified["where"] = null;
+    }
+    if ((simplified["type"] === "UPDATE" || simplified["type"] === "DELETE" || simplified["type"] === "REORDER") && isBooleanNode(simplified["where"], true)) {
+      throw new Error("ArgumentError: empty-array simplification makes the target WHERE always true; use an explicit safe target condition.");
+    }
+    return simplified;
   }
   return node;
 }
+function isBooleanNode(value, expected) {
+  return value !== null && typeof value === "object" && value.type === "BOOLEAN" && (expected === void 0 || value.value === expected);
+}
+function simplifyBooleanWhere(obj) {
+  if (obj["type"] === "NOT" && isBooleanNode(obj["expr"])) {
+    return { type: "BOOLEAN", value: !obj["expr"].value };
+  }
+  if (obj["type"] === "GROUP" && isBooleanNode(obj["expr"])) return obj["expr"];
+  if (obj["type"] === "LOGICAL") {
+    const left = obj["left"];
+    const right = obj["right"];
+    if (obj["op"] === "AND") {
+      if (isBooleanNode(left, false) || isBooleanNode(right, false)) return { type: "BOOLEAN", value: false };
+      if (isBooleanNode(left, true)) return right;
+      if (isBooleanNode(right, true)) return left;
+    } else if (obj["op"] === "OR") {
+      if (isBooleanNode(left, true) || isBooleanNode(right, true)) return { type: "BOOLEAN", value: true };
+      if (isBooleanNode(left, false)) return right;
+      if (isBooleanNode(right, false)) return left;
+    }
+  }
+  return obj;
+}
 function findVariableRef(node) {
   if (Array.isArray(node)) {
     for (const value of node) {
@@ -7890,7 +8685,7 @@ function findVariableRef(node) {
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
-    if (obj["type"] === "VARIABLE" && typeof obj["name"] === "string") return obj["name"];
+    if ((obj["type"] === "VARIABLE" || obj["type"] === "VARIABLE_COL" || obj["type"] === "VARIABLE_IN_LIST") && typeof obj["name"] === "string") return obj["name"];
     for (const value of Object.values(obj)) {
       const found = findVariableRef(value);
       if (found !== null) return found;
@@ -8100,7 +8895,7 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
       }
     } 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") {
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_SUBQUERY_COL" || column.type === "CASE_COL" || column.type === "SCALAR_VALUE_COL") {
       semantics = syntheticSemantics("string");
     }
     if (semantics) aliases.set(column.alias, semantics);
@@ -8133,6 +8928,7 @@ 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]));
+  if (stmt.where.type === "BOOLEAN" && stmt.where.value === false) return;
   const result = classifyWhereCapability(stmt.where, (field) => {
     if (field.field === "$id") return resolveFieldSemantics({ fieldType: "__ID__" });
     const info = byCode.get(field.field);
@@ -8205,6 +9001,9 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   }
   return result;
 }
+function isConstantFalseWhere(where) {
+  return where?.type === "BOOLEAN" && where.value === false;
+}
 function isNoFromSelect(stmt) {
   return stmt.from.appId === 0 && stmt.from.cteName === NO_FROM_CTE_NAME;
 }
@@ -8215,10 +9014,19 @@ function arithHasFieldRef(node) {
   return false;
 }
 function stringFuncArgHasFieldRef(arg) {
-  if (arg.type === "FIELD_REF") return true;
-  if (arg.type === "ARITH") return arithHasFieldRef(arg);
-  if (arg.type === "STRING_FUNC") return stringFuncHasFieldRef(arg);
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return true;
+  return scalarValueHasFieldRef(arg);
+}
+function scalarValueHasFieldRef(expr) {
+  if (expr.type === "FIELD") return true;
+  if (expr.type === "STRING_FUNC") return stringFuncHasFieldRef(expr);
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    return scalarValueHasFieldRef(expr.left) || scalarValueHasFieldRef(expr.right);
+  }
+  if (expr.type === "CASE_WHEN") {
+    const results = [...expr.branches.map((branch) => branch.result), ...expr.elseResult ? [expr.elseResult] : []];
+    return results.some((result) => result.type !== "ARRAY" && (result.type === "FIELD_REF" || result.type === "ARITH" ? arithHasFieldRef(result) : scalarValueHasFieldRef(result)));
+  }
   return false;
 }
 function stringFuncHasFieldRef(expr) {
@@ -8227,6 +9035,8 @@ function stringFuncHasFieldRef(expr) {
 function validateNoFromColumns(stmt) {
   for (const col of stmt.columns) {
     switch (col.type) {
+      case "VARIABLE_COL":
+        throw new Error(`internal error: unresolved SELECT variable @${col.name}`);
       case "LITERAL_COL":
         break;
       case "ARITH_COL":
@@ -8239,6 +9049,11 @@ function validateNoFromColumns(stmt) {
           throw new Error("ArgumentError: field reference is not allowed without FROM.");
         }
         break;
+      case "SCALAR_VALUE_COL":
+        if (scalarValueHasFieldRef(col.expr)) {
+          throw new Error("ArgumentError: field reference is not allowed without FROM.");
+        }
+        break;
       case "WINDOW_COL":
         if (col.partitionBy.length > 0 || col.orderBy.length > 0) {
           throw new Error("ArgumentError: field reference is not allowed without FROM.");
@@ -8457,6 +9272,7 @@ function collectTypedInFieldRefs(expr, out) {
       return;
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return;
   }
 }
@@ -8525,8 +9341,26 @@ function collectStringFuncAggregateRefs(expr, out) {
   for (const arg of expr.args) {
     if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") {
       collectAggregateOperandRefs(arg, out);
-    } else if (arg.type === "STRING_FUNC") {
-      collectStringFuncAggregateRefs(arg, out);
+    } else {
+      collectScalarAggregateRefs(arg, out);
+    }
+  }
+}
+function collectScalarAggregateRefs(expr, out) {
+  if (expr.type === "STRING_FUNC") {
+    collectStringFuncAggregateRefs(expr, out);
+    return;
+  }
+  if (expr.type === "SCALAR_ARITH" || expr.type === "CONCAT_OP") {
+    collectScalarAggregateRefs(expr.left, out);
+    collectScalarAggregateRefs(expr.right, out);
+    return;
+  }
+  if (expr.type === "CASE_WHEN") {
+    const results = [...expr.branches.map((branch) => branch.result), ...expr.elseResult ? [expr.elseResult] : []];
+    for (const result of results) {
+      if (result.type === "STRING_FUNC") collectStringFuncAggregateRefs(result, out);
+      else if (result.type !== "ARRAY" && result.type !== "FIELD_REF" && result.type !== "ARITH") collectScalarAggregateRefs(result, out);
     }
   }
 }
@@ -8539,6 +9373,8 @@ function collectSelectAggregateSortRefs(columns) {
       collectAggregateOperandRefs(column.expr, refs);
     } else if (column.type === "STRFUNC_COL") {
       collectStringFuncAggregateRefs(column.expr, refs);
+    } else if (column.type === "SCALAR_VALUE_COL") {
+      collectScalarAggregateRefs(column.expr, refs);
     }
   }
   return refs;
@@ -8704,10 +9540,11 @@ function stringFunctionColumnMeta(expr) {
 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 === "NUMBER" || result.type === "ARITH" || result.type === "SCALAR_ARITH") return syntheticColumnMeta("number");
   if (result.type === "STRING_FUNC") return stringFunctionColumnMeta(result);
-  const source = resolveField2(aggregateFieldRef(result.field));
-  return source ?? unknownStringColumnMeta();
+  if (result.type === "FIELD_REF") return resolveField2(aggregateFieldRef(result.field)) ?? unknownStringColumnMeta();
+  if (result.type === "FIELD") return resolveField2(result) ?? unknownStringColumnMeta();
+  return unknownStringColumnMeta();
 }
 function mergeExpressionColumnMeta(candidates) {
   if (candidates.length === 0) return unknownStringColumnMeta();
@@ -8809,7 +9646,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
       meta = syntheticColumnMeta("number");
-    } else if (column.type === "LITERAL_COL") {
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") {
       meta = syntheticColumnMeta("string");
     } else if (column.type === "STRFUNC_COL") {
       meta = stringFunctionColumnMeta(column.expr);
@@ -8898,7 +9735,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   validateKlikePushdownPlan(pushdownPlan);
   const mainPushDown = pushdownPlan.mainCondition;
   const tableConditions = pushdownPlan.joinConditions;
-  const mainFetch = fetchTableRecordsForFullScan(
+  const constantFalse = isConstantFalseWhere(stmt.where);
+  const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
     stmt.from,
     client,
@@ -8913,6 +9751,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const parallelJoins = [];
   const onOptJoins = [];
   for (const join2 of stmt.joins) {
+    if (constantFalse) {
+      parallelJoins.push({ join: join2, promise: Promise.resolve([]) });
+      continue;
+    }
     const jCond = join2.table.alias ? tableConditions.get(join2.table.alias) ?? null : null;
     if (jCond !== null) {
       parallelJoins.push({
@@ -9516,7 +10358,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     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 === "LITERAL_COL" || column.type === "SCALAR_VALUE_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") {
@@ -9704,7 +10546,7 @@ var RejectLimitExceededError = class extends Error {
     this.name = "RejectLimitExceededError";
   }
 };
-async function prepareDmlValidation(stmt, client, options, cacheContext, tempTables, statementNumber) {
+async function prepareDmlValidation(stmt, client, options, cacheContext, tempTables, statementNumber, validateMissingCreateFields = true, includePreErrors = true) {
   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) {
@@ -9736,7 +10578,10 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     targetFields,
     fieldInfos,
     statementNumber,
-    numberPrecision
+    numberPrecision,
+    stmt.checkGroups ?? [],
+    validateMissingCreateFields,
+    includePreErrors
   );
   const columns = [...payloadFields, ...VALIDATION_META_COLUMNS];
   const result = {
@@ -9846,15 +10691,33 @@ async function executeOnErrorSkip(stmt, client, options, cacheContext, tempTable
 async function materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode) {
   if (stmt.type === "UPDATE") return materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables);
   let rows;
+  let sourceRows;
+  let evaluationTypes;
   if (stmt.type === "INSERT" || stmt.type === "UPSERT") {
+    assertInsertCheckRefs(stmt, stmt.fields);
+    evaluationTypes = new Map(stmt.fields.map((field) => [field, infoByCode.get(field)?.fieldType ?? ""]));
+    assertCheckComparisonTypes(stmt, evaluationTypes);
     rows = stmt.values.map((row) => row.map(
       (value, i) => value.type === "CASE_VALUE" ? evalCaseWhenValue(value.expr, {}, infoByCode.get(stmt.fields[i])?.fieldType) : value
     ));
   } else {
-    const selectResult = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, { ...options, onLimitReached: "error" }, tempTables, cacheContext) : await executeSelect(stmt.select, client, { ...options, onLimitReached: "error" }, cacheContext);
-    if (selectResult.columns.length !== stmt.fields.length) {
+    const selectResult = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, { ...options, onLimitReached: "error" }, tempTables, cacheContext) : await executeSelect(stmt.select, client, { ...options, onLimitReached: "error" }, cacheContext, void 0, true);
+    const hasChecks = (stmt.checkGroups?.length ?? 0) > 0;
+    if (selectResult.columns.length < stmt.fields.length || !hasChecks && selectResult.columns.length !== stmt.fields.length) {
       throw new Error(`SELECT \u306E\u5217\u6570\uFF08${selectResult.columns.length}\uFF09\u3068 DML \u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u6570\uFF08${stmt.fields.length}\uFF09\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`);
     }
+    if (hasChecks && new Set(selectResult.columns).size !== selectResult.columns.length) {
+      throw customCheckParseError("CHECK \u4ED8\u304D DML \u30BD\u30FC\u30B9 SELECT \u306E\u51FA\u529B\u540D\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
+    }
+    assertInsertCheckRefs(stmt, selectResult.columns);
+    sourceRows = selectResult.rows;
+    const meta = materializedMetaBySelectResult.get(selectResult);
+    evaluationTypes = new Map(selectResult.columns.map((column) => {
+      const columnMeta = meta?.get(column);
+      const type = columnMeta?.fieldType ?? (columnMeta?.semantics?.compareMode === "number" || columnMeta?.sortKind === "number" ? "NUMBER" : "SINGLE_LINE_TEXT");
+      return [column, type];
+    }));
+    assertCheckComparisonTypes(stmt, evaluationTypes);
     rows = selectResult.rows.map((row) => selectResult.columns.map((column) => row[column] ?? ""));
   }
   const candidates = rows.map((values, index) => ({
@@ -9863,7 +10726,11 @@ async function materializeValidationCandidates(stmt, operation, client, options,
     mode: "create",
     payload: new Map(stmt.fields.map((field, i) => [field, values[i]])),
     preErrors: [],
-    record: {}
+    record: {},
+    evaluationRow: sourceRows?.[index] ?? Object.fromEntries(
+      stmt.fields.map((field, i) => [field, renderValidationValue(values[i])])
+    ),
+    evaluationFieldTypes: evaluationTypes
   }));
   if (stmt.type !== "UPSERT" && stmt.type !== "UPSERT_SELECT") return candidates;
   for (const key of stmt.keyFields) {
@@ -9892,26 +10759,74 @@ async function materializeValidationCandidates(stmt, operation, client, options,
   });
   return candidates;
 }
+function checkRefs(stmt) {
+  return stmt.checkGroups ? collectCheckFieldRefs(stmt.checkGroups) : [];
+}
+function assertInsertCheckRefs(stmt, available) {
+  const names = new Set(available);
+  for (const ref of checkRefs(stmt)) {
+    if (ref.tableAlias !== null) {
+      throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.tableAlias}.${ref.field} \u306F\u3053\u306E\u8A55\u4FA1\u884C\u3067\u306F\u4FEE\u98FE\u3067\u304D\u307E\u305B\u3093`);
+    }
+    if (!names.has(ref.field)) {
+      throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u8A55\u4FA1\u884C\u306B\u5B58\u5728\u3057\u307E\u305B\u3093`);
+    }
+  }
+}
+var CHECK_UNSUPPORTED_COMPARISON_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "FILE",
+  "KSQL_ARRAY"
+]);
+function assertCheckComparisonTypes(stmt, types) {
+  if (!stmt.checkGroups) return;
+  for (const ref of collectCheckComparisonFieldRefs(stmt.checkGroups)) {
+    const key = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+    const type = types.get(key) ?? types.get(ref.field);
+    if (CHECK_UNSUPPORTED_COMPARISON_TYPES.has(type ?? "")) {
+      throw customCheckParseError(`CHECK \u306E\u6BD4\u8F03\u3067\u306F ${type} \u30D5\u30A3\u30FC\u30EB\u30C9 ${key} \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
+    }
+  }
+}
 async function materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables) {
   if (stmt.from) return materializeUpdateFromValidationCandidates(stmt, stmt.from, client, options, cacheContext, tempTables);
   await resolveSetSubqueries(stmt.assignments, client, options, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const checkTargetFields = assertUpdateCheckRefs(stmt, fieldTypes);
+  assertCheckComparisonTypes(stmt, updateEvaluationTypes(fieldTypes, stmt.appId));
   let records;
+  let evaluationById = /* @__PURE__ */ new Map();
   if (hasRowDependentAssignment(stmt)) {
     const getParams = updateToGetQueryForArith(stmt);
-    const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [...getParams.fields], {
+    const fields = [.../* @__PURE__ */ new Set([...getParams.fields, ...checkTargetFields])];
+    const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, fields, {
       maxRecords: options.maxRecords ?? 1e4,
       parallel: options.fetchParallel ?? 1,
       onLimit: "error"
     });
+    evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
     records = updateToPutBatchesArith(stmt, resolved.records, fieldTypes).flatMap((batch) => batch.records);
   } else {
     const getParams = updateToGetQuery(stmt);
-    const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
-      maxRecords: options.maxRecords ?? 1e4,
-      parallel: options.fetchParallel ?? 1
-    });
-    records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+    if (checkTargetFields.length > 0) {
+      const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [.../* @__PURE__ */ new Set(["$id", ...checkTargetFields])], {
+        maxRecords: options.maxRecords ?? 1e4,
+        parallel: options.fetchParallel ?? 1,
+        onLimit: "error"
+      });
+      evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
+      records = updateToPutBatches(stmt, [...evaluationById.keys()], fieldTypes).flatMap((batch) => batch.records);
+    } else {
+      const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
+        maxRecords: options.maxRecords ?? 1e4,
+        parallel: options.fetchParallel ?? 1
+      });
+      records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+    }
   }
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
     rowNumber: index + 1,
@@ -9920,13 +10835,48 @@ async function materializeUpdateValidationCandidates(stmt, client, options, cach
     payload: new Map([["$id", String(entry.id)], ...stmt.assignments.map((a) => [a.field, entry.record[a.field]?.value ?? ""])]),
     preErrors: [],
     record: entry.record,
-    targetId: entry.id
+    targetId: entry.id,
+    evaluationRow: updateEvaluationRow(evaluationById.get(entry.id), stmt.appId),
+    evaluationFieldTypes: updateEvaluationTypes(fieldTypes, stmt.appId)
   }));
 }
+function assertUpdateCheckRefs(stmt, targetTypes) {
+  if (stmt.from) return [];
+  const fields = /* @__PURE__ */ new Set();
+  for (const ref of checkRefs(stmt)) {
+    if (ref.tableAlias !== null && ref.tableAlias.toLowerCase() !== `app${stmt.appId}`.toLowerCase()) {
+      throw customCheckParseError(`CHECK \u306E\u4FEE\u98FE\u5B50 ${ref.tableAlias} \u306F\u66F4\u65B0\u5148 APP${stmt.appId} \u3067\u306F\u3042\u308A\u307E\u305B\u3093`);
+    }
+    if (ref.field !== "$id" && !targetTypes.has(ref.field)) {
+      throw customCheckParseError(`CHECK \u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u5B58\u5728\u3057\u307E\u305B\u3093`);
+    }
+    fields.add(ref.field);
+  }
+  return [...fields];
+}
+function updateEvaluationRow(record, appId) {
+  if (!record) return {};
+  const plain = flatten(record, null);
+  return Object.fromEntries([
+    ...Object.entries(plain),
+    ...Object.entries(plain).map(([field, value]) => [`APP${appId}.${field}`, value])
+  ]);
+}
+function updateEvaluationTypes(types, appId) {
+  return new Map([
+    ...types,
+    ...[...types].map(([field, type]) => [`APP${appId}.${field}`, type]),
+    ["$id", "RECORD_NUMBER"],
+    [`APP${appId}.$id`, "RECORD_NUMBER"]
+  ]);
+}
 async function materializeUpdateFromValidationCandidates(stmt, from, client, options, cacheContext, tempTables) {
+  const scope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
+  assertCheckComparisonTypes(stmt, scope.evaluationTypes);
   const matched = await resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const records = updateFromToPutBatches(stmt, matched, fieldTypes).flatMap((batch) => batch.records);
+  const matchedById = new Map(matched.map((pair) => [Number(pair.target["$id"]?.value), pair]));
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
     rowNumber: index + 1,
     operation: "UPDATE",
@@ -9934,7 +10884,9 @@ async function materializeUpdateFromValidationCandidates(stmt, from, client, opt
     payload: new Map([["$id", String(entry.id)], ...stmt.assignments.map((a) => [a.field, entry.record[a.field]?.value ?? ""])]),
     preErrors: [],
     record: entry.record,
-    targetId: entry.id
+    targetId: entry.id,
+    evaluationRow: updateFromEvaluationRow(matchedById.get(entry.id), stmt.appId, from.alias),
+    evaluationFieldTypes: scope.evaluationTypes
   }));
 }
 var UPDATE_FROM_KEY_CHUNK_SIZE = UPSERT_IN_CHUNK_SIZE;
@@ -9948,7 +10900,8 @@ var UPDATE_FROM_UNSUPPORTED_SOURCE_TYPES = /* @__PURE__ */ new Set([
 ]);
 async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables) {
   const joinKind = await resolveUpdateFromTargetJoinKind(stmt, from, client, cacheContext);
-  const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : ""))];
+  const checkScope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
+  const sourceFields = [...new Set(stmt.assignments.filter((a) => a.value.type === "SOURCE_FIELD").map((a) => a.value.type === "SOURCE_FIELD" ? a.value.field : "").concat(checkScope.sourceFields))];
   const requiredSourceFields = [.../* @__PURE__ */ new Set([from.joinKeyField, ...sourceFields])];
   const sourceRows = await loadUpdateFromSourceRows(
     from,
@@ -9974,8 +10927,8 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   }
   if (sourceByKey.size === 0) return [];
   const maxRecords = options.maxRecords ?? 1e4;
-  const targetFields = collectUpdateFromTargetFields(stmt);
-  const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter }).query;
+  const targetFields = [.../* @__PURE__ */ new Set([...collectUpdateFromTargetFields(stmt), ...checkScope.targetFields])];
+  const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter, checkGroups: void 0 }).query;
   const targetRecords = [];
   const seenTargetIds = /* @__PURE__ */ new Set();
   let fetchedTargetCount = 0;
@@ -10093,7 +11046,54 @@ function normalizeUpdateFromJoinKey(raw, kind, side) {
   }
   return JSON.stringify(decimal);
 }
+async function executeCheckedPlainDml(stmt, client, options, cacheContext, tempTables) {
+  const prepared = await prepareDmlValidation(
+    stmt,
+    client,
+    options,
+    cacheContext,
+    tempTables,
+    1,
+    false,
+    false
+  );
+  if (prepared.result.errors.length > 0) {
+    const first = prepared.result.errors[0];
+    throw new Error(
+      `DmlValidationError: ${first["$err_code"]} ${first["$err_message"]} (row=${first["$err_row"]}, field=${first["$err_field"]})`
+    );
+  }
+  const candidates = prepared.candidates;
+  const confirmOperation = stmt.type.startsWith("INSERT") ? "INSERT" : "UPDATE";
+  if (options.confirm && candidates.length > 0) {
+    const ok = await options.confirm(candidates.length, confirmOperation);
+    if (!ok) throw new OperationCancelledError(confirmOperation, candidates.length);
+  }
+  if (stmt.type === "INSERT" || stmt.type === "INSERT_SELECT") {
+    const createdIds = [];
+    for (let i = 0; i < candidates.length; i += 100) {
+      const response = await client.postRecords({ app: stmt.appId, records: candidates.slice(i, i + 100).map((c) => c.record) });
+      createdIds.push(response.ids);
+    }
+    return { type: "INSERT", createdIds, insertedCount: createdIds.flat().length };
+  }
+  if (stmt.type === "UPDATE") {
+    const updates2 = candidates.map((candidate) => ({ id: candidate.targetId, record: candidate.record }));
+    for (let i = 0; i < updates2.length; i += 100) await client.putRecords({ app: stmt.appId, records: updates2.slice(i, i + 100) });
+    return { type: "UPDATE", updatedCount: updates2.length };
+  }
+  const inserts = candidates.filter((candidate) => candidate.mode === "create");
+  const updates = candidates.filter((candidate) => candidate.mode === "update").map((candidate) => ({ id: candidate.targetId, record: candidate.record }));
+  let insertedCount = 0;
+  for (let i = 0; i < inserts.length; i += 100) {
+    const response = await client.postRecords({ app: stmt.appId, records: inserts.slice(i, i + 100).map((c) => c.record) });
+    insertedCount += response.ids.length;
+  }
+  for (let i = 0; i < updates.length; i += 100) await client.putRecords({ app: stmt.appId, records: updates.slice(i, i + 100) });
+  return { type: "UPSERT", insertedCount, updatedCount: updates.length };
+}
 async function executeInsert(stmt, client, options, cacheContext) {
+  if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext);
   if (stmt.subtableCode) {
     return executeInsertSubtable(stmt, client, options, cacheContext);
   }
@@ -10114,6 +11114,7 @@ async function executeInsert(stmt, client, options, cacheContext) {
   };
 }
 async function executeInsertSelect(stmt, client, options, cacheContext, cteCache) {
+  if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext, cteCache);
   const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
   const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
@@ -10151,6 +11152,27 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
   };
 }
 async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
+  if (stmt.checkGroups?.length && isConstantFalseWhere(stmt.where)) {
+    const fieldInfos2 = await loadWritableTopLevelDmlFields(
+      stmt.appId,
+      stmt.assignments.map((assignment) => assignment.field),
+      client,
+      cacheContext
+    );
+    await loadNumberPrecisionForTargets(
+      stmt.appId,
+      stmt.assignments.map((assignment) => assignment.field),
+      fieldInfos2,
+      client,
+      cacheContext
+    );
+    const fieldTypes2 = await getFieldTypeMap(stmt.appId, client, cacheContext);
+    assertUpdateCheckRefs(stmt, fieldTypes2);
+    assertCheckComparisonTypes(stmt, updateEvaluationTypes(fieldTypes2, stmt.appId));
+    await assertDmlWhereCapability(stmt, client, cacheContext);
+    return { type: "UPDATE", updatedCount: 0 };
+  }
+  if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext, tempTables);
   if (stmt.subtableCode) {
     await assertDmlWhereCapability(stmt, client, cacheContext);
     return executeUpdateSubtable(stmt, client, options, cacheContext);
@@ -10170,6 +11192,7 @@ async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
     cacheContext
   );
   await assertDmlWhereCapability(stmt, client, cacheContext);
+  if (isConstantFalseWhere(stmt.where)) return { type: "UPDATE", updatedCount: 0 };
   if (stmt.from != null) {
     return executeUpdateFrom(stmt, stmt.from, client, options, cacheContext, tempTables);
   }
@@ -10251,6 +11274,7 @@ function collectUpdateFromTargetFields(stmt) {
 }
 async function executeDelete(stmt, client, options, cacheContext) {
   await assertDmlWhereCapability(stmt, client, cacheContext);
+  if (isConstantFalseWhere(stmt.where)) return { type: "DELETE", deletedCount: 0 };
   if (stmt.subtableCode) {
     return executeDeleteSubtable(stmt, client, options, cacheContext);
   }
@@ -10276,6 +11300,7 @@ async function executeDelete(stmt, client, options, cacheContext) {
   return { type: "DELETE", deletedCount: ids.length };
 }
 async function executeUpsert(stmt, client, options, cacheContext) {
+  if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext);
   const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
   const toInsert = [];
@@ -10632,6 +11657,7 @@ async function executeReorder(stmt, client, options, cacheContext) {
     cacheContext
   );
   const reorderFields = await getFieldsCached(stmt.appId, client, cacheContext);
+  if (isConstantFalseWhere(stmt.where)) return { type: "REORDER", reorderedParentCount: 0 };
   const reorderSemanticsByCode = new Map(reorderFields.map((field) => [
     field.code,
     field.semantics ?? resolveFieldSemantics(field)
@@ -10710,6 +11736,7 @@ function evalOrderKeyForRow(key, row) {
   }
 }
 async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache) {
+  if (stmt.checkGroups?.length) return executeCheckedPlainDml(stmt, client, options, cacheContext, cteCache);
   const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
   const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
   const selectResult = cteCache !== void 0 && cteCache.size > 0 ? await executeQueryWithCte(stmt.select, client, options, cteCache, cacheContext) : await executeSelect(stmt.select, client, options, cacheContext);
@@ -10857,6 +11884,8 @@ function collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCa
       }));
       break;
     }
+    case "BOOLEAN":
+      break;
   }
 }
 async function resolveSetSubqueries(assignments, client, options, cacheContext) {
@@ -10894,9 +11923,11 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   pending.forEach(([i], idx) => cache.set(i, values[idx]));
   return cache;
 }
+var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
+  const numberPrecisionApps = /* @__PURE__ */ new Set();
   const tracedClient = {
     ...client,
     getFields: async (appId) => {
@@ -10906,6 +11937,10 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     getProcessStatuses: async (appId) => {
       processStatusApps.add(appId);
       return client.getProcessStatuses(appId);
+    },
+    getNumberPrecision: async (appId) => {
+      numberPrecisionApps.add(appId);
+      return client.getNumberPrecision(appId);
     }
   };
   const capabilities = /* @__PURE__ */ new Map();
@@ -10954,6 +11989,51 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
           }));
         }
       }
+    } else if (typed["type"] === "VALIDATE") {
+      const validate = node;
+      fieldApps.add(validate.appId);
+      const fields = await getFieldsCached(validate.appId, tracedClient, cacheContext);
+      const infoByCode = new Map(fields.map((field) => [field.code, field]));
+      const targets = resolveExistingValidationTargets(validate, fields);
+      const checks = collectCheckFieldRefs(validate.checkGroups ?? []);
+      const whereFields = collectValidateWhereFields(validate.where);
+      for (const ref of checks) {
+        if (ref.field !== "$id" && !infoByCode.has(ref.field)) {
+          throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F APP${validate.appId} \u306B\u5B58\u5728\u3057\u307E\u305B\u3093`);
+        }
+      }
+      for (const field of whereFields) {
+        if (field !== "$id" && !infoByCode.has(field)) {
+          throw new Error(`ArgumentError: WHERE field ${field} does not exist in APP${validate.appId}.`);
+        }
+      }
+      const types = new Map(fields.map((field) => [field.code, field.fieldType]));
+      types.set("$id", "RECORD_NUMBER");
+      assertCheckComparisonTypes(validate, types);
+      const capability = classifyWhereCapability(validate.where, (field) => field.field === "$id" ? resolveFieldSemantics({ fieldType: "__ID__" }) : infoByCode.get(field.field)?.semantics ?? (infoByCode.has(field.field) ? resolveFieldSemantics(infoByCode.get(field.field)) : void 0));
+      if (capability.capability === "UNSUPPORTED") {
+        throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
+      }
+      const fieldTypes = new Map(fields.map((field) => [field.code, field.fieldType]));
+      const fieldOptions = new Map(fields.flatMap((field) => field.optionOrder ? [[field.code, new Set(Object.keys(field.optionOrder))]] : []));
+      const prefilter = validate.where === null ? null : capability.capability === "EXACT_PUSHDOWN" ? validate.where : extractSafePushdownLeaves(validate.where, {
+        allowUnqualifiedFields: true,
+        fieldTypes,
+        fieldOptions,
+        allowKlike: false
+      });
+      const needsPrecision = targets.some((field) => field.fieldType === "NUMBER");
+      if (needsPrecision) {
+        numberPrecisionApps.add(validate.appId);
+        await getNumberPrecisionCached(validate.appId, tracedClient, cacheContext);
+      }
+      validateExplainInfo.set(validate, {
+        targetFields: targets.map((field) => field.code),
+        fetchFields: [.../* @__PURE__ */ new Set(["$id", ...targets.map((field) => field.code), ...whereFields, ...checks.map((ref) => ref.field)])],
+        capability,
+        prefilter,
+        numberPrecision: needsPrecision
+      });
     } else if (typed["type"] === "UPDATE" || typed["type"] === "DELETE") {
       fieldApps.add(node.appId);
       await assertDmlWhereCapability(
@@ -10984,12 +12064,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       }));
     }
   }
-  return { capabilities, orderPlans, fieldApps, processStatusApps };
+  return { capabilities, orderPlans, fieldApps, processStatusApps, numberPrecisionApps };
 }
 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}`)
+    ...[...analysis.processStatusApps].sort((a, b) => a - b).map((appId) => `  metadata API: process status APP${appId}`),
+    ...[...analysis.numberPrecisionApps].sort((a, b) => a - b).map((appId) => `  metadata API: number precision APP${appId}`)
   ];
 }
 async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2) {
@@ -11000,7 +12081,7 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
   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);
+    const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
     validateKlikeStatement(planStmt);
     const whereAnalysis = await buildExplainWhereAnalysis(planStmt, client, cacheContext, maxRecords);
     const statementPlan = addCursorConcurrency(buildBatchStatementPlan(
@@ -11016,7 +12097,7 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
       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}` });
+      variables.set(stmt.name, stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? { type: "array", elements: stmt.expr.elements.map((element) => ({ type: "string", value: element.value })) } : { type: "string", value: `@${stmt.name}` });
     }
   }
   return { statementCount: statements.length, statements: plans };
@@ -11151,8 +12232,30 @@ function buildExplainPlan(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);
+  if (query.type === "VALIDATE") return buildValidatePlan(query, label);
   return buildSelectPlan(query, label, capabilities, orderPlans);
 }
+function buildValidatePlan(stmt, label) {
+  const info = validateExplainInfo.get(stmt);
+  const lines = [];
+  if (label) lines.push(label);
+  lines.push(`VALIDATE APP${stmt.appId}`);
+  lines.push("  operation:     read-only existing-record constraint audit (writesKintone=false)");
+  lines.push("  fetch API:     GET records via offset + $id keyset paging (Cursor API unused)");
+  lines.push("  complete input: required (onLimit=truncate disabled)");
+  if (!info) {
+    lines.push("  metadata:      form definition required; number precision required for NUMBER targets");
+    return lines;
+  }
+  lines.push(`  WHERE capability: ${info.capability.capability}`);
+  lines.push(`  kintone query: ${info.prefilter === null ? "(\u5168\u4EF6\u53D6\u5F97)" : whereToKintone(info.prefilter)}`);
+  lines.push(`  audit fields:  ${info.targetFields.length === 0 ? "(\u306A\u3057)" : info.targetFields.join(", ")}`);
+  lines.push(`  fetch fields:  ${info.fetchFields.join(", ")}`);
+  lines.push(`  number precision: ${info.numberPrecision ? "required" : "not required"}`);
+  lines.push("  local checks:  original WHERE re-evaluation + built-in constraints + CHECK groups");
+  lines.push("  records/mutation API during EXPLAIN: none; violation count unavailable");
+  return lines;
+}
 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);
@@ -11164,6 +12267,12 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans) {
   const lines = [];
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
+  if (isConstantFalseWhere(stmt.where)) {
+    lines.push("  predicate:     constant false");
+    lines.push("  records API access: none");
+    lines.push(`  app:           APP${stmt.from.appId} (${stmt.from.appId})`);
+    return lines;
+  }
   if (orderPlan) {
     lines.push(`  order plan:    ${orderPlan.kind}`);
     if (orderPlan.reasonCodes.length > 0) lines.push(`  order reason:  ${orderPlan.reasonCodes.join(", ")}`);
@@ -11311,6 +12420,8 @@ function collectSubqueryPlans(stmt, capabilities, orderPlans) {
         break;
       case "NULL_CHECK":
         break;
+      case "BOOLEAN":
+        break;
     }
   };
   visitWhere(stmt.where);
@@ -11363,7 +12474,7 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans) {
   } else {
     lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
   }
-  lines.push(`  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
+  lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
   const setTypes = [];
   if (isArith) setTypes.push("\u7B97\u8853 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A08\u7B97\uFF09");
   if (isStringFunc) setTypes.push("\u6587\u5B57\u5217\u95A2\u6570 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A55\u4FA1\uFF09");
@@ -11394,7 +12505,7 @@ function buildDeletePlan(stmt, label) {
   lines.push(`  [DELETE]`);
   lines.push(`  target:        APP${stmt.appId} (${stmt.appId})`);
   lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
-  lines.push(`  api:           GET /k/v1/records.json \u2192 DELETE /k/v1/records.json`);
+  lines.push(isConstantFalseWhere(stmt.where) ? "  api:           metadata validation only (records API access: none)" : `  api:           GET /k/v1/records.json \u2192 DELETE /k/v1/records.json`);
   return lines;
 }
 function buildUpsertPlan(stmt, label) {
@@ -11434,7 +12545,7 @@ function buildReorderPlan(stmt, label) {
     `  table:  ${target}`,
     `  scope:  ${scope}`,
     `  by:     ${byStr}`,
-    `  api:    GET /k/v1/records.json\uFF08\u884C ID \u53D6\u5F97\uFF09\u2192 PUT /k/v1/records.json\uFF08id \u914D\u5217\u306E\u307F\u9001\u4FE1\uFF09`
+    isConstantFalseWhere(stmt.where) ? `  api:    metadata validation only (records API access: none)` : `  api:    GET /k/v1/records.json\uFF08\u884C ID \u53D6\u5F97\uFF09\u2192 PUT /k/v1/records.json\uFF08id \u914D\u5217\u306E\u307F\u9001\u4FE1\uFF09`
   ];
   if (!stmt.all && stmt.where) {
     lines.splice(5, 0, `  where:  ${safeWhereToKintone(stmt.where)}`);
@@ -11446,6 +12557,7 @@ function formatOrderByItem(item) {
   return `${key} ${item.direction}`;
 }
 function safeWhereToKintone(where) {
+  if (where.type === "BOOLEAN") return where.value ? "TRUE" : "FALSE (constant)";
   try {
     return whereToKintone(where);
   } catch {
@@ -11457,6 +12569,7 @@ function collectArithRefFields(stmt) {
   for (const { value } of stmt.assignments) {
     if (value.type === "ARITH") collectArithNodeRefs(value, refs);
     if (value.type === "STRING_FUNC") collectArithNodeRefs(value, refs);
+    if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") collectScalarNodeRefs(value, refs);
   }
   return [...refs];
 }
@@ -11471,10 +12584,74 @@ function collectArithNodeRefs(node, out) {
   }
   if (node.type === "STRING_FUNC") {
     for (const arg of node.args) {
-      if (arg.type !== "STRING" && arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") {
-        collectArithNodeRefs(arg, out);
+      if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") collectScalarNodeRefs(arg, out);
+    }
+  }
+}
+async function resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables) {
+  const refs = checkRefs(stmt);
+  const targetTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const sourceTableName = from.cteName;
+  const sourceTypes = sourceTableName !== null ? new Map((tempTables?.get(sourceTableName)?.columns ?? []).map((column) => [
+    column,
+    tempTables?.get(sourceTableName)?.columnMeta?.get(column)?.fieldType ?? (tempTables?.get(sourceTableName)?.columnMeta?.get(column)?.semantics?.compareMode === "number" ? "NUMBER" : "SINGLE_LINE_TEXT")
+  ])) : await getFieldTypeMap(from.appId, client, cacheContext);
+  const targetFields = /* @__PURE__ */ new Set();
+  const sourceFields = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    if (ref.tableAlias !== null) {
+      if (ref.tableAlias.toLowerCase() === `app${stmt.appId}`.toLowerCase()) {
+        if (ref.field !== "$id" && !targetTypes.has(ref.field)) throw customCheckParseError(`CHECK \u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u5B58\u5728\u3057\u307E\u305B\u3093`);
+        targetFields.add(ref.field);
+      } else if (ref.tableAlias.toLowerCase() === from.alias.toLowerCase()) {
+        if (ref.field !== "$id" && !sourceTypes.has(ref.field)) throw customCheckParseError(`CHECK \u306E\u30BD\u30FC\u30B9\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u5B58\u5728\u3057\u307E\u305B\u3093`);
+        sourceFields.add(ref.field);
+      } else {
+        throw customCheckParseError(`CHECK \u306E\u4FEE\u98FE\u5B50 ${ref.tableAlias} \u306F\u66F4\u65B0\u5148\u307E\u305F\u306F FROM alias \u3067\u306F\u3042\u308A\u307E\u305B\u3093`);
       }
+      continue;
     }
+    const inTarget = ref.field === "$id" || targetTypes.has(ref.field);
+    const inSource = ref.field === "$id" || sourceTypes.has(ref.field);
+    if (!inTarget) {
+      throw customCheckParseError(`UPDATE FROM \u306E CHECK \u3067\u306F\u30BD\u30FC\u30B9\u5217 ${ref.field} \u3092\u4FEE\u98FE\u3057\u3066\u304F\u3060\u3055\u3044`);
+    }
+    if (inSource) {
+      throw customCheckParseError(`UPDATE FROM \u306E CHECK \u306E\u975E\u4FEE\u98FE\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u66D6\u6627\u3067\u3059`);
+    }
+    targetFields.add(ref.field);
+  }
+  const evaluationTypes = /* @__PURE__ */ new Map();
+  for (const [field, type] of targetTypes) {
+    evaluationTypes.set(field, type);
+    evaluationTypes.set(`APP${stmt.appId}.${field}`, type);
+  }
+  evaluationTypes.set("$id", "RECORD_NUMBER");
+  evaluationTypes.set(`APP${stmt.appId}.$id`, "RECORD_NUMBER");
+  for (const [field, type] of sourceTypes) evaluationTypes.set(`${from.alias}.${field}`, type);
+  return { targetFields: [...targetFields], sourceFields: [...sourceFields], evaluationTypes };
+}
+function updateFromEvaluationRow(pair, appId, sourceAlias) {
+  if (!pair) return {};
+  const target = flatten(pair.target, null);
+  return Object.fromEntries([
+    ...Object.entries(target),
+    ...Object.entries(target).map(([field, value]) => [`APP${appId}.${field}`, value]),
+    ...Object.entries(pair.source).map(([field, value]) => [`${sourceAlias}.${field}`, value])
+  ]);
+}
+function collectScalarNodeRefs(node, out) {
+  if (node.type === "FIELD") {
+    out.add(node.tableAlias ? `${node.tableAlias}.${node.field}` : node.field);
+    return;
+  }
+  if (node.type === "STRING_FUNC") {
+    for (const arg of node.args) if (arg.type !== "AGG_REF" && arg.type !== "AGG_ARITH") collectScalarNodeRefs(arg, out);
+    return;
+  }
+  if (node.type === "SCALAR_ARITH" || node.type === "CONCAT_OP") {
+    collectScalarNodeRefs(node.left, out);
+    collectScalarNodeRefs(node.right, out);
   }
 }
 function formatAssignment(a) {
@@ -14348,7 +15525,7 @@ async function run() {
         isDmlStatement = writesKintone(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);
+        const supported = stmtType === "SELECT" || stmtType === "UNION" || stmtType === "WITH" || stmtType === "EXPLAIN" || stmtType === "SHOW_APPS" || stmtType === "DESCRIBE" || stmtType === "ASSERT" || stmtType === "VALIDATE" || isDmlType(stmtType);
         if (!supported) {
           process.stderr.write(`ArgumentError: unsupported statement type in CLI: ${stmtType}
 `);
@@ -14398,10 +15575,11 @@ async function run() {
   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 isValidationOnly = batchAnalysis?.containsValidationOnly === true || parsedStmt !== null && typeof parsedStmt === "object" && "validateOnly" in parsedStmt && parsedStmt.validateOnly === true;
-  const surfaceForcesOnLimitError = isDmlStatement || batchContainsDml || isValidationOnly;
+  const isExistingRecordValidation = batchAnalysis?.statements.some((s) => s.statementType === "VALIDATE") === true || getStatementType(parsedStmt) === "VALIDATE";
+  const surfaceForcesOnLimitError = isDmlStatement || batchContainsDml || isValidationOnly || isExistingRecordValidation;
   const effectiveOnLimit = surfaceForcesOnLimitError ? "error" : onLimit;
   if (surfaceForcesOnLimitError && onLimit === "truncate" && !quiet && !args.dryRun) {
-    const reason = isDmlStatement || batchContainsDml ? "DML" : "VALIDATE ONLY";
+    const reason = isDmlStatement || batchContainsDml ? "DML" : isExistingRecordValidation ? "VALIDATE" : "VALIDATE ONLY";
     process.stderr.write(`note: onLimit=truncate is ignored for ${reason} (forced to error)
 `);
   }