@rex0220/kintone-sql-tools 3.1.0 → 3.3.0

package/dist-cli/ksql.js

@@ -117,10 +117,14 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["LTRIM", "LTRIM" /* LTRIM */],
   ["RTRIM", "RTRIM" /* RTRIM */],
   ["LENGTH", "LENGTH" /* LENGTH */],
+  ["LENGTH_CHAR", "LENGTH_CHAR" /* LENGTH_CHAR */],
   ["SUBSTRING", "SUBSTRING" /* SUBSTRING */],
   ["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 */],
@@ -129,6 +133,7 @@ var KEYWORDS = /* @__PURE__ */ new Map([
   ["LEAST", "LEAST" /* LEAST */],
   ["LPAD", "LPAD" /* LPAD */],
   ["RPAD", "RPAD" /* RPAD */],
+  ["TRANSLATE", "TRANSLATE" /* TRANSLATE */],
   ["CAST", "CAST" /* CAST */],
   ["CONVERT", "CONVERT" /* CONVERT */],
   ["FORMAT", "FORMAT" /* FORMAT */],
@@ -252,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])) {
@@ -264,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),
@@ -463,8 +478,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;
@@ -488,13 +589,18 @@ var FUNC_CALL_PREFIX_KINDS = /* @__PURE__ */ new Set([
   "LTRIM" /* LTRIM */,
   "RTRIM" /* RTRIM */,
   "LENGTH" /* LENGTH */,
+  "LENGTH_CHAR" /* LENGTH_CHAR */,
   "SUBSTRING" /* SUBSTRING */,
   "SUBSTR" /* SUBSTR */,
   "CONCAT" /* CONCAT */,
   "REPLACE" /* REPLACE */,
+  "TRANSLATE" /* TRANSLATE */,
   "COALESCE" /* COALESCE */,
   "NULLIF" /* NULLIF */,
   "ISNULL" /* ISNULL */,
+  "REGEXP_LIKE" /* REGEXP_LIKE */,
+  "REGEXP_REPLACE" /* REGEXP_REPLACE */,
+  "REGEXP_SUBSTR" /* REGEXP_SUBSTR */,
   "LEFT" /* LEFT */,
   "RIGHT" /* RIGHT */,
   "INSTR" /* INSTR */,
@@ -543,6 +649,7 @@ var ParseError = class extends Error {
 var Parser = class {
   constructor(tokens) {
     this.tokens = tokens;
+    this.allowUnaryPlusNumber = false;
     this.pos = 0;
     /** WITH 句で定義された CTE 名のセット（parseTableRef で参照） */
     this.cteNames = /* @__PURE__ */ new Set();
@@ -1257,12 +1364,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) {
@@ -1311,11 +1418,19 @@ var Parser = class {
       this.expect(")" /* RPAREN */);
       return expr;
     }
+    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 makeNumberLiteral(`+${number.value}`);
+    }
     if (this.peek().kind === "-" /* MINUS */) {
       this.advance();
+      if (this.peek().kind === "-" /* MINUS */ || this.peek().kind === "+" /* PLUS */) {
+        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();
@@ -1323,7 +1438,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();
@@ -1422,10 +1537,15 @@ var Parser = class {
       ["LTRIM" /* LTRIM */]: "LTRIM",
       ["RTRIM" /* RTRIM */]: "RTRIM",
       ["LENGTH" /* LENGTH */]: "LENGTH",
+      ["LENGTH_CHAR" /* LENGTH_CHAR */]: "LENGTH_CHAR",
       ["SUBSTRING" /* SUBSTRING */]: "SUBSTRING",
       ["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",
       ["ISNULL" /* ISNULL */]: "ISNULL",
@@ -1964,7 +2084,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(
@@ -1991,15 +2111,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 {
@@ -2186,12 +2306,16 @@ var Parser = class {
       } else if (this.peek().kind === "IF" /* IF */) {
         const expr = this.parseIfExpr();
         row.push({ type: "CASE_VALUE", expr });
+      } 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");
+        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);
         }
@@ -2215,6 +2339,12 @@ var Parser = class {
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     this.expect("SET" /* SET */);
     const assignments = this.parseAssignments();
+    if (subtableCode && assignments.some((a) => a.value.type === "STRING_FUNC")) {
+      throw new ParseError(
+        "\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE SET \u3067\u306F\u6587\u5B57\u5217\u95A2\u6570\u3092\u76F4\u63A5\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
+        this.prev()
+      );
+    }
     let from = null;
     if (this.consume("FROM" /* FROM */)) {
       const table = this.parseTableRef();
@@ -2258,7 +2388,14 @@ var Parser = class {
       from.targetFilter = decomposed.targetFilter;
     } else if (assignments.some((a) => a.value.type === "SOURCE_FIELD")) {
       throw new ParseError(
-        "SET \u306E\u5024\u306B\u306F\u30EA\u30C6\u30E9\u30EB\u30FB\u7B97\u8853\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u306E\u307F\u306F\u4E0D\u53EF\uFF09",
+        "SET \u306E\u5024\u306B\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u5358\u72EC\u3067\u6307\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
+        whereTok
+      );
+    } else if (assignments.some(
+      (a) => a.value.type === "STRING_FUNC" && this.nodeContainsAnyQualifier(a.value)
+    )) {
+      throw new ParseError(
+        "UPDATE SET \u306E\u6587\u5B57\u5217\u95A2\u6570\u3067\u306F\u66F4\u65B0\u5148\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u4FEE\u98FE\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044",
         whereTok
       );
     }
@@ -2325,6 +2462,12 @@ var Parser = class {
   }
   validateUpdateFromAssignments(assignments, sourceAlias, tok) {
     for (const assignment of assignments) {
+      if (assignment.value.type === "STRING_FUNC") {
+        throw new ParseError(
+          "UPDATE ... FROM \u306E SET \u3067\u306F\u6587\u5B57\u5217\u95A2\u6570\u3092\u76F4\u63A5\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093",
+          tok
+        );
+      }
       if (assignment.value.type === "SOURCE_FIELD") {
         if (assignment.value.alias.toLowerCase() !== sourceAlias.toLowerCase()) {
           throw new ParseError(`UPDATE ... FROM \u306E SET \u53C2\u7167\u306F\u30BD\u30FC\u30B9 alias ${sourceAlias} \u3067\u4FEE\u98FE\u3057\u3066\u304F\u3060\u3055\u3044`, tok);
@@ -2464,9 +2607,17 @@ var Parser = class {
       this.expect(")" /* RPAREN */);
       return { type: "SCALAR_SUBQUERY", query };
     }
-    const node = this.parseArithAddSub();
+    const previousAllowUnaryPlusNumber = this.allowUnaryPlusNumber;
+    this.allowUnaryPlusNumber = true;
+    let node;
+    try {
+      node = this.parseArithAddSub();
+    } finally {
+      this.allowUnaryPlusNumber = previousAllowUnaryPlusNumber;
+    }
     if (node.type === "NUMBER") return node;
     if (node.type === "ARITH") return node;
+    if (node.type === "STRING_FUNC") return node;
     if (node.type === "FIELD_REF") {
       const dot = node.field.indexOf(".");
       if (dot > 0 && dot < node.field.length - 1) {
@@ -2474,7 +2625,7 @@ var Parser = class {
       }
     }
     throw new ParseError(
-      "SET \u306E\u5024\u306B\u306F\u30EA\u30C6\u30E9\u30EB\u30FB\u7B97\u8853\u5F0F\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\uFF08\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u306E\u307F\u306F\u4E0D\u53EF\uFF09",
+      "SET \u306E\u5024\u306B\u30D5\u30A3\u30FC\u30EB\u30C9\u53C2\u7167\u3092\u5358\u72EC\u3067\u6307\u5B9A\u3059\u308B\u3053\u3068\u306F\u3067\u304D\u307E\u305B\u3093",
       tok
     );
   }
@@ -2998,7 +3149,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":
@@ -3027,7 +3178,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})`;
 }
@@ -3540,7 +3691,7 @@ 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)})`;
 }
@@ -3697,7 +3848,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;
@@ -4302,9 +4453,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 };
@@ -4313,7 +4465,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;
 }
@@ -4413,7 +4565,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);
@@ -4499,6 +4653,149 @@ function applyRoundOp(op, num, digits) {
   if (digits > 0) return String(parseFloat(raw.toFixed(digits)));
   return String(raw);
 }
+function isHighSurrogate(codeUnit) {
+  return codeUnit >= 55296 && codeUnit <= 56319;
+}
+function isLowSurrogate(codeUnit) {
+  return codeUnit >= 56320 && codeUnit <= 57343;
+}
+function splitsSurrogatePair(value, index) {
+  return index > 0 && index < value.length && isHighSurrogate(value.charCodeAt(index - 1)) && isLowSurrogate(value.charCodeAt(index));
+}
+function normalizeSliceIndex(index, length) {
+  if (Number.isNaN(index) || index === Number.NEGATIVE_INFINITY) return 0;
+  if (index === Number.POSITIVE_INFINITY) return length;
+  const integer = Math.trunc(index);
+  return integer < 0 ? Math.max(length + integer, 0) : Math.min(integer, length);
+}
+function sliceSafePrefix(value, budget) {
+  let end = Math.min(Math.max(0, budget), value.length);
+  if (splitsSurrogatePair(value, end)) end -= 1;
+  return value.slice(0, end);
+}
+function sliceSafeSuffix(value, budget) {
+  let start = Math.max(0, value.length - budget);
+  if (splitsSurrogatePair(value, start)) start += 1;
+  return value.slice(start);
+}
+function sliceSafeRange(value, rawStart, rawEnd) {
+  let start = normalizeSliceIndex(rawStart, value.length);
+  let end = normalizeSliceIndex(rawEnd, value.length);
+  if (end <= start) return "";
+  if (splitsSurrogatePair(value, start)) start += 1;
+  if (splitsSurrogatePair(value, end)) end -= 1;
+  return value.slice(start, Math.max(start, end));
+}
+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) {
@@ -4514,23 +4811,26 @@ function evalStringFunc(expr, row) {
       return (args[0] ?? "").trimEnd();
     case "LENGTH":
       return String((args[0] ?? "").length);
+    case "LENGTH_CHAR":
+      assertArity("LENGTH_CHAR", args, 1, 1);
+      return String([...args[0] ?? ""].length);
     case "SUBSTRING": {
       const str = args[0] ?? "";
       const start = Math.max(0, Number(args[1] ?? "1") - 1);
       const len = args[2] !== void 0 ? Number(args[2]) : void 0;
-      return len !== void 0 ? str.slice(start, start + len) : str.slice(start);
+      return sliceSafeRange(str, start, len !== void 0 ? start + len : str.length);
     }
     case "LEFT": {
       assertArity("LEFT", args, 2, 2);
       const str = args[0];
       const n = Math.trunc(Number(args[1]));
-      return Number.isNaN(n) || n <= 0 ? "" : str.slice(0, n);
+      return Number.isNaN(n) || n <= 0 ? "" : sliceSafePrefix(str, n);
     }
     case "RIGHT": {
       assertArity("RIGHT", args, 2, 2);
       const str = args[0];
       const n = Math.trunc(Number(args[1]));
-      return Number.isNaN(n) || n <= 0 ? "" : str.slice(Math.max(0, str.length - n));
+      return Number.isNaN(n) || n <= 0 ? "" : sliceSafeSuffix(str, n);
     }
     case "INSTR":
       assertArity("INSTR", args, 2, 2);
@@ -4541,10 +4841,11 @@ function evalStringFunc(expr, row) {
       const str = args[0];
       const n = Math.trunc(Number(args[1]));
       if (Number.isNaN(n) || n <= 0) return "";
-      if (str.length >= n) return str.slice(0, n);
+      if (str.length >= n) return sliceSafePrefix(str, n);
       const pad = args[2] ?? " ";
       if (pad === "") return str;
-      return expr.func === "LPAD" ? str.padStart(n, pad) : str.padEnd(n, pad);
+      const padding = makeSafePadding(pad, n - str.length);
+      return expr.func === "LPAD" ? padding + str : str + padding;
     }
     case "GREATEST":
     case "LEAST":
@@ -4558,6 +4859,36 @@ 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]];
+      const to = [...args[2]];
+      if (from.length !== to.length) {
+        throw new Error(
+          `ArgumentError: TRANSLATE \u306E from \u3068 to \u306F\u540C\u3058\u6587\u5B57\u6570\u3067\u3042\u308B\u5FC5\u8981\u304C\u3042\u308A\u307E\u3059\uFF08from=${from.length}, to=${to.length}\uFF09`
+        );
+      }
+      const map = /* @__PURE__ */ new Map();
+      from.forEach((ch, i) => {
+        if (!map.has(ch)) map.set(ch, to[i]);
+      });
+      return [...args[0]].map((ch) => map.get(ch) ?? ch).join("");
+    }
     case "COALESCE":
       return args.find((a) => a !== "") ?? "";
     case "NULLIF":
@@ -4721,7 +5052,7 @@ 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 === "NUMBER") return numberLiteralText(arg);
   if (arg.type === "AGG_REF" || arg.type === "AGG_ARITH") return "";
   return String(evalArithExpr(arg, row));
 }
@@ -4770,7 +5101,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;
@@ -4795,6 +5126,7 @@ function evalOp(op, leftStr, right, row, fieldType, resolveFieldType, semantics
 }
 var NUMERIC_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
   "LENGTH",
+  "LENGTH_CHAR",
   "INSTR",
   "ROUND",
   "FLOOR",
@@ -4849,6 +5181,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 {
@@ -4907,7 +5243,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":
@@ -5042,7 +5378,7 @@ 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 === "SOURCE_FIELD") continue;
+    if (value.type === "ARITH" || value.type === "CASE_VALUE" || value.type === "STRING_FUNC" || value.type === "SOURCE_FIELD") continue;
     record[field] = { value: toKintoneValue(value, fieldTypes.get(field)) };
   }
   return record;
@@ -5052,12 +5388,19 @@ function hasArithAssignment(stmt) {
     (a) => a.value.type === "ARITH" || 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"
+  );
+}
 function updateToGetQueryForArith(stmt) {
   assertDmlWhereIsSafe(stmt.where);
   const refFields = /* @__PURE__ */ new Set();
   for (const { value } of stmt.assignments) {
     if (value.type === "ARITH") {
       collectArithFields2(value, refFields);
+    } else if (value.type === "STRING_FUNC") {
+      collectStringFuncFields2(value, refFields);
     } else if (value.type === "CASE_VALUE") {
       collectCaseFields(value.expr, refFields);
     }
@@ -5144,6 +5487,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 === "STRING_FUNC") {
+        record[field] = { value: evalStringFunc(value, row) };
       } else if (value.type === "CASE_VALUE") {
         record[field] = { value: evalCaseWhenValue(value.expr, row, fieldTypes.get(field)) };
       } else if (value.type === "SOURCE_FIELD") {
@@ -5192,6 +5537,8 @@ function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new
           throw new DmlConvertError(`\u6570\u5024\u30D5\u30A3\u30FC\u30EB\u30C9 ${field} \u306B\u5909\u63DB\u3067\u304D\u306A\u3044\u5024\u3067\u3059: ${raw}`);
         }
         record[field] = { value: toKintoneValue({ type: "STRING", value: raw }, fieldType) };
+      } else if (value.type === "STRING_FUNC") {
+        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 === "CASE_VALUE") {
@@ -5336,7 +5683,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":
@@ -5968,7 +6315,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)}`;
 }
@@ -6083,6 +6430,7 @@ function compareSortKeys(a, b, meta) {
 }
 var NUMERIC_ORDER_FUNCTIONS = /* @__PURE__ */ new Set([
   "LENGTH",
+  "LENGTH_CHAR",
   "INSTR",
   "ROUND",
   "FLOOR",
@@ -6317,7 +6665,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)})`;
   };
