@rex0220/kintone-sql-tools 2.10.1 → 2.12.0

package/dist-cli/ksql.js

@@ -2054,6 +2054,26 @@ var Parser = class {
     const { appId, subtableCode } = extractTableRef(name, this.prev());
     this.expect("SET" /* SET */);
     const assignments = this.parseAssignments();
+    let from = null;
+    if (this.consume("FROM" /* FROM */)) {
+      const table = this.parseTableRef();
+      if (table.subtableCode) {
+        throw new ParseError("UPDATE ... FROM \u306E\u30BD\u30FC\u30B9\u306B\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB\u306F\u6307\u5B9A\u3067\u304D\u307E\u305B\u3093", this.prev());
+      }
+      if (table.cteName !== null && !table.cteName.startsWith("#")) {
+        throw new ParseError("UPDATE ... FROM \u306E\u30BD\u30FC\u30B9\u306F #temp \u307E\u305F\u306F APP<n> \u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\uFF08CTE \u306F\u975E\u5BFE\u5FDC\uFF09", this.prev());
+      }
+      if (!table.alias) {
+        throw new ParseError("UPDATE ... FROM \u306E\u30BD\u30FC\u30B9\u306B\u306F\u30A8\u30A4\u30EA\u30A2\u30B9\u304C\u5FC5\u8981\u3067\u3059", this.prev());
+      }
+      from = {
+        appId: table.appId,
+        cteName: table.cteName,
+        alias: table.alias,
+        joinKeyField: "",
+        targetFilter: null
+      };
+    }
     const whereTok = this.peek();
     if (!this.consume("WHERE" /* WHERE */)) {
       throw new ParseError(
@@ -2062,8 +2082,129 @@ var Parser = class {
       );
     }
     const where = this.parseWhereExpr();
+    if (from !== null) {
+      if (subtableCode) {
+        throw new ParseError("\u30B5\u30D6\u30C6\u30FC\u30D6\u30EB UPDATE ... FROM \u306F\u30B5\u30DD\u30FC\u30C8\u3057\u3066\u3044\u307E\u305B\u3093", whereTok);
+      }
+      this.validateUpdateFromAssignments(assignments, from.alias, whereTok);
+      const decomposed = this.decomposeUpdateFromWhere(where, appId, from.alias, whereTok);
+      from.joinKeyField = decomposed.joinKeyField;
+      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",
+        whereTok
+      );
+    }
+    if (from !== null) return { type: "UPDATE", appId, assignments, where, from };
     return subtableCode ? { type: "UPDATE", appId, subtableCode, assignments, where } : { type: "UPDATE", appId, assignments, where };
   }
