@rex0220/kintone-sql-tools 3.63.0 → 3.65.0

package/dist-cli/ksql.js

@@ -10008,6 +10008,10 @@ function resolveField(field, row, resolveFieldType, resolveFieldSemantics2) {
   if (field.type === "ARITH_FIELD") return String(evalArithExpr(field.expr, row));
   if (field.type === "CASE_FIELD") return evalCaseWhen(field.expr, row, resolveFieldType, resolveFieldSemantics2);
   if (field.type === "GROUPING_FIELD") return evalGroupingRef(field.ref, row);
+  if (field.aggregateRef) {
+    const ref = field.aggregateRef;
+    return resolveFieldRef(row, aggregateSyntheticName(ref.func, ref.distinct, ref.arg));
+  }
   const key = field.tableAlias ? `${field.tableAlias}.${field.field}` : field.field;
   return resolveFieldRef(row, key);
 }
@@ -14129,6 +14133,7 @@ async function deriveEmptyWildcardColumns(fields, subtableCode, loadProcessStatu
 // src/engine/process.ts
 var materializedSelectValues = /* @__PURE__ */ new WeakMap();
 var sourceRows = /* @__PURE__ */ new WeakMap();
+var UNRESOLVED_AGGREGATE_COMPARISON_WARNING = "\u6BD4\u8F03\u6761\u4EF6\u3067\u53C2\u7167\u3057\u305F\u96C6\u8A08\u5024\u3092\u78BA\u8A8D\u3067\u304D\u307E\u305B\u3093\u3002SELECT \u30EA\u30B9\u30C8\u306B\u540C\u3058\u96C6\u8A08\u5F0F\u3092\u542B\u3081\u3066\u304F\u3060\u3055\u3044\u3002";
 function asProcessingRow(source) {
   if (sourceRows.has(source)) return source;
   let row;
@@ -14177,6 +14182,31 @@ function getMaterializedLookupValue(row, key) {
 function getLegacyMaterializedValue(row, key) {
   return materializedSelectValues.has(row) ? void 0 : row[key];
 }
+function warnOnUnresolvedAggregateComparisons(node, rows, warnings) {
+  if (!warnings || rows.length === 0) return;
+  const keys = /* @__PURE__ */ new Set();
+  const visit = (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(visit);
+      return;
+    }
+    const record = value;
+    if (record["type"] === "FIELD" && record["aggregateRef"] !== void 0) {
+      const ref = record["aggregateRef"];
+      keys.add(aggregateSyntheticName(ref.func, ref.distinct, ref.arg));
+      return;
+    }
+    if (record["type"] === "SELECT" || record["type"] === "SCALAR_SUBQUERY") return;
+    Object.values(record).forEach(visit);
+  };
+  visit(node);
+  if ([...keys].some((key) => rows.some(
+    (row) => getMaterializedLookupValue(row, key) === void 0 && row[key] === void 0
+  ))) {
+    warnings.add(UNRESOLVED_AGGREGATE_COMPARISON_WARNING);
+  }
+}
 function havingEvaluationRow(row) {
   const lookups = materializedSelectValues.get(row)?.byLookupKey;
   if (!lookups || lookups.size === 0) return row;
@@ -15481,7 +15511,8 @@ function runFullScan(input) {
     tableColumns,
     hiddenQualifiedAliases,
     resolvedGroupingSpec,
-    plainGroupByPlan
+    plainGroupByPlan,
+    warnings
   } = input;
   const effectiveOrderSemantics = deriveOutputOrderSemantics(stmt.columns, aggregateSortKindResolver);
   for (const [key, value] of orderSemantics ?? []) effectiveOrderSemantics.set(key, value);
@@ -15537,7 +15568,9 @@ function runFullScan(input) {
       }
     );
   }
+  warnOnUnresolvedAggregateComparisons(stmt.columns, rows, warnings);
   const resolveHavingSemantics = (field) => field.aggregateRef ? aggregateResultSemantics(field.aggregateRef, aggregateSortKindResolver) : havingFieldSemanticsResolver?.(field);
+  warnOnUnresolvedAggregateComparisons(stmt.having, rows, warnings);
   rows = applyHaving(rows, stmt.having, havingFieldTypeResolver, resolveHavingSemantics);
   rows = applyWindow(
     rows,
@@ -18838,6 +18871,7 @@ async function assertDmlWhereCapability(stmt, client, cacheContext) {
 }
 async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false, forLibraryCapture = false, windowWarningContext = "DIRECT") {
   let result;
+  const subqueryWarnings = /* @__PURE__ */ new Set();
   await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
   if (isNoFromSelect(stmt)) {
     result = executeNoFromSelect(stmt);
@@ -18867,7 +18901,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     cacheContext,
     cteCache
   );
-  await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
+  await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, subqueryWarnings, cteCache);
   const whereCapability = rememberSelectWhereCapability(
     stmt,
     classifyWhereCapability(stmt.where, fieldSemanticsResolver)
@@ -18958,7 +18992,11 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache, forLibraryCapture)
     );
   }