@@ -6346,10 +6694,11 @@ function hasAggregateInStringFuncExpr2(expr) {
 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);
@@ -6467,10 +6816,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)) {
@@ -6489,7 +6871,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) {
@@ -6498,6 +6881,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)) {
@@ -6525,7 +6919,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) {
@@ -6575,34 +6970,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);
@@ -6630,7 +6997,7 @@ 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) {
   const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
   const errors = [];
   const invalid = /* @__PURE__ */ new Set();
@@ -6638,7 +7005,7 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
     candidate.record ??= {};
     const rowErrors = [...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 };
     }
@@ -6648,14 +7015,14 @@ function validateDmlCandidates(candidates, operation, payloadFields, targetField
         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) {
@@ -6683,7 +7050,8 @@ 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);
@@ -6925,6 +7293,7 @@ function createEmptyMetrics() {
     putCalls: 0,
     deleteCalls: 0,
     fieldCalls: 0,
+    numberPrecisionCalls: 0,
     appsCalls: 0,
     processStatusCalls: 0,
     cursorCreateCalls: 0,
@@ -7010,6 +7379,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);
@@ -7277,7 +7650,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}`);
@@ -7295,7 +7668,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 {};
   }
@@ -7471,7 +7847,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":
@@ -7481,7 +7857,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) };
     }
   }
 }
@@ -7496,7 +7872,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)])
@@ -7562,7 +7938,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":
@@ -8303,6 +8679,7 @@ function systemColumnMeta(field) {
 }
 var NUMBER_RETURNING_STRING_FUNCTIONS = /* @__PURE__ */ new Set([
   "LENGTH",
+  "LENGTH_CHAR",
   "INSTR",
   "ROUND",
   "FLOOR",
@@ -8844,8 +9221,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) {
@@ -8997,6 +9374,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);
 }
@@ -9018,6 +9396,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;
@@ -9270,6 +9655,45 @@ var NON_WRITABLE_FIELD_TYPES = /* @__PURE__ */ new Set([
   "CATEGORY",
   "REFERENCE_TABLE"
 ]);
+function assertWritableTopLevelDmlFields(appId, targetFields, fieldInfos) {
+  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
+  for (const code of targetFields) {
+    const info = infoByCode.get(code);
+    if (!info) {
+      throw new Error(`ArgumentError: DML target field ${code} does not exist.`);
+    }
+    if (info.inSubtable) {
+      throw new Error(
+        `ArgumentError: DML target field ${code} is inside a subtable. Use subtable DML syntax (for example, APP${appId}$\u30C6\u30FC\u30D6\u30EB).`
+      );
+    }
+    if (info.writable === false || NON_WRITABLE_FIELD_TYPES.has(info.fieldType)) {
+      throw new Error(`ArgumentError: DML target field ${code} is not writable (${info.fieldType}).`);
+    }
+  }
+}
+async function loadWritableTopLevelDmlFields(appId, targetFields, client, cacheContext) {
+  const fieldInfos = await getFieldsCached(appId, client, cacheContext);
+  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;
 }
@@ -9281,24 +9705,29 @@ var RejectLimitExceededError = class extends Error {
   }
 };
 async function prepareDmlValidation(stmt, client, options, cacheContext, tempTables, statementNumber) {
-  if (stmt.type === "UPDATE") {
-    await assertDmlWhereCapability(stmt, client, cacheContext);
-  }
   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) {
     throw new Error("ArgumentError: DML target fields contain duplicates.");
   }
-  const fieldInfos = await getFieldsCached(stmt.appId, client, cacheContext);
-  const infoByCode = new Map(fieldInfos.map((field) => [field.code, field]));
   const targetFields = stmt.type === "UPDATE" ? stmt.assignments.map((a) => a.field) : stmt.fields;
-  for (const code of targetFields) {
-    const info = infoByCode.get(code);
-    if (!info) throw new Error(`ArgumentError: DML target field ${code} does not exist.`);
-    if (info.writable === false || NON_WRITABLE_FIELD_TYPES.has(info.fieldType)) {
-      throw new Error(`ArgumentError: DML target field ${code} is not writable (${info.fieldType}).`);
-    }
+  const fieldInfos = await loadWritableTopLevelDmlFields(
+    stmt.appId,
+    targetFields,
+    client,
+    cacheContext
+  );
+  if (stmt.type === "UPDATE") {
+    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,
@@ -9306,7 +9735,8 @@ async function prepareDmlValidation(stmt, client, options, cacheContext, tempTab
     payloadFields,
     targetFields,
     fieldInfos,
-    statementNumber
+    statementNumber,
+    numberPrecision
   );
   const columns = [...payloadFields, ...VALIDATION_META_COLUMNS];
   const result = {
@@ -9467,7 +9897,7 @@ async function materializeUpdateValidationCandidates(stmt, client, options, cach
   await resolveSetSubqueries(stmt.assignments, client, options, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   let records;
-  if (hasArithAssignment(stmt)) {
+  if (hasRowDependentAssignment(stmt)) {
     const getParams = updateToGetQueryForArith(stmt);
     const resolved = await fetchRecordsForSharedPlan(client.getRecords, getParams.app, getParams.query, [...getParams.fields], {
       maxRecords: options.maxRecords ?? 1e4,
@@ -9530,6 +9960,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.`);
@@ -9539,6 +9970,7 @@ 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;
@@ -9547,7 +9979,7 @@ async function resolveUpdateFromMatchedRecords(stmt, from, client, options, cach
   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(
@@ -9648,36 +10080,28 @@ 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);
-  }
-  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;
+  return JSON.stringify(decimal);
 }
 async function executeInsert(stmt, client, options, cacheContext) {
   if (stmt.subtableCode) {
     return executeInsertSubtable(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 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);
@@ -9690,6 +10114,8 @@ async function executeInsert(stmt, client, options, cacheContext) {
   };
 }
 async function executeInsertSelect(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) {
@@ -9711,6 +10137,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);
@@ -9724,17 +10151,32 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
   };
 }
 async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
