@rex0220/kintone-sql-tools 3.3.0 → 3.5.0

package/dist-mcp/ksql-mcp.js

@@ -31219,6 +31219,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++;
@@ -31562,6 +31566,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();
@@ -31650,13 +31656,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
     );
   }
@@ -31667,7 +31674,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() {
@@ -31730,17 +31737,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（バッチ内一時テーブル）
@@ -31826,11 +31835,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
   //
@@ -32111,6 +32172,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);
@@ -32226,13 +32303,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;
   }
@@ -32290,6 +32379,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   : + -（左結合・低優先度）
@@ -32411,12 +32599,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 };
@@ -32564,25 +32755,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;
@@ -32670,6 +32855,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;
@@ -32817,9 +33003,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 */)) {
@@ -32836,9 +33020,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 */)) {
@@ -33005,6 +33187,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();
@@ -33135,8 +33329,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 = [];
@@ -33146,11 +33341,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 */);
@@ -33167,8 +33366,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 = [];
@@ -33178,8 +33378,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");
@@ -33311,12 +33512,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 check2 = 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", check2);
+      groups.push({ rules });
+    }
+    return groups.length > 0 ? { checkGroups: groups } : {};
   }
   /** DML末尾の VALIDATE ONLY または ON ERROR SKIP。各語はsoft keyword。 */
   parseDmlControlSuffix() {
@@ -33505,6 +33727,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();
@@ -33781,7 +34009,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);
@@ -33792,6 +34020,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":
@@ -33832,6 +34062,7 @@ function whereRequiresCompleteInput(where) {
     case "EXISTS":
       return selectRequiresCompleteInput(where.query);
     case "NULL_CHECK":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -33855,6 +34086,8 @@ function getInsertValuesCount(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) {
@@ -33934,6 +34167,7 @@ function whereHasLike(where) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -33949,6 +34183,7 @@ function whereHasKlike(where) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -33968,6 +34203,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) {
@@ -34046,6 +34283,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":
@@ -34116,7 +34355,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";
@@ -34125,6 +34364,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":
@@ -34211,6 +34452,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)];
@@ -34236,16 +34479,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") {
@@ -34260,10 +34525,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();
@@ -34398,28 +34676,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) {
@@ -34472,6 +34760,7 @@ function collectRequiredFieldsByTable(stmt) {
         walkWhere(where.expr, phase);
         return;
       case "EXISTS":
+      case "BOOLEAN":
         return;
     }
   };
@@ -34510,6 +34799,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;
@@ -34525,6 +34816,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":
@@ -34575,6 +34869,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;
@@ -34597,14 +34895,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);
 }
@@ -34660,6 +34976,7 @@ function stripCteAlias(where, alias) {
     case "GROUP":
       return { ...where, expr: stripCteAlias(where.expr, alias) };
     case "EXISTS":
+    case "BOOLEAN":
       return where;
   }
 }
@@ -34697,6 +35014,7 @@ function extractAndLeaves(where, accept) {
     case "NULL_CHECK":
     case "NOT":
     case "EXISTS":
+    case "BOOLEAN":
       return null;
   }
 }
@@ -34835,6 +35153,7 @@ function collectKlikes(where, out) {
     case "BINARY":
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return;
   }
 }
@@ -34891,6 +35210,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":
@@ -34978,6 +35302,8 @@ function isDescendantOf(root, target) {
     case "NULL_CHECK":
     case "EXISTS":
       return false;
+    case "BOOLEAN":
+      return false;
   }
 }
 function walkWithoutNestedSelects(node, visitWhere) {
@@ -35039,8 +35365,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);
@@ -35081,9 +35411,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);
@@ -35092,23 +35422,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
+        );
+      }
+      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
         );
       }
-      def.referencedBy.push(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(
@@ -35141,7 +35491,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) {
@@ -35216,6 +35566,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 {
@@ -35492,6 +35843,7 @@ function whereNeedsFieldMetadata(where) {
     case "GROUP":
       return whereNeedsFieldMetadata(where.expr);
     case "EXISTS":
+    case "BOOLEAN":
       return false;
   }
 }
@@ -35516,6 +35868,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;
     }
@@ -35547,6 +35900,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;
@@ -35949,12 +36341,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];
@@ -35970,6 +36359,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":
@@ -36140,6 +36531,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":
@@ -36177,10 +36570,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();
@@ -36224,6 +36620,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)) {
@@ -36261,10 +36714,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
   };
 }
