@rex0220/kintone-sql-tools 3.46.0 → 3.47.0

package/dist-cli/ksql.js

@@ -11619,6 +11619,42 @@ var LOCAL_COLLECTION_TYPES = /* @__PURE__ */ new Set([
 function nativeWhereOperatorsForType(fieldType) {
   return NATIVE_OPERATORS.get(fieldType) ?? /* @__PURE__ */ new Set();
 }
+function normalizeChoiceEquality(where, resolveField2) {
+  const rewrites = [];
+  const visit = (node) => {
+    if (node.type === "BINARY") {
+      if ((node.op === "=" || node.op === "!=" || node.op === "<>") && node.left.type === "FIELD" && node.right.type === "STRING" && node.right.value !== "") {
+        const semantics = resolveField2(node.left);
+        if (semantics !== void 0 && semantics.compareMode === "option" && LOCAL_SCALAR_TYPES.has(semantics.fieldType) && nativeWhereOperatorsForType(semantics.fieldType).has("in") && semantics.optionOrder?.has(node.right.value) === true) {
+          const normalizedOperator = node.op === "=" ? "IN" : "NOT_IN";
+          rewrites.push({
+            field: node.left,
+            originalOperator: node.op,
+            normalizedOperator,
+            value: node.right.value
+          });
+          return {
+            ...node,
+            op: normalizedOperator,
+            right: { type: "IN_LIST", values: [node.right] }
+          };
+        }
+      }
+      return node;
+    }
+    if (node.type === "LOGICAL") {
+      const left = visit(node.left);
+      const right = visit(node.right);
+      return left === node.left && right === node.right ? node : { ...node, left, right };
+    }
+    if (node.type === "GROUP" || node.type === "NOT") {
+      const expr = visit(node.expr);
+      return expr === node.expr ? node : { ...node, expr };
+    }
+    return node;
+  };
+  return { normalizedWhere: visit(where), rewrites };
+}
 function classifyWhereCapability(where, resolveField2) {
   if (where === null) {
     return { capability: "EXACT_PUSHDOWN", reasons: [{ code: "WHERE_EXACT" }] };
@@ -16399,18 +16435,18 @@ async function assertRelativeDateExecutionPlan(stmt, client, cacheContext) {
 }
 async function resolveRelativeDateExecutionPlan(stmt, client, cacheContext) {
   return buildRelativeDatePushdownPlan(stmt, {
-    select: (select) => resolveSelectWhereCapability(select, client, cacheContext),
+    select: async (select) => {
+      const { resolver } = await normalizeSelectChoiceEquality(select, client, cacheContext);
+      return classifyWhereCapability(select.where, resolver);
+    },
     dml: (dml) => resolveDmlWhereCapability(dml, client, cacheContext),
     prefilterDecomposition: async (select) => {
       if (select.where === null) return null;
-      const resolver = await buildWhereFieldSemanticsResolver(
-        select,
-        client,
-        cacheContext
-      );
+      const { resolver } = await normalizeSelectChoiceEquality(select, client, cacheContext);
       return decomposeRelativeDatePrefilter(select, resolver);
     },
     joinServerFunctionPlan: async (select) => {
+      await normalizeSelectChoiceEquality(select, client, cacheContext);
       const metadata = await loadTypedPushdownMeta(select, client, cacheContext);
       const runtimePlan = buildRuntimeJoinPushdownPlan(select, metadata);
       if (runtimePlan === null) return null;
@@ -17480,7 +17516,10 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
     if (node === null || typeof node !== "object") return;
     const value = node;
     if (value["type"] === "SELECT") return;
-    if (value["type"] === "BINARY" && [">", "<", ">=", "<="].includes(String(value["op"]))) {
+    const operator = String(value["op"]);
+    const right = value["right"];
+    const needsOptionExistence = ["=", "!=", "<>"].includes(operator) && right?.["type"] === "STRING" && right["value"] !== "";
+    if (value["type"] === "BINARY" && ([">", "<", ">=", "<="].includes(operator) || needsOptionExistence)) {
       const left = value["left"];
       if (left?.["type"] === "FIELD" && typeof left["field"] === "string") {
         orderedFields.add(left["field"]);
@@ -17547,6 +17586,49 @@ async function buildWhereFieldSemanticsResolver(stmt, client, cacheContext, mate
     return matches.length > 1 ? syntheticSemantics("string") : void 0;
   };
 }
+var choiceEqualityRewritesBySelect = /* @__PURE__ */ new WeakMap();
+async function normalizeSelectChoiceEquality(stmt, client, cacheContext, materializedTables, forcePhysicalMetadata = false) {
+  const resolver = await buildWhereFieldSemanticsResolver(
+    stmt,
+    client,
+    cacheContext,
+    materializedTables,
+    forcePhysicalMetadata
+  );
+  if (stmt.where === null) return { resolver, rewrites: [] };
+  const normalization = normalizeChoiceEquality(stmt.where, resolver);
+  stmt.where = normalization.normalizedWhere;
+  if (normalization.rewrites.length > 0) {
+    choiceEqualityRewritesBySelect.set(stmt, normalization.rewrites);
+  }
+  return { resolver, rewrites: normalization.rewrites };
+}
+function hasDefaultRangeAggregateWindow(stmt) {
+  return stmt.columns.some(
+    (column) => column.type === "WINDOW_COL" && column.windowKind === "AGGREGATE" && column.orderBy.length > 0 && column.frame?.source === "DEFAULT"
+  );
+}
+function collectDefaultRangeWindowWarnings(stmt, resolveField2, context) {
+  const canProveSinglePhysicalInput = context === "DIRECT" && stmt.joins.length === 0 && stmt.from.cteName === null && stmt.from.subtableCode == null;
+  const warnings = [];
+  for (const column of stmt.columns) {
+    if (column.type !== "WINDOW_COL" || column.windowKind !== "AGGREGATE" || column.orderBy.length === 0 || column.frame?.source !== "DEFAULT") continue;
+    const hasTotalOrderKey = canProveSinglePhysicalInput && column.orderBy.some((item) => {
+      if (item.key.type !== "FIELD_NAME") return false;
+      const ref = aggregateFieldRef(item.key.name);
+      return ref.field === "$id" || resolveField2(ref)?.fieldType === "RECORD_NUMBER";
+    });
+    if (hasTotalOrderKey) continue;
+    warnings.push(
+      `${column.alias} \u306F\u65E2\u5B9A\u30D5\u30EC\u30FC\u30E0\uFF08RANGE\uFF09\u3067\u8A55\u4FA1\u3055\u308C\u307E\u3059\u3002ORDER BY \u306E\u5024\u304C\u540C\u3058\u884C\u306F\u3059\u3079\u3066\u540C\u3058\u5024\u306B\u306A\u308A\u307E\u3059\u3002\u884C\u3054\u3068\u306E\u5024\u304C\u5FC5\u8981\u306A\u3089 ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW \u3092\u660E\u793A\u3059\u308B\u304B\u3001ORDER BY \u306B\u30EC\u30B3\u30FC\u30C9\u756A\u53F7\u306A\u3069\u306E\u30BF\u30A4\u30D6\u30EC\u30FC\u30AF\u30AD\u30FC\u3092\u8DB3\u3057\u3066\u304F\u3060\u3055\u3044\u3002`
+    );
+  }
+  return warnings;
+}
+function mergeSelectWarnings(result, additional) {
+  if (additional.length === 0) return result;
+  return { ...result, warnings: [.../* @__PURE__ */ new Set([...result.warnings ?? [], ...additional])] };
+}
 function selectCaseConditionsNeedFieldMetadata(stmt) {
   const visit = (value) => {
     if (value === null || typeof value !== "object") return false;
@@ -17603,11 +17685,6 @@ function buildHavingFieldSemanticsResolver(stmt, rowResolver) {
   }
   return (field) => field.tableAlias === null && aliases.has(field.field) ? aliases.get(field.field) : rowResolver(field);
 }
-async function resolveSelectWhereCapability(stmt, client, cacheContext, materializedTables) {
-  if (stmt.where === null) return classifyWhereCapability(null, () => void 0);
-  const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, materializedTables);
-  return classifyWhereCapability(stmt.where, resolver);
-}
 function formatWhereCapabilityFailure(result) {
   const reason = result.reasons.find(
     (candidate) => candidate.code === "WHERE_FIELD_UNRESOLVED" || candidate.code === "WHERE_OPERATOR_UNSUPPORTED" || candidate.code === "WHERE_OPERATOR_INVALID_FOR_FIELD_TYPE"
@@ -17652,7 +17729,7 @@ async function assertDmlWhereCapability(stmt, client, cacheContext) {
     );
   }
 }
-async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false, forLibraryCapture = false) {
+async function executeSelect(stmt, client, options, cacheContext, cteCache, captureColumnMeta = false, forLibraryCapture = false, windowWarningContext = "DIRECT") {
   let result;
   await validateSelectGroupingPlanning(stmt, client, cacheContext, cteCache);
   if (isNoFromSelect(stmt)) {
@@ -17665,6 +17742,18 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     }
     return result;
   }
+  const { resolver: fieldSemanticsResolver } = await normalizeSelectChoiceEquality(
+    stmt,
+    client,
+    cacheContext,
+    cteCache,
+    hasDefaultRangeAggregateWindow(stmt)
+  );
+  const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
+    stmt,
+    fieldSemanticsResolver,
+    windowWarningContext
+  );
   const plainGroupByPlan = await buildRuntimePlainGroupByPlan(
     stmt,
     client,
@@ -17672,7 +17761,10 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     cteCache
   );
   await resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache);
-  const whereCapability = rememberSelectWhereCapability(stmt, await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache));
+  const whereCapability = rememberSelectWhereCapability(
+    stmt,
+    classifyWhereCapability(stmt.where, fieldSemanticsResolver)
+  );
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
@@ -17759,7 +17851,7 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       await inferSelectColumnMeta(stmt, result.columns, client, cacheContext, cteCache, forLibraryCapture)
     );
   }
-  return result;
+  return mergeSelectWarnings(result, defaultRangeWarnings);
 }
 async function buildRuntimePlainGroupByPlan(stmt, client, cacheContext, materializedTables) {
   if (stmt.groupBy.length === 0) return void 0;
@@ -19270,7 +19362,8 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
         cacheContext,
         void 0,
         captureColumnMeta,
-        forLibraryCapture
+        forLibraryCapture,
+        "DERIVED"
       ),
       executeSelect(
         markCountTotalCountRoot(stmt.right),
@@ -19279,7 +19372,8 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
         cacheContext,
         void 0,
         captureColumnMeta,
-        forLibraryCapture
+        forLibraryCapture,
+        "DERIVED"
       )
     ]);
     const leftCols = leftResult.columns;
@@ -19293,7 +19387,17 @@ async function executeUnion(stmt, client, options, cacheContext, captureColumnMe
     });
     const combined = [...leftResult.rows, ...remappedRight];
     const rows = stmt.all ? combined : deduplicateRows(combined, leftCols);
-    const result = { type: "SELECT", rows, columns: leftCols, rowCount: rows.length };
+    const warnings = [.../* @__PURE__ */ new Set([
+      ...leftResult.warnings ?? [],
+      ...rightResult.warnings ?? []
+    ])];
+    const result = {
+      type: "SELECT",
+      rows,
+      columns: leftCols,
+      rowCount: rows.length,
+      warnings
+    };
     if (captureColumnMeta) {
       materializedMetaBySelectResult.set(result, mergeUnionColumnMeta(leftResult, rightResult));
     }
@@ -19311,25 +19415,44 @@ function deduplicateRows(rows, columns) {
 }
 async function executeWith(stmt, client, options, cacheContext, seed, captureColumnMeta = false) {
   if ((seed == null || seed.size === 0) && canInlineSingleCte(stmt)) {
-    return executeSelect(buildInlinedQuery(stmt), client, options, cacheContext, void 0, captureColumnMeta, false);
+    return executeSelect(
+      buildInlinedQuery(stmt),
+      client,
+      options,
+      cacheContext,
+      void 0,
+      captureColumnMeta,
+      false,
+      "DERIVED"
+    );
   }
   const cteCache = new Map(seed ?? []);
+  const warnings = /* @__PURE__ */ new Set();
   for (const cte of stmt.ctes) {
-    let result;
+    let result2;
     if (cte.query.type === "SHOW_APPS") {
-      result = await executeShowApps(client);
+      result2 = await executeShowApps(client);
     } else if (cte.query.type === "DESCRIBE") {
-      result = await executeDescribe(cte.query, client, cacheContext);
+      result2 = await executeDescribe(cte.query, client, cacheContext);
     } else {
-      result = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext, true);
+      result2 = await executeQueryWithCte(cte.query, client, options, cteCache, cacheContext, true);
     }
+    for (const warning of result2.warnings ?? []) warnings.add(warning);
     cteCache.set(cte.name, {
-      rows: result.rows,
-      columns: result.columns,
-      columnMeta: materializedMetaBySelectResult.get(result)
+      rows: result2.rows,
+      columns: result2.columns,
+      columnMeta: materializedMetaBySelectResult.get(result2)
     });
   }
-  return executeQueryWithCte(stmt.query, client, options, cteCache, cacheContext, captureColumnMeta);
+  const result = await executeQueryWithCte(
+    stmt.query,
+    client,
+    options,
+    cteCache,
+    cacheContext,
+    captureColumnMeta
+  );
+  return mergeSelectWarnings(result, [...warnings]);
 }
 async function executeQueryWithCte(query, client, options, cteCache, cacheContext, captureColumnMeta = false, b86PreflightComplete = false) {
   if (!b86PreflightComplete) {
@@ -19351,7 +19474,17 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
     });
     const combined = [...leftResult.rows, ...remapped];
     const rows = query.all ? combined : deduplicateRows(combined, leftCols);
