@rex0220/kintone-sql-tools 3.23.0 → 3.24.0

package/dist-cli/ksql.js

@@ -12604,6 +12604,133 @@ function requireExactRelativeDatePushdown(result) {
   };
 }
 
+// src/core/optimization/relativeDateFullScanExactPlan.ts
+function buildRelativeDateFullScanExactPlan(input) {
+  const {
+    select,
+    selectMode,
+    capability,
+    context,
+    serializedWholeWhere,
+    relativeFunctionNames
+  } = input;
+  if (select.where === null) return null;
+  if (select.from.appId <= 0 || select.from.cteName !== null) return null;
+  if (select.from.subtableCode) return null;
+  if (select.joins.length > 0) return null;
+  if (!context.allowFullScanExact) return null;
+  if (select.orderMode === "KINTONE_NATIVE") return null;
+  const hasCanonicalOrder2 = select.orderMode === "CANONICAL" && select.orderBy.length > 0;
+  if (selectMode !== "FULL_SCAN" && !hasCanonicalOrder2) return null;
+  if (capability.capability !== "EXACT_PUSHDOWN") return null;
+  const occurrences = relativeDateFunctionOccurrencesInWhere(select.where);
+  if (occurrences.length === 0) return null;
+  if (!sameOccurrenceList(occurrences, relativeFunctionNames)) return null;
+  if (serializedWholeWhere === null || !serializedMultisetContains(serializedWholeWhere, occurrences)) {
+    return null;
+  }
+  const prefilterPlan = {
+    prefilterWhere: select.where,
+    residualWhere: null,
+    exactRelativeLeaves: collectExactRelativeLeaves(select.where),
+    relativeFunctionNames: new Set(occurrences),
+    appliedKlikes: /* @__PURE__ */ new Set(),
+    capability: capability.capability,
+    reasons: capability.reasons
+  };
+  const plan = {
+    allowForm: "FULL_SCAN_EXACT",
+    clientWhereEvaluation: false,
+    serializedWholeWhere,
+    prefilterPlan
+  };
+  assertRelativeDateFullScanExactPlan(plan, input, occurrences);
+  return plan;
+}
+function assertRelativeDateFullScanExactPlan(plan, input, occurrences) {
+  if (plan.allowForm !== "FULL_SCAN_EXACT") {
+    throw new Error("FULL_SCAN_EXACT invariant: allowForm");
+  }
+  if (plan.clientWhereEvaluation !== false) {
+    throw new Error("FULL_SCAN_EXACT invariant: clientWhereEvaluation");
+  }
+  if (input.capability.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: capability");
+  }
+  if (input.select.where === null || plan.prefilterPlan.prefilterWhere !== input.select.where) {
+    throw new Error("FULL_SCAN_EXACT invariant: whole WHERE identity");
+  }
+  if (plan.prefilterPlan.residualWhere !== null) {
+    throw new Error("FULL_SCAN_EXACT invariant: residualWhere");
+  }
+  if (plan.prefilterPlan.capability !== "EXACT_PUSHDOWN") {
+    throw new Error("FULL_SCAN_EXACT invariant: transport capability");
+  }
+  if (!serializedMultisetContains(plan.serializedWholeWhere, occurrences)) {
+    throw new Error("FULL_SCAN_EXACT invariant: relative occurrence serialization");
+  }
+}
+function relativeDateFunctionOccurrencesInWhere(where) {
+  const names = [];
+  const visit = (node) => {
+    if (Array.isArray(node)) {
+      node.forEach(visit);
+      return;
+    }
+    if (node === null || typeof node !== "object") return;
+    const value = node;
+    if (value["type"] === "SELECT") return;
+    if (value["type"] === "KINTONE_FUNC" && typeof value["name"] === "string" && isRelativeDateFunctionName(value["name"])) {
+      names.push(value["name"]);
+      return;
+    }
+    Object.values(value).forEach(visit);
+  };
+  visit(where);
+  return names;
+}
+function collectExactRelativeLeaves(where) {
+  const leaves = [];
+  const visit = (node) => {
+    switch (node.type) {
+      case "BINARY":
+        if (node.right.type === "KINTONE_FUNC" && isRelativeDateFunctionName(node.right.name)) {
+          leaves.push(node);
+        }
+        return;
+      case "LOGICAL":
+        visit(node.left);
+        visit(node.right);
+        return;
+      case "NOT":
+      case "GROUP":
+        visit(node.expr);
+        return;
+      case "EXISTS":
+      case "NULL_CHECK":
+      case "BOOLEAN":
+        return;
+    }
+  };
+  visit(where);
+  return leaves;
+}
+function sameOccurrenceList(actual, expected) {
+  return actual.length === expected.length && actual.every((name, index) => name === expected[index]);
+}
+function serializedMultisetContains(query, expectedNames) {
+  const expected = /* @__PURE__ */ new Map();
+  for (const name of expectedNames) {
+    if (!isRelativeDateFunctionName(name)) return false;
+    expected.set(name, (expected.get(name) ?? 0) + 1);
+  }
+  for (const [name, count] of expected) {
+    const matches = query.match(new RegExp(`\\b${name}\\s*\\(`, "g"));
+    if ((matches?.length ?? 0) < count) return false;
+  }
+  return true;
+}
+
 // src/core/optimization/relativeDatePushdownGuard.ts
 function relativeDateFunctionNamesInNode(node, stopAtNestedSelect) {
   const names = [];
@@ -12649,7 +12776,7 @@ function nestedSelects(node, root) {
   visit(node);
   return found;
 }
-function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true) {
+function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = true, allowFullScanExact = true) {
   const functionNames = relativeDateFunctionNamesInWhere(select.where);
   if (functionNames.length > 0) {
     candidates.push({
@@ -12658,7 +12785,9 @@ function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = t
       where: select.where,
       functionNames,
       path,
-      allowPhase2Prefilter: allowPhase2
+      allowPhase2Prefilter: allowPhase2,
+      allowFullScanExact,
+      relativeFunctionOccurrences: relativeDateFunctionOccurrencesInWhere(select.where)
     });
   }
   nestedSelects(select, select).forEach(
@@ -12667,31 +12796,35 @@ function collectSelect(select, path, candidates, forceForbidden, allowPhase2 = t
       `${path}.select-source[${index}]`,
       candidates,
       forceForbidden,
-      allowPhase2
+      allowPhase2,
+      allowFullScanExact
     )
   );
 }
