@rex0220/kintone-sql-tools 3.29.0 → 3.31.0

package/dist-cli/ksql.js

@@ -670,6 +670,9 @@ function quote(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
 function arithLabel(node, topLevel = false) {
+  if (node.type === "VARIABLE") throw new Error(
+    `InternalError: unresolved arithmetic variable @${node.name} reached aggregate expression labeling.`
+  );
   if (node.type === "FIELD_REF") return node.field;
   if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "STRING_FUNC") return stringFuncLabel(node);
@@ -1054,6 +1057,7 @@ var Parser = class {
     this.cteNames = /* @__PURE__ */ new Set();
     /** パース中に出現した一時テーブル参照（#name）のトークン。単文 API での拒否に使う */
     this.tempTableRefs = [];
+    this.allowSelectArithVariable = false;
   }
   // ----------------------------------------------------------
   // 公開 API
@@ -1893,6 +1897,15 @@ var Parser = class {
     } while (this.consume("," /* COMMA */));
     return cols;
   }
+  parseSelectArith(parse) {
+    const previous = this.allowSelectArithVariable;
+    this.allowSelectArithVariable = true;
+    try {
+      return parse();
+    } finally {
+      this.allowSelectArithVariable = previous;
+    }
+  }
   parseSelectColumn() {
     if (this.consume("*" /* STAR */)) {
       return { type: "WILDCARD" };
@@ -1938,7 +1951,7 @@ var Parser = class {
     if (this.tryStringFuncName() !== null) {
       const funcExpr = this.parseStringFuncExpr();
       if (this.isArithOp(this.peek().kind)) {
-        const node = this.continueArith(funcExpr);
+        const node = this.parseSelectArith(() => this.continueArith(funcExpr));
         const alias3 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
         return { type: "ARITH_COL", expr: node, alias: alias3 };
       }
@@ -1976,7 +1989,7 @@ var Parser = class {
       return { type: "LITERAL_COL", value, alias: alias2 };
     }
     if (this.peek().kind === "(" /* LPAREN */ || this.peek().kind === "NUMBER" /* NUMBER */) {
-      const node = this.parseArithAddSub();
+      const node = this.parseSelectArith(() => this.parseArithAddSub());
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return { type: "ARITH_COL", expr: node, alias: alias2 };
     }
@@ -1989,7 +2002,7 @@ var Parser = class {
     }
     if (this.isArithOp(this.peek().kind)) {
       const left = { type: "FIELD_REF", field };
-      const node = this.continueArith(left);
+      const node = this.parseSelectArith(() => this.continueArith(left));
       const alias2 = this.consume("AS" /* AS */) ? this.parseAliasName() : null;
       return { type: "ARITH_COL", expr: node, alias: alias2 };
     }
@@ -2269,6 +2282,10 @@ var Parser = class {
       this.advance();
       return makeNumberLiteral(tok.value);
     }
+    if (this.allowSelectArithVariable && tok.kind === "VARIABLE" /* VARIABLE */) {
+      this.advance();
+      return { type: "VARIABLE", name: tok.value.slice(1).toLowerCase() };
+    }
     if (tok.kind === "IDENT" /* IDENT */ || tok.kind === "BIDENT" /* BIDENT */) {
       this.advance();
       let field = tok.value;
@@ -5258,6 +5275,9 @@ function collectArithFields(expr, out) {
   collectArithNode(expr.right, out);
 }
 function collectArithNode(node, out) {
+  if (node.type === "VARIABLE") throw new Error(
+    `InternalError: unresolved arithmetic variable @${node.name} reached SELECT field collection.`
+  );
   if (node.type === "FIELD_REF") out.push(normalizeSimpleFieldRef(node.field));
   else if (node.type === "ARITH") collectArithFields(node, out);
   else if (node.type === "STRING_FUNC") collectStringFuncFields(node, out);
@@ -5341,20 +5361,36 @@ function caseResultHasAggregate(result) {
   if (result.type === "ARRAY" || result.type === "FIELD_REF" || result.type === "ARITH") return false;
   return scalarValueHasAggregate(result);
 }
-function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
+function collectSelectFieldReferencesBySource(stmt, plainGroupByPlan) {
+  const unqualified = /* @__PURE__ */ new Set();
+  const states = collectRequiredFieldsByTable(stmt, plainGroupByPlan, {
+    includeMaterialized: true,
+    unqualified
+  });
+  return {
+    bySource: new Map(
+      [...states.entries()].map(([table, state]) => [table, new Set(state.fields)])
+    ),
+    unqualified
+  };
+}
+function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
   const allTables = [stmt.from, ...stmt.joins.map((j) => j.table)];
   const physicalTables = [stmt.from, ...stmt.joins.map((j) => j.table)].filter((t) => t.cteName === null);
+  const targetTables = sourceAware ? allTables : physicalTables;
   const states = /* @__PURE__ */ new Map();
-  for (const table of physicalTables) {
+  for (const table of targetTables) {
     states.set(table, { table, allFields: false, fields: /* @__PURE__ */ new Set() });
   }
   if (states.size === 0) return states;
-  const firstPhysicalTable = physicalTables[0] ?? null;
-  const subtableTable = physicalTables.find((t) => !!t.subtableCode) ?? null;
+  const firstTargetTable = targetTables[0] ?? null;
+  const subtableTable = targetTables.find((t) => !!t.subtableCode) ?? null;
   const aliasToTable = /* @__PURE__ */ new Map();
-  for (const table of physicalTables) {
+  for (const table of targetTables) {
     if (table.alias) aliasToTable.set(table.alias, table);
-    if (!table.subtableCode) {
+    if (table.cteName !== null) {
+      aliasToTable.set(table.cteName, table);
+    } else if (!table.subtableCode) {
       aliasToTable.set(`APP${table.appId}`, table);
       aliasToTable.set(`app${table.appId}`, table);
     }
@@ -5366,11 +5402,11 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
     st.allFields = true;
     st.fields.clear();
   };
-  const markAllPhysicalTables = () => {
-    for (const t of physicalTables) markAll(t);
+  const markAllTargetTables = () => {
+    for (const t of targetTables) markAll(t);
   };
   const markAllSubtableTables = () => {
-    for (const t of physicalTables) {
+    for (const t of targetTables) {
       if (t.subtableCode) markAll(t);
     }
   };
@@ -5400,7 +5436,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
     if (rawName.endsWith(".*")) {
       const qualifier = rawName.slice(0, -2);
       if (!qualifier) {
-        markAllPhysicalTables();
+        markAllTargetTables();
         return;
       }
       if (qualifier === "_p") {
@@ -5417,7 +5453,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
     if (phase === "groupBy" && groupResolution !== void 0) {
       if (groupResolution.kind === "PHYSICAL") {
         const source = allTables[groupResolution.sourceIndex];
-        if (source?.cteName === null) {
+        if (source && (sourceAware || source.cteName === null)) {
           addFieldToTable(source, groupResolution.fieldCode);
         }
       }
@@ -5442,8 +5478,13 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
         addFieldToTable(target, field);
         return;
       }
+      if (sourceAware) return;
+    }
+    if (sourceAware) {
+      sourceAware.unqualified.add(rawName);
+    } else if (firstTargetTable) {
+      addFieldToTable(firstTargetTable, rawName);
     }
-    if (firstPhysicalTable) addFieldToTable(firstPhysicalTable, rawName);
   };
   const addFieldRef = (field, tableAlias, phase = "select") => {
     if (tableAlias) {
@@ -5456,10 +5497,16 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
         addFieldToTable(target, field);
         return;
       }
+      if (sourceAware) return;
     }
     addFieldName(field, phase);
   };
   const walkArith = (node, phase = "select") => {
+    if (node.type === "VARIABLE") {
+      throw new Error(
+        `InternalError: unresolved arithmetic variable @${node.name} reached source-aware field collection.`
+      );
+    }
     if (node.type === "FIELD_REF") {
       addFieldName(node.field, phase);
       return;
@@ -5611,7 +5658,7 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan) {
   for (const col of stmt.columns) {
     switch (col.type) {
       case "WILDCARD":
-        markAllPhysicalTables();
+        markAllTargetTables();
         break;
       case "PARENT_WILDCARD":
         markAllSubtableTables();
@@ -7107,6 +7154,9 @@ function selectScalarExtreme(values, extreme) {
 
 // src/engine/evalFunc.ts
 function evalArithExpr(expr, row) {
+  if (expr.type === "VARIABLE") throw new Error(
+    `InternalError: unresolved arithmetic variable @${expr.name} reached arithmetic evaluation.`
+  );
   if (expr.type === "NUMBER") return expr.value;
   if (expr.type === "FIELD_REF") return Number(resolveFieldRef(row, expr.field));
   if (expr.type === "STRING_FUNC") return Number(evalStringFunc(expr, row));
@@ -8144,6 +8194,9 @@ function collectArithFields2(expr, out) {
   collectArithNode2(expr.right, out);
 }
 function collectArithNode2(node, out) {
+  if (node.type === "VARIABLE") throw new Error(
+    `InternalError: unresolved arithmetic variable @${node.name} reached DML field collection.`
+  );
   if (node.type === "FIELD_REF") out.add(node.field);
   else if (node.type === "ARITH") collectArithFields2(node, out);
   else if (node.type === "STRING_FUNC") collectStringFuncFields2(node, out);
@@ -8341,6 +8394,9 @@ function evalArith(expr, raw) {
   }
 }
 function resolveArithOperand(operand, raw) {
+  if (operand.type === "VARIABLE") throw new Error(
+    `InternalError: unresolved arithmetic variable @${operand.name} reached DML evaluation.`
+  );
   if (operand.type === "NUMBER") return operand.value;
   if (operand.type === "ARITH") return evalArith(operand, raw);
   if (operand.type === "STRING_FUNC") throw new DmlConvertError(
@@ -9490,6 +9546,20 @@ function renderValidationValue(value) {
 }
 
 // src/core/existingRecordValidation.ts
+var VALIDATE_CONSTRAINT_CATEGORIES = [
+  "required",
+  "length",
+  "range",
+  "choice"
+];
+function getAuditableConstraintCategories(field) {
+  return [
+    ...field.required === true ? ["required"] : [],
+    ...field.minLength !== void 0 || field.maxLength !== void 0 ? ["length"] : [],
+    ...field.minValue !== void 0 || field.maxValue !== void 0 ? ["range"] : [],
+    ...field.optionOrder !== void 0 ? ["choice"] : []
+  ];
+}
 function buildValidationFieldMetadataIndex(fieldInfos) {
   const topLevel = fieldInfos.filter((field) => !field.inSubtable);
   const childrenByTable = /* @__PURE__ */ new Map();
@@ -9506,7 +9576,7 @@ function buildValidationFieldMetadataIndex(fieldInfos) {
   };
 }
 function hasAuditableConstraint(field) {
-  return field.required === true || field.minValue !== void 0 || field.maxValue !== void 0 || field.minLength !== void 0 || field.maxLength !== void 0 || field.optionOrder !== void 0;
+  return getAuditableConstraintCategories(field).length > 0;
 }
 function isExistingValidationAuditable(field) {
   return field.fieldType === "NUMBER" || hasAuditableConstraint(field);
@@ -12429,6 +12499,65 @@ function planPlainGroupByResolution(groupBy, columns, schemas) {
   };
 }
 
+// src/core/emptyWildcardSchema.ts
+var EMPTY_WILDCARD_FIELD_TYPE_POLICY = {
+  CALC: "RECORD",
+  CATEGORY: "NON_RECORD",
+  CHECK_BOX: "RECORD",
+  CREATED_TIME: "RECORD",
+  CREATOR: "RECORD",
+  DATE: "RECORD",
+  DATETIME: "RECORD",
+  DROP_DOWN: "RECORD",
+  FILE: "RECORD",
+  GROUP: "NON_RECORD",
+  GROUP_SELECT: "RECORD",
+  LINK: "RECORD",
+  MODIFIER: "RECORD",
+  MULTI_LINE_TEXT: "RECORD",
+  MULTI_SELECT: "RECORD",
+  NUMBER: "RECORD",
+  ORGANIZATION_SELECT: "RECORD",
+  RADIO_BUTTON: "RECORD",
+  RECORD_NUMBER: "RECORD",
+  REFERENCE_TABLE: "NON_RECORD",
+  RICH_TEXT: "RECORD",
+  SINGLE_LINE_TEXT: "RECORD",
+  STATUS: "PROCESS",
+  STATUS_ASSIGNEE: "PROCESS",
+  SUBTABLE: "RECORD",
+  TIME: "RECORD",
+  UPDATED_TIME: "RECORD",
+  USER_SELECT: "RECORD"
+};
+function fieldPolicy(fieldType) {
+  const policy = EMPTY_WILDCARD_FIELD_TYPE_POLICY[fieldType];
+  if (policy === void 0) {
+    throw new Error(
+      `InternalError: empty SELECT * schema policy is not defined for field type ${fieldType}.`
+    );
+  }
+  return policy;
+}
+async function deriveEmptyWildcardColumns(fields, subtableCode, loadProcessStatuses) {
+  if (subtableCode != null) {
+    return [
+      "_pid",
+      "_rid",
+      "_idx",
+      ...fields.filter((field) => field.inSubtable === true && field.subtableCode === subtableCode).map((field) => field.code)
+    ];
+  }
+  const topLevel = fields.filter((field) => !field.inSubtable);
+  const needsProcessSettings = topLevel.some((field) => fieldPolicy(field.fieldType) === "PROCESS");
+  const processEnabled = needsProcessSettings ? (await loadProcessStatuses()).enable : false;
+  const columns = topLevel.filter((field) => {
+    const policy = fieldPolicy(field.fieldType);
+    return policy === "RECORD" || policy === "PROCESS" && processEnabled;
+  }).map((field) => field.code);
+  return [...columns, "$revision", "$id"];
+}
+
 // src/engine/process.ts
 function flatten(record, alias) {
   const row = {};
@@ -13312,6 +13441,9 @@ function stripParentShortcutColumns(row) {
 }
 function arithColDefaultKey(expr) {
   const nodeLabel = (n) => {
+    if (n.type === "VARIABLE") throw new Error(
+      `InternalError: unresolved arithmetic variable @${n.name} reached arithmetic column labeling.`
+    );
     if (n.type === "FIELD_REF") return n.field;
     if (n.type === "NUMBER") return numberLiteralText(n);
     if (n.type === "STRING_FUNC") return stringFuncDefaultKey(n);
@@ -15251,6 +15383,7 @@ var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
 var importSourceByDmlStatement = /* @__PURE__ */ new WeakMap();
 var defaultCacheContextByClient = /* @__PURE__ */ new WeakMap();
 var nextDefaultCacheContextId = 1;
+var nextCacheInvocationId = 1;
 function resolveCacheContext(client, explicit) {
   if (explicit) return explicit;
   let context = defaultCacheContextByClient.get(client);
@@ -15260,31 +15393,40 @@ function resolveCacheContext(client, explicit) {
   }
   return context;
 }
+function createInvocationCacheContext(cacheContext) {
+  return `${cacheContext}\0inv:${nextCacheInvocationId++}`;
+}
 async function execute(sql, client, options = {}) {
   const startedAt = Date.now();
-  const cacheContext = resolveCacheContext(client, options.cacheContext);
-  const stmt = parseSql(sql, options.enableImport === true);
-  const metrics = createEmptyMetrics();
-  const countedClient = wrapClientWithMetrics(client, metrics);
-  const collector = { aborted: false };
-  const guardedClient = wrapClientWithSearchAbort(
-    countedClient,
-    collector,
-    !isSelectLikeStatement(stmt) || statementContainsOuterJoin(stmt)
-  );
-  const result = await executeParsedStatement(
-    stmt,
-    guardedClient,
-    options,
-    cacheContext
+  const cacheContext = createInvocationCacheContext(
+    resolveCacheContext(client, options.cacheContext)
   );
-  metrics.elapsedMs = Date.now() - startedAt;
-  const finalResult = { ...attachSearchAbortWarning(result, collector), metrics };
-  if (result.type === "SELECT") {
-    const columnMeta = materializedMetaBySelectResult.get(result);
-    if (columnMeta) materializedMetaBySelectResult.set(finalResult, columnMeta);
+  try {
+    const stmt = parseSql(sql, options.enableImport === true);
+    const metrics = createEmptyMetrics();
+    const countedClient = wrapClientWithMetrics(client, metrics);
+    const collector = { aborted: false };
+    const guardedClient = wrapClientWithSearchAbort(
+      countedClient,
+      collector,
+      !isSelectLikeStatement(stmt) || statementContainsOuterJoin(stmt)
+    );
+    const result = await executeParsedStatement(
+      stmt,
+      guardedClient,
+      options,
+      cacheContext
+    );
+    metrics.elapsedMs = Date.now() - startedAt;
+    const finalResult = { ...attachSearchAbortWarning(result, collector), metrics };
+    if (result.type === "SELECT") {
+      const columnMeta = materializedMetaBySelectResult.get(result);
+      if (columnMeta) materializedMetaBySelectResult.set(finalResult, columnMeta);
+    }
+    return finalResult;
+  } finally {
+    releaseMetadataCacheScope(cacheContext);
   }
-  return finalResult;
 }
 function createEmptyMetrics() {
   return {
@@ -15629,6 +15771,13 @@ async function executeExistingRecordValidationCore(stmt, client, options, cacheC
   const infoByCode = new Map(fieldInfos.filter((field) => !field.inSubtable).map((field) => [field.code, field]));
   const childCodes = new Set(fieldInfos.filter((field) => field.inSubtable).map((field) => field.code));
   const targets = resolveExistingValidationTargets(stmt, fieldInfos);
+  const presentConstraintCategories = new Set(
+    targets.flatMap((target) => getAuditableConstraintCategories(target.field))
+  );
+  const constraintMetadata = {
+    present: VALIDATE_CONSTRAINT_CATEGORIES.filter((category) => presentConstraintCategories.has(category)),
+    absent: VALIDATE_CONSTRAINT_CATEGORIES.filter((category) => !presentConstraintCategories.has(category))
+  };
   const checkGroups = stmt.checkGroups ?? [];
   const checkRefs2 = collectCheckFieldRefs(checkGroups);
   for (const ref of checkRefs2) {
@@ -15785,7 +15934,11 @@ async function executeExistingRecordValidationCore(stmt, client, options, cacheC
     columns: [...columns],
     rows,
     rowCount: rows.length,
-    validateStats: { errorRecords: errorRecordIds.size, errorCount }
+    validateStats: {
+      errorRecords: errorRecordIds.size,
+      errorCount,
+      constraintMetadata
+    }
   };
   materializedMetaBySelectResult.set(result, existingValidationColumnMeta(stmt.summary === true));
   return result;
@@ -15844,91 +15997,97 @@ async function executeBatch(sql, client, options = {}) {
   const countedClient = wrapClientWithMetrics(client, metrics);
   const startedAt = Date.now();
   const deadline = options.timeoutMs != null ? startedAt + options.timeoutMs : null;
-  const cacheContext = resolveCacheContext(client, options.cacheContext);
-  const tempTables = /* @__PURE__ */ new Map();
-  const variables = /* @__PURE__ */ new Map();
-  const results = [];
-  const failed = /* @__PURE__ */ new Set();
-  let aborted = null;
-  for (let i = 0; i < statements.length; i++) {
-    const info = analysis.statements[i];
-    const base = { index: i, type: info.statementType };
-    if (aborted) {
-      results.push({ ...base, status: "skipped", skippedReason: aborted });
-      failed.add(i);
-      continue;
-    }
-    const brokenDep = info.dependsOn.find((d) => failed.has(d));
-    if (brokenDep !== void 0) {
-      const depName = analysis.statements[brokenDep].tempTablesCreated[0] ?? `statement ${brokenDep}`;
-      results.push({ ...base, status: "skipped", skippedReason: `dependency: ${depName}` });
-      failed.add(i);
-      continue;
-    }
-    if (deadline !== null && Date.now() >= deadline) {
-      results.push({ ...base, status: "skipped", skippedReason: "timeout" });
-      failed.add(i);
-      aborted = "timeout";
-      continue;
-    }
-    try {
-      const remaining = deadline !== null ? deadline - Date.now() : null;
-      const userConfirm = batchOptions.confirm;
-      const stmtOptions = userConfirm ? {
-        ...batchOptions,
-        confirm: (count, operation, detailContext) => userConfirm(count, operation, {
-          statementIndex: i,
-          statementCount: statements.length,
-          statementType: info.statementType,
-          targetAppId: info.targetAppId,
-          ...detailContext?.importDetail ? { importDetail: detailContext.importDetail } : {},
-          ...detailContext?.applyDetail ? { applyDetail: detailContext.applyDetail } : {},
-          ...detailContext?.applyDiagnostic ? { applyDiagnostic: detailContext.applyDiagnostic } : {}
-        })
-      } : batchOptions;
-      const searchAbortCollector = { aborted: false };
-      const statementClient = wrapClientWithSearchAbort(
-        countedClient,
-        searchAbortCollector,
-        info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH" || statementContainsOuterJoin(statements[i])
-      );
-      const cursorScope = wrapClientWithCursorScope(statementClient);
-      const outcome = await runWithDeadline(
-        executeBatchStatement(statements[i], info, cursorScope.client, stmtOptions, cacheContext, tempTables, variables),
-        remaining,
-        cursorScope.closeActive
-      );
-      if (outcome.result) {
-        outcome.result = attachSearchAbortWarning(outcome.result, searchAbortCollector);
+  const cacheContext = createInvocationCacheContext(
+    resolveCacheContext(client, options.cacheContext)
+  );
+  try {
+    const tempTables = /* @__PURE__ */ new Map();
+    const variables = /* @__PURE__ */ new Map();
+    const results = [];
+    const failed = /* @__PURE__ */ new Set();
+    let aborted = null;
+    for (let i = 0; i < statements.length; i++) {
+      const info = analysis.statements[i];
+      const base = { index: i, type: info.statementType };
+      if (aborted) {
+        results.push({ ...base, status: "skipped", skippedReason: aborted });
+        failed.add(i);
+        continue;
       }
-      results.push({ ...base, status: "success", ...outcome });
-    } catch (e) {
-      results.push({
-        ...base,
-        status: "error",
-        error: toBatchStatementError(e),
-        ...e instanceof RejectLimitExceededError ? { result: e.diagnostic } : {}
-      });
-      failed.add(i);
-      if (e instanceof BatchTimeoutError) {
+      const brokenDep = info.dependsOn.find((d) => failed.has(d));
+      if (brokenDep !== void 0) {
+        const depName = analysis.statements[brokenDep].tempTablesCreated[0] ?? `statement ${brokenDep}`;
+        results.push({ ...base, status: "skipped", skippedReason: `dependency: ${depName}` });
+        failed.add(i);
+        continue;
+      }
+      if (deadline !== null && Date.now() >= deadline) {
+        results.push({ ...base, status: "skipped", skippedReason: "timeout" });
+        failed.add(i);
         aborted = "timeout";
-      } else if (e instanceof AssertError) {
-        aborted = "assertion";
-      } else if (info.statementType === "SET_VARIABLE" || info.statementType === "DECLARE_VARIABLE") {
-        aborted = "fail-fast";
-      } else if (!options.continueOnError) {
-        aborted = "fail-fast";
+        continue;
+      }
+      try {
+        const remaining = deadline !== null ? deadline - Date.now() : null;
+        const userConfirm = batchOptions.confirm;
+        const stmtOptions = userConfirm ? {
+          ...batchOptions,
+          confirm: (count, operation, detailContext) => userConfirm(count, operation, {
+            statementIndex: i,
+            statementCount: statements.length,
+            statementType: info.statementType,
+            targetAppId: info.targetAppId,
+            ...detailContext?.importDetail ? { importDetail: detailContext.importDetail } : {},
+            ...detailContext?.applyDetail ? { applyDetail: detailContext.applyDetail } : {},
+            ...detailContext?.applyDiagnostic ? { applyDiagnostic: detailContext.applyDiagnostic } : {}
+          })
+        } : batchOptions;
+        const searchAbortCollector = { aborted: false };
+        const statementClient = wrapClientWithSearchAbort(
+          countedClient,
+          searchAbortCollector,
+          info.statementType !== "SELECT" && info.statementType !== "UNION" && info.statementType !== "WITH" || statementContainsOuterJoin(statements[i])
+        );
+        const cursorScope = wrapClientWithCursorScope(statementClient);
+        const outcome = await runWithDeadline(
+          executeBatchStatement(statements[i], info, cursorScope.client, stmtOptions, cacheContext, tempTables, variables),
+          remaining,
+          cursorScope.closeActive
+        );
+        if (outcome.result) {
+          outcome.result = attachSearchAbortWarning(outcome.result, searchAbortCollector);
+        }
+        results.push({ ...base, status: "success", ...outcome });
+      } catch (e) {
+        results.push({
+          ...base,
+          status: "error",
+          error: toBatchStatementError(e),
+          ...e instanceof RejectLimitExceededError ? { result: e.diagnostic } : {}
+        });
+        failed.add(i);
+        if (e instanceof BatchTimeoutError) {
+          aborted = "timeout";
+        } else if (e instanceof AssertError) {
+          aborted = "assertion";
+        } else if (info.statementType === "SET_VARIABLE" || info.statementType === "DECLARE_VARIABLE") {
+          aborted = "fail-fast";
+        } else if (!options.continueOnError) {
+          aborted = "fail-fast";
+        }
       }
     }
+    metrics.elapsedMs = Date.now() - startedAt;
+    return {
+      ok: results.every((r) => r.status === "success"),
+      statementCount: statements.length,
+      statements: results,
+      analysis,
+      metrics
+    };
+  } finally {
+    releaseMetadataCacheScope(cacheContext);
   }
-  metrics.elapsedMs = Date.now() - startedAt;
-  return {
-    ok: results.every((r) => r.status === "success"),
-    statementCount: statements.length,
-    statements: results,
-    analysis,
-    metrics
-  };
 }
 function statementHasApplyMutation(statement) {
   if (statement.type === "UPDATE" || statement.type === "INSERT") {
@@ -16215,8 +16374,11 @@ function evaluateScalarExpr(expr) {
   }
 }
 function resolveBatchVariableReferences(node, variables) {
+  return resolveBatchVariableReferencesInternal(node, variables, false);
+}
+function resolveBatchVariableReferencesInternal(node, variables, numericArithmeticOperand) {
   if (Array.isArray(node)) {
-    return node.map((v) => resolveBatchVariableReferences(v, variables));
+    return node.map((v) => resolveBatchVariableReferencesInternal(v, variables, false));
   }
   if (node !== null && typeof node === "object") {
     const obj = node;
@@ -16228,6 +16390,11 @@ function resolveBatchVariableReferences(node, variables) {
       if (value.type === "array") {
         throw new Error(`ParseError: array variable @${obj["name"]} can only be used as IN @${obj["name"]}.`);
       }
+      if (numericArithmeticOperand && value.type !== "number") {
+        throw new Error(
+          `ArgumentError: variable @${obj["name"]} is not numeric and cannot be used in arithmetic.`
+        );
+      }
       return value.type === "number" ? { type: "NUMBER", value: value.value, raw: value.raw ?? String(value.value) } : { type: "STRING", value: value.value };
     }
     if (obj["type"] === "VARIABLE_COL" && typeof obj["name"] === "string" && typeof obj["alias"] === "string") {
@@ -16238,7 +16405,14 @@ function resolveBatchVariableReferences(node, variables) {
     }
     if (obj["type"] === "VARIABLE_IN_LIST") return obj;
     const resolved = Object.fromEntries(
-      Object.entries(obj).map(([key, value]) => [key, resolveBatchVariableReferences(value, variables)])
+      Object.entries(obj).map(([key, value]) => [
+        key,
+        resolveBatchVariableReferencesInternal(
+          value,
+          variables,
+          (obj["type"] === "ARITH" || obj["type"] === "SCALAR_ARITH" || obj["type"] === "AGG_ARITH") && (key === "left" || key === "right")
+        )
+      ])
     );
     if (resolved["type"] === "BINARY") {
       const right = resolved["right"];
@@ -16393,6 +16567,11 @@ function withScalarProbeLimit(query) {
   return { query: { ...query, limit: 2 }, probed: true };
 }
 function evalAssertArith(node) {
+  if (node.type === "VARIABLE") {
+    throw new Error(
+      `InternalError: unresolved arithmetic variable @${node.name} reached ASSERT evaluation.`
+    );
+  }
   if (node.type === "NUMBER") return node.value;
   if (node.type === "ARITH") {
     const left = evalAssertArith(node.left);
@@ -16909,6 +17088,11 @@ function isNoFromSelect(stmt) {
   return stmt.from.appId === 0 && stmt.from.cteName === NO_FROM_CTE_NAME;
 }
 function arithHasFieldRef(node) {
+  if (node.type === "VARIABLE") {
+    throw new Error(
+      `InternalError: unresolved arithmetic variable @${node.name} reached SELECT planning.`
+    );
+  }
   if (node.type === "FIELD_REF") return true;
   if (node.type === "ARITH") return arithHasFieldRef(node.left) || arithHasFieldRef(node.right);
   if (node.type === "STRING_FUNC") return stringFuncHasFieldRef(node);
@@ -17051,7 +17235,7 @@ async function executeSimpleSelect(stmt, client, options, cacheContext, orderPla
     );
     rows = applyLimit(rows, stmt.limit, stmt.offset);
   }
-  const { rows: projected, columns } = project(
+  const { rows: projected, columns: projectedColumns } = project(
     rows,
     stmt.columns,
     void 0,
@@ -17059,6 +17243,13 @@ async function executeSimpleSelect(stmt, client, options, cacheContext, orderPla
     void 0,
     projectionSemanticsResolver
   );
+  const columns = await restoreEmptyWildcardColumns(
+    stmt,
+    projected,
+    projectedColumns,
+    client,
+    cacheContext
+  );
   return { type: "SELECT", rows: projected, columns, rowCount: projected.length, warnings: [...warnings] };
 }
 async function validateSelectFieldCodes(stmt, mode, client, cacheContext) {
@@ -17093,6 +17284,159 @@ async function validateSelectFieldCodes(stmt, mode, client, cacheContext) {
     }
   }
 }
+function b86SourceLabel(table) {
+  return table.cteName ?? `APP${table.appId}`;
+}
+function b86SourceAliases(table) {
+  if (table.alias) return [table.alias];
+  if (table.cteName !== null) return [table.cteName];
+  return [`APP${table.appId}`, `app${table.appId}`];
+}
+function b86PhysicalFieldExists(schema, field) {
+  return isSystemLikeFieldCode(field) || schema.validCodes.has(field);
+}
+function b86FieldExists(schema, field) {
+  if (schema.table.cteName !== null) return schema.validCodes.has(field);
+  return b86PhysicalFieldExists(schema, field);
+}
+function collectB86Subqueries(stmt) {
+  const queries = [];
+  const visitWhere = (where) => {
+    if (where === null) return;
+    switch (where.type) {
+      case "BINARY":
+        if (where.right.type === "SUBQUERY_IN_LIST" || where.right.type === "SCALAR_SUBQUERY") {
+          queries.push(where.right.query);
+        }
+        return;
+      case "EXISTS":
+        queries.push(where.query);
+        return;
+      case "LOGICAL":
+        visitWhere(where.left);
+        visitWhere(where.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visitWhere(where.expr);
+        return;
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visitWhere(stmt.where);
+  visitWhere(stmt.having);
+  for (const column of stmt.columns) {
+    if (column.type === "SCALAR_SUBQUERY_COL") {
+      queries.push(column.query);
+    } else if (column.type === "CASE_COL") {
+      for (const branch of column.expr.branches) visitWhere(branch.condition);
+    }
+  }
+  return queries;
+}
+async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext) {
+  const tables = [stmt.from, ...stmt.joins.map((join2) => join2.table)];
+  const materializedByTable = /* @__PURE__ */ new Map();
+  const effectiveAliases = /* @__PURE__ */ new Set();
+  for (const table of tables) {
+    const alias = effectiveTableAlias(table);
+    if (alias === null) continue;
+    if (effectiveAliases.has(alias)) {
+      throw new Error(`ArgumentError: effective alias ${alias} is used by multiple tables.`);
+    }
+    effectiveAliases.add(alias);
+  }
+  for (const table of tables) {
+    if (table.cteName === null || table.cteName === NO_FROM_CTE_NAME) continue;
+    const materialized = cteCache.get(table.cteName);
+    if (!materialized) {
+      throw new Error(`ArgumentError: materialized source ${table.cteName} is not available.`);
+    }
+    if (materialized.rows.length > 0 && materialized.columns.length === 0) {
+      throw new Error(
+        `InternalError: materialized source ${table.cteName} has rows but no column schema.`
+      );
+    }
+    if (stmt.joins.length > 0 && materialized.rows.length === 0 && materialized.columns.length === 0) {
+      throw new Error(
+        `ArgumentError: column schema is unavailable for materialized JOIN source ${table.cteName}.`
+      );
+    }
+    materializedByTable.set(table, materialized);
+  }
+  const schemas = /* @__PURE__ */ new Map();
+  await Promise.all(tables.map(async (table) => {
+    const materialized = materializedByTable.get(table);
+    if (materialized) {
+      schemas.set(table, {
+        table,
+        label: b86SourceLabel(table),
+        validCodes: new Set(materialized.columns),
+        authoritative: true,
+        schemaUnavailable: materialized.rows.length === 0 && materialized.columns.length === 0
+      });
+      return;
+    }
+    if (table.cteName === NO_FROM_CTE_NAME) return;
+    const defs = await getFieldsCached(table.appId, client, cacheContext);
+    schemas.set(table, {
+      table,
+      label: b86SourceLabel(table),
+      validCodes: new Set(defs.map((def) => def.code)),
+      authoritative: defs.length > 0,
+      schemaUnavailable: false
+    });
+  }));
+  const sourceByAlias = /* @__PURE__ */ new Map();
+  for (const schema of schemas.values()) {
+    for (const alias of b86SourceAliases(schema.table)) sourceByAlias.set(alias, schema);
+  }
+  for (const join2 of stmt.joins) {
+    for (const ref of [join2.on.left, join2.on.right]) {
+      if (!ref.tableAlias) continue;
+      const schema = sourceByAlias.get(ref.tableAlias);
+      if (schema && schema.table.cteName !== null && !schema.schemaUnavailable && !b86FieldExists(schema, ref.field)) {
+        throw new Error(
+          `ArgumentError: JOIN key ${ref.tableAlias}.${ref.field} is not available in the materialized table.`
+        );
+      }
+    }
+  }
+  const references = collectSelectFieldReferencesBySource(stmt);
+  for (const [table, fields] of references.bySource) {
+    const schema = schemas.get(table);
+    if (!schema || schema.schemaUnavailable || !schema.authoritative) continue;
+    const unknown = [...fields].filter((field) => !b86FieldExists(schema, field));
+    if (unknown.length > 0) {
+      throw new Error(
+        `ArgumentError: unknown field code(s): ${unknown.join(", ")} (${schema.label})`
+      );
+    }
+  }
+  for (const field of references.unqualified) {
+    const candidates = [...schemas.values()].filter((schema) => !schema.schemaUnavailable);
+    if (candidates.some((schema) => b86FieldExists(schema, field))) continue;
+    if ([...schemas.values()].some((schema) => schema.schemaUnavailable)) continue;
+    if (candidates.some((schema) => schema.table.cteName === null && !schema.authoritative)) continue;
+    const labels = candidates.map((schema) => schema.label).join(", ");
+    throw new Error(`ArgumentError: unknown field code(s): ${field} (${labels})`);
+  }
+}
+async function preflightB86QueryWithCte(query, client, cteCache, cacheContext, seen = /* @__PURE__ */ new Set()) {
+  if (seen.has(query)) return;
+  seen.add(query);
+  if (query.type === "UNION") {
+    await preflightB86QueryWithCte(query.left, client, cteCache, cacheContext, seen);
+    await preflightB86QueryWithCte(query.right, client, cteCache, cacheContext, seen);
+    return;
+  }
+  await validateB86SelectFieldCodes(query, client, cteCache, cacheContext);
+  for (const subquery of collectB86Subqueries(query)) {
+    await preflightB86QueryWithCte(subquery, client, cteCache, cacheContext, seen);
+  }
+}
 function extractMainTypedPushdownCandidate(stmt) {
   if (stmt.where === null || stmt.from.subtableCode || stmt.from.cteName !== null) return null;
   if (stmt.joins.length === 0) {
@@ -17882,7 +18226,7 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     tables.set(join2.table.alias, joinRecords);
   }));
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
-  const { rows, columns } = runFullScan({
+  const { rows, columns: projectedColumns } = runFullScan({
     tables,
     stmt,
     scalarCache,
@@ -17899,6 +18243,13 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt),
     plainGroupByPlan
   });
+  const columns = await restoreEmptyWildcardColumns(
+    stmt,
+    rows,
+    projectedColumns,
+    client,
+    cacheContext
+  );
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
 async function executeUnion(stmt, client, options, cacheContext, captureColumnMeta = false, forLibraryCapture = false) {
@@ -17954,11 +18305,14 @@ async function executeWith(stmt, client, options, cacheContext, seed, captureCol
   }
   return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext, captureColumnMeta);
 }
-async function executeQueryWithCte(query, client, options, cteCache, cacheContext, captureColumnMeta = false) {
+async function executeQueryWithCte(query, client, options, cteCache, cacheContext, captureColumnMeta = false, b86PreflightComplete = false) {
+  if (!b86PreflightComplete) {
+    await preflightB86QueryWithCte(query, client, cteCache, cacheContext);
+  }
   if (query.type === "UNION") {
     const [leftResult, rightResult] = await Promise.all([
-      executeQueryWithCte(query.left, client, options, cteCache, cacheContext, captureColumnMeta),
-      executeQueryWithCte(query.right, client, options, cteCache, cacheContext, captureColumnMeta)
+      executeQueryWithCte(query.left, client, options, cteCache, cacheContext, captureColumnMeta, true),
+      executeQueryWithCte(query.right, client, options, cteCache, cacheContext, captureColumnMeta, true)
     ]);
     const leftCols = leftResult.columns;
     const rightCols = rightResult.columns;
@@ -18138,7 +18492,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   await Promise.all(joinFetches);
   const { optionOrders, sortKinds, semantics } = await orderByMetaPromise;
   const sourceColumns2 = stmt.joins.length === 0 && stmt.from.cteName != null ? requireMaterializedTable(stmt.from.cteName).columns : void 0;
-  const { rows, columns } = runFullScan({
+  const { rows, columns: projectedColumns } = runFullScan({
     tables,
     stmt,
     scalarCache,
@@ -18157,8 +18511,26 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     resolvedGroupingSpec,
     plainGroupByPlan
   });
+  const columns = await restoreEmptyWildcardColumns(
+    stmt,
+    rows,
+    projectedColumns,
+    client,
+    cacheContext
+  );
   return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
 }
+async function restoreEmptyWildcardColumns(stmt, rows, columns, client, cacheContext) {
+  if (rows.length !== 0 || columns.length !== 0 || stmt.columns.length !== 1 || stmt.columns[0].type !== "WILDCARD" || stmt.joins.length !== 0 || stmt.from.cteName !== null) {
+    return [...columns];
+  }
+  const fields = await getFieldsCached(stmt.from.appId, client, cacheContext);
+  return deriveEmptyWildcardColumns(
+    fields,
+    stmt.from.subtableCode,
+    () => getProcessStatusesCached(stmt.from.appId, client, cacheContext)
+  );
+}
 function processRowToKintoneRecord(row) {
   return Object.fromEntries(
     Object.entries(row).map(([k, v]) => [k, { value: v ?? "" }])
@@ -18358,6 +18730,14 @@ var sortKindCache = /* @__PURE__ */ new Map();
 var fieldInfoCache = /* @__PURE__ */ new Map();
 var processStatusCache = /* @__PURE__ */ new Map();
 var numberPrecisionCache = /* @__PURE__ */ new Map();
+function releaseMetadataCacheScope(cacheContext) {
+  fieldTypeCache.delete(cacheContext);
+  optionOrderCache.delete(cacheContext);
+  sortKindCache.delete(cacheContext);
+  fieldInfoCache.delete(cacheContext);
+  processStatusCache.delete(cacheContext);
+  numberPrecisionCache.delete(cacheContext);
+}
 function getScopedCacheValue(root, cacheContext, appId) {
   return root.get(cacheContext)?.get(appId);
 }
@@ -22029,45 +22409,50 @@ function serverFunctionClientEvaluationLabel(leaves) {
   ) ? "relative date client evaluations" : "kintone function client evaluations";
 }
 async function buildBatchExplainPlans(sql, client, injectedVariables, cacheContext = "batch-explain", maxRecords = 1e4, cursorMaxActive = 2, enableImport = false, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
-  const statements = parseSqlBatch(sql, enableImport);
-  const analysis = analyzeBatch(statements);
-  validateDeclaredBatchVariables(statements, injectedVariables);
-  const variables = /* @__PURE__ */ new Map();
-  const plans = [];
-  for (let i = 0; i < statements.length; i++) {
-    const stmt = statements[i];
-    const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
-    validateKlikeStatement(planStmt);
-    const relativeDatePlan = await resolveRelativeDateExecutionPlan(planStmt, client, cacheContext);
-    const whereAnalysis = await buildExplainWhereAnalysis(
-      planStmt,
-      client,
-      cacheContext,
-      maxRecords,
-      relativeDatePlan
-    );
-    const statementPlan = relativeDatePlan.hasServerOnlyWhereFunction && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
-      ...relativeDateExplainLines(relativeDatePlan),
-      ...addCursorConcurrency(buildBatchStatementPlan(
+  const invocationCacheContext = createInvocationCacheContext(cacheContext);
+  try {
+    const statements = parseSqlBatch(sql, enableImport);
+    const analysis = analyzeBatch(statements);
+    validateDeclaredBatchVariables(statements, injectedVariables);
+    const variables = /* @__PURE__ */ new Map();
+    const plans = [];
+    for (let i = 0; i < statements.length; i++) {
+      const stmt = statements[i];
+      const planStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
+      validateKlikeStatement(planStmt);
+      const relativeDatePlan = await resolveRelativeDateExecutionPlan(planStmt, client, invocationCacheContext);
+      const whereAnalysis = await buildExplainWhereAnalysis(
         planStmt,
-        analysis.statements[i],
-        whereAnalysis.capabilities,
-        whereAnalysis.orderPlans,
-        dmlMaxRows,
-        dmlMaxSubtableRows
-      ), cursorMaxActive)
-    ];
-    const metadataPlan = explainMetadataLines(whereAnalysis);
-    plans.push({
-      index: i,
-      type: analysis.statements[i].statementType,
-      plan: statementPlan.length === 0 ? metadataPlan : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1)]
-    });
-    if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
-      variables.set(stmt.name, stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? { type: "array", elements: stmt.expr.elements.map((element) => ({ type: "string", value: element.value })) } : { type: "string", value: `@${stmt.name}` });
+        client,
+        invocationCacheContext,
+        maxRecords,
+        relativeDatePlan
+      );
+      const statementPlan = relativeDatePlan.hasServerOnlyWhereFunction && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
+        ...relativeDateExplainLines(relativeDatePlan),
+        ...addCursorConcurrency(buildBatchStatementPlan(
+          planStmt,
+          analysis.statements[i],
+          whereAnalysis.capabilities,
+          whereAnalysis.orderPlans,
+          dmlMaxRows,
+          dmlMaxSubtableRows
+        ), cursorMaxActive)
+      ];
+      const metadataPlan = explainMetadataLines(whereAnalysis);
+      plans.push({
+        index: i,
+        type: analysis.statements[i].statementType,
+        plan: statementPlan.length === 0 ? metadataPlan : [statementPlan[0], ...metadataPlan, ...statementPlan.slice(1)]
+      });
+      if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
+        variables.set(stmt.name, stmt.type === "SET_VARIABLE" && stmt.expr.type === "ARRAY" ? { type: "array", elements: stmt.expr.elements.map((element) => ({ type: "string", value: element.value })) } : { type: "string", value: `@${stmt.name}` });
+      }
     }
+    return { statementCount: statements.length, statements: plans };
+  } finally {
+    releaseMetadataCacheScope(invocationCacheContext);
   }
-  return { statementCount: statements.length, statements: plans };
 }
 function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS) {
   if (stmt.type === "CREATE_TEMP_TABLE") {
@@ -22847,6 +23232,11 @@ function collectArithRefFields(stmt) {
   return [...refs];
 }
 function collectArithNodeRefs(node, out) {
+  if (node.type === "VARIABLE") {
+    throw new Error(
+      `InternalError: unresolved arithmetic variable @${node.name} reached CHECK field collection.`
+    );
+  }
   if (node.type === "FIELD_REF") {
     out.add(node.field);
     return;
@@ -22942,6 +23332,11 @@ function formatArithExprStr(expr) {
   return `${formatArithNodeStr(expr.left)} ${expr.op} ${formatArithNodeStr(expr.right)}`;
 }
 function formatArithNodeStr(node) {
+  if (node.type === "VARIABLE") {
+    throw new Error(
+      `InternalError: unresolved arithmetic variable @${node.name} reached arithmetic formatting.`
+    );
+  }
   if (node.type === "FIELD_REF") return node.field;
   if (node.type === "NUMBER") return numberLiteralText(node);
   if (node.type === "ARITH") return `(${formatArithExprStr(node)})`;