-    const result2 = { type: "SELECT", rows, columns: leftCols, rowCount: rows.length };
+    const warnings = [.../* @__PURE__ */ new Set([
+      ...leftResult.warnings ?? [],
+      ...rightResult.warnings ?? []
+    ])];
+    const result2 = {
+      type: "SELECT",
+      rows,
+      columns: leftCols,
+      rowCount: rows.length,
+      warnings
+    };
     if (captureColumnMeta) {
       materializedMetaBySelectResult.set(result2, mergeUnionColumnMeta(leftResult, rightResult));
     }
@@ -19359,7 +19492,16 @@ async function executeQueryWithCte(query, client, options, cteCache, cacheContex
   }
   const hasCteRef = query.from.cteName != null && query.from.cteName !== NO_FROM_CTE_NAME || query.joins.some((j) => j.table.cteName != null);
   if (!hasCteRef) {
-    return executeSelect(query, client, options, cacheContext, cteCache, captureColumnMeta, false);
+    return executeSelect(
+      query,
+      client,
+      options,
+      cacheContext,
+      cteCache,
+      captureColumnMeta,
+      false,
+      "DERIVED"
+    );
   }
   const result = await executeFullScanWithCte(query, client, options, cteCache, cacheContext);
   if (captureColumnMeta) {
@@ -19407,6 +19549,18 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
   for (const table of [stmt.from, ...stmt.joins.map((join2) => join2.table)]) {
     if (table.cteName !== null) requireMaterializedTable(table.cteName);
   }
+  const { resolver: choiceAndWindowResolver } = await normalizeSelectChoiceEquality(
+    stmt,
+    client,
+    cacheContext,
+    cteCache,
+    hasDefaultRangeAggregateWindow(stmt)
+  );
+  const defaultRangeWarnings = collectDefaultRangeWindowWarnings(
+    stmt,
+    choiceAndWindowResolver,
+    "DERIVED"
+  );
   const maxRecords = options.maxRecords ?? 1e4;
   const warnings = /* @__PURE__ */ new Set();
   const parallel = options.fetchParallel ?? 1;
@@ -19415,7 +19569,7 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     resolveSubqueries(stmt.having, client, options, cacheContext, cteCache),
     resolveSelectCaseSubqueries(stmt, client, options, cacheContext, cteCache)
   ]);
