@rex0220/kintone-sql-tools 3.30.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);
@@ -5482,6 +5502,11 @@ function collectRequiredFieldsByTable(stmt, plainGroupByPlan, sourceAware) {
     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;
@@ -7129,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));
@@ -8166,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);
@@ -8363,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(
@@ -12465,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 = {};
@@ -13348,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);
@@ -15287,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);
@@ -15296,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 {
@@ -15891,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") {
@@ -16262,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;
@@ -16275,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") {
@@ -16285,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"];
@@ -16440,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);
@@ -16956,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);
@@ -17098,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,
@@ -17106,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) {
@@ -18082,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,
@@ -18099,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) {
@@ -18341,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,
@@ -18360,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 ?? "" }])
@@ -18561,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);
 }
@@ -22232,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") {
@@ -23050,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;
@@ -23145,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)})`;