Reject unsupported query operators during execution planning

2026-09-20 23:58:07 -07:00
parent 47a3fe9eae
commit 08e322e59f
4 changed files with 132 additions and 0 deletions
@@ -0,0 +1,62 @@
+import type { CheckedQuery, QuerySelection } from "../query/types.js";
+import type { QueryPredicate, QueryPathStep } from "../query/relational.js";
+
+/** Supported by the fresh coordinator/replica interpreters. The language parser
+ * can describe more operators; that does not make them executable in this world. */
+export function unsupportedQueryOperator(query: CheckedQuery): string | undefined {
+  const path = (steps: QueryPathStep[]) =>
+    steps.some((step) => step.kind !== "relation") ? "expanded source/target paths" : undefined;
+  const predicate = (value: QueryPredicate): string | undefined => {
+    if (value.kind === "reduce") return "aggregate predicates";
+    if (value.kind === "and" || value.kind === "or") return value.children.map(predicate).find(Boolean);
+    if (value.kind === "not") return predicate(value.child);
+    if (value.kind === "compare")
+      return (
+        path(value.expression.path) ??
+        (value.expression.leaf.kind === "mapKey" ? "keyed relationship operands" : undefined)
+      );
+    if (value.kind === "relation") return path(value.path) ?? (value.predicate && predicate(value.predicate));
+    return undefined;
+  };
+  const conditional = (selections: readonly QuerySelection[]): boolean =>
+    selections.some((selection) => selection.conditions.length > 0 || conditional(selection.selection));
+  const walk = (selections: readonly QuerySelection[]): string | undefined => {
+    for (const selection of selections) {
+      const after = selection.arguments.after;
+      if (after && !(after.kind === "literal" && after.value === null)) return "cursor continuation";
+      if (selection.predicate) {
+        const reason = predicate(selection.predicate);
+        if (reason) return reason;
+      }
+      if (selection.relational) {
+        if (query.declaration.placement?.kind === "replica") return "aggregate selections in canonical-input scopes";
+        const { stages, terminals } = selection.relational;
+        if (stages.length !== 1 || stages[0]!.operation.kind !== "source")
+          return "relational expansion, filtering or distinct stages";
+        if (terminals.length !== 1) return "multiple aggregate terminals";
+        const terminal = terminals[0]!;
+        if (
+          terminal.kind !== "aggregate" ||
+          terminal.stage !== stages[0]!.id ||
+          terminal.keys.length ||
+          terminal.order.length ||
+          terminal.residual ||
+          terminal.where ||
+          terminal.having ||
+          terminal.first ||
+          terminal.all ||
+          terminal.after ||
+          terminal.reductions.some(
+            (reduction) => reduction.reduction.operator !== "count" || reduction.reduction.operand,
+          )
+        )
+          return "grouping or reductions other than a direct relationship count";
+        if (conditional(selection.selection)) return "conditional aggregate projections";
+      }
+      const reason = walk(selection.selection);
+      if (reason) return reason;
+    }
+    return undefined;
+  };
+  return walk(query.selection);
+}