@rex0220/kintone-sql-tools 3.78.0 → 3.80.0

package/dist-cli/ksql.js

@@ -16622,7 +16622,8 @@ __export(index_exports, {
   runWithArgv: () => runWithArgv,
   shouldExitOnEmpty: () => shouldExitOnEmpty,
   toCliImportError: () => toCliImportError,
-  writeBatchOutput: () => writeBatchOutput
+  writeBatchOutput: () => writeBatchOutput,
+  writeSingleSelectWarnings: () => writeSingleSelectWarnings
 });
 module.exports = __toCommonJS(index_exports);
 var import_fs3 = require("fs");
@@ -31747,7 +31748,7 @@ function hasAggregateColumns(columns) {
     (c) => c.type === "AGGREGATE" || c.type === "ARITH_AGG_COL" || c.type === "ARITH_COL" && containsAggregate2(c.expr) || c.type === "CASE_COL" && containsAggregate2(c.expr) || c.type === "STRFUNC_COL" && hasAggregateInStringFuncExpr2(c.expr) || c.type === "SCALAR_VALUE_COL" && scalarValueHasAggregate2(c.expr)
   );
 }
-function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}) {
+function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolutionPlan, aliasEvaluationContext = {}, having = null) {
   if (resolutionPlan && resolutionPlan.items.length !== groupByKeys.length) {
     throw new Error("InternalError: plain GROUP BY resolution plan length does not match group keys.");
   }
@@ -31796,11 +31797,18 @@ function applyGroupBy(rows, groupByKeys, columns, resolveAggSortKind, resolution
       resolveAggSortKind,
       aliasEvaluationContext.evaluationContext
     );
+    materializeAggregateDependencies(
+      outRow,
+      groupRows,
+      having,
+      resolveAggSortKind,
+      aliasEvaluationContext.evaluationContext
+    );
     result.push(outRow);
   }
   return result;
 }
-function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}) {
+function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {}, having = null) {
   const result = [];
   let generatedRows = 0;
   const countBucket = () => {
@@ -31860,6 +31868,13 @@ function applyGroupingSets(rows, spec, columns, resolveAggSortKind, limits = {})
         resolveAggSortKind,
         limits.evaluationContext
       );
+      materializeAggregateDependencies(
+        outRow,
+        groupRows,
+        having,
+        resolveAggSortKind,
+        limits.evaluationContext
+      );
       attachGroupingRowMeta(outRow, includedCanonicalIds);
       result.push(outRow);
     }
@@ -33120,7 +33135,8 @@ function runFullScan(input) {
       resolvedGroupingSpec,
       stmt.columns,
       aggregateSortKindResolver,
-      { maxGeneratedRows: B65_MAX_GENERATED_ROWS, evaluationContext }
+      { maxGeneratedRows: B65_MAX_GENERATED_ROWS, evaluationContext },
+      stmt.having
     );
   } else if (grouping.type === "PLAIN" || hasAggregateColumns(stmt.columns)) {
     rows = applyGroupBy(
@@ -33134,7 +33150,8 @@ function runFullScan(input) {
         resolveFieldType: fieldTypeResolver,
         resolveFieldSemantics: fieldSemanticsResolver,
         evaluationContext
-      }
+      },
+      stmt.having
     );
   }
   warnOnUnresolvedAggregateComparisons(stmt.columns, rows, warnings);
@@ -35211,6 +35228,15 @@ function getSelectColumnMeta(result) {
 }
 var materializedMetaByValidationResult = /* @__PURE__ */ new WeakMap();
 var importSourceByDmlStatement = /* @__PURE__ */ new WeakMap();
+var sourceWarningsByDmlStatement = /* @__PURE__ */ new WeakMap();
+function rememberDmlSourceWarnings(statement, warnings) {
+  if (!warnings?.length) return;
+  sourceWarningsByDmlStatement.set(statement, [...new Set(warnings)]);
+}
+function outcomeWithResultWarnings(statement, result) {
+  const warnings = sourceWarningsByDmlStatement.get(statement);
+  return { result, ...warnings?.length ? { warnings } : {} };
+}
 var statementEvaluationContextKey = /* @__PURE__ */ Symbol("statementEvaluationContext");
 var importSourceMaterializedCallbackKey = /* @__PURE__ */ Symbol("importSourceMaterializedCallback");
 var nativeUpsertExecutionKey = /* @__PURE__ */ Symbol("nativeUpsertExecution");