-function collectUnion(union, path, candidates, forceForbidden) {
-  if (union.left.type === "UNION") collectUnion(union.left, `${path}.left`, candidates, forceForbidden);
-  else collectSelect(union.left, `${path}.left`, candidates, forceForbidden);
-  collectSelect(union.right, `${path}.right`, candidates, forceForbidden);
+function collectUnion(union, path, candidates, forceForbidden, allowFullScanExact = true) {
+  if (union.left.type === "UNION") {
+    collectUnion(union.left, `${path}.left`, candidates, forceForbidden, allowFullScanExact);
+  } else {
+    collectSelect(union.left, `${path}.left`, candidates, forceForbidden, true, allowFullScanExact);
+  }
+  collectSelect(union.right, `${path}.right`, candidates, forceForbidden, true, allowFullScanExact);
 }
 function collectWith(statement, path, candidates, inheritedForbidden) {
   if (!inheritedForbidden && canInlineSingleCte(statement)) {
-    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false);
+    collectSelect(buildInlinedQuery(statement), `${path}.inlined`, candidates, false, true, false);
     return;
   }
   statement.ctes.forEach((cte, index) => {
     if (cte.query.type === "SELECT") {
-      collectSelect(cte.query, `${path}.cte[${index}]`, candidates, true);
+      collectSelect(cte.query, `${path}.cte[${index}]`, candidates, true, true, false);
     } else if (cte.query.type === "UNION") {
-      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true);
+      collectUnion(cte.query, `${path}.cte[${index}]`, candidates, true, false);
     }
   });
   if (statement.query.type === "SELECT") {
-    collectSelect(statement.query, `${path}.main`, candidates, true);
+    collectSelect(statement.query, `${path}.main`, candidates, true, true, false);
   } else {
-    collectUnion(statement.query, `${path}.main`, candidates, true);
+    collectUnion(statement.query, `${path}.main`, candidates, true, false);
   }
 }
 function collectStatement(statement, path, candidates, forceForbidden = false) {
@@ -12707,8 +12840,8 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
       return;
     case "CREATE_TEMP_TABLE":
       if (statement.query.type === "WITH") collectWith(statement.query, `${path}.query`, candidates, true);
-      else if (statement.query.type === "UNION") collectUnion(statement.query, `${path}.query`, candidates, true);
-      else collectSelect(statement.query, `${path}.query`, candidates, true);
+      else if (statement.query.type === "UNION") collectUnion(statement.query, `${path}.query`, candidates, true, false);
+      else collectSelect(statement.query, `${path}.query`, candidates, true, true, false);
       return;
     case "EXPLAIN":
       collectStatement(statement.query, `${path}.query`, candidates, forceForbidden);
@@ -12722,11 +12855,13 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           source: statement,
           where: statement.where,
           functionNames,
-          path
+          path,
+          allowFullScanExact: false,
+          relativeFunctionOccurrences: relativeDateFunctionOccurrencesInWhere(statement.where)
         });
       }
       nestedSelects(statement, statement).forEach(
-        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true)
+        (select, index) => collectSelect(select, `${path}.select-source[${index}]`, candidates, true, true, false)
       );
       return;
     }