-  return mergeSelectWarnings(result, [...defaultRangeWarnings, ...subtableFieldWarnings]);
+  return mergeSelectWarnings(result, [
+    ...subqueryWarnings,
+    ...defaultRangeWarnings,
+    ...subtableFieldWarnings
+  ]);
 }
 function subtableGroupingAdvice(fieldName, owners) {
   if (owners.length === 1) {
@@ -20426,8 +20464,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
   await Promise.all([
-    resolveSubqueries(stmt.where, client, options, cacheContext, cteCache),
-    resolveSubqueries(stmt.having, client, options, cacheContext, cteCache)
+    resolveSubqueries(stmt.where, client, options, cacheContext, warnings, cteCache),
+    resolveSubqueries(stmt.having, client, options, cacheContext, warnings, cteCache)
   ]);
   const [pushdownMeta, typedInFieldTypes, aggregateSortKindResolver] = await Promise.all([
     loadTypedPushdownMeta(stmt, client, cacheContext),
@@ -20461,7 +20499,14 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
   const mainBoundQuery = boundServerFunctionPlan?.queriesByAlias.get(
     stmt.from.alias
   ) ?? "";
-  const scalarCache = await resolveScalarColumns(stmt.columns, client, options, cacheContext, cteCache);
+  const scalarCache = await resolveScalarColumns(
+    stmt.columns,
+    client,
+    options,
+    cacheContext,
+    warnings,
+    cteCache
+  );
   const constantFalse = isConstantFalseWhere(stmt.where);
   const mainFetch = constantFalse ? Promise.resolve([]) : fetchTableRecordsForFullScan(
     stmt,
@@ -20565,7 +20610,8 @@ async function executeFullScanSelect(stmt, client, options, cacheContext, cteCac
     appliedKlikes: prefilterPlan?.appliedKlikes ?? pushdownPlan.appliedKlikes,
     ...prefilterPlan ? { residualWhere: prefilterPlan.residualWhere } : boundServerFunctionPlan ? { residualWhere: boundServerFunctionPlan.joinPlan.residualWhere } : {},
     resolvedGroupingSpec: resolvedGroupingSpecs.get(stmt),
-    plainGroupByPlan
+    plainGroupByPlan,
+    warnings
   });
   const columns = await restoreEmptyWildcardColumns(
     stmt,
@@ -20832,9 +20878,9 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
   await Promise.all([
-    resolveSubqueries(stmt.where, client, options, cacheContext, cteCache),
-    resolveSubqueries(stmt.having, client, options, cacheContext, cteCache),
-    resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache)
+    resolveSubqueries(stmt.where, client, options, cacheContext, warnings, cteCache),
+    resolveSubqueries(stmt.having, client, options, cacheContext, warnings, cteCache),
+    resolveSelectCaseSubqueries(stmt, client, options, cacheContext, warnings, cteCache)
   ]);
   const whereCapability = classifyWhereCapability(stmt.where, choiceAndWindowResolver);
   if (whereCapability.capability === "UNSUPPORTED") {
@@ -20874,6 +20920,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     client,
     effectiveOptions,
     cacheContext,
+    warnings,
     cteCache
   );
   const orderByMetaPromise = Promise.resolve(orderMeta);
@@ -24337,17 +24384,17 @@ function parseSql(sql, enableImport = false) {
     throw e;
   }
 }
-async function resolveSubqueries(where, client, options, cacheContext, cteCache) {
+async function resolveSubqueries(where, client, options, cacheContext, warnings, cteCache) {
   const tasks = [];
-  collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCache);
+  collectSubqueryTasks(where, client, options, cacheContext, tasks, warnings, cteCache);
   await Promise.all(tasks);
 }
-async function resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache) {
+async function resolveSelectCaseSubqueries(stmt, client, options, cacheContext, warnings, cteCache) {
   const tasks = [];
   for (const column of stmt.columns) {
     if (column.type !== "CASE_COL") continue;
     for (const branch of column.expr.branches) {
-      tasks.push(resolveSubqueries(branch.condition, client, options, cacheContext, cteCache));
+      tasks.push(resolveSubqueries(branch.condition, client, options, cacheContext, warnings, cteCache));
     }
   }
   await Promise.all(tasks);
@@ -24358,19 +24405,21 @@ function runSubquery(query, client, options, cacheContext, cteCache) {
   }
   return executeSelect(query, client, options, cacheContext);
 }
-function collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCache) {
+function collectSubqueryTasks(where, client, options, cacheContext, tasks, warnings, cteCache) {
   if (where === null) return;
   switch (where.type) {
     case "BINARY": {
       const right = where.right;
       if (right.type === "SUBQUERY_IN_LIST") {
         tasks.push(runSubquery(right.query, client, options, cacheContext, cteCache).then((result) => {
+          for (const warning of result.warnings ?? []) warnings.add(warning);
           const col = right.column ?? (result.columns[0] ?? "");
           right.resolved = new Set(result.rows.map((r) => r[col] ?? ""));
         }));
       }
       if (right.type === "SCALAR_SUBQUERY") {
         tasks.push(runSubquery(right.query, client, options, cacheContext, cteCache).then((result) => {
+          for (const warning of result.warnings ?? []) warnings.add(warning);
           if (result.rowCount === 0) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u5024\u3092\u8FD4\u3057\u307E\u305B\u3093\u3067\u3057\u305F");
           if (result.rowCount > 1) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u8907\u6570\u884C\u3092\u8FD4\u3057\u307E\u3057\u305F\uFF081\u884C\u306E\u307F\u8A31\u53EF\uFF09");
           const col = result.columns[0] ?? "";
@@ -24380,16 +24429,17 @@ function collectSubqueryTasks(where, client, options, cacheContext, tasks, cteCa
       break;
     }
     case "LOGICAL":
-      collectSubqueryTasks(where.left, client, options, cacheContext, tasks, cteCache);
-      collectSubqueryTasks(where.right, client, options, cacheContext, tasks, cteCache);
+      collectSubqueryTasks(where.left, client, options, cacheContext, tasks, warnings, cteCache);
+      collectSubqueryTasks(where.right, client, options, cacheContext, tasks, warnings, cteCache);
       break;
     case "NOT":
     case "GROUP":
-      collectSubqueryTasks(where.expr, client, options, cacheContext, tasks, cteCache);
+      collectSubqueryTasks(where.expr, client, options, cacheContext, tasks, warnings, cteCache);
       break;
     case "EXISTS": {
       const node = where;
       tasks.push(runSubquery(node.query, client, options, cacheContext, cteCache).then((result) => {
+        for (const warning of result.warnings ?? []) warnings.add(warning);
         node.resolved = result.rowCount > 0;
       }));
       break;
@@ -24409,7 +24459,7 @@ async function resolveSetSubqueries(assignments, client, options, cacheContext)
     a.value = { type: "STRING", value: resolved };
   }
 }
-async function resolveScalarColumns(columns, client, options, cacheContext, cteCache) {
+async function resolveScalarColumns(columns, client, options, cacheContext, warnings, cteCache) {
   const byQuery = /* @__PURE__ */ new Map();
   const pending = [];
   for (let i = 0; i < columns.length; i++) {
@@ -24419,6 +24469,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
     let promise = byQuery.get(key);
     if (!promise) {
       promise = runSubquery(col.query, client, options, cacheContext, cteCache).then((result) => {
+        for (const warning of result.warnings ?? []) warnings.add(warning);
         if (result.rowCount === 0) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u5024\u3092\u8FD4\u3057\u307E\u305B\u3093\u3067\u3057\u305F");
         if (result.rowCount > 1) throw new Error("\u30B9\u30AB\u30E9\u30FC\u30B5\u30D6\u30AF\u30A8\u30EA\u304C\u8907\u6570\u884C\u3092\u8FD4\u3057\u307E\u3057\u305F\uFF081\u884C\u306E\u307F\u8A31\u53EF\uFF09");
         const firstCol = result.columns[0] ?? "";
@@ -24597,6 +24648,10 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       for (const cte of withStatement.ctes) {
         await preflightExplainRelations(cte.query);
         if (cte.query.type === "GENERATE_SERIES") {
+          if (cte.query.args.some((arg) => arg.type === "VARIABLE")) {
+            explainRelations.set(cte.name, { rows: [], columns: [cte.query.columnAlias] });
+            continue;
+          }
           const generated = executeGenerateSeries(cte.query);
           explainRelations.set(cte.name, {
             rows: generated.rows,
@@ -24637,13 +24692,19 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
         cacheContext,
         explainRelations
       );
-      const plainPlan = await buildRuntimePlainGroupByPlan(
-        select,
-        tracedClient,
-        cacheContext,
-        explainRelations
+      const sources = [select.from, ...select.joins.map((join2) => join2.table)];
+      const hasUnavailableMaterializedSource = sources.some(
+        (source) => source.cteName !== null && !explainRelations.has(source.cteName)
       );
-      if (plainPlan) plainGroupByPlans.set(select, plainPlan);
+      if (!hasUnavailableMaterializedSource) {
+        const plainPlan = await buildRuntimePlainGroupByPlan(
+          select,
+          tracedClient,
+          cacheContext,
+          explainRelations
+        );
+        if (plainPlan) plainGroupByPlans.set(select, plainPlan);
+      }
       return;
     }
     for (const child of Object.values(typed)) await preflightExplainRelations(child);
@@ -25172,6 +25233,106 @@ function serverFunctionClientEvaluationLabel(leaves) {
     (leaf) => leaf.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(leaf.right.name)
   ) ? "relative date client evaluations" : "kintone function client evaluations";
 }
+var explainSeriesBindings = /* @__PURE__ */ new WeakMap();
+function resolveExplainGenerateSeriesDefaults(node, literalDefaults) {
+  if (Array.isArray(node)) {
+    return node.map((value) => resolveExplainGenerateSeriesDefaults(value, literalDefaults));
+  }
+  if (node === null || typeof node !== "object") return node;
+  const object = node;
+  if (object["type"] === "GENERATE_SERIES") {
+    const variableNames = /* @__PURE__ */ new Map();
+    const defaultBoundIndexes = /* @__PURE__ */ new Set();
+    const args = object["args"].map((arg, index) => {
+      if (arg.type !== "STRING" || arg.fromVariable !== true || !arg.value.startsWith("@")) return arg;
+      const name = arg.value.slice(1);
+      variableNames.set(index, name);
+      const defaultValue = literalDefaults.get(name);
+      if (defaultValue === void 0) return { type: "VARIABLE", name };
+      defaultBoundIndexes.add(index);
+      return { type: "STRING", value: defaultValue, fromVariable: true };
+    });
+    const resolved = { ...object, args };
+    explainSeriesBindings.set(resolved, { variableNames, defaultBoundIndexes });
+    return resolved;
+  }
+  return Object.fromEntries(Object.entries(object).map(([key, value]) => [
+    key,
+    resolveExplainGenerateSeriesDefaults(value, literalDefaults)
+  ]));
+}
+function inferStaticExplainSchema(node, relations) {
+  if (node.type === "SHOW_APPS") return { status: "STATIC", columns: [...SHOW_APPS_COLUMNS] };
+  if (node.type === "DESCRIBE") return { status: "STATIC", columns: [...DESCRIBE_COLUMNS] };
+  if (node.type === "GENERATE_SERIES") {
+    return { status: "STATIC", columns: [node.columnAlias] };
+  }
+  if (node.type === "WITH") {
+    const local = new Map(relations);
+    for (const cte of node.ctes) {
+      const schema = inferStaticExplainSchema(cte.query, local);
+      local.set(cte.name, schema);
+    }
+    return inferStaticExplainSchema(node.query, local);
+  }
+  if (node.type === "UNION") {
+    const left = inferStaticExplainSchema(node.left, relations);
+    const right = inferStaticExplainSchema(node.right, relations);
+    return left.status === "STATIC" && right.status === "STATIC" ? { status: "STATIC", columns: left.columns } : { status: "DEFERRED" };
+  }
+  const sources = [node.from, ...node.joins.map((join2) => join2.table)];
+  const relationSources = sources.filter((source) => source.cteName !== null && source.cteName !== NO_FROM_CTE_NAME);
+  if (relationSources.some((source) => relations.get(source.cteName)?.status !== "STATIC")) {
+    return { status: "DEFERRED" };
+  }
+  const hasWildcard = node.columns.some(
+    (column) => column.type === "WILDCARD" || column.type === "PARENT_WILDCARD"
+  );
+  if (hasWildcard) {
+    if (sources.length !== 1 || sources[0].cteName === null) return { status: "DEFERRED" };
+  }
+  const sourceColumns2 = relationSources.flatMap((source) => {
+    const schema = relations.get(source.cteName);
+    return schema?.status === "STATIC" ? [...schema.columns] : [];
+  });
+  const columns = [];
+  for (const column of node.columns) {
+    if (column.type === "WILDCARD") columns.push(...sourceColumns2);
+    else if (column.type === "PARENT_WILDCARD") {
+      columns.push(...sourceColumns2.filter((name) => name.startsWith("_p.")));
+    } else {
+      columns.push(...project([], [column]).columns);
+    }
+  }
+  return { status: "STATIC", columns };
+}
+function staticSchemaRelations(ledger) {
+  return new Map([...ledger].flatMap(
+    ([name, entry]) => entry.status === "STATIC" ? [[name, entry.relation]] : []
+  ));
+}
+async function buildStaticTempPlainGroupByPlans(node, client, cacheContext, relations) {
+  const plans = /* @__PURE__ */ new Map();
+  const visit = async (value) => {
+    if (value === null || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      for (const child of value) await visit(child);
+      return;
+    }
+    const object = value;
+    if (object["type"] === "SELECT") {
+      const select = value;
+      const sources = [select.from, ...select.joins.map((join2) => join2.table)];
+      if (sources.some((source) => source.cteName !== null) && sources.every((source) => source.cteName === NO_FROM_CTE_NAME || source.cteName !== null && relations.has(source.cteName))) {
+        const plan = await buildRuntimePlainGroupByPlan(select, client, cacheContext, relations);
+        if (plan) plans.set(select, plan);
+      }
+    }
+    for (const child of Object.values(object)) await visit(child);
+  };
+  await visit(node);
+  return plans;
+}
 var EXPLAIN_FETCH_PLAN = /* @__PURE__ */ Symbol("ksql.explainFetchPlan");
 function setExplainFetchPlan(result, plan) {
   result[EXPLAIN_FETCH_PLAN] = plan;
@@ -25184,19 +25345,27 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     const normalizedInjectedVariables = validateDeclaredBatchVariables(statements, injectedVariables);
     const relativeDateVariables = prepareRelativeDateVariables(statements, normalizedInjectedVariables);
     const variables = /* @__PURE__ */ new Map();
+    const literalDeclareDefaults = /* @__PURE__ */ new Map();
+    const tempSchemaLedger = /* @__PURE__ */ new Map();
     const plans = [];
     const fetchStatements = [];
     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);
+      const placeholderResolvedStmt = stmt.type === "SET_VARIABLE" ? stmt.expr.type === "SCALAR_SUBQUERY" ? { ...stmt, expr: resolveBatchVariableReferences(stmt.expr, variables) } : stmt : resolveBatchVariableReferences(stmt, variables);
+      const planStmt = resolveExplainGenerateSeriesDefaults(
+        placeholderResolvedStmt,
+        literalDeclareDefaults
+      );
       validateStatementStatic(planStmt);
       const relativeDatePlan = await resolveRelativeDateExecutionPlan(planStmt, client, invocationCacheContext);
+      const initialRelations = staticSchemaRelations(tempSchemaLedger);
       const whereAnalysis = resolveMetadata ? await buildExplainWhereAnalysis(
         planStmt,
         client,
         invocationCacheContext,
         maxRecords,
-        relativeDatePlan
+        relativeDatePlan,
+        initialRelations
       ) : {
         capabilities: /* @__PURE__ */ new Map(),
         orderPlans: /* @__PURE__ */ new Map(),
@@ -25206,6 +25375,34 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
         numberPrecisionApps: /* @__PURE__ */ new Set(),
         relativeDatePlan
       };
+      if (!resolveMetadata) {
+        const staticPlans = await buildStaticTempPlainGroupByPlans(
+          planStmt,
+          client,
+          invocationCacheContext,
+          initialRelations
+        );
+        for (const [select, plan] of staticPlans) whereAnalysis.plainGroupByPlans.set(select, plan);
+      }
+      let createdSchema;
+      if (planStmt.type === "CREATE_TEMP_TABLE") {
+        const relationSchemas = new Map([...tempSchemaLedger].map(([name, entry]) => [
+          name,
+          entry.status === "STATIC" ? { status: "STATIC", columns: entry.columns } : { status: "DEFERRED" }
+        ]));
+        const inferred = inferStaticExplainSchema(planStmt.query, relationSchemas);
+        createdSchema = inferred.status === "STATIC" ? {
+          status: "STATIC",
+          columns: inferred.columns,
+          relation: { rows: [], columns: [...inferred.columns] },
+          producerStatement: i + 1
+        } : {
+          status: "DEFERRED",
+          producerStatement: i + 1,
+          reason: "EXPLAIN_TEMP_SCHEMA_UNAVAILABLE"
+        };
+        tempSchemaLedger.set(planStmt.name, createdSchema);
+      }
       const fetchCollector = { sources: [] };
       const statementPlan = relativeDatePlan.hasServerOnlyWhereFunction && !relativeDatePlan.allowed ? relativeDateExplainLines(relativeDatePlan) : [
         ...relativeDateExplainLines(relativeDatePlan),
@@ -25214,9 +25411,12 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
           analysis.statements[i],
           whereAnalysis.capabilities,
           whereAnalysis.orderPlans,
+          whereAnalysis.plainGroupByPlans,
           dmlMaxRows,
           dmlMaxSubtableRows,
-          fetchCollector
+          fetchCollector,
+          tempSchemaLedger,
+          createdSchema
         ), cursorMaxActive)
       ];
       const metadataPlan = explainMetadataLines(whereAnalysis);
@@ -25230,8 +25430,15 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
         fetch: worstExplainFetch(fetchCollector.sources),
         sources: fetchCollector.sources
       });
+      if (planStmt.type === "DROP_TEMP_TABLE") tempSchemaLedger.delete(planStmt.name);
       if (stmt.type === "SET_VARIABLE" || stmt.type === "DECLARE_VARIABLE") {
         variables.set(stmt.name, stmt.type === "DECLARE_VARIABLE" && stmt.annotation === "RELATIVE_DATE" ? { type: "relative-date", value: relativeDateVariables.get(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}`, placeholder: true });
+        if (stmt.type === "DECLARE_VARIABLE" && stmt.annotation === void 0 && (stmt.default.type === "STRING" || stmt.default.type === "NUMBER")) {
+          literalDeclareDefaults.set(
+            stmt.name,
+            stmt.default.type === "STRING" ? stmt.default.value : numberLiteralText(stmt.default)
+          );
+        }
       }
     }
     const result = { statementCount: statements.length, statements: plans };
@@ -25241,19 +25448,28 @@ async function buildBatchExplainPlans(sql, client, injectedVariables, cacheConte
     releaseMetadataCacheScope(invocationCacheContext);
   }
 }
-function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }) {
+function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, plainGroupByPlans, dmlMaxRows = 100, dmlMaxSubtableRows = DEFAULT_APPLY_MAX_SUBTABLE_ROWS, collector = { sources: [] }, tempSchemaLedger = /* @__PURE__ */ new Map(), createdSchema) {
   if (stmt.type === "CREATE_TEMP_TABLE") {
     return [
       `CREATE TEMP TABLE ${stmt.name}`,
       `  scope:         batch\uFF08\u30D0\u30C3\u30C1\u7D42\u4E86\u6642\u306B\u81EA\u52D5\u7834\u68C4\uFF09`,
+      ...createdSchema?.status === "STATIC" ? [
+        `  schema:        ${createdSchema.columns.join(", ")}`,
+        `  schema source: SELECT output of statement ${createdSchema.producerStatement}`
+      ] : createdSchema ? [
+        "  schema:        deferred (could not be derived statically)",
+        `  plan status:   deferred (temp table schema; reason=${createdSchema.reason})`
+      ] : [],
       `  rows:          \u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u4E0D\u660E\uFF08\u65E2\u5B9A\u4E0A\u9650 ${TEMP_TABLE_MAX_ROWS} \u884C\u3001tempTableMaxRows \u3067\u5909\u66F4\u53EF\u3001\u8D85\u904E\u306F\u30A8\u30E9\u30FC\uFF09`,
       ...buildPlanForBatchQuery(
         stmt.query,
         info,
         capabilities,
         orderPlans,
+        plainGroupByPlans,
         collector,
-        "main"
+        "main",
+        tempSchemaLedger
       ).map((l) => `  ${l}`)
     ];
   }
@@ -25275,7 +25491,10 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
           subInfo,
           capabilities,
           orderPlans,
-          collector
+          plainGroupByPlans,
+          collector,
+          "main",
+          tempSchemaLedger
         ).map((l) => `  ${l}`)
       ];
     }
@@ -25304,7 +25523,10 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
       info,
       capabilities,
       orderPlans,
-      collector
+      plainGroupByPlans,
+      collector,
+      "main",
+      tempSchemaLedger
     );
   }
   if (stmt.type === "ASSERT") {
@@ -25323,15 +25545,36 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
         subInfo,
         capabilities,
         orderPlans,
-        collector
+        plainGroupByPlans,
+        collector,
+        "main",
+        tempSchemaLedger
       ).map((l) => `  ${l}`));
     });
     return lines;
   }
   if (stmt.type === "UPDATE" && (stmt.applyBlocks?.length ?? 0) > 0) {
-    return buildExplainPlan(stmt, void 0, capabilities, orderPlans, dmlMaxRows, dmlMaxSubtableRows);
+    return buildExplainPlan(
+      stmt,
+      void 0,
+      capabilities,
+      orderPlans,
+      dmlMaxRows,
+      dmlMaxSubtableRows,
+      1e4,
+      plainGroupByPlans
+    );
   }
-  return buildPlanForBatchQuery(stmt, info, capabilities, orderPlans, collector);
+  return buildPlanForBatchQuery(
+    stmt,
+    info,
+    capabilities,
+    orderPlans,
+    plainGroupByPlans,
+    collector,
+    "main",
+    tempSchemaLedger
+  );
 }
 function hasTempTableRef(node) {
   if (Array.isArray(node)) return node.some(hasTempTableRef);
@@ -25343,7 +25586,7 @@ function hasTempTableRef(node) {
   }
   return false;
 }
-function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector = { sources: [] }, sourceRole = "main") {
+function buildPlanForBatchQuery(query, info, capabilities, orderPlans, plainGroupByPlans, collector = { sources: [] }, sourceRole = "main", tempSchemaLedger = /* @__PURE__ */ new Map()) {
   if (info.tempTablesReferenced.length === 0) {
     return buildExplainPlan(
       query,
@@ -25353,7 +25596,7 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector
       100,
       DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
       1e4,
-      void 0,
+      plainGroupByPlans,
       true,
       collector,
       sourceRole
@@ -25373,6 +25616,26 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector
   lines.push(
     `  temp:          ${info.tempTablesReferenced.join(", ")}\uFF08\u30A4\u30F3\u30E1\u30E2\u30EA\u8D70\u67FB\u3002\u5B9F\u4F53\u5316\u524D\u306E\u305F\u3081\u884C\u6570\u4E0D\u660E\uFF09`
   );
+  const entries = info.tempTablesReferenced.map((name) => [name, tempSchemaLedger.get(name)]);
+  for (const [name, entry] of entries) {
+    if (entry?.status === "STATIC") {
+      lines.push(`  source:        temp table ${name} (schema from statement ${entry.producerStatement})`);
+    } else {
+      lines.push(`  source:        temp table ${name}`);
+      lines.push("  schema:        deferred (could not be derived statically)");
+    }
+  }
+  lines.push("  rows:          runtime (not materialized by EXPLAIN)");
+  const directSelect = query.type === "SELECT" ? query : query.type === "EXPLAIN" && query.query.type === "SELECT" ? query.query : void 0;
+  if (directSelect) {
+    lines.push(...renderPlainGroupByExplainLines(
+      directSelect,
+      plainGroupByPlans?.get(directSelect),
+      entries.some(([, entry]) => entry?.status !== "STATIC")
+    ));
+  }
+  lines.push(entries.every(([, entry]) => entry?.status === "STATIC") ? "  plan status:   static schema / runtime rows" : "  plan status:   deferred (temp table schema)");
+  lines.push("  records API:   none");
   const apps = info.appIds.filter(
     (a) => query.type !== "INSERT_SELECT" && query.type !== "UPSERT_SELECT" || a !== query.appId
   );
@@ -25642,6 +25905,33 @@ function formatChoiceEqualityRewrite(rewrite) {
   const normalizedOperator = rewrite.normalizedOperator === "IN" ? "in" : "not in";
   return `  pushdown normalized: ${field} ${rewrite.originalOperator} '${originalValue}' -> ${field} ${normalizedOperator} ("${normalizedValue}")`;
 }
+function renderPlainGroupByExplainLines(stmt, plainGroupByPlan, schemaDeferred) {
+  const normalizedGrouping = normalizeGroupingSpec(stmt);
+  if (normalizedGrouping.type !== "PLAIN") return [];
+  const lines = [];
+  if (plainGroupByPlan) {
+    plainGroupByPlan.items.forEach((item, index) => {
+      const key = normalizedGrouping.allItems[index];
+      if (key?.type !== "FIELD_NAME") return;
+      if (item.kind === "PHYSICAL") {
+        lines.push(
+          `  group key ${key.name}: PHYSICAL (source=${item.sourceIndex}, field=${item.fieldCode})`
+        );
+      } else if (item.kind === "ALIAS_SAFE") {
+        lines.push(`  group key ${key.name}: ALIAS_SAFE (column=${item.columnIndex})`);
+      } else if (item.kind === "EXPRESSION") {
+        lines.push(`  group key ${key.name}: EXPRESSION`);
+      }
+    });
+  } else if (schemaDeferred) {
+    for (const key of normalizedGrouping.allItems) {
+      if (key.type === "FIELD_NAME") {
+        lines.push(`  group key ${key.name}: DEFERRED (temp table schema unavailable)`);
+      }
+    }
+  }
+  return lines;
+}
 function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlans, allowTotalCountPlan = true, emitFetch = true, collector = { sources: [] }, sourceRole = "main") {
   const whereCapability = capabilities?.get(stmt) ?? (capabilities ? [...capabilities].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
   const orderPlan = orderPlans?.get(stmt) ?? (orderPlans ? [...orderPlans].find(([candidate]) => JSON.stringify(candidate) === JSON.stringify(stmt))?.[1] : void 0);
@@ -25691,35 +25981,11 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
       `  grouping output rows: runtime checked (limit: ${groupingMetadata.outputRowLimit}, before HAVING/DISTINCT/LIMIT)`
     );
   }
-  const normalizedGrouping = normalizeGroupingSpec(stmt);
-  if (normalizedGrouping.type === "PLAIN") {
-    const groupBy = normalizedGrouping.allItems;
-    if (plainGroupByPlan) {
-      plainGroupByPlan.items.forEach((item, index) => {
-        const key = groupBy[index];
-        if (key?.type !== "FIELD_NAME") return;
-        if (item.kind === "PHYSICAL") {
-          lines.push(
-            `  group key ${key.name}: PHYSICAL (source=${item.sourceIndex}, field=${item.fieldCode})`
-          );
-        } else if (item.kind === "ALIAS_SAFE") {
-          lines.push(
-            `  group key ${key.name}: ALIAS_SAFE (column=${item.columnIndex})`
-          );
-        } else if (item.kind === "EXPRESSION") {
-          lines.push(`  group key ${key.name}: EXPRESSION`);
-        }
-      });
-    } else if ([stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)) {
-      for (const key of groupBy) {
-        if (key.type === "FIELD_NAME") {
-          lines.push(
-            `  group key ${key.name}: DEFERRED (materialized schema unavailable)`
-          );
-        }
-      }
-    }
-  }
+  lines.push(...renderPlainGroupByExplainLines(
+    stmt,
+    plainGroupByPlan,
+    [stmt.from, ...stmt.joins.map((join2) => join2.table)].some((table) => table.cteName !== null)
+  ));
   for (const column of stmt.columns) {
     if (column.type !== "WINDOW_COL" || column.windowKind === void 0 || column.windowKind === "RANKING") continue;
     const clauses = [];
@@ -26041,7 +26307,9 @@ function populateWithCrossJoinExplain(stmt) {
   };
   for (const cte of stmt.ctes) {
     if (cte.query.type === "GENERATE_SERIES") {
-      exactRows.set(cte.name, resolveGenerateSeries(cte.query).rowCount);
+      if (!cte.query.args.some((arg) => arg.type === "VARIABLE")) {
+        exactRows.set(cte.name, resolveGenerateSeries(cte.query).rowCount);
+      }
     } else if (cte.query.type === "SELECT") {
       const rows = analyze(cte.query);
       if (rows !== null) exactRows.set(cte.name, rows);
@@ -26069,18 +26337,45 @@ function buildWithPlan(stmt, capabilities, orderPlans, plainGroupByPlans, collec
       ));
       lines.push("");
     } else if (cte.query.type === "GENERATE_SERIES") {
-      const series = resolveGenerateSeries(cte.query);
+      const seriesStatement = cte.query;
+      const binding = explainSeriesBindings.get(seriesStatement);
+      const unresolved = seriesStatement.args.some((arg) => arg.type === "VARIABLE");
+      if (unresolved) {
+        const argumentLabel = (index) => {
+          const arg = seriesStatement.args[index];
+          if (!arg) return index === 2 ? "runtime" : "deferred";
+          if (arg.type === "VARIABLE") return `@${arg.name} (runtime)`;
+          if (index < 2) return "literal";
+          return arg.type === "NUMBER" ? numberLiteralText(arg) : arg.value;
+        };
+        lines.push(
+          `[cte: ${cte.name}]`,
+          "  source:        GENERATE_SERIES",
+          `  column:        ${seriesStatement.columnAlias}`,
+          "  series type:   deferred (variable)",
+          `  start:         ${argumentLabel(0)}`,
+          `  stop:          ${argumentLabel(1)}`,
+          `  step:          ${argumentLabel(2)}`,
+          "  rows:          runtime",
+          `  row guard:     runtime / ${GENERATE_SERIES_MAX_ROWS}`,
+          "  records API:   none",
+          ""
+        );
+        continue;
+      }
+      const series = resolveGenerateSeries(seriesStatement);
       const step = series.kind === "DATE" ? `${series.step} ${String(series.dateUnit ?? "DAY").toLowerCase()}${Math.abs(series.step) === 1 ? "" : "s"}` : String(series.step);
       lines.push(
         `[cte: ${cte.name}]`,
         "  source:        GENERATE_SERIES",
-        `  column:        ${cte.query.columnAlias}`,
-        `  series type:   ${series.kind}`,
-        `  start:         ${series.start}`,
-        `  stop:          ${series.stop}`,
+        `  column:        ${seriesStatement.columnAlias}`,
+        `  series type:   ${series.kind}${binding?.defaultBoundIndexes.size ? " (DECLARE default)" : ""}`,
+        `  start:         ${binding?.variableNames.has(0) ? `@${binding.variableNames.get(0)} (DECLARE default; value hidden)` : series.start}`,
+        `  stop:          ${binding?.variableNames.has(1) ? `@${binding.variableNames.get(1)} (DECLARE default; value hidden)` : series.stop}`,
         `  step:          ${step}`,
-        `  rows:          ${series.rowCount}`,
+        `  rows:          ${series.rowCount}${binding?.defaultBoundIndexes.size ? " (DECLARE default estimate)" : ""}`,
         `  row guard:     ${series.rowCount} / ${GENERATE_SERIES_MAX_ROWS}`,
+        ...binding?.defaultBoundIndexes.size ? ["  binding:       DECLARE defaults; runtime injection may change this plan"] : [],
         "  records API:   none",
         ""
       );
@@ -29204,6 +29499,9 @@ function createDryRunClient() {
 function hasStaticTypedPushdownCandidate(statement) {
   if (statement === null || typeof statement !== "object") return false;
   const node = statement;
+  if (node["type"] === "CREATE_TEMP_TABLE") {
+    return hasStaticTypedPushdownCandidate(node["query"]);
+  }
   if (node["type"] === "WITH") {
     const query = node["query"];
     const containsCross = (value) => {
@@ -29923,7 +30221,10 @@ async function run() {
         return false;
       });
       dryRunNeedsMetadata = statements.some(explainNeedsAppMetadata);
-      dryRunUsesStaticTypedPlan = statements.some(hasStaticTypedPushdownCandidate) && !statements.some(statementUsesRelativeDateResolution);
+      const staticEligible = statements.every(
+        (statement) => !explainNeedsAppMetadata(statement) || hasStaticTypedPushdownCandidate(statement)
+      );
+      dryRunUsesStaticTypedPlan = statements.some(hasStaticTypedPushdownCandidate) && staticEligible && !statements.some(statementUsesRelativeDateResolution);
       if (statements.length > 1) {
         batchAnalysis = analyzeBatch(statements);
         isBatchSql = true;