+  validateUpdateFromAssignments(assignments, sourceAlias, tok) {
+    for (const assignment of assignments) {
+      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);
+        }
+        continue;
+      }
+      if (this.nodeContainsQualifiedField(assignment.value, sourceAlias)) {
+        throw new ParseError("UPDATE ... FROM \u306E\u30BD\u30FC\u30B9\u5217\u306F SET \u306E\u76F4\u63A5\u5024\u3068\u3057\u3066\u306E\u307F\u53C2\u7167\u3067\u304D\u307E\u3059", tok);
+      }
+      if (assignment.value.type === "SCALAR_SUBQUERY") {
+        throw new ParseError("UPDATE ... FROM \u306E SET \u3067\u306F\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u3092\u4F7F\u7528\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      if (this.nodeContainsAnyQualifier(assignment.value)) {
+        throw new ParseError("UPDATE ... FROM \u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u5F0F\u3067\u306F\u30D5\u30A3\u30FC\u30EB\u30C9\u3092\u4FEE\u98FE\u3057\u306A\u3044\u3067\u304F\u3060\u3055\u3044", tok);
+      }
+    }
+  }
+  decomposeUpdateFromWhere(where, targetAppId, sourceAlias, tok) {
+    const leaves = this.flattenTopLevelAnd(where);
+    const joins = [];
+    leaves.forEach((leaf, index) => {
+      const sourceField = this.matchUpdateFromJoin(leaf, targetAppId, sourceAlias);
+      if (sourceField !== null) joins.push({ index, sourceField });
+    });
+    if (joins.length !== 1) {
+      throw new ParseError("UPDATE ... FROM \u306E WHERE \u306B\u306F target.$id = source.key \u306E\u7D50\u5408\u7B49\u5024\u304C\u3061\u3087\u3046\u30691\u3064\u5FC5\u8981\u3067\u3059", tok);
+    }
+    const join2 = joins[0];
+    for (let i = 0; i < leaves.length; i++) {
+      if (i !== join2.index && this.nodeContainsQualifiedField(leaves[i], sourceAlias)) {
+        throw new ParseError("UPDATE ... FROM \u306E\u30BD\u30FC\u30B9 alias \u306F\u7D50\u5408\u7B49\u5024\u4EE5\u5916\u306E WHERE \u6761\u4EF6\u3067\u306F\u53C2\u7167\u3067\u304D\u307E\u305B\u3093", tok);
+      }
+      if (i !== join2.index && this.nodeContainsForeignQualifier(leaves[i], targetAppId)) {
+        throw new ParseError(`UPDATE ... FROM \u306E\u30BF\u30FC\u30B2\u30C3\u30C8\u30D5\u30A3\u30EB\u30BF\u306F APP${targetAppId} \u306E\u30D5\u30A3\u30FC\u30EB\u30C9\u3060\u3051\u3092\u53C2\u7167\u3067\u304D\u307E\u3059`, tok);
+      }
+    }
+    const filters = leaves.filter((_, index) => index !== join2.index);
+    const targetFilter = filters.reduce(
+      (acc, expr) => acc === null ? expr : { type: "LOGICAL", op: "AND", left: acc, right: expr },
+      null
+    );
+    return { joinKeyField: join2.sourceField, targetFilter };
+  }
+  flattenTopLevelAnd(expr) {
+    if (expr.type === "GROUP") return this.flattenTopLevelAnd(expr.expr);
+    if (expr.type === "LOGICAL" && expr.op === "AND") {
+      return [...this.flattenTopLevelAnd(expr.left), ...this.flattenTopLevelAnd(expr.right)];
+    }
+    return [expr];
+  }
+  matchUpdateFromJoin(expr, targetAppId, sourceAlias) {
+    if (expr.type !== "BINARY" || expr.op !== "=" || expr.left.type !== "FIELD") return null;
+    const right = expr.right.type === "ARITH_VALUE" && expr.right.expr.type === "FIELD_REF" ? this.splitQualifiedField(expr.right.expr.field) : null;
+    if (right === null) return null;
+    const left = { alias: expr.left.tableAlias, field: expr.left.field };
+    if (this.isTargetIdRef(left, targetAppId) && this.isSourceRef(right, sourceAlias)) return right.field;
+    if (this.isSourceRef(left, sourceAlias) && this.isTargetIdRef(right, targetAppId)) return left.field;
+    return null;
+  }
+  splitQualifiedField(field) {
+    const dot = field.indexOf(".");
+    return dot < 0 ? { alias: null, field } : { alias: field.slice(0, dot), field: field.slice(dot + 1) };
+  }
+  isTargetIdRef(ref, appId) {
+    return ref.field === "$id" && (ref.alias === null || ref.alias.toLowerCase() === `app${appId}`.toLowerCase());
+  }
+  isSourceRef(ref, alias) {
+    return ref.alias?.toLowerCase() === alias.toLowerCase();
+  }
+  nodeContainsQualifiedField(node, alias) {
+    if (Array.isArray(node)) return node.some((v) => this.nodeContainsQualifiedField(v, alias));
+    if (node === null || typeof node !== "object") return false;
+    const obj = node;
+    if (obj["type"] === "FIELD" && typeof obj["tableAlias"] === "string" && obj["tableAlias"].toLowerCase() === alias.toLowerCase()) return true;
+    if (obj["type"] === "FIELD_REF" && typeof obj["field"] === "string") {
+      const ref = this.splitQualifiedField(obj["field"]);
+      if (this.isSourceRef(ref, alias)) return true;
+    }
+    return Object.values(obj).some((v) => this.nodeContainsQualifiedField(v, alias));
+  }
+  nodeContainsForeignQualifier(node, targetAppId) {
+    if (Array.isArray(node)) return node.some((v) => this.nodeContainsForeignQualifier(v, targetAppId));
+    if (node === null || typeof node !== "object") return false;
+    const obj = node;
+    const expected = `app${targetAppId}`.toLowerCase();
+    if (obj["type"] === "FIELD" && typeof obj["tableAlias"] === "string") {
+      return obj["tableAlias"].toLowerCase() !== expected;
+    }
+    if (obj["type"] === "FIELD_REF" && typeof obj["field"] === "string") {
+      const ref = this.splitQualifiedField(obj["field"]);
+      if (ref.alias !== null) return ref.alias.toLowerCase() !== expected;
+    }
+    return Object.values(obj).some((v) => this.nodeContainsForeignQualifier(v, targetAppId));
+  }
+  nodeContainsAnyQualifier(node) {
+    if (Array.isArray(node)) return node.some((v) => this.nodeContainsAnyQualifier(v));
+    if (node === null || typeof node !== "object") return false;
+    const obj = node;
+    if (obj["type"] === "FIELD" && typeof obj["tableAlias"] === "string") return true;
+    if (obj["type"] === "FIELD_REF" && typeof obj["field"] === "string") {
+      if (this.splitQualifiedField(obj["field"]).alias !== null) return true;
+    }
+    return Object.values(obj).some((v) => this.nodeContainsAnyQualifier(v));
+  }
   parseAssignments() {
     const assignments = [];
     do {
@@ -2098,6 +2239,12 @@ var Parser = class {
     const node = this.parseArithAddSub();
     if (node.type === "NUMBER") return node;
     if (node.type === "ARITH") return node;
+    if (node.type === "FIELD_REF") {
+      const dot = node.field.indexOf(".");
+      if (dot > 0 && dot < node.field.length - 1) {
+        return { type: "SOURCE_FIELD", alias: node.field.slice(0, dot), field: node.field.slice(dot + 1) };
+      }
+    }
     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",
       tok
@@ -3685,7 +3832,8 @@ function analyzeBatch(statements) {
       tempTablesDropped: dropped,
       dependsOn: [...dependsOn].sort((a, b) => a - b),
       tempOnlySource,
-      targetAppId: isDmlType(statementType) && typeof stmt.appId === "number" ? stmt.appId : null
+      targetAppId: isDmlType(statementType) && typeof stmt.appId === "number" ? stmt.appId : null,
+      isUpdateFrom: stmt.type === "UPDATE" && stmt.from != null
     });
   });
   const containsDml = results.some((r) => r.isDml);