-  const whereCapability = await resolveSelectWhereCapability(stmt, client, cacheContext, cteCache);
+  const whereCapability = classifyWhereCapability(stmt.where, choiceAndWindowResolver);
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
@@ -19544,7 +19698,10 @@ async function executeFullScanWithCte(stmt, client, options, cteCache, cacheCont
     client,
     cacheContext
   );
-  return { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] };
+  return mergeSelectWarnings(
+    { type: "SELECT", rows, columns, rowCount: rows.length, warnings: [...warnings] },
+    defaultRangeWarnings
+  );
 }
 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) {
@@ -22958,6 +23115,7 @@ async function resolveScalarColumns(columns, client, options, cacheContext, cteC
   return cache;
 }
 var explainJoinPushdownPlans = /* @__PURE__ */ new WeakMap();
+var explainChoiceEqualityRewrites = /* @__PURE__ */ new WeakMap();
 var validateExplainInfo = /* @__PURE__ */ new WeakMap();
 var applyParentExplainPlan = /* @__PURE__ */ new WeakMap();
 async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords = 1e4, relativeDatePlan) {
@@ -23013,7 +23171,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
       if (needsWhereSchema || select.orderBy.length > 0 || select.columns.some((column) => column.type === "WINDOW_COL" && column.orderBy.length > 0)) {
         physicalApps.forEach((appId) => fieldApps.add(appId));
       }
-      const capability = await resolveSelectWhereCapability(select, tracedClient, cacheContext);
+      const { resolver, rewrites } = await normalizeSelectChoiceEquality(
+        select,
+        tracedClient,
+        cacheContext
+      );
+      if (rewrites.length > 0) explainChoiceEqualityRewrites.set(select, rewrites);
+      const capability = classifyWhereCapability(select.where, resolver);
       const relativeNode = relativeNodeFor(select);
       if (capability.capability === "UNSUPPORTED" && !relativeNode) {
         throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
@@ -23125,7 +23289,13 @@ async function buildExplainWhereAnalysis(query, client, cacheContext, maxRecords
   await visit(query);
   if (typeof query === "object" && query !== null && query.type === "WITH" && canInlineSingleCte(query)) {
     const inlined = buildInlinedQuery(query);
-    const capability = await resolveSelectWhereCapability(inlined, tracedClient, cacheContext);
+    const { resolver, rewrites } = await normalizeSelectChoiceEquality(
+      inlined,
+      tracedClient,
+      cacheContext
+    );
+    if (rewrites.length > 0) explainChoiceEqualityRewrites.set(inlined, rewrites);
+    const capability = classifyWhereCapability(inlined.where, resolver);
     const relativeNode = relativeNodeFor(inlined);
     if (capability.capability === "UNSUPPORTED" && !relativeNode) {
       throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(capability)}).`);
@@ -23897,6 +24067,13 @@ function buildValidatePlan(stmt, label) {
   lines.push("  records/mutation API during EXPLAIN: none; violation count unavailable");
   return lines;
 }
+function formatChoiceEqualityRewrite(rewrite) {
+  const field = rewrite.field.tableAlias ? `${rewrite.field.tableAlias}.${rewrite.field.field}` : rewrite.field.field;
+  const originalValue = rewrite.value.replace(/'/g, "''");
+  const normalizedValue = rewrite.value.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  const normalizedOperator = rewrite.normalizedOperator === "IN" ? "in" : "not in";
+  return `  pushdown normalized: ${field} ${rewrite.originalOperator} '${originalValue}' -> ${field} ${normalizedOperator} ("${normalizedValue}")`;
+}
 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);
@@ -23914,6 +24091,9 @@ function buildSelectPlan(stmt, label, capabilities, orderPlans, plainGroupByPlan
   );
   if (label) lines.push(label);
   lines.push(`  mode:          ${mode}`);
+  for (const rewrite of explainChoiceEqualityRewrites.get(stmt) ?? choiceEqualityRewritesBySelect.get(stmt) ?? []) {
+    lines.push(formatChoiceEqualityRewrite(rewrite));
+  }
   if (groupingMetadata) {
     lines.push(`  grouping source: ${groupingMetadata.source}`);
     lines.push(