@@ -36278,19 +36732,19 @@ function updateToPutBatches(stmt, ids, fieldTypes = /* @__PURE__ */ new Map()) {
 function buildUpdateRecord(assignments, fieldTypes) {
   const record2 = {};
   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;
     record2[field] = { value: toKintoneValue(value, fieldTypes.get(field)) };
   }
   return record2;
 }
 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) {
@@ -36299,12 +36753,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),
@@ -36325,16 +36782,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") {
@@ -36347,9 +36815,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) {
@@ -36377,6 +36848,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()) {
@@ -36387,6 +36861,8 @@ function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new
     for (const { field, value } of stmt.assignments) {
       if (value.type === "ARITH") {
         record2[field] = { value: String(evalArith(value, raw)) };
+      } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+        record2[field] = { value: String(evalScalarValueExpr(value, row)) };
       } else if (value.type === "STRING_FUNC") {
         record2[field] = { value: evalStringFunc(value, row) };
       } else if (value.type === "CASE_VALUE") {
@@ -36441,6 +36917,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") {
         record2[field] = { value: String(evalArith(value, target)) };
+      } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+        record2[field] = { value: String(evalScalarValueExpr(value, targetRow)) };
       } else if (value.type === "CASE_VALUE") {
         record2[field] = { value: evalCaseWhenValue(value.expr, targetRow, fieldType) };
       } else {
@@ -36551,7 +37029,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) {
@@ -36580,6 +37066,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":
@@ -37104,7 +37592,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) {
@@ -37141,6 +37629,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);
@@ -37411,6 +37903,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;
@@ -37471,6 +37965,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) ?? "";
@@ -37507,6 +38008,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":
@@ -37521,6 +38024,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":
@@ -37576,18 +38081,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));
 }
@@ -37603,7 +38139,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 {
@@ -37624,7 +38171,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"));
@@ -37897,19 +38444,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;
@@ -37931,6 +38479,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 custom2 of evaluateCustomChecks(checkGroups, row, resolveType)) {
+          rowErrors.push({ field: "", code: "ERR_CHECK", message: custom2.message });
+        }
+      } catch (error51) {
+        firstEvaluationError ??= error51;
+      }
+    }
     if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
     for (const error51 of rowErrors) {
       const row = {};
@@ -37944,6 +38509,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) {
@@ -37958,6 +38524,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"];
@@ -38032,6 +38603,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":
@@ -38358,6 +38931,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":
@@ -38403,6 +38978,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((record2) => ({
+    id: String(record2["$id"]?.value ?? ""),
+    record: record2,
+    flat: flatten(record2, 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 check2 of evaluateCustomChecks(checkGroups, row.flat, (field) => evaluationTypes.get(field.field))) {
+      rows.push({
+        "$id": row.id,
+        "$err_field": "",
+        "$err_code": "ERR_CHECK",
+        "$err_message": check2.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);
@@ -38536,9 +39249,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,
@@ -38575,8 +39293,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,
@@ -38761,9 +39498,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;
@@ -38772,14 +39509,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) {
@@ -38790,7 +39585,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;
@@ -39000,7 +39795,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);
@@ -39033,6 +39828,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);
@@ -39105,6 +39901,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;
 }
@@ -39115,10 +39914,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) {
@@ -39127,6 +39935,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":
@@ -39139,6 +39949,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.");
@@ -39357,6 +40172,7 @@ function collectTypedInFieldRefs(expr, out) {
       return;
     case "NULL_CHECK":
     case "EXISTS":
+    case "BOOLEAN":
       return;
   }
 }
@@ -39425,8 +40241,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);
     }
   }
 }
@@ -39439,6 +40273,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;
@@ -39604,10 +40440,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();
@@ -39709,7 +40546,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
       meta3 = syntheticColumnMeta("number");
