@rex0220/kintone-sql-tools 3.2.0 → 3.4.0

package/dist-cli/ksql.js

@@ -122,6 +122,9 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["SUBSTR", "SUBSTR" /* SUBSTR */],
   ["CONCAT", "CONCAT" /* CONCAT */],
   ["REPLACE", "REPLACE" /* REPLACE */],
+  ["REGEXP_LIKE", "REGEXP_LIKE" /* REGEXP_LIKE */],
+  ["REGEXP_REPLACE", "REGEXP_REPLACE" /* REGEXP_REPLACE */],
+  ["REGEXP_SUBSTR", "REGEXP_SUBSTR" /* REGEXP_SUBSTR */],
   ["COALESCE", "COALESCE" /* COALESCE */],
   ["NULLIF", "NULLIF" /* NULLIF */],
   ["ISNULL", "ISNULL" /* ISNULL */],
@@ -254,7 +257,7 @@ var Lexer = class {
     );
   }
   // ----------------------------------------------------------
-  // 数値: 整数 or 小数（123 / 3.14）
+  // 数値: digits[.digits][e[+-]digits]（先頭/末尾 dot は受理しない）
   // ----------------------------------------------------------
   readNumber(start) {
     while (this.pos < this.input.length && isDigit(this.input[this.pos])) {
@@ -266,6 +269,16 @@ var Lexer = class {
         this.pos++;
       }
     }
+    if (this.pos < this.input.length && (this.input[this.pos] === "e" || this.input[this.pos] === "E")) {
+      this.pos++;
+      if (this.pos < this.input.length && (this.input[this.pos] === "+" || this.input[this.pos] === "-")) {
+        this.pos++;
+      }
+      if (this.pos >= this.input.length || !isDigit(this.input[this.pos])) {
+        throw new LexError("\u6307\u6570\u90E8\u306B\u306F\u6570\u5B57\u304C\u5FC5\u8981\u3067\u3059", start, this.input, this.pos >= this.input.length);
+      }
+      while (this.pos < this.input.length && isDigit(this.input[this.pos])) this.pos++;
+    }
     return this.makeToken(
       "NUMBER" /* NUMBER */,
       this.input.slice(start, this.pos),
@@ -294,6 +307,10 @@ var Lexer = class {
       this.pos += 2;
       return this.makeToken("<=" /* LTE */, "<=", start);
     }
+    if (ch === "|" && ch2 === "|") {
+      this.pos += 2;
+      return this.makeToken("||" /* CONCAT_OP */, "||", start);
+    }
     switch (ch) {
       case "=":
         this.pos++;
@@ -465,8 +482,94 @@ function isJapanese(cp) {
   return cp >= 12352 && cp <= 12543 || cp >= 13312 && cp <= 40959 || cp >= 63744 && cp <= 64255 || cp >= 65281 && cp <= 65376;
 }
 
+// src/core/exactDecimal.ts
+var DECIMAL_PATTERN = /^([+-]?)(?:(\d+)(?:\.(\d*))?|\.(\d+))(?:[eE]([+-]?)(\d+))?$/;
+function parseSafeExponent(sign, digits) {
+  if (digits === void 0) return 0;
+  let value = 0;
+  for (const digit of digits) {
+    value = value * 10 + (digit.charCodeAt(0) - 48);
+    if (!Number.isSafeInteger(value)) return null;
+  }
+  return sign === "-" ? -value : value;
+}
+function parseExactDecimal(input) {
+  const match = DECIMAL_PATTERN.exec(input.trim());
+  if (match === null) return null;
+  const exponent = parseSafeExponent(match[5], match[6]);
+  if (exponent === null) return null;
+  const fraction = match[3] ?? match[4] ?? "";
+  let coefficient = `${match[2] ?? ""}${fraction}`.replace(/^0+/, "");
+  if (coefficient === "") return { sign: 0, coefficient: "0", scale: 0 };
+  let scale = fraction.length - exponent;
+  if (!Number.isSafeInteger(scale)) return null;
+  const trailingZeros = /0+$/.exec(coefficient)?.[0].length ?? 0;
+  if (trailingZeros > 0) {
+    coefficient = coefficient.slice(0, -trailingZeros);
+    scale -= trailingZeros;
+    if (!Number.isSafeInteger(scale)) return null;
+  }
+  if (!Number.isSafeInteger(coefficient.length - scale)) return null;
+  const sign = match[1] === "-" ? -1 : 1;
+  return { sign, coefficient, scale };
+}
+function formatPlainDecimal(dec) {
+  if (dec.sign === 0) return "0";
+  const digits = dec.coefficient;
+  let magnitude;
+  if (dec.scale <= 0) {
+    magnitude = `${digits}${"0".repeat(-dec.scale)}`;
+  } else if (digits.length > dec.scale) {
+    const point = digits.length - dec.scale;
+    magnitude = `${digits.slice(0, point)}.${digits.slice(point)}`;
+  } else {
+    magnitude = `0.${"0".repeat(dec.scale - digits.length)}${digits}`;
+  }
+  return dec.sign === -1 ? `-${magnitude}` : magnitude;
+}
+function toPlainDecimal(input) {
+  const dec = parseExactDecimal(input);
+  return dec === null ? null : formatPlainDecimal(dec);
+}
+function compareMagnitudes(left, right) {
+  const leftPoint = left.coefficient.length - left.scale;
+  const rightPoint = right.coefficient.length - right.scale;
+  if (!Number.isSafeInteger(leftPoint) || !Number.isSafeInteger(rightPoint)) {
+    throw new Error("ArgumentError: exact decimal scale is outside the supported range.");
+  }
+  if (leftPoint !== rightPoint) return leftPoint < rightPoint ? -1 : 1;
+  const width = Math.max(left.coefficient.length, right.coefficient.length);
+  for (let index = 0; index < width; index++) {
+    const a = index < left.coefficient.length ? left.coefficient.charCodeAt(index) : 48;
+    const b = index < right.coefficient.length ? right.coefficient.charCodeAt(index) : 48;
+    if (a !== b) return a < b ? -1 : 1;
+  }
+  return 0;
+}
+function compareExactDecimal(left, right) {
+  if (left.sign !== right.sign) return left.sign < right.sign ? -1 : 1;
+  if (left.sign === 0) return 0;
+  const magnitude = compareMagnitudes(left, right);
+  return left.sign === -1 ? magnitude === 0 ? 0 : magnitude === -1 ? 1 : -1 : magnitude;
+}
+function compareDecimal(left, right) {
+  const a = parseExactDecimal(left);
+  const b = parseExactDecimal(right);
+  if (a === null || b === null) {
+    throw new Error("ArgumentError: compareDecimal requires finite decimal inputs.");
+  }
+  return compareExactDecimal(a, b);
+}
+
 // src/types/ast.ts
 var NO_FROM_CTE_NAME = "__NO_FROM__";
+function makeNumberLiteral(raw) {
+  return { type: "NUMBER", value: Number(raw), raw };
+}
+function numberLiteralText(node) {
+  const source = node.raw ?? String(node.value);
+  return toPlainDecimal(source) ?? source;
+}
 
 // src/parser/parser.ts
 var MAX_BATCH_STATEMENTS = 20;
@@ -499,6 +602,9 @@ var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "COALESCE" /* COALESCE */,
   "NULLIF" /* NULLIF */,
   "ISNULL" /* ISNULL */,
+  "REGEXP_LIKE" /* REGEXP_LIKE */,
+  "REGEXP_REPLACE" /* REGEXP_REPLACE */,
+  "REGEXP_SUBSTR" /* REGEXP_SUBSTR */,
   "LEFT" /* LEFT */,
   "RIGHT" /* RIGHT */,
   "INSTR" /* INSTR */,
@@ -548,6 +654,8 @@ var Parser = class {
   constructor(tokens) {
     this.tokens = tokens;
     this.allowUnaryPlusNumber = false;
+    this.scalarAllowsAggregateArgs = true;
+    this.scalarAllowsCase = true;
     this.pos = 0;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
@@ -716,17 +824,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（バッチ内一時テーブル）
@@ -1097,6 +1207,11 @@ 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 };
+    }
     const windowFunc = this.tryWindowFunc();
     if (windowFunc !== null) {
       return this.parseWindowColumn(windowFunc);
@@ -1212,13 +1327,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;
   }
@@ -1262,12 +1389,12 @@ var Parser = class {
     if (this.peek().kind === "-" /* MINUS */) {
       this.advance();
       const operand = this.parseAggPrimary();
-      if (operand.type === "NUMBER") return { type: "NUMBER", value: -operand.value };
-      return { type: "AGG_ARITH", left: { type: "NUMBER", value: 0 }, op: "-", right: operand };
+      if (operand.type === "NUMBER") return makeNumberLiteral(`-${numberLiteralText(operand)}`);
+      return { type: "AGG_ARITH", left: makeNumberLiteral("0"), op: "-", right: operand };
     }
     if (this.peek().kind === "NUMBER" /* NUMBER */) {
       const tok = this.advance();
-      return { type: "NUMBER", value: Number(tok.value) };
+      return makeNumberLiteral(tok.value);
     }
     const aggFunc = this.tryAggregateFunc();
     if (aggFunc !== null) {
@@ -1276,6 +1403,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   : + -（左結合・低優先度）
@@ -1319,7 +1545,7 @@ var Parser = class {
     if (this.allowUnaryPlusNumber && this.peek().kind === "+" /* PLUS */) {
       this.advance();
       const number = this.expect("NUMBER" /* NUMBER */, "\u5358\u9805 + \u306E\u76F4\u5F8C\u306B\u306F\u6570\u5024\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
-      return { type: "NUMBER", value: Number(number.value) };
+      return makeNumberLiteral(`+${number.value}`);
     }
     if (this.peek().kind === "-" /* MINUS */) {
       this.advance();
@@ -1327,8 +1553,8 @@ var Parser = class {
         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.parseArithPrimary();
-      if (operand.type === "NUMBER") return { type: "NUMBER", value: -operand.value };
-      return { type: "ARITH", left: { type: "NUMBER", value: 0 }, op: "-", right: operand };
+      if (operand.type === "NUMBER") return makeNumberLiteral(`-${numberLiteralText(operand)}`);
+      return { type: "ARITH", left: makeNumberLiteral("0"), op: "-", right: operand };
     }
     if (this.tryStringFuncName() !== null) {
       return this.parseStringFuncExpr();
@@ -1336,7 +1562,7 @@ var Parser = class {
     const tok = this.peek();
     if (tok.kind === "NUMBER" /* NUMBER */) {
       this.advance();
-      return { type: "NUMBER", value: Number(tok.value) };
+      return makeNumberLiteral(tok.value);
     }
     if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) {
       this.advance();
@@ -1397,12 +1623,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 };
@@ -1440,6 +1669,9 @@ var Parser = class {
       ["SUBSTR" /* SUBSTR */]: "SUBSTRING",
       ["CONCAT" /* CONCAT */]: "CONCAT",
       ["REPLACE" /* REPLACE */]: "REPLACE",
+      ["REGEXP_LIKE" /* REGEXP_LIKE */]: "REGEXP_LIKE",
+      ["REGEXP_REPLACE" /* REGEXP_REPLACE */]: "REGEXP_REPLACE",
+      ["REGEXP_SUBSTR" /* REGEXP_SUBSTR */]: "REGEXP_SUBSTR",
       ["TRANSLATE" /* TRANSLATE */]: "TRANSLATE",
       ["COALESCE" /* COALESCE */]: "COALESCE",
       ["NULLIF" /* NULLIF */]: "NULLIF",
@@ -1547,25 +1779,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;
@@ -1653,6 +1879,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;
@@ -1979,7 +2206,7 @@ var Parser = class {
     }
     if (tok.kind === "NUMBER" /* NUMBER */ || tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */ || tok.kind === "(" /* LPAREN */ || tok.kind === "-" /* MINUS */ || this.tryStringFuncName() !== null) {
       const expr = this.parseArithAddSub();
-      if (expr.type === "NUMBER") return { type: "NUMBER", value: expr.value };
+      if (expr.type === "NUMBER") return expr;
       return { type: "ARITH_VALUE", expr };
     }
     throw new ParseError(
@@ -2006,15 +2233,15 @@ var Parser = class {
       if (tok.kind === "STRING" /* STRING */) {
         values.push({ type: "STRING", value: tok.value });
       } else if (tok.kind === "NUMBER" /* NUMBER */) {
-        values.push({ type: "NUMBER", value: Number(tok.value) });
+        values.push(makeNumberLiteral(tok.value));
       } else if (tok.kind === "-" /* MINUS */ || tok.kind === "+" /* PLUS */) {
         const number = this.peek();
         if (number.kind !== "NUMBER" /* NUMBER */) {
           throw new ParseError(invalidValueMessage, tok);
         }
         this.advance();
-        const sign = tok.kind === "-" /* MINUS */ ? -1 : 1;
-        values.push({ type: "NUMBER", value: sign * Number(number.value) });
+        const sign = tok.kind === "-" /* MINUS */ ? "-" : "+";
+        values.push(makeNumberLiteral(`${sign}${number.value}`));
       } else if (tok.kind === "VARIABLE" /* VARIABLE */) {
         values.push({ type: "VARIABLE", name: tok.value.slice(1).toLowerCase() });
       } else {
@@ -2118,8 +2345,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 = [];
@@ -2129,11 +2357,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 */);
@@ -2150,8 +2382,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 = [];
@@ -2161,8 +2394,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");
@@ -2204,14 +2438,13 @@ var Parser = class {
       } else if (this.peek().kind === "-" /* MINUS */ || this.peek().kind === "+" /* PLUS */) {
         const sign = this.advance();
         const number = this.expect("NUMBER" /* NUMBER */, "INSERT \u306E\u5358\u9805\u7B26\u53F7\u306E\u76F4\u5F8C\u306B\u306F\u6570\u5024\u30EA\u30C6\u30E9\u30EB\u304C\u5FC5\u8981\u3067\u3059");
-        const value = Number(number.value);
-        row.push({ type: "NUMBER", value: sign.kind === "-" /* MINUS */ ? -value : value });
+        row.push(makeNumberLiteral(`${sign.kind === "-" /* MINUS */ ? "-" : "+"}${number.value}`));
       } else {
         const tok = this.advance();
         if (tok.kind === "STRING" /* STRING */) {
           row.push({ type: "STRING", value: tok.value });
         } else if (tok.kind === "NUMBER" /* NUMBER */) {
-          row.push({ type: "NUMBER", value: Number(tok.value) });
+          row.push(makeNumberLiteral(tok.value));
         } else {
           throw new ParseError("INSERT \u306E\u5024\u306B\u306F\u6587\u5B57\u5217\u30FB\u6570\u5024\u30FB\u914D\u5217\u30EA\u30C6\u30E9\u30EB\u30FBCASE WHEN \u304C\u5FC5\u8981\u3067\u3059", tok);
         }
@@ -2295,12 +2528,33 @@ var Parser = class {
         whereTok
       );
     }
+    const checkGroups = this.parseCheckGroups();
     const validation = this.parseDmlControlSuffix();
+    if (subtableCode && checkGroups.checkGroups) {
+      throw new ParseError("CHECK \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
+    }
     if (subtableCode && (validation.validateOnly || validation.onErrorSkip)) {
       throw new ParseError("VALIDATE ONLY / ON ERROR SKIP \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093", this.prev());
     }
-    if (from !== null) return { type: "UPDATE", appId, assignments, where, from, ...validation };
-    return subtableCode ? { type: "UPDATE", appId, subtableCode, assignments, where, ...validation } : { type: "UPDATE", appId, assignments, where, ...validation };
+    if (from !== null) return { type: "UPDATE", appId, assignments, where, from, ...checkGroups, ...validation };
+    return subtableCode ? { type: "UPDATE", appId, subtableCode, assignments, where, ...checkGroups, ...validation } : { type: "UPDATE", appId, assignments, where, ...checkGroups, ...validation };
+  }
+  /** CHECK WHEN ... THEN ... blocks. CHECK is a soft keyword. */
+  parseCheckGroups() {
+    const groups = [];
+    while (this.isSoftKeyword("CHECK") && this.peekAt(1).kind === "WHEN" /* WHEN */) {
+      const check = this.advance();
+      const rules = [];
+      while (this.consume("WHEN" /* WHEN */)) {
+        const condition = this.parseWhereExpr();
+        this.expect("THEN" /* THEN */, "CHECK WHEN \u306E\u6761\u4EF6\u306E\u5F8C\u306B\u306F THEN \u304C\u5FC5\u8981\u3067\u3059");
+        const message = this.parseScalarValueExpr({ allowCase: false });
+        rules.push({ condition, message });
+      }
+      if (rules.length === 0) throw new ParseError("CHECK \u306E\u5F8C\u306B\u306F WHEN \u304C\u6700\u4F4E 1 \u3064\u5FC5\u8981\u3067\u3059", check);
+      groups.push({ rules });
+    }
+    return groups.length > 0 ? { checkGroups: groups } : {};
   }
   /** DML末尾の VALIDATE ONLY または ON ERROR SKIP。各語はsoft keyword。 */
   parseDmlControlSuffix() {
@@ -2489,6 +2743,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();
@@ -3045,7 +3305,7 @@ function convertValue(value, op) {
     case "STRING":
       return convertString(value);
     case "NUMBER":
-      return String(value.value);
+      return numberLiteralText(value);
     case "KINTONE_FUNC":
       return convertKintoneFunc(value);
     case "IN_LIST":
@@ -3074,7 +3334,7 @@ function convertInList(v, op) {
   }
   assertResolvedInListValues(v.values);
   const values = v.values.map(
-    (item) => item.type === "STRING" ? convertString(item) : String(item.value)
+    (item) => item.type === "STRING" ? convertString(item) : numberLiteralText(item)
   ).join(",");
   return `(${values})`;
 }
@@ -3112,7 +3372,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";
@@ -3207,6 +3467,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)];
@@ -3232,16 +3494,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") {
@@ -3256,10 +3540,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();
@@ -3394,28 +3691,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) {
@@ -3521,6 +3828,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":
@@ -3571,6 +3881,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;
@@ -3587,20 +3901,38 @@ function aggregateSyntheticName(func, distinct, arg) {
 }
 function arithNodeLabel(node) {
   if (node.type === "FIELD_REF") return node.field;
-  if (node.type === "NUMBER") return String(node.value);
+  if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "STRING_FUNC") return stringFuncLabel(node);
   return `(${arithNodeLabel(node.left)}${node.op}${arithNodeLabel(node.right)})`;
 }
 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);
 }
@@ -3744,7 +4076,7 @@ function isNumericCandidate(expr, options) {
   if (!isTargetField(expr.left, options)) return false;
   if (expr.right.type !== "NUMBER") return false;
   if (expr.op === "=") return true;
-  return (expr.op === "<" || expr.op === ">") && Number.isSafeInteger(expr.right.value);
+  return (expr.op === "<" || expr.op === ">") && /^[+-]?\d+$/.test(numberLiteralText(expr.right)) && Number.isSafeInteger(expr.right.value);
 }
 function isSelectionInCandidate(expr, options) {
   if (expr.left.type !== "FIELD" || expr.left.field === "$id") return false;
@@ -4349,9 +4681,10 @@ function triCompare(left, right) {
 }
 function numberKey(value) {
   if (value === "") return { band: 0 };
+  const decimal = parseExactDecimal(value);
+  if (decimal !== null) return { band: 2, value: decimal };
   const numeric = Number(value);
   if (numeric === Number.NEGATIVE_INFINITY) return { band: 1 };
-  if (Number.isFinite(numeric)) return { band: 2, value: numeric };
   if (numeric === Number.POSITIVE_INFINITY) return { band: 3 };
   if (value === "NaN") return { band: 4 };
   return { band: 5, value };
@@ -4360,7 +4693,7 @@ function compareNumbers(left, right) {
   const a = numberKey(left);
   const b = numberKey(right);
   if (a.band !== b.band) return a.band < b.band ? -1 : 1;
-  if (a.band === 2 && b.band === 2) return triCompare(a.value, b.value);
+  if (a.band === 2 && b.band === 2) return compareExactDecimal(a.value, b.value);
   if (a.band === 5 && b.band === 5) return compareCodePointStrings(a.value, b.value);
   return 0;
 }
@@ -4460,7 +4793,9 @@ function selectScalarExtreme(values, extreme) {
   const numeric = candidates.every((value) => !Number.isNaN(Number(value)));
   const compare = (left, right) => {
     if (numeric) {
-      const numericCmp = triCompare(Number(left), Number(right));
+      const leftDecimal = parseExactDecimal(left);
+      const rightDecimal = parseExactDecimal(right);
+      const numericCmp = leftDecimal !== null && rightDecimal !== null ? compareExactDecimal(leftDecimal, rightDecimal) : triCompare(Number(left), Number(right));
       if (numericCmp !== 0) return numericCmp;
     }
     return compareCodePointStrings(left, right);
@@ -4540,6 +4875,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;
@@ -4583,6 +4957,112 @@ function makeSafePadding(pad, gap) {
   const repeated = pad.repeat(Math.ceil(gap / pad.length));
   return sliceSafePrefix(repeated, gap);
 }
+var REGEXP_CACHE_MAX = 200;
+var regexpCache = /* @__PURE__ */ new Map();
+function normalizeRegexpFlags(flags) {
+  if (/[^ims]/.test(flags)) {
+    throw new Error("ArgumentError: regular expression flags may contain only i, m, or s.");
+  }
+  if (new Set(flags).size !== flags.length) {
+    throw new Error("ArgumentError: regular expression flags must not contain duplicates.");
+  }
+  return `${flags}u`;
+}
+function compileRegexp(pattern, flags, global = false) {
+  const normalizedFlags = normalizeRegexpFlags(flags) + (global ? "g" : "");
+  const key = `${pattern}\0${normalizedFlags}`;
+  const cached = regexpCache.get(key);
+  if (cached !== void 0) {
+    cached.lastIndex = 0;
+    return cached;
+  }
+  let regexp;
+  try {
+    regexp = new RegExp(pattern, normalizedFlags);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`ArgumentError: invalid regular expression: ${detail}`);
+  }
+  if (regexpCache.size >= REGEXP_CACHE_MAX) {
+    const oldest = regexpCache.keys().next().value;
+    if (oldest !== void 0) regexpCache.delete(oldest);
+  }
+  regexpCache.set(key, regexp);
+  return regexp;
+}
+function assertRegexpReplacement(replacement) {
+  if (replacement.includes("$`") || replacement.includes("$'")) {
+    throw new Error("ArgumentError: REGEXP_REPLACE replacement must not contain $` or $'.");
+  }
+}
+function parseRegexpOccurrence(arg) {
+  if (arg === void 0) return 0;
+  if (!/^\d+$/.test(arg)) {
+    throw new Error("ArgumentError: REGEXP_REPLACE occurrence must be a non-negative integer.");
+  }
+  return Number(arg);
+}
+function expandRegexpReplacement(replacement, match, captures, namedGroups) {
+  let result = "";
+  for (let i = 0; i < replacement.length; i += 1) {
+    const char = replacement[i];
+    if (char !== "$" || i + 1 >= replacement.length) {
+      result += char;
+      continue;
+    }
+    const next = replacement[i + 1];
+    if (next === "$") {
+      result += "$";
+      i += 1;
+      continue;
+    }
+    if (next === "&") {
+      result += match;
+      i += 1;
+      continue;
+    }
+    if (next === "<" && namedGroups !== void 0) {
+      const end = replacement.indexOf(">", i + 2);
+      if (end >= 0) {
+        result += namedGroups[replacement.slice(i + 2, end)] ?? "";
+        i = end;
+        continue;
+      }
+    }
+    if (/\d/.test(next)) {
+      const secondDigit = replacement[i + 2];
+      if (secondDigit !== void 0 && /\d/.test(secondDigit)) {
+        const twoDigitIndex = Number(next + secondDigit);
+        if (twoDigitIndex >= 1 && twoDigitIndex <= captures.length) {
+          result += captures[twoDigitIndex - 1] ?? "";
+          i += 2;
+          continue;
+        }
+      }
+      const oneDigitIndex = Number(next);
+      if (oneDigitIndex >= 1 && oneDigitIndex <= captures.length) {
+        result += captures[oneDigitIndex - 1] ?? "";
+        i += 1;
+        continue;
+      }
+    }
+    result += "$";
+  }
+  return result;
+}
+function replaceNthMatch(input, globalRe, replacement, n) {
+  let matchCount = 0;
+  return input.replace(globalRe, (match, ...callbackArgs) => {
+    matchCount += 1;
+    if (matchCount !== n) return match;
+    const lastArg = callbackArgs[callbackArgs.length - 1];
+    const hasNamedGroups = typeof lastArg === "object" && lastArg !== null;
+    const capturesEnd = callbackArgs.length - (hasNamedGroups ? 3 : 2);
+    const captures = callbackArgs.slice(0, capturesEnd);
+    const namedGroups = hasNamedGroups ? lastArg : void 0;
+    return expandRegexpReplacement(replacement, match, captures, namedGroups);
+  });
+}
 function evalStringFunc(expr, row) {
   const args = expr.args.map((a) => evalStringFuncArg(a, row));
   switch (expr.func) {
@@ -4646,6 +5126,21 @@ function evalStringFunc(expr, row) {
       const to = args[2] ?? "";
       return from === "" ? str : str.split(from).join(to);
     }
+    case "REGEXP_LIKE": {
+      assertArity("REGEXP_LIKE", args, 2, 3);
+      return compileRegexp(args[1], args[2] ?? "").test(args[0]) ? "1" : "0";
+    }
+    case "REGEXP_REPLACE": {
+      assertArity("REGEXP_REPLACE", args, 3, 5);
+      assertRegexpReplacement(args[2]);
+      const occurrence = parseRegexpOccurrence(args[4]);
+      const regexp = compileRegexp(args[1], args[3] ?? "", true);
+      return occurrence === 0 ? args[0].replace(regexp, args[2]) : replaceNthMatch(args[0], regexp, args[2], occurrence);
+    }
+    case "REGEXP_SUBSTR": {
+      assertArity("REGEXP_SUBSTR", args, 2, 3);
+      return compileRegexp(args[1], args[2] ?? "").exec(args[0])?.[0] ?? "";
+    }
     case "TRANSLATE": {
       assertArity("TRANSLATE", args, 3, 3);
       const from = [...args[1]];
@@ -4821,12 +5316,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 String(arg.value);
   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];
@@ -4873,7 +5365,7 @@ function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics
     let values = null;
     if (right.type === "IN_LIST") {
       assertResolvedInListValues2(right.values);
-      values = new Set(right.values.map((v) => String(v.value)));
+      values = new Set(right.values.map((v) => v.type === "NUMBER" ? fieldType === "NUMBER" ? numberLiteralText(v) : String(v.value) : v.value));
     }
     if (right.type === "SUBQUERY_IN_LIST") {
       values = right.resolved;
@@ -4953,6 +5445,10 @@ var SINGLE_OBJECT_FIELD_TYPES = /* @__PURE__ */ new Set(["CREATOR", "MODIFIER"])
 function typedInContains(leftStr, values, fieldType) {
   const fallback = () => values.has(leftStr);
   if (fieldType === void 0) return fallback();
+  if (fieldType === "NUMBER") {
+    const semantics = syntheticSemantics("number");
+    return [...values].some((value) => compareScalarValues("=", leftStr, value, semantics));
+  }
   let parsed;
   if (STRING_ARRAY_FIELD_TYPES.has(fieldType) || OBJECT_ARRAY_FIELD_TYPES.has(fieldType) || SINGLE_OBJECT_FIELD_TYPES.has(fieldType)) {
     try {
@@ -5011,7 +5507,7 @@ function resolveValue(value, row, resolveFieldType, resolveFieldSemantics2) {
     case "STRING":
       return value.value;
     case "NUMBER":
-      return String(value.value);
+      return numberLiteralText(value);
     case "KINTONE_FUNC":
       return resolveKintoneFunc(value.name);
     case "IN_LIST":
@@ -5045,10 +5541,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();
@@ -5092,6 +5591,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)) {
@@ -5129,10 +5685,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
   };
 }
@@ -5146,19 +5703,19 @@ function updateToPutBatches(stmt, ids, fieldTypes = /* @__PURE__ */ new Map()) {
 function buildUpdateRecord(assignments, fieldTypes) {
   const record = {};
   for (const { field, value } of assignments) {
-    if (value.type === "ARITH" || value.type === "CASE_VALUE" || value.type === "STRING_FUNC" || value.type === "SOURCE_FIELD") continue;
+    if (value.type === "ARITH" || value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP" || value.type === "CASE_VALUE" || value.type === "STRING_FUNC" || value.type === "SOURCE_FIELD") continue;
     record[field] = { value: toKintoneValue(value, fieldTypes.get(field)) };
   }
   return record;
 }
 function hasArithAssignment(stmt) {
   return stmt.assignments.some(
-    (a) => a.value.type === "ARITH" || a.value.type === "CASE_VALUE"
+    (a) => a.value.type === "ARITH" || a.value.type === "SCALAR_ARITH" || a.value.type === "CONCAT_OP" || a.value.type === "CASE_VALUE"
   );
 }
 function hasRowDependentAssignment(stmt) {
   return stmt.assignments.some(
-    (a) => a.value.type === "ARITH" || a.value.type === "CASE_VALUE" || a.value.type === "STRING_FUNC"
+    (a) => a.value.type === "ARITH" || a.value.type === "SCALAR_ARITH" || a.value.type === "CONCAT_OP" || a.value.type === "CASE_VALUE" || a.value.type === "STRING_FUNC"
   );
 }
 function updateToGetQueryForArith(stmt) {
@@ -5167,12 +5724,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),
@@ -5193,16 +5753,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") {
@@ -5215,9 +5786,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) {
@@ -5255,6 +5829,8 @@ function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new
     for (const { field, value } of stmt.assignments) {
       if (value.type === "ARITH") {
         record[field] = { value: String(evalArith(value, raw)) };
+      } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+        record[field] = { value: String(evalScalarValueExpr(value, row)) };
       } else if (value.type === "STRING_FUNC") {
         record[field] = { value: evalStringFunc(value, row) };
       } else if (value.type === "CASE_VALUE") {
@@ -5309,6 +5885,8 @@ function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new
         throw new DmlConvertError("UPDATE ... FROM \u306E SET \u3067\u306F\u6587\u5B57\u5217\u95A2\u6570\u3092\u76F4\u63A5\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093");
       } else if (value.type === "ARITH") {
         record[field] = { value: String(evalArith(value, target)) };
+      } else if (value.type === "SCALAR_ARITH" || value.type === "CONCAT_OP") {
+        record[field] = { value: String(evalScalarValueExpr(value, targetRow)) };
       } else if (value.type === "CASE_VALUE") {
         record[field] = { value: evalCaseWhenValue(value.expr, targetRow, fieldType) };
       } else {
@@ -5419,7 +5997,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) {
@@ -5451,7 +6037,7 @@ function convertDmlSqlValue(value, fieldType) {
     case "STRING":
       return convertString2(value.value, fieldType);
     case "NUMBER":
-      return String(value.value);
+      return numberLiteralText(value);
     case "ARRAY":
       return convertArray(value.elements.map((e) => e.value), fieldType);
     case "KINTONE_FUNC":
@@ -5972,7 +6558,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) {
@@ -6009,6 +6595,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);
@@ -6083,7 +6673,7 @@ function evalAggArithExpr(node, rows, resolveAggSortKind) {
   }
 }
 function aggArithDefaultKey(node) {
-  if (node.type === "NUMBER") return String(node.value);
+  if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "AGG_REF") return aggregateSyntheticName2(node.func, node.distinct, node.arg);
   return `${aggArithDefaultKey(node.left)}${node.op}${aggArithDefaultKey(node.right)}`;
 }
@@ -6339,6 +6929,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) ?? "";
@@ -6389,6 +6986,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":
@@ -6433,7 +7032,7 @@ function stripParentShortcutColumns(row) {
 function arithColDefaultKey(expr) {
   const nodeLabel = (n) => {
     if (n.type === "FIELD_REF") return n.field;
-    if (n.type === "NUMBER") return String(n.value);
+    if (n.type === "NUMBER") return numberLiteralText(n);
     if (n.type === "STRING_FUNC") return stringFuncDefaultKey(n);
     return `(${nodeLabel(n.left)}${n.op}${nodeLabel(n.right)})`;
   };
@@ -6444,33 +7043,76 @@ 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));
 }
 function resolveAggInStringFuncArg(arg, rows, resolveAggSortKind) {
   if (arg.type === "AGG_REF") {
     const value = evalAggregate(arg.func, arg.distinct, arg.arg, arg.separator, rows, resolveAggSortKind);
-    return typeof value === "number" ? { type: "NUMBER", value } : { type: "STRING", value };
+    return typeof value === "number" ? { type: "NUMBER", value, raw: String(value) } : { type: "STRING", value };
   }
   if (arg.type === "AGG_ARITH") {
-    return { type: "NUMBER", value: evalAggArithExpr(arg, rows, resolveAggSortKind) };
+    const value = evalAggArithExpr(arg, rows, resolveAggSortKind);
+    return { type: "NUMBER", value, raw: String(value) };
   }
   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 {
@@ -6491,7 +7133,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"));
@@ -6583,10 +7225,43 @@ function toFlatString(value) {
   }
 }
 
+// src/core/numberPrecision.ts
+function parseIntegerSetting(value, name, min, max) {
+  if (typeof value !== "string" || !/^\d+$/.test(value)) {
+    throw new Error(`SettingsError: numberPrecision.${name} must be an integer string.`);
+  }
+  let parsed = 0;
+  for (const digit of value) parsed = parsed * 10 + digit.charCodeAt(0) - 48;
+  if (parsed < min || parsed > max) {
+    throw new Error(`SettingsError: numberPrecision.${name} must be between ${min} and ${max}.`);
+  }
+  return parsed;
+}
+function parseNumberPrecisionSettings(response) {
+  const raw = response.numberPrecision;
+  if (raw === void 0 || raw === null || typeof raw !== "object") {
+    throw new Error("SettingsError: numberPrecision is missing from app settings.");
+  }
+  const digits = parseIntegerSetting(raw.digits, "digits", 1, 30);
+  const decimalPlaces = parseIntegerSetting(raw.decimalPlaces, "decimalPlaces", 0, 10);
+  const roundingMode = raw.roundingMode;
+  if (roundingMode !== "HALF_EVEN" && roundingMode !== "UP" && roundingMode !== "DOWN") {
+    throw new Error("SettingsError: numberPrecision.roundingMode is unsupported.");
+  }
+  return { digits, decimalPlaces, roundingMode };
+}
+function exactDecimalDigitCounts(value) {
+  if (value.sign === 0) return { integerDigits: 0, fractionDigits: 0 };
+  return {
+    integerDigits: Math.max(value.coefficient.length - value.scale, 0),
+    fractionDigits: Math.max(value.scale, 0)
+  };
+}
+
 // src/core/dmlValidation.ts
 var ARRAY_TYPES2 = /* @__PURE__ */ new Set(["CHECK_BOX", "MULTI_SELECT"]);
 var CHOICE_TYPES = /* @__PURE__ */ new Set(["DROP_DOWN", "RADIO_BUTTON", "CHECK_BOX", "MULTI_SELECT"]);
-function validateAndNormalizeDmlValue(raw, field) {
+function validateAndNormalizeDmlValue(raw, field, numberPrecision) {
   if (field.fieldType === "DATE" || field.fieldType === "TIME" || field.fieldType === "DATETIME") {
     const original = rawScalarText(raw);
     if (original !== "" && !isValidTemporalInput(original, field.fieldType)) {
@@ -6605,7 +7280,8 @@ function validateAndNormalizeDmlValue(raw, field) {
   }
   if (!isEmpty(value) && field.fieldType === "NUMBER") {
     const text = String(value);
-    if (!isFiniteDecimal(text)) {
+    const decimal = parseExactDecimal(text);
+    if (decimal === null) {
       return { ok: false, code: "ERR_TYPE_NUMBER", message: `${field.code} \u306F\u6570\u5024\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044` };
     }
     if (field.minValue != null && compareDecimal(text, field.minValue) < 0) {
@@ -6614,6 +7290,17 @@ function validateAndNormalizeDmlValue(raw, field) {
     if (field.maxValue != null && compareDecimal(text, field.maxValue) > 0) {
       return { ok: false, code: "ERR_RANGE_MAX", message: `${field.code} \u306F ${field.maxValue} \u4EE5\u4E0B\u3067\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044` };
     }
+    if (numberPrecision !== void 0) {
+      const { integerDigits } = exactDecimalDigitCounts(decimal);
+      const integerBudget = numberPrecision.digits - numberPrecision.decimalPlaces;
+      if (integerDigits > integerBudget) {
+        return {
+          ok: false,
+          code: "ERR_NUMBER_INTEGER_DIGITS",
+          message: `${field.code} \u306E\u6574\u6570\u90E8\u306F ${integerDigits} \u6841\u3067\u3059\u3002\u8A31\u5BB9\u306F ${integerBudget} \u6841\u307E\u3067\u3067\u3059 (digits=${numberPrecision.digits}, decimalPlaces=${numberPrecision.decimalPlaces})`
+        };
+      }
+    }
   }
   if (!isEmpty(value) && (field.fieldType === "DATE" || field.fieldType === "TIME" || field.fieldType === "DATETIME")) {
     if (!isValidTemporal(String(value), field.fieldType)) {
@@ -6641,7 +7328,8 @@ function validateAndNormalizeDmlValue(raw, field) {
 }
 function rawScalarText(raw) {
   if (raw == null) return "";
-  if (isSqlValue(raw) && (raw.type === "STRING" || raw.type === "NUMBER")) return String(raw.value);
+  if (isSqlValue(raw) && raw.type === "NUMBER") return numberLiteralText(raw);
+  if (isSqlValue(raw) && raw.type === "STRING") return raw.value;
   return typeof raw === "string" || typeof raw === "number" ? String(raw) : "";
 }
 function isValidTemporalInput(value, type) {
@@ -6691,34 +7379,6 @@ function isEmpty(value) {
 function typeCode(type) {
   return type === "NUMBER" ? "ERR_TYPE_NUMBER" : "ERR_TYPE_DATE";
 }
-function isFiniteDecimal(value) {
-  return /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(value.trim());
-}
-function compareDecimal(left, right) {
-  const normalize = (input) => {
-    let s = input.trim();
-    let sign = 1;
-    if (s.startsWith("-")) {
-      sign = -1;
-      s = s.slice(1);
-    } else if (s.startsWith("+")) s = s.slice(1);
-    let [whole, fraction = ""] = s.split(".");
-    whole = (whole || "0").replace(/^0+(?=\d)/, "");
-    fraction = fraction.replace(/0+$/, "");
-    if (/^0*$/.test(whole) && fraction === "") sign = 1;
-    return { sign, whole, fraction };
-  };
-  const a = normalize(left);
-  const b = normalize(right);
-  if (a.sign !== b.sign) return a.sign < b.sign ? -1 : 1;
-  const direction = a.sign;
-  if (a.whole.length !== b.whole.length) return a.whole.length < b.whole.length ? -direction : direction;
-  if (a.whole !== b.whole) return a.whole < b.whole ? -direction : direction;
-  const width = Math.max(a.fraction.length, b.fraction.length);
-  const af = a.fraction.padEnd(width, "0");
-  const bf = b.fraction.padEnd(width, "0");
-  return af === bf ? 0 : af < bf ? -direction : direction;
-}
 function isValidTemporal(value, type) {
   if (type === "TIME") {
     const m2 = /^(\d{2}):(\d{2})(?::(\d{2}))?$/.exec(value);
@@ -6746,32 +7406,33 @@ var VALIDATION_META_COLUMNS = [
   "$err_code",
   "$err_message"
 ];
-function validateDmlCandidates(candidates, operation, payloadFields, targetFields, fieldInfos, statementNumber) {
+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));
+      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;
         const emptyDefault = isEmptyDmlValue(info.defaultValue);
         if (!emptyDefault) {
-          const defaultResult = validateAndNormalizeDmlValue(info.defaultValue, info);
+          const defaultResult = validateAndNormalizeDmlValue(info.defaultValue, info, numberPrecision);
           if (!defaultResult.ok) rowErrors.push({
             field: info.code,
             code: defaultResult.code,
             message: `\u65E2\u5B9A\u5024: ${defaultResult.message}`
           });
         } else {
-          const emptyResult = validateAndNormalizeDmlValue("", info);
+          const emptyResult = validateAndNormalizeDmlValue("", info, numberPrecision);
           if (!emptyResult.ok) {
             rowErrors.push({ field: info.code, code: emptyResult.code, message: emptyResult.message });
           } else if (info.required) {
@@ -6780,6 +7441,23 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         }
       }
     }
+    if (checkGroups.length > 0) {
+      const row = candidate.evaluationRow ?? Object.fromEntries(
+        [...candidate.payload].map(([field, value]) => [field, renderValidationValue(value)])
+      );
+      const types = candidate.evaluationFieldTypes;
+      const resolveType = (field) => {
+        const qualified = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
+        return types?.get(qualified) ?? types?.get(field.field);
+      };
+      try {
+        for (const custom of evaluateCustomChecks(checkGroups, row, resolveType)) {
+          rowErrors.push({ field: "", code: "ERR_CHECK", message: custom.message });
+        }
+      } catch (error) {
+        firstEvaluationError ??= error;
+      }
+    }
     if (rowErrors.length > 0) invalid.add(candidate.rowNumber);
     for (const error of rowErrors) {
       const row = {};
@@ -6793,13 +7471,15 @@ 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) {
   if (value == null) return "";
   if (typeof value === "object" && "type" in value) {
     const sql = value;
-    if (sql.type === "STRING" || sql.type === "NUMBER") return String(sql.value ?? "");
+    if (sql.type === "NUMBER") return sql.raw ?? String(sql.value ?? "");
+    if (sql.type === "STRING") return String(sql.value ?? "");
     if (sql.type === "ARRAY") return JSON.stringify(sql.elements?.map((e) => e.value) ?? []);
   }
   if (Array.isArray(value)) return JSON.stringify(value);
@@ -7041,6 +7721,7 @@ function createEmptyMetrics() {
     putCalls: 0,
     deleteCalls: 0,
     fieldCalls: 0,
+    numberPrecisionCalls: 0,
     appsCalls: 0,
     processStatusCalls: 0,
     cursorCreateCalls: 0,
@@ -7126,6 +7807,10 @@ function wrapClientWithMetrics(client, metrics) {
       metrics.fieldCalls += 1;
       return client.getFields(appId);
     },
+    getNumberPrecision: (appId) => {
+      metrics.numberPrecisionCalls += 1;
+      return client.getNumberPrecision(appId);
+    },
     getProcessStatuses: (appId) => {
       metrics.processStatusCalls += 1;
       return client.getProcessStatuses(appId);
@@ -7393,7 +8078,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
         const first = resolvedStmt2.expr.query.columns[0];
         const numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG");
         const numberValue = numeric ? Number(value) : Number.NaN;
-        variables.set(stmt.name, numeric && Number.isFinite(numberValue) ? { type: "number", value: numberValue } : { type: "string", value });
+        variables.set(stmt.name, numeric && Number.isFinite(numberValue) ? { type: "number", value: numberValue, raw: value } : { type: "string", value });
       } catch (e) {
         if (e instanceof ScalarSubqueryError) {
           throw new Error(`ArgumentError: ${e.message}`);
@@ -7411,7 +8096,10 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
       variables.set(stmt.name, { type: "string", value: injected[stmt.name] });
     } else {
       const value = evaluateScalarExpr(stmt.default);
-      variables.set(stmt.name, { type: "string", value: String(value.value) });
+      variables.set(stmt.name, {
+        type: "string",
+        value: value.type === "number" ? value.raw ?? String(value.value) : value.value
+      });
     }
     return {};
   }
@@ -7587,7 +8275,7 @@ function evaluateScalarExpr(expr) {
     case "STRING":
       return { type: "string", value: expr.value };
     case "NUMBER":
-      return { type: "number", value: expr.value };
+      return { type: "number", value: expr.value, raw: numberLiteralText(expr) };
     case "KINTONE_FUNC":
       return { type: "string", value: resolveKintoneFunc(expr.name) };
     case "STRING_FUNC":
@@ -7597,7 +8285,7 @@ function evaluateScalarExpr(expr) {
       if (!Number.isFinite(value)) {
         throw new Error("ArgumentError: SET scalar arithmetic produced a non-finite number.");
       }
-      return { type: "number", value };
+      return { type: "number", value, raw: String(value) };
     }
   }
 }
@@ -7612,7 +8300,7 @@ function resolveVariableRefs(node, variables) {
       if (value === void 0) {
         throw new Error(`ParseError: variable @${obj["name"]} is not defined in this batch.`);
       }
-      return value.type === "number" ? { type: "NUMBER", value: value.value } : { type: "STRING", value: value.value };
+      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)])
@@ -7678,7 +8366,7 @@ async function evalAssertOperand(operand, client, options, cacheContext, tempTab
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${operand.name}.`);
     case "NUMBER":
-      return String(operand.value);
+      return numberLiteralText(operand);
     case "STRING":
       return operand.value;
     case "ARITH":
@@ -7840,7 +8528,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);
@@ -7955,10 +8643,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) {
@@ -7979,6 +8676,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.");
@@ -8265,8 +8967,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);
     }
   }
 }
@@ -8279,6 +8999,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;
@@ -8444,10 +9166,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();
@@ -8549,7 +9272,7 @@ async function inferSelectColumnMeta(stmt, outputColumns, client, cacheContext,
       }
     } else if (column.type === "ARITH_AGG_COL" || column.type === "ARITH_COL") {
       meta = syntheticColumnMeta("number");
-    } else if (column.type === "LITERAL_COL") {
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") {
       meta = syntheticColumnMeta("string");
     } else if (column.type === "STRFUNC_COL") {
       meta = stringFunctionColumnMeta(column.expr);
@@ -8961,8 +9684,8 @@ async function fetchTableRecordsForFullScan(stmt, table, client, maxRecords, par
 }
 var UPSERT_IN_CHUNK_SIZE = 50;
 function normalizeKeyPart(v) {
-  const t = v.trim();
-  if (t !== "" && !Number.isNaN(Number(t))) return String(Number(t));
+  const decimal = parseExactDecimal(v);
+  if (decimal !== null) return JSON.stringify(decimal);
   return v;
 }
 function upsertCompositeKey(parts) {
@@ -9114,6 +9837,7 @@ var optionOrderCache = /* @__PURE__ */ new Map();
 var sortKindCache = /* @__PURE__ */ new Map();
 var fieldInfoCache = /* @__PURE__ */ new Map();
 var processStatusCache = /* @__PURE__ */ new Map();
+var numberPrecisionCache = /* @__PURE__ */ new Map();
 function getScopedCacheValue(root, cacheContext, appId) {
   return root.get(cacheContext)?.get(appId);
 }
@@ -9135,6 +9859,13 @@ async function getFieldsCached(appId, client, cacheContext) {
   setScopedCacheValue(fieldInfoCache, cacheContext, appId, loading);
   return loading;
 }
+async function getNumberPrecisionCached(appId, client, cacheContext) {
+  const cached = getScopedCacheValue(numberPrecisionCache, cacheContext, appId);
+  if (cached) return cached;
+  const loading = client.getNumberPrecision(appId);
+  setScopedCacheValue(numberPrecisionCache, cacheContext, appId, loading);
+  return loading;
+}
 async function getProcessStatusesCached(appId, client, cacheContext) {
   const cached = getScopedCacheValue(processStatusCache, cacheContext, appId);
   if (cached) return cached;
@@ -9248,7 +9979,7 @@ async function buildOrderSemanticsForSelect(stmt, client, cacheContext, material
     if (column.type === "FIELD") meta = resolveField2(aggregateFieldRef(column.field));
     else if (column.type === "ARITH_COL" || column.type === "ARITH_AGG_COL" || column.type === "WINDOW_COL") {
       meta = syntheticColumnMeta("number");
-    } else if (column.type === "LITERAL_COL") meta = syntheticColumnMeta("string");
+    } else if (column.type === "LITERAL_COL" || column.type === "SCALAR_VALUE_COL") meta = syntheticColumnMeta("string");
     else if (column.type === "STRFUNC_COL") meta = stringFunctionColumnMeta(column.expr);
     else if (column.type === "SCALAR_SUBQUERY_COL") meta = unknownStringColumnMeta();
     else if (column.type === "CASE_COL") {
@@ -9409,6 +10140,23 @@ async function loadWritableTopLevelDmlFields(appId, targetFields, client, cacheC
   assertWritableTopLevelDmlFields(appId, targetFields, fieldInfos);
   return fieldInfos;
 }
+async function loadNumberPrecisionForTargets(appId, targetFields, fieldInfos, client, cacheContext) {
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  return targetFields.some((code) => infoByCode.get(code)?.fieldType === "NUMBER") ? getNumberPrecisionCached(appId, client, cacheContext) : void 0;
+}
+function assertValidDmlRecords(records, targetFields, fieldInfos, numberPrecision) {
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  records.forEach((record, rowIndex) => {
+    for (const code of targetFields) {
+      const info = infoByCode.get(code);
+      const result = validateAndNormalizeDmlValue(record[code]?.value ?? "", info, numberPrecision);
+      if (!result.ok) {
+        throw new Error(`DmlValidationError: ${result.code} ${result.message} (row=${rowIndex + 1}, field=${code})`);
+      }
+      record[code] = { value: result.value };
+    }
+  });
+}
 async function executeDmlValidation(stmt, client, options, cacheContext, tempTables, statementNumber) {
   return (await prepareDmlValidation(stmt, client, options, cacheContext, tempTables, statementNumber)).result;
 }
@@ -9419,7 +10167,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) {
@@ -9436,6 +10184,13 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     await assertDmlWhereCapability(stmt, client, cacheContext);
   }
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  const numberPrecision = await loadNumberPrecisionForTargets(
+    stmt.appId,
+    targetFields,
+    fieldInfos,
+    client,
+    cacheContext
+  );
   const candidates = await materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode);
   const { errors, invalidRows, invalidRowNumbers } = validateDmlCandidates(
     candidates,
@@ -9443,7 +10198,11 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     payloadFields,
     targetFields,
     fieldInfos,
-    statementNumber
+    statementNumber,
+    numberPrecision,
+    stmt.checkGroups ?? [],
+    validateMissingCreateFields,
+    includePreErrors
   );
   const columns = [...payloadFields, ...VALIDATION_META_COLUMNS];
   const result = {
@@ -9553,15 +10312,33 @@ async function executeOnErrorSkip(stmt, client, options, cacheContext, tempTable
 async function materializeValidationCandidates(stmt, operation, client, options, cacheContext, tempTables, infoByCode) {
   if (stmt.type === "UPDATE") return materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables);
   let rows;
+  let sourceRows;
+  let evaluationTypes;
   if (stmt.type === "INSERT" || stmt.type === "UPSERT") {
+    assertInsertCheckRefs(stmt, stmt.fields);
+    evaluationTypes = new Map(stmt.fields.map((field) => [field, infoByCode.get(field)?.fieldType ?? ""]));
+    assertCheckComparisonTypes(stmt, evaluationTypes);
     rows = stmt.values.map((row) => row.map(
       (value, i) => value.type === "CASE_VALUE" ? evalCaseWhenValue(value.expr, {}, infoByCode.get(stmt.fields[i])?.fieldType) : value
     ));
   } else {
-    const selectResult = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, { ...options, onLimitReached: "error" }, tempTables, cacheContext) : await executeSelect(stmt.select, client, { ...options, onLimitReached: "error" }, cacheContext);
-    if (selectResult.columns.length !== stmt.fields.length) {
+    const selectResult = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, { ...options, onLimitReached: "error" }, tempTables, cacheContext) : await executeSelect(stmt.select, client, { ...options, onLimitReached: "error" }, cacheContext, void 0, true);
+    const hasChecks = (stmt.checkGroups?.length ?? 0) > 0;
+    if (selectResult.columns.length < stmt.fields.length || !hasChecks && selectResult.columns.length !== stmt.fields.length) {
       throw new Error(`SELECT \u306E\u5217\u6570\uFF08${selectResult.columns.length}\uFF09\u3068 DML \u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u6570\uFF08${stmt.fields.length}\uFF09\u304C\u4E00\u81F4\u3057\u307E\u305B\u3093`);
     }
+    if (hasChecks && new Set(selectResult.columns).size !== selectResult.columns.length) {
+      throw customCheckParseError("CHECK \u4ED8\u304D DML \u30BD\u30FC\u30B9 SELECT \u306E\u51FA\u529B\u540D\u306F\u4E00\u610F\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059");
+    }
+    assertInsertCheckRefs(stmt, selectResult.columns);
+    sourceRows = selectResult.rows;
+    const meta = materializedMetaBySelectResult.get(selectResult);
+    evaluationTypes = new Map(selectResult.columns.map((column) => {
+      const columnMeta = meta?.get(column);
+      const type = columnMeta?.fieldType ?? (columnMeta?.semantics?.compareMode === "number" || columnMeta?.sortKind === "number" ? "NUMBER" : "SINGLE_LINE_TEXT");
+      return [column, type];
+    }));
+    assertCheckComparisonTypes(stmt, evaluationTypes);
     rows = selectResult.rows.map((row) => selectResult.columns.map((column) => row[column] ?? ""));
   }
   const candidates = rows.map((values, index) => ({
@@ -9570,7 +10347,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) {
@@ -9599,26 +10380,74 @@ async function materializeValidationCandidates(stmt, operation, client, options,
   });
   return candidates;
 }
+function checkRefs(stmt) {
+  return stmt.checkGroups ? collectCheckFieldRefs(stmt.checkGroups) : [];
+}
+function assertInsertCheckRefs(stmt, available) {
+  const names = new Set(available);
+  for (const ref of checkRefs(stmt)) {
+    if (ref.tableAlias !== null) {
+      throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.tableAlias}.${ref.field} \u306F\u3053\u306E\u8A55\u4FA1\u884C\u3067\u306F\u4FEE\u98FE\u3067\u304D\u307E\u305B\u3093`);
+    }
+    if (!names.has(ref.field)) {
+      throw customCheckParseError(`CHECK \u306E\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u8A55\u4FA1\u884C\u306B\u5B58\u5728\u3057\u307E\u305B\u3093`);
+    }
+  }
+}
+var CHECK_UNSUPPORTED_COMPARISON_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "FILE",
+  "KSQL_ARRAY"
+]);
+function assertCheckComparisonTypes(stmt, types) {
+  if (!stmt.checkGroups) return;
+  for (const ref of collectCheckComparisonFieldRefs(stmt.checkGroups)) {
+    const key = ref.tableAlias ? `${ref.tableAlias}.${ref.field}` : ref.field;
+    const type = types.get(key) ?? types.get(ref.field);
+    if (CHECK_UNSUPPORTED_COMPARISON_TYPES.has(type ?? "")) {
+      throw customCheckParseError(`CHECK \u306E\u6BD4\u8F03\u3067\u306F ${type} \u30D5\u30A3\u30FC\u30EB\u30C9 ${key} \u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
+    }
+  }
+}
 async function materializeUpdateValidationCandidates(stmt, client, options, cacheContext, tempTables) {
   if (stmt.from) return materializeUpdateFromValidationCandidates(stmt, stmt.from, client, options, cacheContext, tempTables);
   await resolveSetSubqueries(stmt.assignments, client, options, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const checkTargetFields = assertUpdateCheckRefs(stmt, fieldTypes);
+  assertCheckComparisonTypes(stmt, updateEvaluationTypes(fieldTypes, stmt.appId));
   let records;
+  let evaluationById = /* @__PURE__ */ new Map();
   if (hasRowDependentAssignment(stmt)) {
     const getParams = updateToGetQueryForArith(stmt);
-    const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [...getParams.fields], {
+    const fields = [.../* @__PURE__ */ new Set([...getParams.fields, ...checkTargetFields])];
+    const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, fields, {
       maxRecords: options.maxRecords ?? 1e4,
       parallel: options.fetchParallel ?? 1,
       onLimit: "error"
     });
+    evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
     records = updateToPutBatchesArith(stmt, resolved.records, fieldTypes).flatMap((batch) => batch.records);
   } else {
     const getParams = updateToGetQuery(stmt);
-    const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
-      maxRecords: options.maxRecords ?? 1e4,
-      parallel: options.fetchParallel ?? 1
-    });
-    records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+    if (checkTargetFields.length > 0) {
+      const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [.../* @__PURE__ */ new Set(["$id", ...checkTargetFields])], {
+        maxRecords: options.maxRecords ?? 1e4,
+        parallel: options.fetchParallel ?? 1,
+        onLimit: "error"
+      });
+      evaluationById = new Map(resolved.records.map((record) => [Number(record["$id"]?.value), record]));
+      records = updateToPutBatches(stmt, [...evaluationById.keys()], fieldTypes).flatMap((batch) => batch.records);
+    } else {
+      const resolved = await resolveDmlTargetIds(client.getRecords, getParams.app, getParams.query, {
+        maxRecords: options.maxRecords ?? 1e4,
+        parallel: options.fetchParallel ?? 1
+      });
+      records = updateToPutBatches(stmt, resolved.ids, fieldTypes).flatMap((batch) => batch.records);
+    }
   }
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
     rowNumber: index + 1,
@@ -9627,13 +10456,48 @@ async function materializeUpdateValidationCandidates(stmt, client, options, cach
     payload: new Map([["$id", String(entry.id)], ...stmt.assignments.map((a) => [a.field, entry.record[a.field]?.value ?? ""])]),
     preErrors: [],
     record: entry.record,
-    targetId: entry.id
+    targetId: entry.id,
+    evaluationRow: updateEvaluationRow(evaluationById.get(entry.id), stmt.appId),
+    evaluationFieldTypes: updateEvaluationTypes(fieldTypes, stmt.appId)
   }));
 }
+function assertUpdateCheckRefs(stmt, targetTypes) {
+  if (stmt.from) return [];
+  const fields = /* @__PURE__ */ new Set();
+  for (const ref of checkRefs(stmt)) {
+    if (ref.tableAlias !== null && ref.tableAlias.toLowerCase() !== `app${stmt.appId}`.toLowerCase()) {
+      throw customCheckParseError(`CHECK \u306E\u4FEE\u98FE\u5B50 ${ref.tableAlias} \u306F\u66F4\u65B0\u5148 APP${stmt.appId} \u3067\u306F\u3042\u308A\u307E\u305B\u3093`);
+    }
+    if (ref.field !== "$id" && !targetTypes.has(ref.field)) {
+      throw customCheckParseError(`CHECK \u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u30D5\u30A3\u30FC\u30EB\u30C9 ${ref.field} \u306F\u5B58\u5728\u3057\u307E\u305B\u3093`);
+    }
+    fields.add(ref.field);
+  }
+  return [...fields];
+}
+function updateEvaluationRow(record, appId) {
+  if (!record) return {};
+  const plain = flatten(record, null);
+  return Object.fromEntries([
+    ...Object.entries(plain),
+    ...Object.entries(plain).map(([field, value]) => [`APP${appId}.${field}`, value])
+  ]);
+}
+function updateEvaluationTypes(types, appId) {
+  return new Map([
+    ...types,
+    ...[...types].map(([field, type]) => [`APP${appId}.${field}`, type]),
+    ["$id", "RECORD_NUMBER"],
+    [`APP${appId}.$id`, "RECORD_NUMBER"]
+  ]);
+}
 async function materializeUpdateFromValidationCandidates(stmt, from, client, options, cacheContext, tempTables) {
+  const scope = await resolveUpdateFromCheckScope(stmt, from, client, cacheContext, tempTables);
+  assertCheckComparisonTypes(stmt, scope.evaluationTypes);
   const matched = await resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const records = updateFromToPutBatches(stmt, matched, fieldTypes).flatMap((batch) => batch.records);
+  const matchedById = new Map(matched.map((pair) => [Number(pair.target["$id"]?.value), pair]));
   return records.sort((a, b) => a.id - b.id).map((entry, index) => ({
     rowNumber: index + 1,
     operation: "UPDATE",
@@ -9641,7 +10505,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;
@@ -9655,7 +10521,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,
@@ -9667,6 +10534,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
     tempTables
   );
   const sourceByKey = /* @__PURE__ */ new Map();
+  const sourceQueryByKey = /* @__PURE__ */ new Map();
   for (const row of sourceRows) {
     if (!Object.prototype.hasOwnProperty.call(row, from.joinKeyField)) {
       throw new Error(`ArgumentError: UPDATE ... FROM source column ${from.joinKeyField} does not exist.`);
@@ -9676,15 +10544,16 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
       throw new Error(`ArgumentError: UPDATE ... FROM source has multiple rows for normalized key ${key}.`);
     }
     sourceByKey.set(key, row);
+    sourceQueryByKey.set(key, String(row[from.joinKeyField]).trim());
   }
   if (sourceByKey.size === 0) return [];
   const maxRecords = options.maxRecords ?? 1e4;
-  const targetFields = collectUpdateFromTargetFields(stmt);
-  const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter }).query;
+  const targetFields = [.../* @__PURE__ */ new Set([...collectUpdateFromTargetFields(stmt), ...checkScope.targetFields])];
+  const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter, checkGroups: void 0 }).query;
   const targetRecords = [];
   const seenTargetIds = /* @__PURE__ */ new Set();
   let fetchedTargetCount = 0;
-  for (const keys of splitChunks([...sourceByKey.keys()], UPDATE_FROM_KEY_CHUNK_SIZE)) {
+  for (const keys of splitChunks([...sourceQueryByKey.values()], UPDATE_FROM_KEY_CHUNK_SIZE)) {
     const keyQuery = `${from.targetJoinField} in (${keys.map(sqlQuote).join(",")})`;
     const query = filterQuery ? `(${keyQuery}) and (${filterQuery})` : keyQuery;
     const resolved = await fetchRecordsForSharedPlan(
@@ -9785,37 +10654,75 @@ function normalizeUpdateFromJoinKey(raw, kind, side) {
   }
   if (kind === "number" && side === "target" && raw === "") return null;
   if (kind === "id") {
-    const text2 = raw.trim();
-    const id = Number(text2);
-    if (text2 === "" || !Number.isSafeInteger(id) || id <= 0) {
+    const text = raw.trim();
+    const id = Number(text);
+    if (text === "" || !Number.isSafeInteger(id) || id <= 0) {
       throw new Error(`ArgumentError: UPDATE ... FROM ${side} key must be a positive safe integer: ${raw}`);
     }
     return String(id);
   }
-  const text = raw.trim();
-  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)$/.test(text)) {
+  const decimal = parseExactDecimal(raw);
+  if (decimal === null) {
     throw new Error(`ArgumentError: UPDATE ... FROM ${side} key must be a finite decimal: ${raw}`);
   }
-  let unsigned = text;
-  let negative = false;
-  if (unsigned.startsWith("-") || unsigned.startsWith("+")) {
-    negative = unsigned[0] === "-";
-    unsigned = unsigned.slice(1);
+  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 };
   }
-  let [whole, fraction = ""] = unsigned.split(".");
-  whole = (whole || "0").replace(/^0+(?=\d)/, "");
-  fraction = fraction.replace(/0+$/, "");
-  const zero = /^0*$/.test(whole) && fraction === "";
-  const canonical = fraction === "" ? whole : `${whole}.${fraction}`;
-  return negative && !zero ? `-${canonical}` : canonical;
+  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);
   }
-  await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
+  const fieldInfos = await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
+  const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, stmt.fields, fieldInfos, client, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const batches = insertToPostBatches(stmt, fieldTypes);
+  assertValidDmlRecords(batches.flatMap((batch) => batch.records), stmt.fields, fieldInfos, numberPrecision);
   const createdIds = [];
   for (const batch of batches) {
     const res = await client.postRecords(batch);
@@ -9828,7 +10735,9 @@ async function executeInsert(stmt, client, options, cacheContext) {
   };
 }
 async function executeInsertSelect(stmt, client, options, cacheContext, cteCache) {
-  await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
+  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);
   const { rows, columns } = selectResult;
   if (columns.length !== stmt.fields.length) {
@@ -9850,6 +10759,7 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
     });
     return record;
   });
+  assertValidDmlRecords(allRecords, stmt.fields, fieldInfos, numberPrecision);
   const createdIds = [];
   for (let i = 0; i < allRecords.length; i += 100) {
     const batch = allRecords.slice(i, i + 100);
@@ -9863,16 +10773,25 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
   };
 }
 async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
+  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);
   }
-  await loadWritableTopLevelDmlFields(
+  const fieldInfos = await loadWritableTopLevelDmlFields(
     stmt.appId,
     stmt.assignments.map((assignment) => assignment.field),
     client,
     cacheContext
   );
+  const targetFields = stmt.assignments.map((assignment) => assignment.field);
+  const numberPrecision = await loadNumberPrecisionForTargets(
+    stmt.appId,
+    targetFields,
+    fieldInfos,
+    client,
+    cacheContext
+  );
   await assertDmlWhereCapability(stmt, client, cacheContext);
   if (stmt.from != null) {
     return executeUpdateFrom(stmt, stmt.from, client, options, cacheContext, tempTables);
@@ -9890,11 +10809,12 @@ async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
       { maxRecords, parallel: options.fetchParallel ?? 1 }
     );
     const records = resolved2.records;
+    const batches2 = updateToPutBatchesArith(stmt, records, fieldTypes);
+    assertValidDmlRecords(batches2.flatMap((batch) => batch.records.map((entry) => entry.record)), targetFields, fieldInfos, numberPrecision);
     if (options.confirm) {
       const ok = await options.confirm(records.length, "UPDATE");
       if (!ok) throw new OperationCancelledError("UPDATE", records.length);
     }
-    const batches2 = updateToPutBatchesArith(stmt, records, fieldTypes);
     for (const batch of batches2) {
       await client.putRecords(batch);
     }
@@ -9908,11 +10828,12 @@ async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
     { maxRecords, parallel: options.fetchParallel ?? 1 }
   );
   const ids = resolved.ids;
+  const batches = updateToPutBatches(stmt, ids, fieldTypes);
+  assertValidDmlRecords(batches.flatMap((batch) => batch.records.map((entry) => entry.record)), targetFields, fieldInfos, numberPrecision);
   if (options.confirm) {
     const ok = await options.confirm(ids.length, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", ids.length);
   }
-  const batches = updateToPutBatches(stmt, ids, fieldTypes);
   for (const batch of batches) {
     await client.putRecords(batch);
   }
@@ -9920,12 +10841,16 @@ async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
 }
 async function executeUpdateFrom(stmt, from, client, options, cacheContext, tempTables) {
   const matched = await resolveUpdateFromMatchedRecords(stmt, from, client, options, cacheContext, tempTables);
+  const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const batches = updateFromToPutBatches(stmt, matched, fieldTypes);
+  const targetFields = stmt.assignments.map((assignment) => assignment.field);
+  const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
+  const numberPrecision = await loadNumberPrecisionForTargets(stmt.appId, targetFields, fieldInfos, client, cacheContext);
+  assertValidDmlRecords(batches.flatMap((batch) => batch.records.map((entry) => entry.record)), targetFields, fieldInfos, numberPrecision);
   if (options.confirm) {
     const ok = await options.confirm(matched.length, "UPDATE");
     if (!ok) throw new OperationCancelledError("UPDATE", matched.length);
   }
-  const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  const batches = updateFromToPutBatches(stmt, matched, fieldTypes);
   for (const batch of batches) await client.putRecords(batch);
   return { type: "UPDATE", updatedCount: matched.length };
 }
@@ -9974,7 +10899,9 @@ async function executeDelete(stmt, client, options, cacheContext) {
   return { type: "DELETE", deletedCount: ids.length };
 }
 async function executeUpsert(stmt, client, options, cacheContext) {
-  await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, 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 = [];
   const toUpdate = [];
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
@@ -9983,7 +10910,7 @@ async function executeUpsert(stmt, client, options, cacheContext) {
       const idx = stmt.fields.indexOf(key);
       if (idx === -1) throw new Error(`ON DUPLICATE \u306E\u30AD\u30FC\u300C${key}\u300D\u304C INSERT \u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u542B\u307E\u308C\u3066\u3044\u307E\u305B\u3093`);
       const val = row[idx];
-      return val.type === "STRING" ? val.value : val.type === "NUMBER" ? String(val.value) : val.type === "CASE_VALUE" ? evalCaseWhen(val.expr, {}) : val.elements.map((e) => e.value).join(",");
+      return val.type === "STRING" ? val.value : val.type === "NUMBER" ? numberLiteralText(val) : val.type === "CASE_VALUE" ? evalCaseWhen(val.expr, {}) : val.elements.map((e) => e.value).join(",");
     })
   );
   const targetIndex = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeyValues, client, options, fieldTypes);
@@ -10004,6 +10931,12 @@ async function executeUpsert(stmt, client, options, cacheContext) {
       toInsert.push(record);
     }
   });
+  assertValidDmlRecords(
+    [...toInsert, ...toUpdate.map((entry) => entry.record)],
+    stmt.fields,
+    fieldInfos,
+    numberPrecision
+  );
   if (options.confirm && toInsert.length + toUpdate.length > 0) {
     const total = toInsert.length + toUpdate.length;
     const ok = await options.confirm(total, "UPDATE");
@@ -10279,14 +11212,14 @@ function buildSubtableReorderPutParams(appId, parentId, revision, subtableCode,
 }
 function evalAssignmentValueForSubtable(value, row, resolveFieldType) {
   if (value.type === "STRING") return value.value;
-  if (value.type === "NUMBER") return String(value.value);
+  if (value.type === "NUMBER") return numberLiteralText(value);
   if (value.type === "ARITH") return String(evalArithExpr(value, row));
   if (value.type === "CASE_VALUE") return evalCaseWhen(value.expr, row, resolveFieldType);
   throw new Error(`${value.type} \u306F\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE \u306E\u5024\u3068\u3057\u3066\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093`);
 }
 function valueToString(value) {
   if (value.type === "STRING") return value.value;
-  if (value.type === "NUMBER") return String(value.value);
+  if (value.type === "NUMBER") return numberLiteralText(value);
   if (value.type === "CASE_VALUE") return evalCaseWhen(value.expr, {});
   return value.elements.map((e) => e.value).join(",");
 }
@@ -10401,7 +11334,9 @@ function evalOrderKeyForRow(key, row) {
   }
 }
 async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache) {
-  await loadWritableTopLevelDmlFields(stmt.appId, stmt.fields, client, cacheContext);
+  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);
   const { rows, columns } = selectResult;
   if (columns.length !== stmt.fields.length) {
@@ -10424,6 +11359,7 @@ async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache
     });
     return record;
   });
+  assertValidDmlRecords(records, stmt.fields, fieldInfos, numberPrecision);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const rowKeyValues = records.map(
     (record) => stmt.keyFields.map((key) => String(record[key]?.value ?? ""))
@@ -11146,6 +12082,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];
 }
@@ -11160,10 +12097,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) {
@@ -11182,7 +12183,7 @@ function formatArithExprStr(expr) {
 }
 function formatArithNodeStr(node) {
   if (node.type === "FIELD_REF") return node.field;
-  if (node.type === "NUMBER") return String(node.value);
+  if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "ARITH") return `(${formatArithExprStr(node)})`;
   return "...";
 }
@@ -11651,6 +12652,7 @@ function withRequestGate(client, gate) {
     },
     getApps: () => gate.runReadOnly(() => client.getApps()),
     getFields: (appId) => gate.runReadOnly(() => client.getFields(appId)),
+    getNumberPrecision: (appId) => gate.runReadOnly(() => client.getNumberPrecision(appId)),
     getProcessStatuses: (appId) => gate.runReadOnly(() => client.getProcessStatuses(appId)),
     postRecords: (params) => gate.runMutation(() => client.postRecords(params)),
     putRecords: (params) => gate.runMutation(() => client.putRecords(params)),
@@ -12212,6 +13214,16 @@ function createNodeKintoneClient(baseUrl, tokenResolver) {
       );
       return flattenFormFieldProperties(res.properties);
     },
+    async getNumberPrecision(appId) {
+      const qs = new URLSearchParams();
+      qs.set("app", String(appId));
+      const res = await requestJson(
+        `${apiBasePath}/app/settings.json?${qs.toString()}`,
+        { method: "GET" },
+        appId
+      );
+      return parseNumberPrecisionSettings(res);
+    },
     async getProcessStatuses(appId) {
       const qs = new URLSearchParams();
       qs.set("app", String(appId));
@@ -13342,6 +14354,9 @@ function createDryRunClient() {
     getFields: notUsed,
     async getProcessStatuses() {
       return { enable: false, states: [] };
+    },
+    async getNumberPrecision() {
+      return { digits: 30, decimalPlaces: 10, roundingMode: "HALF_EVEN" };
     }
   };
 }
@@ -14359,6 +15374,12 @@ async function run() {
         if (!routed) throw new Error(`AuthError: profile "${pName}" is not resolved for APP${appId}.`);
         return routed.getFields(binding.appId);
       },
+      getNumberPrecision: (appId) => {
+        const binding = appBindingByMappedApp.get(appId) ?? { appId, profile: profileName.toLowerCase() };
+        const routed = profileClientMap.get(binding.profile);
+        if (!routed) throw new Error(`AuthError: profile "${binding.profile}" is not resolved for APP${appId}.`);
+        return routed.getNumberPrecision(binding.appId);
+      },
       getProcessStatuses: (appId) => {
         const binding = appBindingByMappedApp.get(appId) ?? { appId, profile: profileName.toLowerCase() };
         const pName = binding.profile;