@rex0220/kintone-sql-tools 3.63.0 → 3.64.0

package/dist-cli/ksql.js

@@ -24597,6 +24597,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 +24641,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 +25182,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 +25294,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 +25324,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 +25360,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 +25379,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 +25397,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 +25440,10 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
           subInfo,
           capabilities,
           orderPlans,
-          collector
+          plainGroupByPlans,
+          collector,
+          "main",
+          tempSchemaLedger
         ).map((l) => `  ${l}`)
       ];
     }
@@ -25304,7 +25472,10 @@ function buildBatchStatementPlan(stmt, info, capabilities, orderPlans, dmlMaxRow
       info,
       capabilities,
       orderPlans,
-      collector
+      plainGroupByPlans,
+      collector,
+      "main",
+      tempSchemaLedger
     );
   }
   if (stmt.type === "ASSERT") {
@@ -25323,15 +25494,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 +25535,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 +25545,7 @@ function buildPlanForBatchQuery(query, info, capabilities, orderPlans, collector
       100,
       DEFAULT_APPLY_MAX_SUBTABLE_ROWS,
       1e4,
-      void 0,
+      plainGroupByPlans,
       true,
       collector,
       sourceRole
@@ -25373,6 +25565,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 +25854,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 +25930,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 +26256,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 +26286,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 +29448,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 +30170,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;