@@ -12740,7 +12875,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           source: statement,
           where: statement.where,
           functionNames,
-          path
+          path,
+          allowFullScanExact: false,
+          relativeFunctionOccurrences: relativeDateFunctionOccurrencesInWhere(statement.where)
         });
       }
       if (statement.type === "UPDATE" && statement.applyBlocks?.length) {
@@ -12751,7 +12888,9 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
             source: statement,
             where: null,
             functionNames: applyFunctions,
-            path: `${path}.apply`
+            path: `${path}.apply`,
+            allowFullScanExact: false,
+            relativeFunctionOccurrences: []
           });
         }
       }
@@ -12761,6 +12900,7 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           `${path}.select-source[${index}]`,
           candidates,
           forceForbidden,
+          false,
           false
         )
       );
@@ -12773,6 +12913,7 @@ function collectStatement(statement, path, candidates, forceForbidden = false) {
           `${path}.select-source[${index}]`,
           candidates,
           forceForbidden,
+          false,
           false
         )
       );
@@ -12851,6 +12992,21 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
           allowed2 = true;
         }
       }
+      let fullScanExactPlan;
+      if (!allowed2 && capability2.capability === "EXACT_PUSHDOWN") {
+        fullScanExactPlan = buildRelativeDateFullScanExactPlan({
+          select,
+          selectMode,
+          capability: capability2,
+          context: { allowFullScanExact: candidate.allowFullScanExact },
+          serializedWholeWhere: restQuery2 || null,
+          relativeFunctionNames: candidate.relativeFunctionOccurrences
+        }) ?? void 0;
+        if (fullScanExactPlan) {
+          prefilterPlan = fullScanExactPlan.prefilterPlan;
+          allowed2 = true;
+        }
+      }
       const node2 = {
         kind: candidate.kind,
         source: candidate.source,
@@ -12860,6 +13016,7 @@ async function buildRelativeDatePushdownPlan(statement, resolver) {
         capability: capability2,
         restQuery: restQuery2,
         ...prefilterPlan ? { prefilterPlan, phase2PrefilterEligible } : {},
+        ...fullScanExactPlan ? { fullScanExactPlan, allowForm: fullScanExactPlan.allowForm } : {},
         clientWhereEvaluation: !allowed2,
         allowed: allowed2
       };
@@ -12991,7 +13148,7 @@ function decomposeRelativeDatePrefilter(stmt, resolveField2, testSeam = {}) {
     return reject(["PREFILTER_SERIALIZATION_FAILED"]);
   }
   const expectedNames = confirmedLeaves.map((leaf) => relativeNameOf(leaf));
-  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains(prefilterQuery, expectedNames)) {
+  if (!containsFunctions(prefilterQuery, [...new Set(expectedNames)]) || !serializedMultisetContains2(prefilterQuery, expectedNames)) {
     return reject(["PREFILTER_FUNCTION_MISSING"]);
   }
   const residualWhere = testSeam.rewriteResidual ? testSeam.rewriteResidual(stmt.where, adoptedLeaves) : replaceAdoptedLeaves(stmt.where, adoptedLeaves);
@@ -13213,7 +13370,7 @@ function collectFieldMetadata(where, resolveField2) {
   }
   return { fieldTypes, fieldOptions };
 }