-    } else if (column.type === "LITERAL_COL") {
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") {
       meta3 = syntheticColumnMeta("string");
     } else if (column.type === "STRFUNC_COL") {
       meta3 = stringFunctionColumnMeta(column.expr);
@@ -39798,7 +40635,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,
@@ -39813,6 +40651,10 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const parallelJoins = [];
   const onOptJoins = [];
   for (const join of stmt.joins) {
+    if (constantFalse) {
+      parallelJoins.push({ join, promise: Promise.resolve([]) });
+      continue;
+    }
     const jCond = join.table.alias ? tableConditions.get(join.table.alias) ?? null : null;
     if (jCond !== null) {
       parallelJoins.push({
@@ -40416,7 +41258,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     if (column.type === "FIELD") meta3 = resolveField2(aggregateFieldRef(column.field));
     else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
       meta3 = syntheticColumnMeta("number");
-    } else if (column.type === "LITERAL_COL") meta3 = syntheticColumnMeta("string");
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") meta3 = syntheticColumnMeta("string");
     else if (column.type === "STRFUNC_COL") meta3 = stringFunctionColumnMeta(column.expr);
     else if (column.type === "SCALAR_SUBQUERY_COL") meta3 = unknownStringColumnMeta();
     else if (column.type === "CASE_COL") {
@@ -40604,7 +41446,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) {
@@ -40636,7 +41478,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 = {
@@ -40746,15 +41591,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 meta3 = materializedMetaBySelectResult.get(selectResult);
+    evaluationTypes = new Map(selectResult.columns.map((column) => {
+      const columnMeta = meta3?.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) => ({
@@ -40763,7 +41626,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) {
@@ -40792,26 +41659,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((record2) => [Number(record2["$id"]?.value), record2]));
     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((record2) => [Number(record2["$id"]?.value), record2]));
+      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,
@@ -40820,13 +41735,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(record2, appId) {
+  if (!record2) return {};
+  const plain = flatten(record2, 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",
@@ -40834,7 +41784,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;
@@ -40848,7 +41800,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,
@@ -40874,8 +41827,8 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   }
   if (sourceByKey.size === 0) return [];
   const maxRecords2 = 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;
@@ -40993,7 +41946,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);
   }
@@ -41014,6 +42014,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);
@@ -41051,6 +42052,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);
@@ -41070,6 +42092,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);
   }
@@ -41151,6 +42174,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);
   }
@@ -41176,6 +42200,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 = [];
@@ -41532,6 +42557,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)
@@ -41610,6 +42636,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);
@@ -41757,6 +42784,8 @@ function collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCa
       }));
       break;
     }
+    case "BOOLEAN":
+      break;
   }
 }
 async function resolveSetSubqueries(assignments, client, options, cacheContext) {
@@ -41794,9 +42823,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, maxRecords2 = 1e4) {
   const fieldApps = /* @__PURE__ */ new Set();
   const processStatusApps = /* @__PURE__ */ new Set();
+  const numberPrecisionApps = /* @__PURE__ */ new Set();
   const tracedClient = {
     ...client,
     getFields: async (appId) => {
@@ -41806,6 +42837,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();
@@ -41854,6 +42889,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(
@@ -41884,12 +42964,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", maxRecords2 = 1e4, cursorMaxActive2 = 2) {
@@ -41900,7 +42981,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, maxRecords2);
     const statementPlan = addCursorConcurrency(buildBatchStatementPlan(
@@ -41916,7 +42997,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 };
@@ -42051,8 +43132,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);
@@ -42064,6 +43167,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(", ")}`);
@@ -42211,6 +43320,8 @@ function collectSubqueryPlans(stmt, capabilities, orderPlans) {
         break;
       case "NULL_CHECK":
         break;
+      case "BOOLEAN":
+        break;
     }
   };
   visitWhere(stmt.where);
@@ -42263,7 +43374,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");
@@ -42294,7 +43405,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) {
@@ -42334,7 +43445,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)}`);
@@ -42346,6 +43457,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 {
@@ -42357,6 +43469,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];
 }
@@ -42371,10 +43484,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) {
@@ -44520,7 +45697,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
         profile: input.profile,
         maxRecords: input.maxRecords,
         fetchParallel: input.fetchParallel,
-        onLimit: validation.containsValidationOnly ? "error" : input.onLimit,
+        onLimit: validation.containsValidationOnly || validation.statements.some((s) => s.statementType === "VALIDATE") ? "error" : input.onLimit,
         timeout: input.timeout,
         tempTableMaxRows: input.tempTableMaxRows,
         cursorMaxActive: input.cursorMaxActive
@@ -44567,7 +45744,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
       profile: input.profile,
       maxRecords: input.maxRecords,
       fetchParallel: input.fetchParallel,
-      onLimit: validation.containsValidationOnly ? "error" : input.onLimit,
+      onLimit: validation.containsValidationOnly || validation.statements.some((s) => s.statementType === "VALIDATE") ? "error" : input.onLimit,
       timeout: input.timeout,
       cursorMaxActive: input.cursorMaxActive
     });