@@ -4230,7 +4378,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") continue;
+    if (value.type === "ARITH" || value.type === "CASE_VALUE" || value.type === "SOURCE_FIELD") continue;
     record[field] = { value: toKintoneValue(value, fieldTypes.get(field)) };
   }
   return record;
@@ -4334,6 +4482,8 @@ function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new
         record[field] = { value: String(evalArith(value, raw)) };
       } else if (value.type === "CASE_VALUE") {
         record[field] = { value: evalCaseWhenValue(value.expr, row, fieldTypes.get(field)) };
+      } else if (value.type === "SOURCE_FIELD") {
+        throw new DmlConvertError("SOURCE_FIELD \u306F UPDATE ... FROM \u5C02\u7528\u3067\u3059");
       } else {
         record[field] = { value: toKintoneValue(value, fieldTypes.get(field)) };
       }
@@ -4345,6 +4495,51 @@ function updateToPutBatchesArith(stmt, records, fieldTypes = /* @__PURE__ */ new
     records: batch
   }));
 }
+var UPDATE_FROM_UNSUPPORTED_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "FILE"
+]);
+function updateFromToPutBatches(stmt, matched, fieldTypes = /* @__PURE__ */ new Map()) {
+  const updateRecords = matched.map(({ target, source }) => {
+    const id = Number(target["$id"]?.value);
+    if (!Number.isSafeInteger(id) || id <= 0) {
+      throw new DmlConvertError("UPDATE ... FROM \u306E\u5BFE\u8C61\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u304C\u4E0D\u6B63\u3067\u3059");
+    }
+    const targetRow = kintoneRecordToProcessRow(target);
+    const record = {};
+    for (const { field, value } of stmt.assignments) {
+      const fieldType = fieldTypes.get(field);
+      if (value.type === "SOURCE_FIELD") {
+        if (UPDATE_FROM_UNSUPPORTED_TYPES.has(fieldType ?? "")) {
+          throw new DmlConvertError(`UPDATE ... FROM \u306E SOURCE_FIELD \u306F ${fieldType} \u30D5\u30A3\u30FC\u30EB\u30C9\u306B\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u305B\u3093\uFF08\u30D5\u30A3\u30FC\u30EB\u30C9: ${field}\uFF09`);
+        }
+        if (!Object.prototype.hasOwnProperty.call(source, value.field)) {
+          throw new DmlConvertError(`UPDATE ... FROM \u306E\u30BD\u30FC\u30B9\u5217 ${value.field} \u304C\u5B58\u5728\u3057\u307E\u305B\u3093`);
+        }
+        const raw = source[value.field];
+        if (typeof raw !== "string") {
+          throw new DmlConvertError(`UPDATE ... FROM \u306E SOURCE_FIELD \u306F\u30B9\u30AB\u30E9\u30FC\u5024\u306E\u307F\u5BFE\u5FDC\u3057\u3066\u3044\u307E\u3059\uFF08\u5217: ${value.field}\uFF09`);
+        }
+        if ((fieldType === "NUMBER" || fieldType === "CALC") && raw !== "" && !Number.isFinite(Number(raw))) {
+          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 === "ARITH") {
+        record[field] = { value: String(evalArith(value, target)) };
+      } else if (value.type === "CASE_VALUE") {
+        record[field] = { value: evalCaseWhenValue(value.expr, targetRow, fieldType) };
+      } else {
+        record[field] = { value: toKintoneValue(value, fieldType) };
+      }
+    }
+    return { id, record };
+  });
+  return chunk(updateRecords, 100).map((records) => ({ app: stmt.appId, records }));
+}
 function kintoneRecordToProcessRow(raw) {
   return Object.fromEntries(
     Object.entries(raw).map(([k, v]) => [
@@ -4514,6 +4709,11 @@ async function fetchAll(fetcher, app, query, fields, options = {}) {
   const parallel = Math.max(1, options.parallel ?? PARALLEL_DEFAULT);
   const maxRecords = options.maxRecords ?? MAX_RECORDS_DEFAULT;
   const onLimit = options.onLimit ?? "error";
+  const stopAfter = options.stopAfter;
+  if (stopAfter !== void 0 && (!Number.isSafeInteger(stopAfter) || stopAfter <= 0 || stopAfter > maxRecords)) {
+    throw new RangeError("stopAfter must be a positive safe integer <= maxRecords");
+  }
+  const fetchCap = stopAfter ?? maxRecords;
   const fetchFields = fields.length > 0 && !fields.includes("$id") ? [...fields, "$id"] : fields;
   const allRecords = [];
   let notified = false;
@@ -4524,6 +4724,9 @@ async function fetchAll(fetcher, app, query, fields, options = {}) {
   const first = await fetchPage(fetcher, app, cursorQuery0, fetchFields, pageSize, windowOffset);
   notifySearchAborted(first, options);
   allRecords.push(...first.records);
+  if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+    return allRecords.slice(0, stopAfter);
+  }
   if (allRecords.length > maxRecords) {
     if (onLimit === "truncate") {
       if (!notified && options.onTruncate) {
@@ -4541,6 +4744,9 @@ async function fetchAll(fetcher, app, query, fields, options = {}) {
     windowOffset = 0;
   }
   while (true) {
+    if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+      return allRecords.slice(0, stopAfter);
+    }
     if (allRecords.length >= maxRecords) {
       if (onLimit === "truncate") {
         if (!notified && options.onTruncate) {
@@ -4551,7 +4757,7 @@ async function fetchAll(fetcher, app, query, fields, options = {}) {
       }
       throw new FetchAllLimitError(limitMessage);
     }
-    const remaining = maxRecords - allRecords.length;
+    const remaining = fetchCap - allRecords.length;
     const maxPagesByLimit = Math.ceil(remaining / pageSize);
     const batchParallel = Math.max(1, Math.min(parallel, maxPagesByLimit));
     const batchOffsets = [];
@@ -4570,6 +4776,9 @@ async function fetchAll(fetcher, app, query, fields, options = {}) {
     let done = false;
     for (const res of responses) {
       allRecords.push(...res.records);
+      if (stopAfter !== void 0 && allRecords.length >= stopAfter) {
+        return allRecords.slice(0, stopAfter);
+      }
       if (allRecords.length > maxRecords) {
         if (onLimit === "truncate") {
           if (!notified && options.onTruncate) {
@@ -4995,10 +5204,10 @@ function applyLimit(rows, limit, offset) {
   if (limit === null) return rows.slice(start);
   return rows.slice(start, start + limit);
 }
-function project(rows, columns, scalarCache, resolveFieldType) {
+function project(rows, columns, scalarCache, resolveFieldType, sourceColumns) {
   if (columns.length === 1 && columns[0].type === "WILDCARD") {
     const projected2 = rows.map((row) => stripParentShortcutColumns(row));
-    const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [];
+    const cols = projected2.length > 0 ? Object.keys(projected2[0]) : [...sourceColumns ?? []];
     return { rows: projected2, columns: cols };
   }
   const defaultFieldKeys = buildDefaultFieldOutputKeys(columns);
@@ -5007,6 +5216,9 @@ function project(rows, columns, scalarCache, resolveFieldType) {
   );
   const outputKeys = hasWildcard ? null : computeOutputKeys(columns, defaultFieldKeys);
   const orderedKeys = outputKeys ?? [];
+  if (hasWildcard && rows.length === 0) {
+    return { rows: [], columns: computeExplicitOutputKeys(columns, defaultFieldKeys) };
+  }
   const projected = rows.map((row, rowIdx) => {
     const out = {};
     for (const [colIdx, col] of columns.entries()) {
@@ -5084,29 +5296,43 @@ function project(rows, columns, scalarCache, resolveFieldType) {
   return { rows: projected, columns: orderedKeys };
 }
 function computeOutputKeys(columns, defaultFieldKeys) {
-  return columns.map((col, colIdx) => {
-    switch (col.type) {
-      case "FIELD":
-        return col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
-      case "LITERAL_COL":
-        return col.alias ?? `'${col.value}'`;
-      case "AGGREGATE":
-        return col.alias ?? aggregateSyntheticName2(col.func, col.distinct, col.arg);
-      case "ARITH_AGG_COL":
-        return col.alias ?? aggArithDefaultKey(col.expr);
-      case "ARITH_COL":
-        return col.alias ?? arithColDefaultKey(col.expr);
-      case "CASE_COL":
-        return col.alias ?? "case";
-      case "STRFUNC_COL":
-        return col.alias ?? stringFuncDefaultKey(col.expr);
-      case "SCALAR_SUBQUERY_COL":
-        return col.alias ?? "(subquery)";
-      case "WILDCARD":
-      case "PARENT_WILDCARD":
-        throw new Error("internal: computeOutputKeys received a wildcard column");
+  return columns.map((col, colIdx) => computeOutputKey(col, colIdx, defaultFieldKeys));
+}
+function computeExplicitOutputKeys(columns, defaultFieldKeys) {
+  const keys = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [colIdx, col] of columns.entries()) {
+    if (col.type === "WILDCARD" || col.type === "PARENT_WILDCARD") continue;
+    const key = computeOutputKey(col, colIdx, defaultFieldKeys);
+    if (!seen.has(key)) {
+      seen.add(key);
+      keys.push(key);
     }
-  });
+  }
+  return keys;
+}
+function computeOutputKey(col, colIdx, defaultFieldKeys) {
+  switch (col.type) {
+    case "FIELD":
+      return col.alias ?? defaultFieldKeys.get(colIdx) ?? col.field;
+    case "LITERAL_COL":
+      return col.alias ?? `'${col.value}'`;
+    case "AGGREGATE":
+      return col.alias ?? aggregateSyntheticName2(col.func, col.distinct, col.arg);
+    case "ARITH_AGG_COL":
+      return col.alias ?? aggArithDefaultKey(col.expr);
+    case "ARITH_COL":
+      return col.alias ?? arithColDefaultKey(col.expr);
+    case "CASE_COL":
+      return col.alias ?? "case";
+    case "STRFUNC_COL":
+      return col.alias ?? stringFuncDefaultKey(col.expr);
+    case "SCALAR_SUBQUERY_COL":
+      return col.alias ?? "(subquery)";
+    case "WILDCARD":
+    case "PARENT_WILDCARD":
+      throw new Error("internal: computeOutputKey received a wildcard column");
+  }
 }
 function buildDefaultFieldOutputKeys(columns) {
   const qualifierCollisionCount = /* @__PURE__ */ new Map();
@@ -5200,7 +5426,8 @@ function runFullScan(input) {
     sortKinds,
     fieldTypeResolver,
     havingFieldTypeResolver,
-    appliedKlikes
+    appliedKlikes,
+    sourceColumns
   } = input;
   let rows = [];
   const mainAlias = stmt.from.alias;
@@ -5222,7 +5449,7 @@ function runFullScan(input) {
   }
   rows = applyOrderBy(rows, stmt.orderBy, optionOrders, sortKinds);
   rows = applyLimit(rows, stmt.limit, stmt.offset);
-  return project(rows, stmt.columns, scalarCache, fieldTypeResolver);
+  return project(rows, stmt.columns, scalarCache, fieldTypeResolver, sourceColumns);
 }
 
 // src/converter/subtableAdapter.ts
@@ -5427,6 +5654,8 @@ async function executeBatch(sql, client, options = {}) {
   for (const s of analysis.statements) {
     if (!s.isDml || s.tempTablesReferenced.length === 0) continue;
     if (s.statementType === "INSERT_SELECT" || s.statementType === "UPSERT_SELECT") continue;
+    const parsed = statements[s.index];
+    if (parsed?.type === "UPDATE" && parsed.from?.cteName != null) continue;
     throw new BatchAnalysisError(
       `ArgumentError: temp table references in ${s.statementType} are not supported yet.`,
       s.index
@@ -5556,7 +5785,7 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
       onLimitReached: "error"
     };
     const result = await runSelectLike(resolvedStmt.query, client, materializeOptions, cacheContext, tempTables);
-    tempTables.set(resolvedStmt.name, result.rows);
+    tempTables.set(resolvedStmt.name, { rows: result.rows, columns: result.columns });
     return { tempTable: resolvedStmt.name, rowCount: result.rows.length };
   }
   if (stmt.type === "DROP_TEMP_TABLE") {
@@ -5583,6 +5812,9 @@ async function executeBatchStatement(stmt, info, client, options, cacheContext,
     if (resolvedStmt.type === "UPSERT_SELECT") {
       return { result: await executeUpsertSelect(resolvedStmt, client, options, cacheContext, tempTables) };
     }
+    if (resolvedStmt.type === "UPDATE" && resolvedStmt.from?.cteName != null) {
+      return { result: await executeUpdate(resolvedStmt, client, options, cacheContext, tempTables) };
+    }
     throw new Error(`ArgumentError: temp table references in ${stmt.type} are not supported yet.`);
   }
   return { result: await executeParsedStatement(resolvedStmt, client, options, cacheContext) };
@@ -5874,6 +6106,8 @@ async function executeSimpleSelect(stmt, client, options, cacheContext) {
   const onLimit = options.onLimitReached ?? "error";
   const parallel = options.fetchParallel ?? 1;
   const useSingleGet = stmt.limit !== null && stmt.limit <= 500;
+  const needed = stmt.limit === null ? null : (stmt.offset ?? 0) + stmt.limit;
+  const stopAfter = stmt.orderBy.length === 0 && needed !== null && needed <= maxRecords && !whereHasKlike(stmt.where) ? needed : void 0;
   let records;
   if (useSingleGet) {
     const res = await client.getRecords({
@@ -5892,6 +6126,7 @@ async function executeSimpleSelect(stmt, client, options, cacheContext) {
       {
         parallel,
         maxRecords,
+        stopAfter,
         onLimit,
         onTruncate: (max) => {
           warnings.add(`\u53D6\u5F97\u4E0A\u9650\uFF08${max} \u4EF6\uFF09\u306B\u9054\u3057\u305F\u305F\u3081\u3001${max} \u4EF6\u3067\u6253\u3061\u5207\u3063\u3066\u8868\u793A\u3057\u3066\u3044\u307E\u3059\u3002`);
@@ -6256,7 +6491,7 @@ async function executeWith(stmt, client, options, cacheContext, seed) {
     } else {
       result = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext);
     }
-    cteCache.set(cte.name, result.rows);
+    cteCache.set(cte.name, { rows: result.rows, columns: result.columns });
   }
   return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext);
 }
@@ -6309,8 +6544,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   });
   const tables = /* @__PURE__ */ new Map();
   if (stmt.from.cteName != null) {
-    const rows2 = cteCache.get(stmt.from.cteName) ?? [];
-    tables.set(stmt.from.alias, rows2.map(processRowToKintoneRecord));
+    const table = cteCache.get(stmt.from.cteName);
+    tables.set(stmt.from.alias, (table?.rows ?? []).map(processRowToKintoneRecord));
   } else {
     const mainRecords = await fetchTableRecordsForFullScan(
       stmt,
@@ -6327,8 +6562,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   }
   const joinFetches = stmt.joins.map(async (join2) => {
     if (join2.table.cteName != null) {
-      const rows2 = cteCache.get(join2.table.cteName) ?? [];
-      tables.set(join2.table.alias, rows2.map(processRowToKintoneRecord));
+      const table = cteCache.get(join2.table.cteName);
+      tables.set(join2.table.alias, (table?.rows ?? []).map(processRowToKintoneRecord));
     } else {
       const pushDownCond = join2.table.alias ? pushdownPlan.joinConditions.get(join2.table.alias) ?? null : null;
       const optimized = await tryFetchJoinRecordsBySourceKeys(
@@ -6359,6 +6594,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   await Promise.all(joinFetches);
   const scalarCache = await scalarCachePromise;
   const { optionOrders, sortKinds } = await orderByMetaPromise;
+  const sourceColumns = stmt.joins.length === 0 && stmt.from.cteName != null ? cteCache.get(stmt.from.cteName)?.columns : void 0;
   const { rows, columns } = runFullScan({
     tables,
     stmt,
@@ -6367,7 +6603,8 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     sortKinds,
     fieldTypeResolver: fieldTypeResolvers.row,
     havingFieldTypeResolver: fieldTypeResolvers.having,
-    appliedKlikes: pushdownPlan.appliedKlikes
+    appliedKlikes: pushdownPlan.appliedKlikes,
+    sourceColumns
   });
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
@@ -6763,10 +7000,13 @@ async function executeInsertSelect(stmt, client, options, cacheContext, cteCache
     insertedCount: createdIds.flat().length
   };
 }
-async function executeUpdate(stmt, client, options, cacheContext) {
+async function executeUpdate(stmt, client, options, cacheContext, tempTables) {
   if (stmt.subtableCode) {
     return executeUpdateSubtable(stmt, client, options, 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);
@@ -6808,6 +7048,113 @@ async function executeUpdate(stmt, client, options, cacheContext) {
   }
   return { type: "UPDATE", updatedCount: ids.length };
 }
+var UPDATE_FROM_ID_CHUNK_SIZE = 50;
+var UPDATE_FROM_UNSUPPORTED_SOURCE_TYPES = /* @__PURE__ */ new Set([
+  "CHECK_BOX",
+  "MULTI_SELECT",
+  "USER_SELECT",
+  "ORGANIZATION_SELECT",
+  "GROUP_SELECT",
+  "FILE"
+]);
+async function executeUpdateFrom(stmt, from, client, options, 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 : ""))];
+  const requiredSourceFields = [.../* @__PURE__ */ new Set([from.joinKeyField, ...sourceFields])];
+  let sourceRows;
+  if (from.cteName !== null) {
+    const table = tempTables?.get(from.cteName);
+    if (!table) throw new Error(`ArgumentError: temp table ${from.cteName} is not available.`);
+    for (const field of requiredSourceFields) {
+      if (!table.columns.includes(field)) {
+        throw new Error(`ArgumentError: UPDATE ... FROM source column ${field} does not exist.`);
+      }
+    }
+    sourceRows = table.rows;
+  } else {
+    const sourceTypes = await getFieldTypeMap(from.appId, client, cacheContext);
+    for (const field of requiredSourceFields) {
+      if (field !== "$id" && !sourceTypes.has(field)) {
+        throw new Error(`ArgumentError: UPDATE ... FROM source column ${field} does not exist.`);
+      }
+      const type = sourceTypes.get(field);
+      if (UPDATE_FROM_UNSUPPORTED_SOURCE_TYPES.has(type ?? "")) {
+        throw new Error(`ArgumentError: UPDATE ... FROM does not support source field type ${type} (${field}).`);
+      }
+    }
+    const maxRecords = options.maxRecords ?? 1e4;
+    const resolved = await fetchRecordsForSharedPlan(
+      client.getRecords,
+      from.appId,
+      "",
+      requiredSourceFields,
+      { maxRecords, parallel: options.fetchParallel ?? 1, onLimit: "error" }
+    );
+    sourceRows = resolved.records.map((record) => flatten(record, null));
+  }
+  const sourceById = /* @__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.`);
+    }
+    const raw = row[from.joinKeyField];
+    const text = typeof raw === "string" ? raw.trim() : "";
+    const id = Number(text);
+    if (text === "" || !Number.isSafeInteger(id) || id <= 0) {
+      throw new Error(`ArgumentError: UPDATE ... FROM source key must be a positive safe integer: ${String(raw)}`);
+    }
+    if (sourceById.has(id)) {
+      throw new Error(`ArgumentError: UPDATE ... FROM source has multiple rows for target $id ${id}.`);
+    }
+    sourceById.set(id, row);
+  }
+  const targetIds = [...sourceById.keys()];
+  const targetFields = collectUpdateFromTargetFields(stmt);
+  const filterQuery = from.targetFilter === null ? "" : updateToGetQuery({ ...stmt, from: null, where: from.targetFilter }).query;
+  const targetRecords = [];
+  for (const ids of splitChunks(targetIds, UPDATE_FROM_ID_CHUNK_SIZE)) {
+    const idQuery = `$id in (${ids.map((id) => sqlQuote(String(id))).join(",")})`;
+    const query = filterQuery ? `(${idQuery}) and (${filterQuery})` : idQuery;
+    const resolved = await fetchRecordsForSharedPlan(
+      client.getRecords,
+      stmt.appId,
+      query,
+      targetFields,
+      { maxRecords: Math.max(ids.length, 1), parallel: options.fetchParallel ?? 1, onLimit: "error" }
+    );
+    targetRecords.push(...resolved.records);
+  }
+  if (options.confirm) {
+    const ok = await options.confirm(targetRecords.length, "UPDATE");
+    if (!ok) throw new OperationCancelledError("UPDATE", targetRecords.length);
+  }
+  const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
+  const matched = targetRecords.map((target) => {
+    const id = Number(target["$id"]?.value);
+    const source = sourceById.get(id);
+    if (!source) throw new Error(`ArgumentError: UPDATE ... FROM could not resolve source row for target $id ${id}.`);
+    return { target, source };
+  });
+  const batches = updateFromToPutBatches(stmt, matched, fieldTypes);
+  for (const batch of batches) await client.putRecords(batch);
+  return { type: "UPDATE", updatedCount: targetRecords.length };
+}
+function collectUpdateFromTargetFields(stmt) {
+  const fields = /* @__PURE__ */ new Set(["$id"]);
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const obj = node;
+    if (obj["type"] === "FIELD_REF" && typeof obj["field"] === "string") fields.add(obj["field"]);
+    for (const value of Object.values(obj)) visit(value);
+  };
+  for (const assignment of stmt.assignments) {
+    if (assignment.value.type !== "SOURCE_FIELD") visit(assignment.value);
+  }
+  return [...fields];
+}
 async function executeDelete(stmt, client, options, cacheContext) {
   if (stmt.subtableCode) {
     return executeDeleteSubtable(stmt, client, options, cacheContext);
@@ -7733,9 +8080,16 @@ function buildUpdatePlan(stmt, label) {
   const isSubq = stmt.assignments.some((a) => a.value.type === "SCALAR_SUBQUERY");
   const lines = [];
   if (label) lines.push(label);
-  lines.push(`  [UPDATE]`);
+  lines.push(stmt.from ? `  [UPDATE FROM]` : `  [UPDATE]`);
   lines.push(`  target:        APP${stmt.appId} (${stmt.appId})`);
-  lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
+  if (stmt.from) {
+    const source = stmt.from.cteName ?? `APP${stmt.from.appId}`;
+    lines.push(`  source:        ${source} AS ${stmt.from.alias}`);
+    lines.push(`  join:          APP${stmt.appId}.$id = ${stmt.from.alias}.${stmt.from.joinKeyField}`);
+    lines.push(`  target filter: ${stmt.from.targetFilter ? safeWhereToKintone(stmt.from.targetFilter) : "(none)"}`);
+  } else {
+    lines.push(`  kintone query: ${safeWhereToKintone(stmt.where)}`);
+  }
   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");
@@ -7848,6 +8202,7 @@ function formatAssignment(a) {
   if (v.type === "ARITH") return `${a.field} = ${formatArithExprStr(v)}`;
   if (v.type === "CASE_VALUE") return `${a.field} = CASE WHEN ...`;
   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})`;
 }
 function formatArithExprStr(expr) {
@@ -10333,6 +10688,11 @@ async function run() {
   const yes = args.yes || envBool("KSQL_YES") === true || Boolean(profile.dml?.yes);
   const allowWithoutWhere = args.allowWithoutWhere || envBool("KSQL_ALLOW_WITHOUT_WHERE") === true || Boolean(profile.dml?.allowWithoutWhere);
   const dmlMaxRows = args.dmlMaxRows ?? envInt2("KSQL_DML_MAX_ROWS") ?? profile.dml?.maxRows ?? 100;
+  const dmlForcesOnLimitError = isDmlStatement || batchContainsDml;
+  const effectiveOnLimit = dmlForcesOnLimitError ? "error" : onLimit;
+  if (dmlForcesOnLimitError && onLimit === "truncate" && !quiet && !args.dryRun) {
+    process.stderr.write("note: onLimit=truncate is ignored for DML (forced to error)\n");
+  }
   if (format === "markdown" && noHeader) {
     process.stderr.write("ArgumentError: --no-header cannot be used with --format markdown|md.\n");
     return 2;
@@ -10684,7 +11044,7 @@ query=${label}`);
       const batchResult = await executeBatch(sql, client, {
         maxRecords,
         fetchParallel,
-        onLimitReached: onLimit,
+        onLimitReached: effectiveOnLimit,
         cacheContext,
         continueOnError: args.continueOnError,
         tempTableMaxRows,
@@ -10702,7 +11062,7 @@ query=${label}`);
     let result = args.dryRun ? await execute(`EXPLAIN ${sql}`, client, { maxRecords, onLimitReached: onLimit, cacheContext }) : await execute(sql, client, {
       maxRecords,
       fetchParallel,
-      onLimitReached: onLimit,
+      onLimitReached: effectiveOnLimit,
       confirm: isDmlStatement ? confirm : void 0,
       cacheContext
     });