@rex0220/kintone-sql-tools 3.71.0 → 3.73.0

package/dist-cli/ksql.js

@@ -4161,7 +4161,7 @@ var Parser = class {
     const values = [];
     do {
       this.expect("(" /* LPAREN */);
-      const row = this.parseInsertRow(fields.length);
+      const row = this.parseInsertRow(fields.length, true);
       this.expect(")" /* RPAREN */);
       values.push(row);
     } while (this.consume("," /* COMMA */));
@@ -4222,7 +4222,7 @@ var Parser = class {
     const values = [];
     do {
       this.expect("(" /* LPAREN */);
-      values.push(this.parseInsertRow(fields.length));
+      values.push(this.parseInsertRow(fields.length, false));
       this.expect(")" /* RPAREN */);
     } while (this.consume("," /* COMMA */));
     const keyFields = this.parseOnDuplicate();
@@ -4546,7 +4546,7 @@ var Parser = class {
     this.expect("]" /* RBRACKET */);
     return { type: "ARRAY", elements };
   }
-  parseInsertRow(expectedLen) {
+  parseInsertRow(expectedLen, allowAsOf) {
     const row = [];
     do {
       if (this.peek().kind === "[" /* LBRACKET */) {
@@ -4567,8 +4567,11 @@ var Parser = class {
           row.push({ type: "STRING", value: tok.value });
         } else if (tok.kind === "NUMBER" /* NUMBER */) {
           row.push(makeNumberLiteral(tok.value));
+        } else if (allowAsOf && this.isDialect1AsOfCall(tok)) {
+          row.push(this.finishVariableReference(tok));
         } 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);
+          const hint = this.isDialect1AsOfCall(tok) ? " INSERT ... VALUES \u3067\u306F\u4F7F\u7528\u3067\u304D\u307E\u3059\u3002\u3053\u306E\u6587\u578B\u3067\u306F INSERT ... SELECT \u3067\u6CE8\u5165\u3057\u3066\u304F\u3060\u3055\u3044\u3002" : "";
+          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${hint}`, tok);
         }
       }
     } while (this.consume("," /* COMMA */));
@@ -4580,6 +4583,9 @@ var Parser = class {
     }
     return row;
   }
+  isDialect1AsOfCall(tok) {
+    return this.capabilities.dialect1 === true && tok.kind === "VARIABLE" /* VARIABLE */ && isAsOfFunctionName(tok.value.slice(1).toUpperCase()) && this.peek().kind === "(" /* LPAREN */ && this.peekAt(1).kind === ")" /* RPAREN */;
+  }
   // ----------------------------------------------------------
   // UPDATE
   // ----------------------------------------------------------
@@ -4742,7 +4748,7 @@ var Parser = class {
       const values = [];
       do {
         this.expect("(" /* LPAREN */, "APPEND VALUES \u306E\u5404\u884C\u306F ( \u3067\u59CB\u3081\u3066\u304F\u3060\u3055\u3044");
-        values.push(this.parseInsertRow(fields.length));
+        values.push(this.parseInsertRow(fields.length, false));
         this.expect(")" /* RPAREN */);
       } while (this.consume("," /* COMMA */));
       return { kind: "APPEND", fields, values };
@@ -18460,6 +18466,24 @@ var materializedMetaBySelectResult = /* @__PURE__ */ new WeakMap();
 var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
 var importSourceByDmlStatement = /* @__PURE__ */ new WeakMap();
 var statementEvaluationContextKey = /* @__PURE__ */ Symbol("statementEvaluationContext");
+var nativeUpsertExecutionKey = /* @__PURE__ */ Symbol("nativeUpsertExecution");
+var nativeUpsertExplainCapabilityKey = /* @__PURE__ */ Symbol("nativeUpsertExplainCapability");
+function withNativeUpsertExecutionOption(options, enabled, explainClientCapability) {
+  return {
+    ...options,
+    [nativeUpsertExecutionKey]: enabled,
+    ...explainClientCapability === void 0 ? {} : { [nativeUpsertExplainCapabilityKey]: explainClientCapability }
+  };
+}
+function nativeUpsertExecutionEnabled(options) {
+  return options[nativeUpsertExecutionKey] === true;
+}
+function hasNativeUpsertExecutionOption(options) {
+  return nativeUpsertExecutionKey in options;
+}
+function nativeUpsertExplainClientCapability(options) {
+  return options[nativeUpsertExplainCapabilityKey];
+}
 function bindStatementEvaluationContext(options) {
   const internal = options;
   if (internal[statementEvaluationContextKey]) return options;
@@ -18524,6 +18548,7 @@ function createEmptyMetrics() {
     getCalls: 0,
     postCalls: 0,
     putCalls: 0,
+    nativeUpsertCalls: 0,
     deleteCalls: 0,
     fieldCalls: 0,
     numberPrecisionCalls: 0,
@@ -18552,7 +18577,7 @@ function markLimitReached(client, appId) {
   if (!metrics.limitReachedApps.includes(appId)) metrics.limitReachedApps.push(appId);
 }
 function wrapClientWithMetrics(client, metrics) {
-  return {
+  const wrapped = {
     [LIMIT_METRICS_SINK]: metrics,
     getRecords: async (params) => {
       metrics.getCalls += 1;
@@ -18631,6 +18656,14 @@ function wrapClientWithMetrics(client, metrics) {
       return client.getProcessStatuses(appId);
     }
   };
+  if (clientHasNativeUpsert(client)) {
+    wrapped.upsertRecords = (params) => {
+      metrics.putCalls += 1;
+      metrics.nativeUpsertCalls += 1;
+      return client.upsertRecords(params);
+    };
+  }
+  return wrapped;
 }
 var SEARCH_ABORT_FAIL_CLOSED = /* @__PURE__ */ Symbol("searchAbortFailClosed");
 function wrapClientWithSearchAbort(client, collector, failClosed) {
@@ -18803,7 +18836,12 @@ async function executeParsedStatement(stmt, client, options, cacheContext) {
         relativeDatePlan,
         options.recursiveCteMaxDepth,
         options.recursiveCteMaxRows,
-        options.recursiveCteMaxExpansions
+        options.recursiveCteMaxExpansions,
+        hasNativeUpsertExecutionOption(options) ? {
+          surface: "CLI",
+          enableNativeUpsert: nativeUpsertExecutionEnabled(options),
+          clientHasNativeUpsert: nativeUpsertExplainClientCapability(options) ?? clientHasNativeUpsert(client)
+        } : { surface: "DOCUMENT_ONLY" }
       );
     // 一時テーブルはバッチスコープのため単文実行では拒否する（executeBatch を使う）
     case "CREATE_TEMP_TABLE":
@@ -19266,18 +19304,12 @@ async function executeBatchStatement(context) {
           cacheContext,
           tempTables
         );
-        const first = resolvedStmt2.expr.query.columns[0];
-        let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" && (first.windowKind === void 0 || first.windowKind === "RANKING" || first.windowKind === "AGGREGATE" && (first.aggFunc === "COUNT" || first.aggFunc === "SUM" || first.aggFunc === "AVG")) || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
-        if (first?.type === "AGGREGATE" && first.func === "MODE" || first?.type === "WINDOW_COL" && first.windowKind === "VALUE" || first?.type === "WINDOW_COL" && first.windowKind === "AGGREGATE" && (first.aggFunc === "MIN" || first.aggFunc === "MAX")) {
-          const meta = (await inferSelectColumnMeta(
-            resolvedStmt2.expr.query,
-            ["__scalar__"],
-            client,
-            cacheContext,
-            tempTables
-          )).get("__scalar__");
-          numeric = meta?.semantics?.compareMode === "number" || meta?.sortKind === "number";
-        }
+        const numeric = await scalarSubqueryHasNumericResult(
+          resolvedStmt2.expr.query,
+          client,
+          cacheContext,
+          tempTables
+        );
         const numberValue = numeric ? Number(value) : Number.NaN;
         variables.set(stmt.name, numeric && Number.isFinite(numberValue) ? { type: "number", value: numberValue, raw: value } : { type: "string", value });
       } catch (e) {
@@ -19762,7 +19794,6 @@ async function executeExit(stmt, client, options, cacheContext, tempTables) {
 }
 async function evaluateAssertCondition(stmt, client, options, cacheContext, tempTables) {
   const left = await evalAssertOperand(stmt.left, client, options, cacheContext, tempTables);
-  const semantics = stmt.left.type === "NUMBER" || stmt.left.type === "ARITH" ? syntheticSemantics("number") : syntheticSemantics("string");
   if (stmt.op === "BETWEEN") {
     if (stmt.low === null || stmt.high === null) {
       throw new Error("ArgumentError: malformed ASSERT statement.");
@@ -19770,35 +19801,49 @@ async function evaluateAssertCondition(stmt, client, options, cacheContext, temp
     const low = await evalAssertOperand(stmt.low, client, options, cacheContext, tempTables);
     const high = await evalAssertOperand(stmt.high, client, options, cacheContext, tempTables);
     return {
-      passed: compareScalarValues(">=", left, low, semantics) && compareScalarValues("<=", left, high, semantics),
-      actual: left
+      passed: compareScalarValues(">=", left.value, low.value, assertComparisonSemantics(left, low)) && compareScalarValues("<=", left.value, high.value, assertComparisonSemantics(left, high)),
+      actual: left.value
     };
   }
   if (stmt.right === null) {
     throw new Error("ArgumentError: malformed ASSERT statement.");
   }
   const right = await evalAssertOperand(stmt.right, client, options, cacheContext, tempTables);
-  return { passed: compareScalarValues(stmt.op, left, right, semantics), actual: left };
+  const semantics = stmt.op === "=" || stmt.op === "!=" || stmt.op === "<>" ? stmt.left.type === "NUMBER" || stmt.left.type === "ARITH" ? syntheticSemantics("number") : syntheticSemantics("string") : assertComparisonSemantics(left, right);
+  return {
+    passed: compareScalarValues(stmt.op, left.value, right.value, semantics),
+    actual: left.value
+  };
+}
+function assertComparisonSemantics(left, right) {
+  return syntheticSemantics(left.semantics === "number" && right.semantics === "number" ? "number" : "string");
 }
 async function evalAssertOperand(operand, client, options, cacheContext, tempTables) {
   switch (operand.type) {
     case "VARIABLE":
       throw new Error(`ParseError: unresolved batch variable @${operand.name}.`);
     case "NUMBER":
-      return numberLiteralText(operand);
+      return { value: numberLiteralText(operand), semantics: "number" };
     case "STRING":
-      return operand.value;
+      return { value: operand.value, semantics: "string" };
     case "ARITH":
-      return String(evalAssertArith(operand));
+      return { value: String(evalAssertArith(operand)), semantics: "number" };
     case "SCALAR_SUBQUERY": {
       try {
-        return await evaluateScalarSubquery(
+        const value = await evaluateScalarSubquery(
           operand.query,
           client,
           options,
           cacheContext,
           tempTables
         );
+        const numeric = await scalarSubqueryHasNumericResult(
+          operand.query,
+          client,
+          cacheContext,
+          tempTables
+        );
+        return { value, semantics: numeric ? "number" : "string" };
       } catch (e) {
         if (e instanceof ScalarSubqueryError) throw new AssertError(e.message);
         throw e;
@@ -19806,6 +19851,21 @@ async function evalAssertOperand(operand, client, options, cacheContext, tempTab
     }
   }
 }
+async function scalarSubqueryHasNumericResult(query, client, cacheContext, tempTables) {
+  const first = query.columns[0];
+  let numeric = first?.type === "ARITH_COL" || first?.type === "ARITH_AGG_COL" || first?.type === "WINDOW_COL" && (first.windowKind === void 0 || first.windowKind === "RANKING" || first.windowKind === "AGGREGATE" && (first.aggFunc === "COUNT" || first.aggFunc === "SUM" || first.aggFunc === "AVG")) || first?.type === "AGGREGATE" && (first.func === "COUNT" || first.func === "SUM" || first.func === "AVG" || first.func === "STDDEV_POP" || first.func === "STDDEV_SAMP" || first.func === "VAR_POP" || first.func === "VAR_SAMP" || first.func === "MEDIAN");
+  if (first?.type === "AGGREGATE" && first.func === "MODE" || first?.type === "WINDOW_COL" && first.windowKind === "VALUE" || first?.type === "WINDOW_COL" && first.windowKind === "AGGREGATE" && (first.aggFunc === "MIN" || first.aggFunc === "MAX")) {
+    const meta = (await inferSelectColumnMeta(
+      query,
+      ["__scalar__"],
+      client,
+      cacheContext,
+      tempTables
+    )).get("__scalar__");
+    numeric = meta?.semantics?.compareMode === "number" || meta?.sortKind === "number";
+  }
+  return numeric;
+}
 async function evaluateScalarSubquery(sourceQuery, client, options, cacheContext, tempTables) {
   const { query, probed } = withScalarProbeLimit(sourceQuery);
   const result = await runSubquery(query, client, options, cacheContext, tempTables);
@@ -22785,6 +22845,206 @@ function upsertCompositeKey(parts) {
 function upsertNormalizedKey(parts, numericKey) {
   return JSON.stringify(parts.map((p, i) => numericKey[i] ? normalizeKeyPart(p) : p));
 }
+var NATIVE_UPSERT_CONDITION_NAMES = {
+  1: "CLIENT_CAPABILITY",
+  2: "OPT_IN",
+  3: "KEY_SCHEMA",
+  4: "PLAIN_UPSERT",
+  5: "EMPTY_KEY",
+  6: "SOURCE_DUPLICATE"
+};
+function nativeUpsertExplainReason(condition, unknown, surface, unknownConditions = []) {
+  if (unknown) {
+    if (condition === 1) return "\u901A\u5E38\u5B9F\u884C client \u306E native \u80FD\u529B\u304C\u4E0D\u660E";
+    if (condition === 2) return "native \u8A2D\u5B9A\u304C\u4E0D\u660E";
+    if (condition === 3) return "\u30D5\u30A9\u30FC\u30E0\u30E1\u30BF\u30C7\u30FC\u30BF\u672A\u53D6\u5F97";
+    if (condition === 5 || unknownConditions.includes(5)) return "\u30BD\u30FC\u30B9\u884C\u672A materialize";
+    if (condition === 6) return "\u30AD\u30FC\u578B\u60C5\u5831\u304C\u672A\u78BA\u5B9A\u306E\u305F\u3081\u91CD\u8907\u5224\u5B9A\u4E0D\u80FD";
+  }
+  if (condition === 1) return "client \u304C upsertRecords \u80FD\u529B\u3092\u6301\u305F\u306A\u3044";
+  if (condition === 2) return surface === "CLI" ? "--native-upsert \u304C\u6307\u5B9A\u3055\u308C\u3066\u3044\u306A\u3044" : "enableNativeUpsert \u304C false";
+  if (condition === 3) return "\u30AD\u30FC\u9805\u76EE\u306F\u91CD\u8907\u7981\u6B62\u306E SINGLE_LINE_TEXT \u307E\u305F\u306F NUMBER \u3067\u306F\u306A\u3044";
+  if (condition === 4) return "CHECK / APPLY / IMPORT / VALIDATE ONLY / ON ERROR SKIP \u3092\u4F34\u3046\u7D20\u3067\u306A\u3044 UPSERT";
+  if (condition === 5) return "\u30BD\u30FC\u30B9\u306B\u7A7A\u6587\u5B57\u30AD\u30FC\u304C\u3042\u308B";
+  return "\u30BD\u30FC\u30B9\u5185\u306B\u540C\u4E00\u30AD\u30FC\u304C\u3042\u308B";
+}
+function renderNativeUpsertEligibilityResult(label, result, surface) {
+  if (result.status === "ELIGIBLE") {
+    return `  ${label}: ELIGIBLE\uFF08${label.includes("statement/data") ? "\u6761\u4EF6 3\u301C6 \u3092" : "6 \u6761\u4EF6\u3092\u3059\u3079\u3066"}\u6E80\u305F\u3059\uFF09`;
+  }
+  if (result.status === "INELIGIBLE") {
+    return `  ${label}: INELIGIBLE\uFF08\u6761\u4EF6 ${result.condition}: ${NATIVE_UPSERT_CONDITION_NAMES[result.condition]} \u2014 ${nativeUpsertExplainReason(result.condition, false, surface)}\uFF09`;
+  }
+  const unknownConditionNumbers = result.unknownConditions.map(({ condition }) => condition);
+  const details = result.unknownConditions.map(
+    ({ condition }) => `\u6761\u4EF6 ${condition}: ${NATIVE_UPSERT_CONDITION_NAMES[condition]} \u2014 ${nativeUpsertExplainReason(condition, true, surface, unknownConditionNumbers)}`
+  );
+  return `  ${label}: UNKNOWN\uFF08${details.join("; ")}\uFF09`;
+}
+function renderNativeUpsertEligibility(evaluation, surface) {
+  if (surface === "DOCUMENT_ONLY") {
+    return [
+      renderNativeUpsertEligibilityResult("native UPSERT statement/data eligibility", evaluation.statement, surface),
+      `  native UPSERT execution surface: NOT_APPLICABLE\uFF08\u3053\u306E\u9762\u3067\u306F\u5B9F\u884C\u3057\u306A\u3044${evaluation.statement.status === "ELIGIBLE" ? "\u3002/flow \u307E\u305F\u306F CLI --native-upsert \u3067\u306F native \u5019\u88DC" : ""}\uFF09`
+    ];
+  }
+  const lines = [renderNativeUpsertEligibilityResult("native UPSERT eligibility", evaluation.execution, surface)];
+  if (evaluation.conditions[1].state === "FAIL" || evaluation.conditions[2].state === "FAIL") {
+    lines.push(renderNativeUpsertEligibilityResult("native UPSERT statement/data eligibility", evaluation.statement, surface));
+  }
+  return lines;
+}
+function explainNativeUpsertStatement(statement) {
+  const candidate = statement.type === "EXPLAIN" ? statement.query : statement;
+  return candidate.type === "UPSERT" || candidate.type === "UPSERT_SELECT" ? candidate : null;
+}
+function nativeUpsertExplainEvaluation(statement, fieldInfos, options) {
+  let rowKeyValues = null;
+  if (statement.type === "UPSERT") {
+    try {
+      rowKeyValues = buildUpsertRowKeyValues(statement);
+    } catch {
+    }
+  }
+  return evaluateNativeUpsertEligibility({
+    surface: options.surface === "DOCUMENT_ONLY" ? "DOCUMENT_ONLY" : "EXECUTION",
+    clientCapability: options.surface === "DOCUMENT_ONLY" ? null : options.clientHasNativeUpsert ?? null,
+    enabled: options.surface === "DOCUMENT_ONLY" ? null : options.surface === "FLOW" ? options.enableNativeUpsert !== false : options.enableNativeUpsert === true,
+    statement: {
+      kind: statement.type === "UPSERT" ? "VALUES" : "SELECT",
+      keyFields: statement.keyFields,
+      hasCheck: Boolean(statement.checkGroups?.length),
+      hasApply: statement.type === "UPSERT" && Boolean(statement.onInsertApplyBlocks?.length || statement.onUpdateApplyBlocks?.length),
+      validateOnly: statement.validateOnly === true,
+      onErrorSkip: statement.onErrorSkip === true,
+      importDerived: importSourceByDmlStatement.has(statement)
+    },
+    fieldInfos,
+    rowKeyValues
+  });
+}
+async function nativeUpsertExplainLines(statement, cacheContext, options) {
+  const upsert = explainNativeUpsertStatement(statement);
+  if (!upsert) return [];
+  const fieldInfos = await getFieldsIfCached(upsert.appId, cacheContext);
+  return renderNativeUpsertEligibility(
+    nativeUpsertExplainEvaluation(upsert, fieldInfos, options),
+    options.surface
+  );
+}
+function evaluateNativeUpsertEligibility(input) {
+  const keyField = input.statement.keyFields.length === 1 ? input.statement.keyFields[0] : void 0;
+  const keyInfo = keyField === void 0 || input.fieldInfos === null ? void 0 : input.fieldInfos.find((field) => field.code === keyField);
+  const supportedKeyType = keyInfo?.fieldType === "SINGLE_LINE_TEXT" || keyInfo?.fieldType === "NUMBER";
+  const schemaPass = input.fieldInfos === null ? null : Boolean(
+    keyField !== void 0 && keyInfo && supportedKeyType && keyInfo.isUnique === true
+  );
+  const plain = !input.statement.hasCheck && !input.statement.hasApply && !input.statement.validateOnly && !input.statement.onErrorSkip && !(input.statement.kind === "SELECT" && input.statement.importDerived);
+  const rows = input.rowKeyValues;
+  const noEmpty = rows === null ? null : rows.every((parts) => parts.every((part) => part !== ""));
+  let noDuplicates = null;
+  if (rows !== null && keyField !== void 0 && supportedKeyType) {
+    const seen = /* @__PURE__ */ new Set();
+    noDuplicates = true;
+    for (const parts of rows) {
+      const normalized = upsertNormalizedKey([...parts], [keyInfo.fieldType === "NUMBER"]);
+      if (seen.has(normalized)) {
+        noDuplicates = false;
+        break;
+      }
+      seen.add(normalized);
+    }
+  }
+  const state = (value, reason) => ({
+    state: value === null ? "UNKNOWN" : value ? "PASS" : "FAIL",
+    reason
+  });
+  const conditions = {
+    1: input.surface === "DOCUMENT_ONLY" ? { state: "NOT_APPLICABLE", reason: "client capability is not applicable on this surface" } : state(input.clientCapability, "client does not provide upsertRecords"),
+    2: input.surface === "DOCUMENT_ONLY" ? { state: "NOT_APPLICABLE", reason: "native setting is not applicable on this surface" } : state(input.enabled, "native UPSERT is disabled"),
+    3: state(schemaPass, "update key schema is not a single unique text or number field"),
+    4: state(plain, "statement is not a plain UPSERT"),
+    5: state(noEmpty, "source contains an empty update key"),
+    6: state(noDuplicates, "source contains duplicate update keys")
+  };
+  const summarize = (ordered) => {
+    const failed = ordered.find((condition) => conditions[condition].state === "FAIL");
+    if (failed !== void 0) return { status: "INELIGIBLE", condition: failed, reason: conditions[failed].reason };
+    const unknownConditions = ordered.filter((condition) => conditions[condition].state === "UNKNOWN").map((condition) => ({ condition, reason: conditions[condition].reason }));
+    return unknownConditions.length > 0 ? { status: "UNKNOWN", unknownConditions } : { status: "ELIGIBLE" };
+  };
+  return {
+    conditions,
+    execution: summarize([1, 2, 3, 4, 5, 6]),
+    statement: summarize([3, 4, 5, 6])
+  };
+}
+function clientHasNativeUpsert(client) {
+  return "upsertRecords" in client && typeof client.upsertRecords === "function";
+}
+function nativeEligibilityInput(stmt, client, options, fieldInfos, rowKeyValues) {
+  return {
+    surface: "EXECUTION",
+    clientCapability: clientHasNativeUpsert(client),
+    enabled: nativeUpsertExecutionEnabled(options),
+    statement: {
+      kind: stmt.type === "UPSERT" ? "VALUES" : "SELECT",
+      keyFields: stmt.keyFields,
+      hasCheck: Boolean(stmt.checkGroups?.length),
+      hasApply: stmt.type === "UPSERT" && Boolean(stmt.onInsertApplyBlocks?.length || stmt.onUpdateApplyBlocks?.length),
+      validateOnly: stmt.validateOnly === true,
+      onErrorSkip: stmt.onErrorSkip === true,
+      importDerived: importSourceByDmlStatement.has(stmt)
+    },
+    fieldInfos,
+    rowKeyValues
+  };
+}
+var NativeUpsertResponseError = class extends Error {
+  constructor() {
+    super("NativeUpsertResponseError: upsertRecords returned an invalid response.");
+    this.name = "NativeUpsertResponseError";
+  }
+};
+function validateNativeUpsertResponse(response, expectedRecords) {
+  if (!response || !Array.isArray(response.records) || response.records.length !== expectedRecords) {
+    throw new NativeUpsertResponseError();
+  }
+  let insertedCount = 0;
+  let updatedCount = 0;
+  for (const record of response.records) {
+    if (!record || typeof record.id !== "string" || typeof record.revision !== "string" || record.operation !== "INSERT" && record.operation !== "UPDATE") {
+      throw new NativeUpsertResponseError();
+    }
+    if (record.operation === "INSERT") insertedCount += 1;
+    else updatedCount += 1;
+  }
+  return { insertedCount, updatedCount };
+}
+async function executeNativeUpsertRecords(appId, keyField, records, rowKeyValues, client, options) {
+  if (records.length === 0) return { type: "UPSERT", insertedCount: 0, updatedCount: 0 };
+  if (options.confirm) {
+    const ok = await options.confirm(records.length, "UPDATE");
+    if (!ok) throw new OperationCancelledError("UPDATE", records.length);
+  }
+  let insertedCount = 0;
+  let updatedCount = 0;
+  for (let offset = 0; offset < records.length; offset += 100) {
+    const nativeRecords = records.slice(offset, offset + 100).map((record, index) => {
+      const payload = {};
+      for (const [field, value] of Object.entries(record)) if (field !== keyField) payload[field] = value;
+      return {
+        updateKey: { field: keyField, value: rowKeyValues[offset + index][0] },
+        record: payload
+      };
+    });
+    const response = await client.upsertRecords({ app: appId, upsert: true, records: nativeRecords });
+    const counts = validateNativeUpsertResponse(response, nativeRecords.length);
+    insertedCount += counts.insertedCount;
+    updatedCount += counts.updatedCount;
+  }
+  return { type: "UPSERT", insertedCount, updatedCount };
+}
 function lookupUpsertTarget(index, keyParts) {
   const exact = index.raw.get(upsertCompositeKey(keyParts));
   if (exact !== void 0) return exact;
@@ -23001,6 +23261,10 @@ async function getFieldsCached(appId, client, cacheContext) {
   setScopedCacheValue(fieldInfoCache, cacheContext, appId, loading);
   return loading;
 }
+async function getFieldsIfCached(appId, cacheContext) {
+  const cached = getScopedCacheValue(fieldInfoCache, cacheContext, appId);
+  return cached ? await cached : null;
+}
 async function getNumberPrecisionCached(appId, client, cacheContext) {
   const cached = getScopedCacheValue(numberPrecisionCache, cacheContext, appId);
   if (cached) return cached;
@@ -25568,6 +25832,16 @@ async function executeDelete(stmt, client, options, cacheContext) {
   }
   return { type: "DELETE", deletedCount: ids.length };
 }
+function materializeUpsertValueRecords(stmt, fieldTypes, options) {
+  return stmt.values.map((row) => {
+    const record = {};
+    stmt.fields.forEach((field, index) => {
+      const value = row[index];
+      record[field] = { value: value.type === "CASE_VALUE" ? evalCaseWhenValue(value.expr, {}, fieldTypes.get(field), statementEvaluationContext(options)) : toKintoneValue(value, fieldTypes.get(field)) };
+    });
+    return record;
+  });
+}
 async function executeUpsert(stmt, client, options, cacheContext) {
   if (stmt.onInsertApplyBlocks?.length || stmt.onUpdateApplyBlocks?.length) {
     return executeApplyUpsert(stmt, client, options, cacheContext);
@@ -25579,6 +25853,14 @@ async function executeUpsert(stmt, client, options, cacheContext) {
   const toUpdate = [];
   const fieldTypes = await getFieldTypeMap(stmt.appId, client, cacheContext);
   const rowKeyValues = buildUpsertRowKeyValues(stmt);
+  const nativeEligibility = evaluateNativeUpsertEligibility(
+    nativeEligibilityInput(stmt, client, options, fieldInfos, rowKeyValues)
+  );
+  if (nativeEligibility.execution.status === "ELIGIBLE") {
+    const records = materializeUpsertValueRecords(stmt, fieldTypes, options);
+    assertValidDmlRecords(records, stmt.fields, fieldInfos, numberPrecision);
+    return executeNativeUpsertRecords(stmt.appId, stmt.keyFields[0], records, rowKeyValues, client, options);
+  }
   const targetIndex = await resolveUpsertTargets(stmt.appId, stmt.keyFields, rowKeyValues, client, options, fieldTypes);
   stmt.values.forEach((row, rowIdx) => {
     const record = {};
@@ -25905,6 +26187,9 @@ function buildSubtableReorderPutParams(appId, parentId, revision, subtableCode,
   };
 }
 function valueToString(value) {
+  if (value.type === "VARIABLE") {
+    throw new Error(`InternalError: unresolved variable @${value.name} reached INSERT evaluation.`);
+  }
   if (value.type === "STRING") return value.value;
   if (value.type === "NUMBER") return numberLiteralText(value);
   if (value.type === "CASE_VALUE") return evalCaseWhen(value.expr, {});
@@ -26064,6 +26349,12 @@ async function executeUpsertSelect(stmt, client, options, cacheContext, cteCache
   const rowKeyValues = records.map(
     (record) => stmt.keyFields.map((key) => String(record[key]?.value ?? ""))
   );
+  const nativeEligibility = evaluateNativeUpsertEligibility(
+    nativeEligibilityInput(stmt, client, options, fieldInfos, rowKeyValues)
+  );
+  if (nativeEligibility.execution.status === "ELIGIBLE") {
+    return executeNativeUpsertRecords(stmt.appId, stmt.keyFields[0], records, rowKeyValues, client, options);
+  }
   if (importSourceByDmlStatement.has(stmt)) {
     const numericKey = stmt.keyFields.map((key) => fieldTypes.get(key) === "NUMBER");
     const sourceKeys = /* @__PURE__ */ new Set();
@@ -27115,7 +27406,7 @@ var EXPLAIN_FETCH_PLAN = /* @__PURE__ */ Symbol("ksql.explainFetchPlan");
 function setExplainFetchPlan(result, plan) {
   result[EXPLAIN_FETCH_PLAN] = plan;
 }
-async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, resolveMetadata = true, recursiveCteMaxDepth, recursiveCteMaxRows, recursiveCteMaxExpansions, asOf, timezone) {
+async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, resolveMetadata = true, recursiveCteMaxDepth, recursiveCteMaxRows, recursiveCteMaxExpansions, asOf, timezone, nativeUpsertOptions = { surface: "DOCUMENT_ONLY" }) {
   const asOfClock = createAsOfClock(asOf ?? /* @__PURE__ */ new Date(), timezone);
   const recursiveLimits = resolveRecursiveCteLimits({
     recursiveCteMaxDepth,
@@ -27214,10 +27505,15 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
         maxRecords,
         dmlMaxRows
       ) : [];
+      const nativeUpsertPlan = await nativeUpsertExplainLines(
+        planStmt,
+        invocationCacheContext,
+        nativeUpsertOptions
+      );
       plans.push({
         index: i,
         type: analysis.statements[i].statementType,
-        plan: statementPlan.length === 0 ? [...metadataPlan, ...dialect1Estimate] : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1), ...dialect1Estimate]
+        plan: statementPlan.length === 0 ? [...metadataPlan, ...nativeUpsertPlan, ...dialect1Estimate] : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1), ...nativeUpsertPlan, ...dialect1Estimate]
       });
       fetchStatements.push({
         index: i,
@@ -27531,7 +27827,7 @@ var explainMaterializedTables = /* @__PURE__ */ new WeakMap();
 function defaultRecursiveExplainContext() {
   return { maxRecords: 1e4, recursiveLimits: resolveRecursiveCteLimits({}) };
 }
-async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, relativeDatePlan, recursiveCteMaxDepth, recursiveCteMaxRows, recursiveCteMaxExpansions) {
+async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxActive, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, relativeDatePlan, recursiveCteMaxDepth, recursiveCteMaxRows, recursiveCteMaxExpansions, nativeUpsertOptions = { surface: "DOCUMENT_ONLY" }) {
   const recursiveLimits = resolveRecursiveCteLimits({
     recursiveCteMaxDepth,
     recursiveCteMaxRows,
@@ -27569,7 +27865,8 @@ async function executeExplain(stmt, client, cacheContext, maxRecords, cursorMaxA
       cursorMaxActive
     )
   ];
-  const lines = addFetchSummary(planLines, fetchCollector.sources);
+  const nativeUpsertPlan = await nativeUpsertExplainLines(stmt, cacheContext, nativeUpsertOptions);
+  const lines = addFetchSummary([...planLines, ...nativeUpsertPlan], fetchCollector.sources);
   const result = {
     type: "SELECT",
     columns: ["plan"],
@@ -29492,7 +29789,7 @@ var RequestGate = class {
   }
 };
 function withRequestGate(client, gate) {
-  return {
+  const wrapped = {
     getRecords: (params) => gate.runReadOnly(() => client.getRecords(params)),
     openCursor: async (params) => {
       const handle = await gate.runCursorStep(() => client.openCursor(params));
@@ -29510,6 +29807,10 @@ function withRequestGate(client, gate) {
     putRecords: (params) => gate.runMutation(() => client.putRecords(params)),
     deleteRecords: (params) => gate.runMutation(() => client.deleteRecords(params))
   };
+  if ("upsertRecords" in client && typeof client.upsertRecords === "function") {
+    wrapped.upsertRecords = (params) => gate.runMutation(() => client.upsertRecords(params));
+  }
+  return wrapped;
 }
 var globalGate = null;
 function getGlobalRequestGate(options) {
@@ -30266,6 +30567,16 @@ function createNodeKintoneConnection(baseUrl, tokenResolver) {
         _params.app
       );
     },
+    async upsertRecords(_params) {
+      return requestJson(
+        `${apiBasePath}/records.json`,
+        {
+          method: "PUT",
+          body: JSON.stringify({ app: _params.app, upsert: true, records: _params.records })
+        },
+        _params.app
+      );
+    },
     async deleteRecords(_params) {
       await requestJson(
         `${apiBasePath}/records.json`,
@@ -30665,6 +30976,9 @@ var CLI_HELP_TEXT = HELP_TEXT.replace(
   "  --max-records <n>          Max records to fetch (default: 500)",
   `  --max-records <n>          Max records to fetch (default: 500)
 ${RECURSIVE_CTE_HELP_LINES}`
+).replace(
+  "  --allow-dml                Enable UPDATE/DELETE/INSERT/UPSERT/REORDER execution",
+  "  --allow-dml                Enable UPDATE/DELETE/INSERT/UPSERT/REORDER execution\n  --native-upsert            Allow eligible plain UPSERT to use kintone native UPSERT"
 );
 var CLI_IMPORT_SOURCE_REQUIRED_MESSAGE = "IMPORT \u306B\u306F\u30BD\u30FC\u30B9\u304C\u5FC5\u8981\u3067\u3059\u3002--import-csv <name=path> \u307E\u305F\u306F --import-json <name=path> \u3067\u30D5\u30A1\u30A4\u30EB\u3092\u6307\u5B9A\u3057\u3066\u304F\u3060\u3055\u3044\u3002";
 function toCliImportError(error, importEnabled) {
@@ -30716,6 +31030,7 @@ function parseArgs(argv) {
     debugHeaders: false,
     exitOnEmpty: false,
     allowDml: false,
+    nativeUpsert: false,
     yes: false,
     allowWithoutWhere: false,
     continueOnError: false,
@@ -30788,6 +31103,10 @@ function parseArgs(argv) {
       out.allowDml = true;
       continue;
     }
+    if (a === "--native-upsert") {
+      out.nativeUpsert = true;
+      continue;
+    }
     if (a === "--yes") {
       out.yes = true;
       continue;
@@ -31625,6 +31944,7 @@ function buildReplExecArgv(base, sql, dryRun, format) {
   if (base.exitOnEmpty) argv.push("--exit-on-empty");
   if (base.allowDml) argv.push("--yes");
   if (base.allowDml) argv.push("--allow-dml");
+  if (base.nativeUpsert) argv.push("--native-upsert");
   if (base.allowWithoutWhere) argv.push("--allow-without-where");
   if (base.continueOnError) argv.push("--continue-on-error");
   return argv;
@@ -31801,7 +32121,8 @@ async function runConsole(base) {
       `  auth=${base.auth ?? "(auto)"}`,
       `  format=${format ?? "(default)"}`,
       `  dryrun=${dryRun ? "on" : "off"}`,
-      `  allow-dml=${base.allowDml ? "on" : "off"}`
+      `  allow-dml=${base.allowDml ? "on" : "off"}`,
+      `  native-upsert=${base.nativeUpsert ? "on" : "off"}`
     ].join("\n") + "\n"
   );
   try {
@@ -31932,6 +32253,7 @@ async function runConsole(base) {
             `app=${base.app ?? "(from SQL or config)"}`,
             `resolved-app-profiles=${lastResolvedProfiles}`,
             `allow-dml=${base.allowDml ? "on" : "off"}`,
+            `native-upsert=${base.nativeUpsert ? "on" : "off"}`,
             `dml-max-rows=${base.dmlMaxRows ?? "(default)"}`,
             `dml-max-subtable-rows=${base.dmlMaxSubtableRows ?? "(default)"}`
           ];
@@ -32514,6 +32836,14 @@ async function run() {
         if (!routed) throw new Error(`AuthError: profile "${pName}" is not resolved for APP${params.app}.`);
         return routed.putRecords({ ...params, app: binding.appId });
       },
+      upsertRecords: (params) => {
+        const binding = appBindingByMappedApp.get(params.app) ?? { appId: params.app, profile: profileName.toLowerCase() };
+        const routed = profileClientMap.get(binding.profile);
+        if (!routed || typeof routed.upsertRecords !== "function") {
+          throw new Error(`AuthError: native UPSERT client is not resolved for APP${params.app}.`);
+        }
+        return routed.upsertRecords({ ...params, app: binding.appId });
+      },
       deleteRecords: (params) => {
         const binding = appBindingByMappedApp.get(params.app) ?? { appId: params.app, profile: profileName.toLowerCase() };
         const pName = binding.profile;
@@ -32567,7 +32897,14 @@ async function run() {
         !dryRunUsesStaticTypedPlan,
         recursiveCteMaxDepth,
         recursiveCteMaxRows,
-        recursiveCteMaxExpansions
+        recursiveCteMaxExpansions,
+        void 0,
+        void 0,
+        {
+          surface: "CLI",
+          enableNativeUpsert: args.nativeUpsert,
+          clientHasNativeUpsert: true
+        }
       );
       const out = [];
       const restoredStatements = sqlDiagnosticContext ? restoreSqlDiagnosticValue(plans.statements, sqlDiagnosticContext.appBindingByMappedApp) : plans.statements;
@@ -32648,7 +32985,7 @@ query=${label}`);
           return 2;
         }
       }
-      let batchResult = await executeBatch(sql, client, {
+      let batchResult = await executeBatch(sql, client, withNativeUpsertExecutionOption({
         maxRecords,
         fetchParallel,
         onLimitReached: effectiveOnLimit,
@@ -32686,7 +33023,7 @@ query=${label}`);
           }
           return true;
         } : void 0
-      });
+      }, args.nativeUpsert, true));
       if (sqlDiagnosticContext) {
         batchResult = {
           ...batchResult,
@@ -32703,7 +33040,7 @@ query=${label}`);
       }
       return writeBatchOutput(batchResult, { format, noHeader, pretty, displayOptions, outputPath, quiet });
     }
-    let result = args.dryRun ? await execute(`EXPLAIN ${sql}`, client, {
+    let result = args.dryRun ? await execute(`EXPLAIN ${sql}`, client, withNativeUpsertExecutionOption({
       maxRecords,
       onLimitReached: onLimit,
       cacheContext,
@@ -32715,7 +33052,7 @@ query=${label}`);
       recursiveCteMaxDepth,
       recursiveCteMaxRows,
       recursiveCteMaxExpansions
-    }) : await execute(sql, client, {
+    }, args.nativeUpsert, true)) : await execute(sql, client, withNativeUpsertExecutionOption({
       maxRecords,
       fetchParallel,
       onLimitReached: effectiveOnLimit,
@@ -32733,7 +33070,7 @@ query=${label}`);
         dmlMaxSubtableRows
       } : {},
       ...containsApplyMutation ? { allowApplyMutation: true } : {}
-    });
+    }, args.nativeUpsert, true));
     if ((args.dryRun || parsedStatements[0]?.type === "EXPLAIN") && sqlDiagnosticContext) {
       result = restoreSqlDiagnosticValue(result, sqlDiagnosticContext.appBindingByMappedApp);
     }