@@ -36011,13 +36037,17 @@ async function executeBatch(sql, client, options = {}) {
       }
     }
     metrics.elapsedMs = Date.now() - startedAt;
+    const warnings = [.../* @__PURE__ */ new Set([
+      ...dialect1Warnings,
+      ...results.flatMap((statement) => statement.warnings ?? [])
+    ])];
     const batchResult = {
       ok: results.every((r) => r.status === "success" || r.skippedReason === "exit"),
       statementCount: statements.length,
       statements: results,
       analysis,
       metrics,
-      ...dialect1Warnings.length > 0 ? { warnings: dialect1Warnings } : {}
+      ...warnings.length > 0 ? { warnings } : {}
     };
     const observer = options[batchCompletionObserverKey];
     if (observer) {
@@ -36128,7 +36158,7 @@ async function executeBatchStatement(context) {
   }
   await assertRelativeDateExecutionPlan(resolvedStmt, client, cacheContext);
   if (resolvedStmt.type === "VALIDATE") {
-    const result = await executeExistingRecordValidationCore(
+    const result2 = await executeExistingRecordValidationCore(
       resolvedStmt,
       client,
       { ...options, onLimitReached: "error" },
@@ -36138,19 +36168,20 @@ async function executeBatchStatement(context) {
       appendValidationErrors(
         tempTables,
         resolvedStmt.errorTable,
-        result.columns,
-        result.rows,
+        result2.columns,
+        result2.rows,
         options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
-        materializedMetaBySelectResult.get(result) ?? existingValidationColumnMeta(resolvedStmt.summary === true)
+        materializedMetaBySelectResult.get(result2) ?? existingValidationColumnMeta(resolvedStmt.summary === true)
       );
     }
-    return { result };
+    return { result: result2 };
   }
   if (resolvedStmt.type === "IMPORT") {
-    return { result: await executeImport(resolvedStmt, client, options, cacheContext, tempTables) };
+    const result2 = await executeImport(resolvedStmt, client, options, cacheContext, tempTables);
+    return outcomeWithResultWarnings(resolvedStmt, result2);
   }
   if ("validateOnly" in resolvedStmt && resolvedStmt.validateOnly === true) {
-    const result = await executeDmlValidation(
+    const result2 = await executeDmlValidation(
       resolvedStmt,
       client,
       { ...options, onLimitReached: "error" },
@@ -36162,25 +36193,24 @@ async function executeBatchStatement(context) {
       appendValidationErrors(
         tempTables,
         resolvedStmt.validationErrorTable,
-        result.columns,
-        result.errors,
+        result2.columns,
+        result2.errors,
         options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
-        materializedMetaByValidationResult.get(result) ?? /* @__PURE__ */ new Map()
+        materializedMetaByValidationResult.get(result2) ?? /* @__PURE__ */ new Map()
       );
     }
-    return { result };
+    return outcomeWithResultWarnings(resolvedStmt, result2);
   }
   if ("onErrorSkip" in resolvedStmt && resolvedStmt.onErrorSkip === true) {
-    return {
-      result: await executeOnErrorSkip(
-        resolvedStmt,
-        client,
-        { ...options, onLimitReached: "error" },
-        cacheContext,
-        tempTables,
-        info.index + 1
-      )
-    };
+    const result2 = await executeOnErrorSkip(
+      resolvedStmt,
+      client,
+      { ...options, onLimitReached: "error" },
+      cacheContext,
+      tempTables,
+      info.index + 1
+    );
+    return outcomeWithResultWarnings(resolvedStmt, result2);
   }
   if (resolvedStmt.type === "CREATE_TEMP_TABLE") {
     const materializeOptions = {
@@ -36188,13 +36218,17 @@ async function executeBatchStatement(context) {
       maxRecords: options.tempTableMaxRows ?? TEMP_TABLE_MAX_ROWS,
       onLimitReached: "error"
     };
-    const result = await runSelectLike(resolvedStmt.query, client, materializeOptions, cacheContext, tempTables);
+    const result2 = await runSelectLike(resolvedStmt.query, client, materializeOptions, cacheContext, tempTables);
     tempTables.set(resolvedStmt.name, {
-      rows: result.rows,
-      columns: result.columns,
-      columnMeta: materializedMetaBySelectResult.get(result)
+      rows: result2.rows,
+      columns: result2.columns,
+      columnMeta: materializedMetaBySelectResult.get(result2)
     });
-    return { tempTable: resolvedStmt.name, rowCount: result.rows.length };
+    return {
+      tempTable: resolvedStmt.name,
+      rowCount: result2.rows.length,
+      ...result2.warnings?.length ? { warnings: [...result2.warnings] } : {}
+    };
   }
   if (stmt.type === "DROP_TEMP_TABLE") {
     tempTables.delete(stmt.name);
@@ -36210,12 +36244,12 @@ async function executeBatchStatement(context) {
     }
   }
   if (resolvedStmt.type === "ASSERT") {
-    const result = await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
-    return result.warning !== void 0 ? { result } : {};
+    const result2 = await executeAssert(resolvedStmt, client, options, cacheContext, tempTables);
+    return result2.warning !== void 0 ? { result: result2 } : {};
   }
   if (resolvedStmt.type === "EXIT") {
-    const result = await executeExit(resolvedStmt, client, options, cacheContext, tempTables);
-    return { result, ...result.exited ? { exitTriggered: true } : {} };
+    const result2 = await executeExit(resolvedStmt, client, options, cacheContext, tempTables);
+    return { result: result2, ...result2.exited ? { exitTriggered: true } : {} };
   }
   if (info.tempTablesReferenced.length > 0) {
     if (resolvedStmt.type === "SELECT" || resolvedStmt.type === "UNION") {
@@ -36234,17 +36268,20 @@ async function executeBatchStatement(context) {
       return { result: await executeWith(resolvedStmt, client, options, cacheContext, tempTables) };
     }
     if (resolvedStmt.type === "INSERT_SELECT") {
-      return { result: await executeInsertSelect(resolvedStmt, client, options, cacheContext, tempTables) };
+      const result2 = await executeInsertSelect(resolvedStmt, client, options, cacheContext, tempTables);
+      return outcomeWithResultWarnings(resolvedStmt, result2);
     }
     if (resolvedStmt.type === "UPSERT_SELECT") {
-      return { result: await executeUpsertSelect(resolvedStmt, client, options, cacheContext, tempTables) };
+      const result2 = await executeUpsertSelect(resolvedStmt, client, options, cacheContext, tempTables);
+      return outcomeWithResultWarnings(resolvedStmt, result2);
     }
     if (resolvedStmt.type === "UPDATE" && resolvedStmt.from?.cteName != null) {
       return { result: await executeUpdate(resolvedStmt, client, options, cacheContext, tempTables) };
     }
     throw new Error(`ArgumentError: temp table references in ${stmt.type} are not supported yet.`);
   }
-  return { result: await executeParsedStatement(resolvedStmt, client, options, cacheContext) };
+  const result = await executeParsedStatement(resolvedStmt, client, options, cacheContext);
+  return outcomeWithResultWarnings(resolvedStmt, result);
 }
 async function runSelectLike(query, client, options, cacheContext, tempTables) {
   if (query.type === "WITH") {
@@ -36757,7 +36794,8 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
       return fromPhysical(stmt.from, field.field, true);
     }
     const matches = tables.flatMap((table) => {
-      const semantics = table.cteName !== null ? resolveMaterializedColumnMeta(materializedTables?.get(table.cteName), field.field)?.semantics : fromPhysical(table, field.field, true);
+      const materialized = table.cteName !== null ? materializedTables?.get(table.cteName) : void 0;
+      const semantics = table.cteName !== null ? resolveMaterializedColumn(materialized, field.field) !== void 0 ? resolveMaterializedColumnMeta(materialized, field.field)?.semantics ?? syntheticSemantics("string") : void 0 : fromPhysical(table, field.field, true);
       return semantics ? [semantics] : [];
     });
     if (matches.length === 1) return matches[0];
@@ -37806,9 +37844,10 @@ function collectB86Subqueries(stmt) {
   }
   return queries;
 }
-async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext) {
+async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext, cachedPhysicalFieldsOnly = false) {
   const tables = [stmt.from, ...stmt.joins.map((join3) => join3.table)];
   const materializedByTable = /* @__PURE__ */ new Map();
+  const unavailableMaterializedTables = /* @__PURE__ */ new Set();
   const effectiveAliases = /* @__PURE__ */ new Set();
   for (const table of tables) {
     const alias = effectiveTableAlias(table);
@@ -37822,6 +37861,10 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
     if (table.cteName === null || table.cteName === NO_FROM_CTE_NAME) continue;
     const materialized = cteCache.get(table.cteName);
     if (!materialized) {
+      if (cachedPhysicalFieldsOnly) {
+        unavailableMaterializedTables.add(table);
+        continue;
+      }
       throw new Error(`ArgumentError: materialized source ${table.cteName} is not available.`);
     }
     if (materialized.rows.length > 0 && materialized.columns.length === 0) {
@@ -37838,6 +37881,16 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
   }
   const schemas = /* @__PURE__ */ new Map();
   await Promise.all(tables.map(async (table) => {
+    if (unavailableMaterializedTables.has(table)) {
+      schemas.set(table, {
+        table,
+        label: b86SourceLabel(table),
+        validCodes: /* @__PURE__ */ new Set(),
+        authoritative: false,
+        schemaUnavailable: true
+      });
+      return;
+    }
     const materialized = materializedByTable.get(table);
     if (materialized) {
       schemas.set(table, {
@@ -37850,12 +37903,12 @@ async function validateB86SelectFieldCodes(stmt, client, cteCache, cacheContext)
       return;
     }
     if (table.cteName === NO_FROM_CTE_NAME) return;
-    const defs = await getFieldsCached(table.appId, client, cacheContext);
+    const defs = cachedPhysicalFieldsOnly ? await getFieldsIfCached(table.appId, cacheContext) : await getFieldsCached(table.appId, client, cacheContext);
     schemas.set(table, {
       table,
       label: b86SourceLabel(table),
-      validCodes: new Set(defs.map((def) => def.code)),
-      authoritative: defs.length > 0,
+      validCodes: new Set((defs ?? []).map((def) => def.code)),
+      authoritative: defs !== null && defs.length > 0,
       schemaUnavailable: false
     });
   }));
@@ -41767,6 +41820,8 @@ async function executeImport(stmt, client, options, cacheContext, tempTables) {
   importSourceByDmlStatement.set(generated, executionSource);
   const withAudit = (result2) => {
     if (executionSource.audit) Object.assign(result2, { importAudit: executionSource.audit });
+    const warnings = sourceWarningsByDmlStatement.get(generated);
+    if (warnings?.length) sourceWarningsByDmlStatement.set(stmt, warnings);
     return result2;
   };
   if (generated.validateOnly) {
@@ -42056,6 +42111,7 @@ async function materializeDmlSource(stmt, client, options, cacheContext, tempTab
   const imported = importSourceByDmlStatement.get(stmt);
   if (!imported) {
     const selected2 = tempTables && tempTables.size > 0 ? await executeQueryWithCte(stmt.select, client, options, tempTables, cacheContext, true) : await executeSelect(stmt.select, client, options, cacheContext, void 0, true);
+    rememberDmlSourceWarnings(stmt, selected2.warnings);
     return { rows: selected2.rows, columns: selected2.columns, columnMeta: materializedMetaBySelectResult.get(selected2) };
   }
   const payload = await loadImportSource(imported.handle, imported.cache);
@@ -42071,6 +42127,7 @@ async function materializeDmlSource(stmt, client, options, cacheContext, tempTab
   const tables = new Map(tempTables ?? []);
   tables.set(IMPORT_PROJECTION_SOURCE, raw);
   const selected = await executeQueryWithCte(projection, client, { ...options, onLimitReached: "error" }, tables, cacheContext, true);
+  rememberDmlSourceWarnings(stmt, selected.warnings);
   return { rows: selected.rows, columns: selected.columns, columnMeta: materializedMetaBySelectResult.get(selected) };
 }
 var dmlSourceMaterializer = { materialize: materializeDmlSource };
@@ -43503,6 +43560,7 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   const capabilities = /* @__PURE__ */ new Map();
   const orderPlans = /* @__PURE__ */ new Map();
   const plainGroupByPlans = /* @__PURE__ */ new Map();
+  const explainSelectsForColumnCheck = [];
   const seen = /* @__PURE__ */ new Set();
   const sharedRelativeDatePlan = relativeDatePlan ?? await resolveRelativeDateExecutionPlan(query, tracedClient, cacheContext);
   const relativeNodeFor = (source) => sharedRelativeDatePlan.nodes.find(
@@ -43636,6 +43694,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     if (typed["type"] === "WITH") {
       const withStatement = node;
       for (const cte of withStatement.ctes) {
+        if (cte.recursiveSpec) {
+          const columns2 = recursiveOutputColumns(cte);
+          if (cte.recursiveSpec.cycle) columns2.push(cte.recursiveSpec.cycle.markColumn);
+          explainRelations.set(cte.name, { rows: [], columns: columns2 });
+          await preflightExplainRelations(cte.query);
+          continue;
+        }
         await preflightExplainRelations(cte.query);
         if (cte.query.type === "GENERATE_SERIES") {
           if (cte.query.args.some((arg) => arg.type === "VARIABLE")) {
@@ -43671,6 +43736,8 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
     if (typed["type"] === "SELECT") {
       const select = node;
       await bindProjectedNamesForSelectWithSchemas(select, explainRelations, tracedClient, cacheContext);
+      await validateB86SelectFieldCodes(select, tracedClient, explainRelations, cacheContext, true);
+      explainSelectsForColumnCheck.push(select);
       analyzeStaticSelectRows(select);
       for (const column of select.columns) {
         if (column.type === "SCALAR_SUBQUERY_COL") await preflightExplainRelations(column.query);
@@ -43734,7 +43801,8 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       const { resolver, rewrites } = await normalizeSelectChoiceEquality(
         select,
         tracedClient,
-        cacheContext
+        cacheContext,
+        explainRelations
       );
       if (rewrites.length > 0) explainChoiceEqualityRewrites.set(select, rewrites);
       const capability = classifyWhereCapability(select.where, resolver);
@@ -43932,6 +44000,9 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       }));
     }
   }
+  for (const select of explainSelectsForColumnCheck) {
+    await validateB86SelectFieldCodes(select, tracedClient, explainRelations, cacheContext, true);
+  }
   return {
     capabilities,
     orderPlans,
@@ -46704,6 +46775,7 @@ function buildBatchEnvelope(batch, options = {}) {
     if (s.status === "skipped" && s.skippedReason) entry.skippedReason = s.skippedReason;
     if (s.tempTable !== void 0) entry.tempTable = s.tempTable;
     if (s.rowCount !== void 0) entry.rowCount = s.rowCount;
+    if (s.warnings?.length) entry.warnings = s.warnings;
     if (s.status === "success" && s.result?.type === "SELECT") {
       totalRows += s.result.rowCount;
       if (maxTotalRecords !== void 0 && totalRows > maxTotalRecords) {
@@ -46760,8 +46832,9 @@ function buildBatchEnvelope(batch, options = {}) {
     statementCount: batch.statementCount,
     statements,
     results,
-    // バッチ全体の警告（仕様 §6.2）。文ごとの警告は results[].warnings に入る
-    warnings: []
+    // バッチ全体の警告（仕様 §6.2）＝dialect 1 の警告 + 結果セットを持たない文（CREATE TEMP TABLE・
+    // SELECT-based DML）の実行時警告（B188・文順・重複なし）。SELECT の文ごとの警告は従来どおり results[].warnings
+    warnings: batch.warnings ?? []
   };
 }
 
@@ -49323,12 +49396,23 @@ function buildBatchStatementSummary(s) {
     }
   }
   if (s.status === "skipped" && s.skippedReason) parts.push(`reason=${s.skippedReason}`);
+  const warnings = s.warnings ?? (s.result?.type === "SELECT" ? s.result.warnings : void 0);
+  if (s.status === "success" && warnings) {
+    for (const warning of warnings) parts.push(`warning=${warning}`);
+  }
   return parts.join(" ");
 }
 function buildSelectSummary(result) {
   const validateSummary = result.validateStats ? ` errorRecords=${result.validateStats.errorRecords} errorCount=${result.validateStats.errorCount}` : "";
   return `rowCount=${result.rowCount}${validateSummary}`;
 }
+function writeSingleSelectWarnings(result, format, quiet) {
+  if (quiet || format === "json") return;
+  for (const warning of result.warnings ?? []) {
+    process.stderr.write(`warning=${warning}
+`);
+  }
+}
 function buildBatchDmlConfirmMessage(analysis) {
   const lines = ["[DML Confirm] batch"];
   for (const s of analysis.statements) {
@@ -50792,6 +50876,7 @@ query=${label}`);
       process.stderr.write(`${buildSelectSummary(result)}
 `);
     }
+    writeSingleSelectWarnings(result, format, quiet);
     if (exportPlan) {
       const exportCode = runSingleSelectCliExport(exportPlan, result, quiet);
       if (exportCode !== 0) return exportCode;
@@ -50852,5 +50937,6 @@ if (isDirectCliRun()) {
   runWithArgv,
   shouldExitOnEmpty,
   toCliImportError,
-  writeBatchOutput
+  writeBatchOutput,
+  writeSingleSelectWarnings
 });