@@ -44869,7 +46046,7 @@ function createKsqlMcpTools(serverOptions, deps = {}) {
 var profile = external_exports.string().min(1).describe("kintone connection profile name from ksql.config.json (default: the server's default profile).").optional();
 var maxRecords = external_exports.number().int().positive().describe("Maximum records fetched per SELECT (default 500).").optional();
 var fetchParallel = external_exports.number().int().min(1).max(10).describe("Number of parallel kintone record-fetch requests (1-10).").optional();
-var onLimit = external_exports.enum(["error", "truncate"]).describe("Behavior when maxRecords is exceeded: 'error' rejects, 'truncate' returns the first maxRecords rows (default 'error'). Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. VALIDATE ONLY always overrides 'truncate' to 'error'.").optional();
+var onLimit = external_exports.enum(["error", "truncate"]).describe("Behavior when maxRecords is exceeded: 'error' rejects, 'truncate' returns the first maxRecords rows (default 'error'). Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. Leading VALIDATE and DML VALIDATE ONLY always override 'truncate' to 'error'.").optional();
 var tempTableMaxRows = external_exports.number().int().positive().describe("Per-temp-table cap on materialized rows for CREATE TEMP TABLE ... AS SELECT (default 10000). Overflow always errors \u2014 'truncate' never applies to temp tables, so downstream statements never see silently truncated data. Raising this increases memory use (up to 16 temp tables per batch); prefer narrowing the SELECT with WHERE.").optional();
 var timeout = external_exports.number().int().positive().describe("Request timeout in milliseconds. For multi-statement batches this also acts as the total batch deadline.").optional();
 var cursorMaxActive = external_exports.number().int().min(1).max(5).describe("Maximum active Cursor API handles per kintone host in this process (1-5, default 2). Later calls update the host limit; lowering it keeps existing cursors and delays new ones until active usage falls below the new limit. Create/Get are never automatically retried; capacity waits up to 30 seconds.").optional();
@@ -44998,7 +46175,7 @@ Options:
   -h, --help         Show help
 `);
 }
-var SERVER_VERSION = true ? "3.3.0" : "0.0.0-dev";
+var SERVER_VERSION = true ? "3.5.0" : "0.0.0-dev";
 function createServer(args) {
   const server = new McpServer({
     name: "ksql-mcp",
@@ -45020,7 +46197,7 @@ function createServer(args) {
   }, tools.explainTool);
   server.registerTool("ksql_query", {
     title: "Run read-only kSQL",
-    description: "Execute read-only kSQL: SELECT, WITH, UNION, EXPLAIN, SHOW APPS, DESCRIBE, ASSERT, and INSERT/UPSERT/UPDATE ... VALIDATE ONLY. ASSERT failure always stops the batch. Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. VALIDATE ONLY always treats onLimit=truncate as error. VALIDATE ONLY performs local Tier-0 validation with zero write API calls; NUMBER targets use the app numberPrecision settings for integer-digit validation and fail closed if settings cannot be read. Excess fractional digits pass through for kintone to round automatically. Supports multi-statement batches with temp tables, including VALIDATE ONLY INTO #err for later SELECT. Mutating DML is rejected.",
+    description: "Execute read-only kSQL: SELECT, WITH, UNION, EXPLAIN, SHOW APPS, DESCRIBE, ASSERT, leading VALIDATE app existing-record audits, and INSERT/UPSERT/UPDATE ... VALIDATE ONLY. ASSERT failure always stops the batch. Local ORDER BY plans require complete input and fail instead of returning a truncated top-N; REST top-N and KORDER_NATIVE do not fetch a partial candidate set. VALIDATE and VALIDATE ONLY always treat onLimit=truncate as error and perform zero write API calls. Existing-record VALIDATE applies built-in form constraints plus optional CHECK groups and can materialize its fixed five diagnostic columns with INTO #err in a batch. NUMBER targets use the app numberPrecision settings for integer-digit validation and fail closed if settings cannot be read. Excess fractional digits pass through for kintone to round automatically. Supports multi-statement batches with temp tables, including VALIDATE ONLY INTO #err for later SELECT. Mutating DML is rejected.",
     inputSchema: queryInputShape
   }, tools.queryTool);
   server.registerTool("ksql_mutate", {