-function serializedMultisetContains(query, expectedNames) {
+function serializedMultisetContains2(query, expectedNames) {
   const expected = /* @__PURE__ */ new Map();
   for (const name of expectedNames) {
     if (!RELATIVE_DATE_FUNCTION_NAMES.has(name)) return false;
@@ -15436,7 +15593,9 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
   if (whereCapability.capability === "UNSUPPORTED") {
     throw new Error(`ArgumentError: WHERE predicate is unsupported (${formatWhereCapabilityFailure(whereCapability)}).`);
   }
+  const staticMode = resolveSelectMode(stmt);
   let prefilterPlan;
+  let fullScanExactPlan;
   if (whereCapability.capability === "SUPERSET_PREFILTER") {
     const resolver = await buildWhereFieldSemanticsResolver(stmt, client, cacheContext, cteCache);
     const decomposition = decomposeRelativeDatePrefilter(stmt, resolver);
@@ -15444,7 +15603,23 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
       prefilterPlan = decomposition.plan;
     }
   }
-  const staticMode = resolveSelectMode(stmt);
+  if (prefilterPlan === void 0 && whereCapability.capability === "EXACT_PUSHDOWN" && stmt.where !== null) {
+    let serializedWholeWhere = null;
+    try {
+      serializedWholeWhere = whereToKintone(stmt.where);
+    } catch {
+      serializedWholeWhere = null;
+    }
+    fullScanExactPlan = buildRelativeDateFullScanExactPlan({
+      select: stmt,
+      selectMode: staticMode,
+      capability: whereCapability,
+      context: { allowFullScanExact: true },
+      serializedWholeWhere,
+      relativeFunctionNames: relativeDateFunctionOccurrencesInWhere(stmt.where)
+    }) ?? void 0;
+    if (fullScanExactPlan) prefilterPlan = fullScanExactPlan.prefilterPlan;
+  }
   const mode = whereCapability.capability === "EXACT_PUSHDOWN" ? staticMode : "FULL_SCAN";
   const orderMeta = await buildOrderByMetaForSelect(stmt, client, cacheContext, cteCache);
   const orderPlan = hasCanonicalOrder(stmt) ? (stmt.orderMode === "KINTONE_NATIVE" ? planKorder : planCanonicalOrder)({
@@ -15462,18 +15637,31 @@ async function executeSelect(stmt, client, options, cacheContext, cteCache, capt
     client,
     cacheContext
   );
-  const completePolicy = buildCompleteInputPolicy(stmt, options, orderPlan);
+  const completePolicy = buildCompleteInputPolicy(
+    stmt,
+    options,
+    orderPlan
+  );
+  const failClosedForB72Local = fullScanExactPlan !== void 0 && (staticMode === "FULL_SCAN" || orderPlan?.kind === "CANONICAL_LOCAL");
+  const executionClient = failClosedForB72Local ? wrapClientWithSearchAbort(client, { aborted: false }, true) : client;
   try {
     if (mode === "SIMPLE") {
-      result = await executeSimpleSelect(stmt, client, completePolicy.effectiveOptions, cacheContext, orderPlan, orderMeta);
+      result = await executeSimpleSelect(
+        stmt,
+        executionClient,
+        completePolicy.effectiveOptions,
+        cacheContext,
+        orderPlan,
+        orderMeta
+      );
     } else {
       result = await executeFullScanSelect(
         stmt,
-        client,
+        executionClient,
         completePolicy.effectiveOptions,
         cacheContext,
         cteCache,
-        whereCapability.capability === "EXACT_PUSHDOWN",
+        whereCapability.capability === "EXACT_PUSHDOWN" && prefilterPlan === void 0,
         orderMeta,
         prefilterPlan,
         plainGroupByPlan
@@ -20558,6 +20746,32 @@ function relativeDateExplainLines(plan) {
   }
   const lines = [];
   for (const node of plan.nodes) {
+    const fullScanExactPlan = node.fullScanExactPlan;
+    if (node.allowed && node.allowForm === "FULL_SCAN_EXACT" && fullScanExactPlan) {
+      for (const leaf of fullScanExactPlan.prefilterPlan.exactRelativeLeaves) {
+        const functionName = leaf.right.type === "KINTONE_FUNC" ? leaf.right.name : "(unknown)";
+        const field = leaf.left.type === "FIELD" ? leaf.left.field : void 0;
+        const operator = relativeReasonOperator(leaf.op);
+        const detail = node.capability?.reasons.find(
+          (reason) => reason.functionName === functionName && (field === void 0 || reason.field === field) && reason.operator === operator
+        );
+        lines.push(
+          `  relative date function: ${functionName}`,
+          "  relative date evaluation: kintone server whole-WHERE exact",
+          `  field: ${detail?.field ?? field ?? "(unknown)"} (${detail?.fieldType ?? "unknown"})`,
+          `  operator: ${detail?.operator ?? operator}`
+        );
+      }
+      const wholeWhereQuery = fullScanExactPlan.serializedWholeWhere;
+      lines.push(
+        "  where capability: EXACT_PUSHDOWN",
+        `  server predicate: ${wholeWhereQuery}`,
+        "  client residual: (none)",
+        "  relative date client evaluations: 0",
+        `  kintone query: ${wholeWhereQuery}`
+      );
+      continue;
+    }
     const prefilterPlan = node.prefilterPlan;
     if (node.allowed && prefilterPlan?.prefilterWhere && prefilterPlan.residualWhere) {
       for (const leaf of prefilterPlan.exactRelativeLeaves) {