-  await assertDmlWhereCapability(stmt, client, cacheContext);
   if (stmt.subtableCode) {
+    await assertDmlWhereCapability(stmt, client, cacheContext);
     return executeUpdateSubtable(stmt, client, options, cacheContext);
   }
+  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);
   }
   const maxRecords = options.maxRecords ?? 1e4;
   await resolveSetSubqueries(stmt.assignments, client, options, cacheContext);
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
-  if (hasArithAssignment(stmt)) {
+  if (hasRowDependentAssignment(stmt)) {
     const getParams2 = updateToGetQueryForArith(stmt);
     const resolved2 = await fetchRecordsForSharedPlan(
       client.getRecords,
@@ -9744,11 +10186,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);
     }
@@ -9762,11 +10205,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);
   }
@@ -9774,12 +10218,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 };
 }
@@ -9828,6 +10276,8 @@ async function executeDelete(stmt, client, options, cacheContext) {
   return { type: "DELETE", deletedCount: ids.length };
 }
 async function executeUpsert(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);
@@ -9836,7 +10286,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);
@@ -9857,6 +10307,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");
@@ -10132,14 +10588,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(",");
 }
@@ -10254,6 +10710,8 @@ function evalOrderKeyForRow(key, row) {
   }
 }
 async function executeUpsertSelect(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) {
@@ -10276,6 +10734,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 ?? ""))
@@ -10889,6 +11348,8 @@ function buildInsertSelectPlan(stmt, label, capabilities, orderPlans) {
 }
 function buildUpdatePlan(stmt, label, capabilities, orderPlans) {
   const isArith = hasArithAssignment(stmt);
+  const isStringFunc = stmt.assignments.some((a) => a.value.type === "STRING_FUNC");
+  const isRowDependent = hasRowDependentAssignment(stmt);
   const isSubq = stmt.assignments.some((a) => a.value.type === "SCALAR_SUBQUERY");
   const lines = [];
   if (label) lines.push(label);
@@ -10905,10 +11366,11 @@ function buildUpdatePlan(stmt, label, capabilities, orderPlans) {
   lines.push(`  api:           GET /k/v1/records.json \u2192 PUT /k/v1/records.json`);
   const setTypes = [];
   if (isArith) setTypes.push("\u7B97\u8853 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A08\u7B97\uFF09");
+  if (isStringFunc) setTypes.push("\u6587\u5B57\u5217\u95A2\u6570 SET\uFF08\u73FE\u5728\u5024\u3092\u53D6\u5F97\u3057\u3066\u8A55\u4FA1\uFF09");
   if (isSubq) setTypes.push("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA SET");
-  if (!isArith && !isSubq) setTypes.push("\u5358\u7D14 SET");
+  if (!isRowDependent && !isSubq) setTypes.push("\u5358\u7D14 SET");
   lines.push(`  set type:      ${setTypes.join(", ")}`);
-  if (isArith) {
+  if (isRowDependent) {
     const refFields = collectArithRefFields(stmt);
     if (refFields.length > 0) {
       lines.push(`  ref fields:    ${refFields.join(", ")}\uFF08GET \u306B\u542B\u3081\u308B\uFF09`);
@@ -10994,6 +11456,7 @@ function collectArithRefFields(stmt) {
   const refs = /* @__PURE__ */ new Set();
   for (const { value } of stmt.assignments) {
     if (value.type === "ARITH") collectArithNodeRefs(value, refs);
+    if (value.type === "STRING_FUNC") collectArithNodeRefs(value, refs);
   }
   return [...refs];
 }
@@ -11006,6 +11469,13 @@ function collectArithNodeRefs(node, out) {
     collectArithNodeRefs(node.left, out);
     collectArithNodeRefs(node.right, 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);
+      }
+    }
+  }
 }
 function formatAssignment(a) {
   const v = a.value;
@@ -11013,6 +11483,7 @@ function formatAssignment(a) {
   if (v.type === "NUMBER") return `${a.field} = ${v.value}`;
   if (v.type === "ARITH") return `${a.field} = ${formatArithExprStr(v)}`;
   if (v.type === "CASE_VALUE") return `${a.field} = CASE WHEN ...`;
+  if (v.type === "STRING_FUNC") return `${a.field} = ${v.func}(...)`;
   if (v.type === "SCALAR_SUBQUERY") return `${a.field} = (SELECT ...)`;
   if (v.type === "SOURCE_FIELD") return `${a.field} = ${v.alias}.${v.field}`;
   return `${a.field} = (${v.type})`;
@@ -11022,7 +11493,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 "...";
 }
@@ -11491,6 +11962,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)),
@@ -12052,6 +12524,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));
@@ -13182,6 +13664,9 @@ function createDryRunClient() {
     getFields: notUsed,
     async getProcessStatuses() {
       return { enable: false, states: [] };
+    },
+    async getNumberPrecision() {
+      return { digits: 30, decimalPlaces: 10, roundingMode: "HALF_EVEN" };
     }
   };
 }
@@ -14199,6 +14684,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;