@undefineds.co/xpod 0.3.18 → 0.3.22

package/dist/storage/rdf/RdfLocalQueryEngine.js

@@ -50,19 +50,46 @@ class RdfLocalQueryEngine {
         const joinBasicAggregatePushdown = this.joinBasicAggregatePushdown(query, requiredPatterns, requiredFilters, aggregates);
         let groupedAggregatePushed = false;
         if (countPushdown) {
-            const countEstimate = countPushdown.distinctKey
-                ? this.index.countDistinct(countPushdown.pattern, countPushdown.distinctKey)
-                : undefined;
-            const count = countEstimate?.rows ?? this.index.count(countPushdown.pattern);
+            const distinctKeys = countPushdown.distinctKeys ?? [];
+            const distinctKey = distinctKeys.length === 1 ? distinctKeys[0] : undefined;
+            const distinctTupleKeys = distinctKeys.length > 1 ? distinctKeys : undefined;
+            const useRdf3xPrimary = this.canUseRdf3xPrimaryScan(countPushdown.pattern) && !distinctTupleKeys;
+            let rdf3xCount;
+            if (useRdf3xPrimary) {
+                const rdf3xPattern = toRdf3xTriplePattern(countPushdown.pattern);
+                if (distinctKey) {
+                    rdf3xCount = this.rdf3xPrimaryIndex.countDistinct(rdf3xPattern, distinctKey);
+                }
+                else {
+                    const rdf3xCountScan = this.rdf3xPrimaryIndex.scan(rdf3xPattern, { limit: 0 });
+                    rdf3xCount = {
+                        count: rdf3xCountScan.metrics.matchedRows,
+                        metrics: rdf3xCountScan.metrics,
+                    };
+                }
+            }
+            const countEstimate = !useRdf3xPrimary && distinctTupleKeys
+                ? this.index.countDistinctTuple(countPushdown.pattern, distinctTupleKeys)
+                : !useRdf3xPrimary && distinctKey
+                    ? this.index.countDistinct(countPushdown.pattern, distinctKey)
+                    : undefined;
+            const count = rdf3xCount?.count ?? countEstimate?.rows ?? this.index.count(countPushdown.pattern);
             const result = countLiteral(count);
             metrics.scannedRows = count;
             metrics.joinedRows = count;
             metrics.returnedRows = 1;
             metrics.durationMs = Date.now() - start;
-            metrics.indexChoices.push('count');
+            metrics.indexChoices.push(useRdf3xPrimary ? rdf3xCount.metrics.indexChoice : 'count');
             metrics.filtersPushedDown += countPushdown.pushedDownFilters;
-            metrics.plan.push(`IndexCount(${describePattern(requiredPatterns[0])})`);
-            metrics.plan.push(countPushdown.distinctKey ? 'Aggregate(count-distinct-index)' : 'Aggregate(count-index)');
+            if (rdf3xCount) {
+                metrics.plan.push(...storagePlanMarkers(rdf3xCount.metrics.queryPlan));
+                metrics.plan.push(`${distinctKey ? 'Rdf3xPrimaryCountDistinct' : 'Rdf3xPrimaryCount'}(${describePattern(requiredPatterns[0])})`);
+                metrics.plan.push(distinctKey ? 'Aggregate(count-distinct-rdf3x-primary)' : 'Aggregate(count-rdf3x-primary)');
+            }
+            else {
+                metrics.plan.push(`IndexCount(${describePattern(requiredPatterns[0])})`);
+                metrics.plan.push(distinctTupleKeys ? 'Aggregate(count-distinct-tuple-index)' : distinctKey ? 'Aggregate(count-distinct-index)' : 'Aggregate(count-index)');
+            }
             return {
                 bindings: [{ [countPushdown.as]: result }],
                 count,
@@ -70,9 +97,14 @@ class RdfLocalQueryEngine {
             };
         }
         if (joinCountPushdown) {
-            const scan = this.index.countJoinPatterns(joinCountPushdown.patterns, {
-                aggregates,
-            });
+            const useRdf3xPrimary = this.canUseRdf3xPrimaryJoin(joinCountPushdown.patterns);
+            const scan = useRdf3xPrimary
+                ? this.rdf3xPrimaryIndex.countJoinPatterns(joinCountPushdown.patterns, {
+                    aggregates,
+                })
+                : this.index.countJoinPatterns(joinCountPushdown.patterns, {
+                    aggregates,
+                });
             const firstAggregate = aggregates[0];
             const firstCount = firstAggregate ? Number(scan.bindings[0]?.[firstAggregate.as]?.value ?? 0) : 0;
             metrics.scannedRows = scan.metrics.matchedRows;
@@ -81,11 +113,11 @@ class RdfLocalQueryEngine {
             metrics.durationMs = Date.now() - start;
             metrics.indexChoices.push(scan.metrics.indexChoice);
             metrics.filtersPushedDown += joinCountPushdown.pushedDownFilters;
-            if (joinCountPushdown.reorderPlan) {
+            if (!useRdf3xPrimary && joinCountPushdown.reorderPlan) {
                 metrics.plan.push(joinCountPushdown.reorderPlan);
             }
             metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
-            metrics.plan.push(`IndexJoinCount(${joinCountPushdown.patterns.map((source) => describePatternSource(source)).join('|')})`);
+            metrics.plan.push(`${useRdf3xPrimary ? 'Rdf3xPrimaryJoinCount' : 'IndexJoinCount'}(${joinCountPushdown.patterns.map((source) => describePatternSource(source)).join('|')})`);
             metrics.plan.push(aggregatePlan(aggregates, false));
             metrics.plan.push(aggregates.some((aggregate) => aggregate.distinct)
                 ? 'Aggregate(join-count-distinct-index)'
@@ -97,20 +129,25 @@ class RdfLocalQueryEngine {
             };
         }
         if (joinBasicAggregatePushdown) {
-            const scan = this.index.aggregateJoinPatterns(joinBasicAggregatePushdown.patterns, {
-                aggregates,
-            });
+            const useRdf3xPrimary = this.canUseRdf3xPrimaryJoin(joinBasicAggregatePushdown.patterns);
+            const scan = useRdf3xPrimary
+                ? this.rdf3xPrimaryIndex.aggregateJoinPatterns(joinBasicAggregatePushdown.patterns, {
+                    aggregates,
+                })
+                : this.index.aggregateJoinPatterns(joinBasicAggregatePushdown.patterns, {
+                    aggregates,
+                });
             metrics.scannedRows = scan.metrics.matchedRows;
             metrics.joinedRows = scan.metrics.matchedRows;
             metrics.returnedRows = scan.bindings.length;
             metrics.durationMs = Date.now() - start;
             metrics.indexChoices.push(scan.metrics.indexChoice);
             metrics.filtersPushedDown += joinBasicAggregatePushdown.pushedDownFilters;
-            if (joinBasicAggregatePushdown.reorderPlan) {
+            if (!useRdf3xPrimary && joinBasicAggregatePushdown.reorderPlan) {
                 metrics.plan.push(joinBasicAggregatePushdown.reorderPlan);
             }
             metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
-            metrics.plan.push(`IndexJoinAggregate(${joinBasicAggregatePushdown.patterns.map((source) => describePatternSource(source)).join('|')})`);
+            metrics.plan.push(`${useRdf3xPrimary ? 'Rdf3xPrimaryJoinAggregate' : 'IndexJoinAggregate'}(${joinBasicAggregatePushdown.patterns.map((source) => describePatternSource(source)).join('|')})`);
             metrics.plan.push(aggregatePlan(aggregates, false));
             metrics.plan.push(aggregates.length > 1
                 ? 'Aggregate(join-basic-multi-index)'
@@ -123,31 +160,35 @@ class RdfLocalQueryEngine {
         const remainingSources = buildRequiredSources(requiredPatterns, query);
         const requiredBgpPushdown = this.requiredBgpPushdown(query, requiredPatterns, requiredFilters);
         if (groupAggregatePushdown) {
+            const rdf3xGroupAggregatePatterns = groupAggregatePushdown.countOnly
+                ? groupAggregatePushdown.patterns
+                : stripRdf3xNumericAggregateGuards(groupAggregatePushdown.patterns, aggregates);
+            const useRdf3xPrimary = this.canUseRdf3xPrimaryJoin(rdf3xGroupAggregatePatterns);
+            const groupOptions = {
+                groupBy: query.groupBy ?? [],
+                aggregates,
+                ...(groupAggregatePushdown.having ? { having: groupAggregatePushdown.having } : {}),
+                ...(groupAggregatePushdown.orderPushed ? { orderBy: query.orderBy } : {}),
+                ...(groupAggregatePushdown.paginationPushed && query.limit !== undefined ? { limit: Math.max(0, query.limit) } : {}),
+                ...(groupAggregatePushdown.paginationPushed && query.offset !== undefined ? { offset: Math.max(0, query.offset) } : {}),
+            };
             const scan = groupAggregatePushdown.countOnly
-                ? this.index.groupCountJoinPatterns(groupAggregatePushdown.patterns, {
-                    groupBy: query.groupBy ?? [],
-                    aggregates,
-                    ...(groupAggregatePushdown.having ? { having: groupAggregatePushdown.having } : {}),
-                    ...(groupAggregatePushdown.orderPushed ? { orderBy: query.orderBy } : {}),
-                    ...(groupAggregatePushdown.paginationPushed && query.limit !== undefined ? { limit: Math.max(0, query.limit) } : {}),
-                    ...(groupAggregatePushdown.paginationPushed && query.offset !== undefined ? { offset: Math.max(0, query.offset) } : {}),
-                })
-                : this.index.groupAggregateJoinPatterns(groupAggregatePushdown.patterns, {
-                    groupBy: query.groupBy ?? [],
-                    aggregates,
-                    ...(groupAggregatePushdown.having ? { having: groupAggregatePushdown.having } : {}),
-                    ...(groupAggregatePushdown.orderPushed ? { orderBy: query.orderBy } : {}),
-                    ...(groupAggregatePushdown.paginationPushed && query.limit !== undefined ? { limit: Math.max(0, query.limit) } : {}),
-                    ...(groupAggregatePushdown.paginationPushed && query.offset !== undefined ? { offset: Math.max(0, query.offset) } : {}),
-                });
-            const groupPlanPrefix = groupAggregatePushdown.countOnly ? 'IndexGroupCount' : 'IndexGroupAggregate';
+                ? useRdf3xPrimary
+                    ? this.rdf3xPrimaryIndex.groupCountJoinPatterns(rdf3xGroupAggregatePatterns, groupOptions)
+                    : this.index.groupCountJoinPatterns(groupAggregatePushdown.patterns, groupOptions)
+                : useRdf3xPrimary
+                    ? this.rdf3xPrimaryIndex.groupAggregateJoinPatterns(rdf3xGroupAggregatePatterns, groupOptions)
+                    : this.index.groupAggregateJoinPatterns(groupAggregatePushdown.patterns, groupOptions);
+            const groupPlanPrefix = useRdf3xPrimary
+                ? groupAggregatePushdown.countOnly ? 'Rdf3xPrimaryGroupCount' : 'Rdf3xPrimaryGroupAggregate'
+                : groupAggregatePushdown.countOnly ? 'IndexGroupCount' : 'IndexGroupAggregate';
             bindings = scan.bindings;
             metrics.scannedRows += scan.metrics.matchedRows;
             metrics.joinedRows = scan.metrics.matchedRows;
             metrics.indexChoices.push(scan.metrics.indexChoice);
             metrics.filtersPushedDown += groupAggregatePushdown.pushedDownFilters;
             metrics.filtersPushedDown += groupAggregatePushdown.pushedDownHaving;
-            if (groupAggregatePushdown.reorderPlan) {
+            if (!useRdf3xPrimary && groupAggregatePushdown.reorderPlan) {
                 metrics.plan.push(groupAggregatePushdown.reorderPlan);
             }
             metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
@@ -175,6 +216,7 @@ class RdfLocalQueryEngine {
             const scanOptions = {
                 ...(requiredBgpPushdown.project ? { project: requiredBgpPushdown.project } : {}),
                 ...(requiredBgpPushdown.distinctPushed ? { distinct: true } : {}),
+                ...(requiredBgpPushdown.values ? { values: requiredBgpPushdown.values } : {}),
                 ...(requiredBgpPushdown.orderPushed ? { orderBy: query.orderBy } : {}),
                 ...(requiredBgpPushdown.paginationPushed && query.limit !== undefined ? { limit: Math.max(0, query.limit) } : {}),
                 ...(requiredBgpPushdown.paginationPushed && query.offset !== undefined ? { offset: Math.max(0, query.offset) } : {}),
@@ -343,14 +385,17 @@ class RdfLocalQueryEngine {
             const sourceVariables = variablesInRequiredSource(source);
             const connected = sourceVariables.length === 0
                 || sourceVariables.some((variableName) => boundVariables.has(variableName));
+            const estimate = this.estimateSource(source, bindings, filters, metrics);
             return {
                 index,
                 disconnectedPenalty: hasBoundVariables && !connected ? 1 : 0,
-                estimatedRows: this.estimateSourceRows(source, bindings, filters, metrics),
+                estimatedRows: estimate.rows,
+                estimatedCostRows: estimate.costRows,
                 rank: this.sourceRank(source, sampleBinding),
             };
         });
         choices.sort((left, right) => (left.disconnectedPenalty - right.disconnectedPenalty
+            || left.estimatedCostRows - right.estimatedCostRows
             || left.estimatedRows - right.estimatedRows
             || left.rank - right.rank
             || left.index - right.index));
@@ -424,33 +469,33 @@ class RdfLocalQueryEngine {
         })
             .map((slot) => ({ key: slot.key, variable: slot.value.variable }));
     }
-    estimateSourceRows(source, bindings, filters, metrics) {
+    estimateSource(source, bindings, filters, metrics) {
         if (source.kind === 'pattern') {
-            if (source.tupleValues) {
-                return this.estimateTuplePatternRows(source, bindings, filters, metrics);
-            }
-            return this.estimatePatternRows(source.pattern, bindings, filters, metrics);
+            const rows = source.tupleValues
+                ? this.estimateTuplePatternRows(source, bindings, filters, metrics)
+                : this.estimatePatternRows(source.pattern, bindings, filters, metrics);
+            return { rows, costRows: rows };
         }
         if (source.kind === 'values') {
-            return source.source.rows.length * Math.max(1, bindings.length);
+            const rows = source.source.rows.length * Math.max(1, bindings.length);
+            return { rows, costRows: rows };
         }
         const sample = (bindings.length > 0 ? bindings : [{}]).slice(0, PLANNER_SAMPLE_BINDINGS);
         if (!this.searchSourceHasBoundVariables(source, sample)) {
-            metrics.searchCardinalityEstimates = (metrics.searchCardinalityEstimates ?? 0) + 1;
-            const estimate = source.kind === 'text'
-                ? this.estimateTextSearchRows(source)
-                : this.estimateVectorSearchRows(source);
-            return estimate * Math.max(1, bindings.length);
+            return this.estimateUnboundSearchSource(source, bindings, metrics);
         }
         const sourceVariable = source.pattern.source;
         const boundSourceEstimate = sourceVariable && this.canUseBoundSourceSearch(sample, source, sourceVariable)
             ? this.estimateSearchRowsByBoundSource(source, sample, metrics)
             : undefined;
         if (boundSourceEstimate !== undefined) {
-            if (bindings.length > sample.length && sample.length > 0) {
-                return Math.ceil(boundSourceEstimate * (bindings.length / sample.length));
-            }
-            return boundSourceEstimate;
+            const rows = bindings.length > sample.length && sample.length > 0
+                ? Math.ceil(boundSourceEstimate * (bindings.length / sample.length))
+                : boundSourceEstimate;
+            return { rows, costRows: rows };
+        }
+        if (hasSearchWindow(source)) {
+            return this.estimateUnboundSearchSource(source, bindings, metrics);
         }
         const results = source.kind === 'text'
             ? this.textSearchResults(source)
@@ -467,9 +512,30 @@ class RdfLocalQueryEngine {
             }
         }
         if (bindings.length > sample.length && sample.length > 0) {
-            return Math.ceil(rows * (bindings.length / sample.length));
-        }
-        return rows;
+            const estimatedRows = Math.ceil(rows * (bindings.length / sample.length));
+            return { rows: estimatedRows, costRows: estimatedRows };
+        }
+        return { rows, costRows: rows };
+    }
+    estimateUnboundSearchSource(source, bindings, metrics) {
+        metrics.searchCardinalityEstimates = (metrics.searchCardinalityEstimates ?? 0) + 1;
+        const rows = source.kind === 'text'
+            ? this.estimateTextSearchRows(source)
+            : this.estimateVectorSearchRows(source);
+        const bindingCount = Math.max(1, bindings.length);
+        if (!hasSearchWindow(source)) {
+            const estimatedRows = rows * bindingCount;
+            return { rows: estimatedRows, costRows: estimatedRows };
+        }
+        metrics.searchCardinalityEstimates = (metrics.searchCardinalityEstimates ?? 0) + 1;
+        const candidateRows = source.kind === 'text'
+            ? this.estimateTextSearchRows(source, undefined, false)
+            : this.estimateVectorSearchRows(source, undefined, false);
+        const estimatedRows = rows * bindingCount;
+        return {
+            rows: estimatedRows,
+            costRows: candidateRows + estimatedRows,
+        };
     }
     estimateTuplePatternRows(source, bindings, filters, metrics) {
         const sample = (bindings.length > 0 ? bindings : [{}]).slice(0, PLANNER_SAMPLE_BINDINGS);
@@ -530,18 +596,18 @@ class RdfLocalQueryEngine {
         }
         return sawBoundSource ? rows : undefined;
     }
-    estimateTextSearchRows(source, exactSource) {
+    estimateTextSearchRows(source, exactSource, includeWindow = true) {
         if (!this.textIndex) {
             throw new Error('RdfLocalQuery textSearch requires a configured RdfTextIndex');
         }
-        const options = this.textSearchOptions(source.pattern, exactSource);
+        const options = this.textSearchOptions(source.pattern, exactSource, includeWindow);
         return options ? this.textIndex.estimateSearchCardinality(options).rows : 0;
     }
-    estimateVectorSearchRows(source, exactSource) {
+    estimateVectorSearchRows(source, exactSource, includeWindow = true) {
         if (!this.vectorIndex) {
             throw new Error('RdfLocalQuery vectorSearch requires a configured RdfVectorIndex');
         }
-        const options = this.vectorSearchOptions(source.pattern, exactSource);
+        const options = this.vectorSearchOptions(source.pattern, exactSource, includeWindow);
         return options ? this.vectorIndex.estimateSearchCardinality(options).rows : 0;
     }
     boundVariables(bindings) {
@@ -589,15 +655,16 @@ class RdfLocalQueryEngine {
     joinRequiredSource(input, source, filters, metrics, singleScanPushdown) {
         switch (source.kind) {
             case 'pattern': {
-                const bindings = this.joinPattern(input, source, filters, metrics, false, singleScanPushdown?.options);
-                metrics.plan.push(`IndexScan(${describePattern(source.pattern)})`);
+                const result = this.joinPattern(input, source, filters, metrics, false, singleScanPushdown?.options);
+                const scanPlan = requiredSourceScanPlan(result.scanBackend);
+                metrics.plan.push(`${scanPlan}(${describePattern(source.pattern)})`);
                 if (singleScanPushdown?.orderPushed) {
-                    metrics.plan.push(`IndexOrder(${describeScanOrder(singleScanPushdown.options)})`);
+                    metrics.plan.push(`${scanPlanOrder(scanPlan)}(${describeScanOrder(singleScanPushdown.options)})`);
                 }
                 if (singleScanPushdown?.paginationPushed) {
-                    metrics.plan.push('IndexLimit');
+                    metrics.plan.push(scanPlanLimit(scanPlan));
                 }
-                return bindings;
+                return result.bindings;
             }
             case 'text': {
                 const bindings = this.joinTextSearch(input, source, metrics);
@@ -636,10 +703,18 @@ class RdfLocalQueryEngine {
                     return [binding];
                 }
             }
-            for (const pattern of optionalGroup.patterns) {
-                matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, optionalFilters, metrics, true);
-                if (matches.length === 0) {
-                    return [binding];
+            const grouped = (optionalGroup.values?.length ?? 0) === 0
+                ? this.joinPatternGroupRdf3x(matches, optionalGroup.patterns, optionalFilters, metrics, true)
+                : undefined;
+            if (grouped) {
+                matches = grouped.bindings;
+            }
+            else {
+                for (const pattern of optionalGroup.patterns) {
+                    matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, optionalFilters, metrics, true).bindings;
+                    if (matches.length === 0) {
+                        return [binding];
+                    }
                 }
             }
             for (const unionGroup of optionalGroup.unions ?? []) {
@@ -702,8 +777,26 @@ class RdfLocalQueryEngine {
                 if (matches.length === 0) {
                     continue;
                 }
-                for (const pattern of branch.patterns) {
-                    matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, branchFilters, metrics, false);
+                const grouped = (branch.values?.length ?? 0) === 0
+                    ? this.joinPatternGroupRdf3x(matches, branch.patterns, branchFilters, metrics, false)
+                    : undefined;
+                if (grouped) {
+                    matches = grouped.bindings;
+                }
+                else {
+                    for (const pattern of branch.patterns) {
+                        matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, branchFilters, metrics, false).bindings;
+                        if (matches.length === 0) {
+                            break;
+                        }
+                    }
+                }
+                if (matches.length === 0) {
+                    continue;
+                }
+                for (const unionGroup of branch.unions ?? []) {
+                    matches = this.joinUnionGroup(matches, unionGroup.branches, branchFilters, metrics);
+                    metrics.plan.push(`UnionNested(${unionGroup.branches.map((nestedBranch) => nestedBranch.patterns.map(describePattern).join(',')).join('|')})`);
                     if (matches.length === 0) {
                         break;
                     }
@@ -757,10 +850,18 @@ class RdfLocalQueryEngine {
         for (const binding of input) {
             let matches = [binding];
             matches = this.applyDependentValues(matches, minusGroup.values, metrics, 'Minus');
-            for (const pattern of minusGroup.patterns) {
-                matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, filters, metrics, false);
-                if (matches.length === 0) {
-                    break;
+            const grouped = (minusGroup.values?.length ?? 0) === 0
+                ? this.joinPatternGroupRdf3x(matches, minusGroup.patterns, filters, metrics, false)
+                : undefined;
+            if (grouped) {
+                matches = grouped.bindings;
+            }
+            else {
+                for (const pattern of minusGroup.patterns) {
+                    matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, filters, metrics, false).bindings;
+                    if (matches.length === 0) {
+                        break;
+                    }
                 }
             }
             if (matches.length > 0) {
@@ -798,10 +899,18 @@ class RdfLocalQueryEngine {
         for (const binding of input) {
             let matches = [binding];
             matches = this.applyDependentValues(matches, existsGroup.values, metrics, 'Exists');
-            for (const pattern of existsGroup.patterns) {
-                matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, filters, metrics, false);
-                if (matches.length === 0) {
-                    break;
+            const grouped = (existsGroup.values?.length ?? 0) === 0
+                ? this.joinPatternGroupRdf3x(matches, existsGroup.patterns, filters, metrics, false)
+                : undefined;
+            if (grouped) {
+                matches = grouped.bindings;
+            }
+            else {
+                for (const pattern of existsGroup.patterns) {
+                    matches = this.joinPattern(matches, { kind: 'pattern', pattern, originalIndex: -1 }, filters, metrics, false).bindings;
+                    if (matches.length === 0) {
+                        break;
+                    }
                 }
             }
             if (matches.length > 0) {
@@ -833,8 +942,60 @@ class RdfLocalQueryEngine {
         }
         return output;
     }
+    joinPatternGroupRdf3x(input, patterns, filters, metrics, optional) {
+        if (!this.rdf3xPrimaryIndex || patterns.length < 2) {
+            return undefined;
+        }
+        const compiledByBinding = input.map((binding) => {
+            const compiled = patterns.map((pattern) => this.compileJoinPatternForBinding(pattern, binding, filters));
+            return {
+                binding,
+                patterns: compiled,
+            };
+        });
+        if (compiledByBinding.some((entry) => (entry.patterns.some((pattern) => !pattern)
+            || !this.canUseRdf3xPrimaryJoin(entry.patterns)))) {
+            return undefined;
+        }
+        const output = [];
+        for (const entry of compiledByBinding) {
+            const compiled = entry.patterns;
+            const scan = this.rdf3xPrimaryIndex.joinPatterns(compiled);
+            metrics.scannedRows += scan.metrics.matchedRows;
+            metrics.indexChoices.push(scan.metrics.indexChoice);
+            metrics.filtersPushedDown += uniqueNumbers(compiled.flatMap((pattern) => pattern.pattern.pushedDownFilterIndexes)).length;
+            metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
+            const remainingFilters = filtersWithoutIndexes(filters, uniqueNumbers(compiled.flatMap((pattern) => pattern.pattern.pushedDownFilterIndexes)));
+            const before = output.length;
+            for (const row of scan.bindings) {
+                const next = mergeBindingRows(entry.binding, row);
+                if (next && this.matchesNewlyBoundFilters(next, entry.binding, remainingFilters)) {
+                    output.push(next);
+                }
+            }
+            if (optional && output.length === before) {
+                output.push(entry.binding);
+            }
+        }
+        return {
+            bindings: output,
+            scanBackend: 'rdf3x',
+        };
+    }
+    compileJoinPatternForBinding(pattern, binding, filters) {
+        const variables = {};
+        for (const key of TERM_KEYS) {
+            const value = pattern[key];
+            if (isVariable(value) && !binding[value.variable]) {
+                variables[key] = value.variable;
+            }
+        }
+        const compiled = this.compilePattern(pattern, binding, filters);
+        return compiled ? { pattern: compiled, variables } : undefined;
+    }
     joinPattern(input, source, filters, metrics, optional, scanOptions) {
         const output = [];
+        const backends = new Set();
         const { pattern } = source;
         for (const binding of input) {
             const compiled = this.compilePattern(pattern, binding, filters);
@@ -845,9 +1006,8 @@ class RdfLocalQueryEngine {
                 continue;
             }
             const tupleValues = this.tupleValuesForBinding(source, binding);
-            const scan = tupleValues
-                ? this.index.scanWithTupleConstraints(compiled, tupleValues, scanOptions)
-                : this.index.scan(compiled, scanOptions);
+            const scan = this.scanCompiledPattern(compiled, tupleValues, scanOptions);
+            backends.add(scan.metrics.engine === 'solid-rdf3x' ? 'rdf3x' : 'index');
             metrics.scannedRows += scan.metrics.matchedRows;
             metrics.indexChoices.push(scan.metrics.indexChoice);
             metrics.filtersPushedDown += compiled.pushedDownFilters;
@@ -860,11 +1020,32 @@ class RdfLocalQueryEngine {
                 }
             }
         }
-        return output;
+        return {
+            bindings: output,
+            scanBackend: backends.size === 0
+                ? 'none'
+                : backends.size === 1
+                    ? [...backends][0]
+                    : 'mixed',
+        };
+    }
+    scanCompiledPattern(compiled, tupleValues, scanOptions) {
+        if (this.canUseRdf3xPrimaryScan(compiled, scanOptions)) {
+            const rdf3xPattern = toRdf3xTriplePattern(compiled);
+            return tupleValues
+                ? this.rdf3xPrimaryIndex.scanWithTupleConstraints(rdf3xPattern, tupleValues, toRdf3xScanOptions(scanOptions))
+                : this.rdf3xPrimaryIndex.scan(rdf3xPattern, toRdf3xScanOptions(scanOptions));
+        }
+        return tupleValues
+            ? this.index.scanWithTupleConstraints(compiled, tupleValues, scanOptions)
+            : this.index.scan(compiled, scanOptions);
+    }
+    canUseRdf3xPrimaryScan(pattern, scanOptions) {
+        return Boolean(this.rdf3xPrimaryIndex)
+            && isRdf3xCompatiblePattern(pattern);
     }
     requiredBgpPushdown(query, requiredPatterns, filters) {
         if (requiredPatterns.length < 1
-            || (query.values?.length ?? 0) > 0
             || (query.textSearch?.length ?? 0) > 0
             || (query.vectorSearch?.length ?? 0) > 0
             || (query.unions?.length ?? 0) > 0
@@ -881,6 +1062,12 @@ class RdfLocalQueryEngine {
         if (!this.canPushRequiredBgpFilters(requiredPatterns, filters)) {
             return undefined;
         }
+        const values = query.values?.length
+            ? this.requiredBgpValuesPushdown(query.values, requiredPatterns)
+            : undefined;
+        if ((query.values?.length ?? 0) > 0 && !values) {
+            return undefined;
+        }
         const distinctProject = query.distinct
             ? this.requiredBgpDistinctProject(query, requiredPatterns, filters)
             : undefined;
@@ -899,9 +1086,13 @@ class RdfLocalQueryEngine {
         if (compiled.some((entry) => !entry)) {
             return undefined;
         }
+        if (values && !this.canUseRdf3xPrimaryJoin(compiled)) {
+            return undefined;
+        }
         const reordered = this.reorderJoinPatterns(requiredPatterns, compiled, filters);
         return {
             patterns: reordered.patterns,
+            ...(values ? { values } : {}),
             ...(reordered.reorderPlan ? { reorderPlan: reordered.reorderPlan } : {}),
             orderPushed,
             paginationPushed: query.limit !== undefined || query.offset !== undefined,
@@ -910,6 +1101,21 @@ class RdfLocalQueryEngine {
             pushedDownFilters: filters.length,
         };
     }
+    requiredBgpValuesPushdown(values, requiredPatterns) {
+        const visibleVariables = new Set(requiredPatterns.flatMap((pattern) => variablesInPattern(pattern)));
+        for (const source of values) {
+            if (source.variables.length === 0 || new Set(source.variables).size !== source.variables.length) {
+                return undefined;
+            }
+            if (source.variables.some((variableName) => !visibleVariables.has(variableName))) {
+                return undefined;
+            }
+            if (source.rows.some((row) => source.variables.some((variableName) => !row[variableName]))) {
+                return undefined;
+            }
+        }
+        return values;
+    }
     requiredBgpDistinctProject(query, requiredPatterns, filters) {
         const visibleVariables = new Set(requiredPatterns.flatMap((pattern) => variablesInPattern(pattern)));
         const projectedVariables = uniqueStrings(query.select && query.select.length > 0
@@ -1170,18 +1376,18 @@ class RdfLocalQueryEngine {
         }
         return results;
     }
-    textSearchOptions(pattern, exactSource) {
+    textSearchOptions(pattern, exactSource, includeWindow = true) {
         return {
             query: pattern.query,
             source: exactSource,
             workspace: pattern.scope?.workspace,
             sourcePrefix: pattern.scope?.sourcePrefix,
-            limit: pattern.limit,
-            offset: pattern.offset,
+            limit: includeWindow ? pattern.limit : undefined,
+            offset: includeWindow ? pattern.offset : undefined,
             orderBy: pattern.orderBy,
         };
     }
-    vectorSearchOptions(pattern, exactSource) {
+    vectorSearchOptions(pattern, exactSource, includeWindow = true) {
         return {
             embedding: pattern.embedding,
             metric: pattern.metric,
@@ -1189,8 +1395,8 @@ class RdfLocalQueryEngine {
             source: exactSource,
             workspace: pattern.scope?.workspace,
             sourcePrefix: pattern.scope?.sourcePrefix,
-            limit: pattern.limit,
-            offset: pattern.offset,
+            limit: includeWindow ? pattern.limit : undefined,
+            offset: includeWindow ? pattern.offset : undefined,
             threshold: pattern.threshold,
             orderBy: pattern.orderBy,
         };
@@ -1230,6 +1436,19 @@ class RdfLocalQueryEngine {
                 const value = this.evaluateBindExpression(expression.expression, binding);
                 return value ? n3_1.DataFactory.literal(value.value.toLocaleUpperCase('en-US')) : undefined;
             }
+            case 'coalesce': {
+                for (const item of expression.expressions) {
+                    const value = this.evaluateBindExpression(item, binding);
+                    if (value) {
+                        return value;
+                    }
+                }
+                return undefined;
+            }
+            case 'if':
+                return this.matchesFilters(binding, expression.condition)
+                    ? this.evaluateBindExpression(expression.then, binding)
+                    : this.evaluateBindExpression(expression.else, binding);
             case 'substring': {
                 const value = this.evaluateBindExpression(expression.expression, binding);
                 const startTerm = this.evaluateBindExpression(expression.start, binding);
@@ -1261,6 +1480,22 @@ class RdfLocalQueryEngine {
                     return undefined;
                 }
             }
+            case 'strdt': {
+                const lexical = this.evaluateBindExpression(expression.lexical, binding);
+                const datatype = this.evaluateBindExpression(expression.datatype, binding);
+                if (!lexical || !datatype || datatype.termType !== 'NamedNode') {
+                    return undefined;
+                }
+                return n3_1.DataFactory.literal(lexical.value, n3_1.DataFactory.namedNode(datatype.value));
+            }
+            case 'strlang': {
+                const lexical = this.evaluateBindExpression(expression.lexical, binding);
+                const language = this.evaluateBindExpression(expression.language, binding);
+                if (!lexical || !language) {
+                    return undefined;
+                }
+                return n3_1.DataFactory.literal(lexical.value, language.value);
+            }
             default: {
                 const exhaustive = expression;
                 throw new Error(`Unsupported RDF local BIND expression: ${JSON.stringify(exhaustive)}`);
@@ -1329,10 +1564,10 @@ class RdfLocalQueryEngine {
         if (aggregate.variable && !variablesInPattern(pattern).includes(aggregate.variable)) {
             return undefined;
         }
-        const distinctKey = aggregate.distinct
-            ? this.distinctCountKey(pattern, aggregate.variable)
+        const distinctKeys = aggregate.distinct
+            ? this.distinctCountKeys(pattern, aggregate.variable, aggregate.distinctVariables)
             : undefined;
-        if (aggregate.distinct && !distinctKey) {
+        if (aggregate.distinct && (!distinctKeys || distinctKeys.length === 0)) {
             return undefined;
         }
         if (!this.canPushAllFiltersForPattern(pattern, filters)) {
@@ -1343,7 +1578,7 @@ class RdfLocalQueryEngine {
             ? {
                 as: aggregate.as,
                 pattern: compiled,
-                distinctKey,
+                distinctKeys,
                 pushedDownFilters: compiled.pushedDownFilters,
             }
             : undefined;
@@ -1540,15 +1775,30 @@ class RdfLocalQueryEngine {
         }
         return compiled;
     }
-    distinctCountKey(pattern, variableName) {
-        if (!variableName) {
-            return undefined;
+    distinctCountKeys(pattern, variableName, distinctVariables) {
+        if (variableName) {
+            const keys = TERM_KEYS.filter((key) => {
+                const value = pattern[key];
+                return isVariable(value) && value.variable === variableName;
+            });
+            return keys.length === 1 ? keys : undefined;
+        }
+        if (distinctVariables) {
+            const keys = [];
+            for (const distinctVariable of distinctVariables) {
+                const key = termKeyForVariable(pattern, distinctVariable);
+                if (!key) {
+                    return undefined;
+                }
+                keys.push(key);
+            }
+            return uniquePatternKeys(keys);
         }
         const keys = TERM_KEYS.filter((key) => {
             const value = pattern[key];
-            return isVariable(value) && value.variable === variableName;
+            return isVariable(value);
         });
-        return keys.length === 1 ? keys[0] : undefined;
+        return uniquePatternKeys(keys);
     }
     scanOrderForPattern(pattern, orderBy) {
         if (orderBy.length === 0) {
@@ -1647,12 +1897,12 @@ class RdfLocalQueryEngine {
         }
         return next;
     }
-    countBindings(bindings, variable, distinct) {
+    countBindings(bindings, variable, distinct, distinctVariables) {
         if (!distinct) {
             return variable ? bindings.filter((binding) => binding[variable]).length : bindings.length;
         }
         if (!variable) {
-            return new Set(bindings.map((binding) => bindingKey(binding))).size;
+            return new Set(bindings.map((binding) => bindingKey(binding, distinctVariables))).size;
         }
         return new Set(bindings
             .map((binding) => binding[variable])
@@ -1664,7 +1914,7 @@ class RdfLocalQueryEngine {
         let firstCount = 0;
         aggregates.forEach((aggregate, index) => {
             const count = aggregate.type === 'count'
-                ? this.countBindings(bindings, aggregate.variable, aggregate.distinct)
+                ? this.countBindings(bindings, aggregate.variable, aggregate.distinct, aggregate.distinctVariables)
                 : 0;
             if (index === 0) {
                 firstCount = count;
@@ -1710,7 +1960,7 @@ class RdfLocalQueryEngine {
     }
     aggregateLiteral(bindings, aggregate) {
         if (aggregate.type === 'count') {
-            return countLiteral(this.countBindings(bindings, aggregate.variable, aggregate.distinct));
+            return countLiteral(this.countBindings(bindings, aggregate.variable, aggregate.distinct, aggregate.distinctVariables));
         }
         const values = this.numericAggregateValues(bindings, aggregate.variable, aggregate.distinct);
         if (values.length === 0) {
@@ -1927,24 +2177,46 @@ class RdfLocalQueryEngine {
                 const text = filterStringValue(value, comparisonValue);
                 return typeof filter.value === 'string' && text.startsWith(filter.value);
             }
+            case '$notStartsWith': {
+                const text = filterStringValue(value, comparisonValue);
+                return typeof filter.value === 'string' && !text.startsWith(filter.value);
+            }
             case '$contains': {
                 const text = filterStringValue(value, comparisonValue);
                 return typeof filter.value === 'string' && text.includes(filter.value);
             }
+            case '$notContains': {
+                const text = filterStringValue(value, comparisonValue);
+                return typeof filter.value === 'string' && !text.includes(filter.value);
+            }
             case '$endsWith': {
                 const text = filterStringValue(value, comparisonValue);
                 return typeof filter.value === 'string' && text.endsWith(filter.value);
             }
+            case '$notEndsWith': {
+                const text = filterStringValue(value, comparisonValue);
+                return typeof filter.value === 'string' && !text.endsWith(filter.value);
+            }
             case '$regex': {
                 const text = filterStringValue(value, comparisonValue);
                 return typeof filter.value === 'string' && new RegExp(filter.value, filter.flags).test(text);
             }
+            case '$notRegex': {
+                const text = filterStringValue(value, comparisonValue);
+                return typeof filter.value === 'string' && !new RegExp(filter.value, filter.flags).test(text);
+            }
             case '$termType':
                 return typeof filter.value === 'string' && matchesTermType(value, filter.value);
+            case '$notTermType':
+                return typeof filter.value === 'string' && !matchesTermType(value, filter.value);
             case '$sameTerm': {
                 const right = filter.variable2 ? binding[filter.variable2] : filter.value;
                 return Boolean(right && (0, types_1.isTerm)(right) && sameTerm(value, right));
             }
+            case '$notSameTerm': {
+                const right = filter.variable2 ? binding[filter.variable2] : filter.value;
+                return Boolean(right && (0, types_1.isTerm)(right) && !sameTerm(value, right));
+            }
             case '$lang':
                 return typeof filter.value === 'string'
                     && value.termType === 'Literal'
@@ -1953,10 +2225,20 @@ class RdfLocalQueryEngine {
                 return typeof filter.value === 'string'
                     && value.termType === 'Literal'
                     && value.language !== filter.value;
+            case '$langIn':
+                return value.termType === 'Literal'
+                    && (filter.values ?? []).some((candidate) => typeof candidate === 'string' && value.language === candidate);
+            case '$notLangIn':
+                return value.termType === 'Literal'
+                    && !(filter.values ?? []).some((candidate) => typeof candidate === 'string' && value.language === candidate);
             case '$langMatches':
                 return typeof filter.value === 'string'
                     && value.termType === 'Literal'
                     && langMatches(value.language, filter.value);
+            case '$notLangMatches':
+                return typeof filter.value === 'string'
+                    && value.termType === 'Literal'
+                    && !langMatches(value.language, filter.value);
             case '$datatype':
                 return filter.value !== undefined
                     && value.termType === 'Literal'
@@ -1965,6 +2247,12 @@ class RdfLocalQueryEngine {
                 return filter.value !== undefined
                     && value.termType === 'Literal'
                     && !sameTermOrLexical(value.datatype, filter.value);
+            case '$datatypeIn':
+                return value.termType === 'Literal'
+                    && (filter.values ?? []).some((candidate) => sameTermOrLexical(value.datatype, candidate));
+            case '$notDatatypeIn':
+                return value.termType === 'Literal'
+                    && !(filter.values ?? []).some((candidate) => sameTermOrLexical(value.datatype, candidate));
             default: {
                 const exhaustive = filter.operator;
                 throw new Error(`Unsupported RDF local query filter operator: ${exhaustive}`);
@@ -2094,6 +2382,9 @@ function variablesInRequiredSource(source) {
 function uniqueStrings(values) {
     return [...new Set(values)];
 }
+function uniqueNumbers(values) {
+    return [...new Set(values)];
+}
 function filtersWithoutIndexes(filters, indexes) {
     if (indexes.length === 0) {
         return filters;
@@ -2113,6 +2404,17 @@ function joinValuesSource(input, source) {
     }
     return output;
 }
+function mergeBindingRows(left, right) {
+    const next = { ...left };
+    for (const [variableName, term] of Object.entries(right)) {
+        const existing = next[variableName];
+        if (existing && !sameTerm(existing, term)) {
+            return null;
+        }
+        next[variableName] = term;
+    }
+    return next;
+}
 function mergeTupleValuesBinding(binding, variables, row) {
     const next = { ...binding };
     for (const variableName of variables) {
@@ -2372,10 +2674,13 @@ function compareBindings(left, right, orderBy) {
     }
     return 0;
 }
-function bindingKey(binding) {
-    return Object.keys(binding)
+function bindingKey(binding, variables) {
+    return [...(variables ?? Object.keys(binding))]
         .sort()
-        .map((key) => `${key}=${(0, n3_1.termToId)(binding[key])}`)
+        .map((key) => {
+        const term = binding[key];
+        return `${key}=${term ? (0, n3_1.termToId)(term) : '__UNBOUND__'}`;
+    })
         .join('\u001f');
 }
 function distinctBindings(bindings) {
@@ -2510,6 +2815,10 @@ function describeBindExpression(expression) {
             return `LCASE(${describeBindExpression(expression.expression)})`;
         case 'upperCase':
             return `UCASE(${describeBindExpression(expression.expression)})`;
+        case 'coalesce':
+            return `COALESCE(${expression.expressions.map(describeBindExpression).join(',')})`;
+        case 'if':
+            return `IF(${expression.condition.map(describeFilter).join('&')},${describeBindExpression(expression.then)},${describeBindExpression(expression.else)})`;
         case 'substring':
             return `SUBSTR(${[
                 describeBindExpression(expression.expression),
@@ -2520,6 +2829,10 @@ function describeBindExpression(expression) {
             return `CONCAT(${expression.expressions.map(describeBindExpression).join(',')})`;
         case 'iri':
             return `IRI(${describeBindExpression(expression.expression)})`;
+        case 'strdt':
+            return `STRDT(${describeBindExpression(expression.lexical)},${describeBindExpression(expression.datatype)})`;
+        case 'strlang':
+            return `STRLANG(${describeBindExpression(expression.lexical)},${describeBindExpression(expression.language)})`;
         default: {
             const exhaustive = expression;
             return JSON.stringify(exhaustive);
@@ -2561,61 +2874,225 @@ function storagePlanMarkers(queryPlan) {
         || entry.startsWith('JoinGroupAggregateHaving(')
         || entry.startsWith('JoinGroupAggregateNumeric(')));
 }
+function requiredSourceScanPlan(backend) {
+    switch (backend) {
+        case 'rdf3x':
+            return 'Rdf3xPrimaryScan';
+        case 'mixed':
+            return 'MixedScan';
+        case 'index':
+        case 'none':
+            return 'IndexScan';
+        default: {
+            const exhaustive = backend;
+            throw new Error(`Unsupported RDF required source scan backend: ${exhaustive}`);
+        }
+    }
+}
+function scanPlanOrder(plan) {
+    switch (plan) {
+        case 'Rdf3xPrimaryScan':
+            return 'Rdf3xPrimaryOrder';
+        case 'MixedScan':
+            return 'MixedOrder';
+        case 'IndexScan':
+            return 'IndexOrder';
+        default: {
+            const exhaustive = plan;
+            throw new Error(`Unsupported RDF scan plan for order marker: ${exhaustive}`);
+        }
+    }
+}
+function scanPlanLimit(plan) {
+    switch (plan) {
+        case 'Rdf3xPrimaryScan':
+            return 'Rdf3xPrimaryLimit';
+        case 'MixedScan':
+            return 'MixedLimit';
+        case 'IndexScan':
+            return 'IndexLimit';
+        default: {
+            const exhaustive = plan;
+            throw new Error(`Unsupported RDF scan plan for limit marker: ${exhaustive}`);
+        }
+    }
+}
+function toRdf3xScanOptions(options) {
+    if (!options) {
+        return undefined;
+    }
+    return {
+        ...(options.order ? { order: options.order } : {}),
+        ...(options.orderDirections ? { orderDirections: options.orderDirections } : {}),
+        ...(options.reverse ? { reverse: true } : {}),
+        ...(options.limit !== undefined ? { limit: options.limit } : {}),
+        ...(options.offset !== undefined ? { offset: options.offset } : {}),
+    };
+}
+function toRdf3xTriplePattern(pattern) {
+    const result = {};
+    for (const key of TERM_KEYS) {
+        const value = pattern[key];
+        if (!value) {
+            continue;
+        }
+        if ((0, types_1.isTerm)(value)) {
+            result[key] = value;
+            continue;
+        }
+        if (isRdf3xTermInPattern(value)) {
+            result[key] = value;
+            continue;
+        }
+        if (isRdf3xTermNotInPattern(value)) {
+            result[key] = value;
+            continue;
+        }
+        if (isRdf3xCompatibleOperatorPattern(key, value)) {
+            result[key] = value;
+            continue;
+        }
+        throw new Error(`RDF-3X primary scan cannot compile unsupported ${key} pattern`);
+    }
+    return result;
+}
+function stripRdf3xNumericAggregateGuards(patterns, aggregates) {
+    const numericVariables = new Set(aggregates
+        .filter((aggregate) => aggregate.type !== 'count')
+        .map((aggregate) => aggregate.variable)
+        .filter((variableName) => Boolean(variableName)));
+    if (numericVariables.size === 0) {
+        return patterns;
+    }
+    return patterns.map((entry) => {
+        let changed = false;
+        const pattern = {
+            ...entry.pattern,
+            pushedDownFilters: entry.pattern.pushedDownFilters,
+            pushedDownFilterIndexes: [...entry.pattern.pushedDownFilterIndexes],
+        };
+        for (const key of TERM_KEYS) {
+            const variableName = entry.variables[key];
+            if (!variableName || !numericVariables.has(variableName)) {
+                continue;
+            }
+            const value = pattern[key];
+            if (!value || (0, types_1.isTerm)(value) || typeof value !== 'object') {
+                continue;
+            }
+            if (value.$termType !== 'numeric') {
+                continue;
+            }
+            const stripped = { ...value };
+            delete stripped.$termType;
+            if (Object.keys(stripped).length === 0) {
+                delete pattern[key];
+            }
+            else {
+                pattern[key] = stripped;
+            }
+            changed = true;
+        }
+        return changed ? { pattern, variables: entry.variables } : entry;
+    });
+}
 function isRdf3xCompatiblePattern(pattern) {
     return TERM_KEYS.every((key) => {
         const value = pattern[key];
         if (!value || (0, types_1.isTerm)(value)) {
             return true;
         }
-        if (key === 'graph' && isGraphPrefixPattern(value)) {
+        if (isRdf3xTermInPattern(value)) {
             return true;
         }
-        if (key === 'object' && isRdf3xNumericRangePattern(value)) {
+        if (isRdf3xTermNotInPattern(value)) {
+            return true;
+        }
+        if (isRdf3xCompatibleOperatorPattern(key, value)) {
             return true;
         }
         return false;
     });
 }
-function isGraphPrefixPattern(value) {
+function isRdf3xTermInPattern(value) {
     return value !== null
         && typeof value === 'object'
+        && !('termType' in value)
         && Object.keys(value).length === 1
-        && '$startsWith' in value
-        && typeof value.$startsWith === 'string';
+        && Array.isArray(value.$in)
+        && (value.$in).length > 0
+        && (value.$in).every((entry) => (0, types_1.isTerm)(entry));
 }
-function isRdf3xNumericRangePattern(value) {
+function isRdf3xTermNotInPattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !('termType' in value)
+        && Object.keys(value).length === 1
+        && Array.isArray(value.$notIn)
+        && (value.$notIn).length > 0
+        && (value.$notIn).every((entry) => (0, types_1.isTerm)(entry));
+}
+function isRdf3xCompatibleOperatorPattern(key, value) {
     if (value === null || typeof value !== 'object' || 'termType' in value) {
         return false;
     }
-    const operators = ['$gt', '$gte', '$lt', '$lte'];
-    if (Object.keys(value).some((key) => !operators.includes(key))) {
+    const allowed = new Set([
+        '$in',
+        '$notIn',
+        '$termType',
+        '$language',
+        '$notLanguage',
+        '$langMatches',
+        '$datatype',
+        '$notDatatype',
+        ...(key === 'graph' ? ['$startsWith'] : []),
+        ...(key === 'object' ? ['$gt', '$gte', '$lt', '$lte', '$contains', '$endsWith'] : []),
+    ]);
+    if (Object.keys(value).length === 0 || Object.keys(value).some((operator) => !allowed.has(operator))) {
         return false;
     }
-    let hasRange = false;
-    for (const operator of operators) {
-        const rangeValue = value[operator];
-        if (rangeValue === undefined) {
-            continue;
-        }
-        hasRange = true;
-        if (rdf3xNumericRangeValue(rangeValue) === undefined) {
+    const operators = value;
+    if (operators.$in !== undefined && !isRdf3xTermInPattern({ $in: operators.$in }))
+        return false;
+    if (operators.$notIn !== undefined && !isRdf3xTermNotInPattern({ $notIn: operators.$notIn }))
+        return false;
+    if (operators.$startsWith !== undefined && typeof operators.$startsWith !== 'string')
+        return false;
+    if (operators.$termType !== undefined && !['iri', 'blank', 'literal', 'numeric'].includes(operators.$termType))
+        return false;
+    for (const languageOperator of ['$language', '$notLanguage', '$langMatches']) {
+        if (operators[languageOperator] !== undefined && typeof operators[languageOperator] !== 'string')
+            return false;
+    }
+    for (const datatypeOperator of ['$datatype', '$notDatatype']) {
+        const datatype = operators[datatypeOperator];
+        if (datatype !== undefined && (!(0, types_1.isTerm)(datatype) || datatype.termType !== 'NamedNode'))
             return false;
+    }
+    if (key === 'object') {
+        for (const rangeOperator of ['$gt', '$gte', '$lt', '$lte']) {
+            const rangeValue = operators[rangeOperator];
+            if (rangeValue !== undefined && !isRdf3xObjectRangeValue(rangeValue))
+                return false;
+        }
+        for (const textOperator of ['$contains', '$endsWith']) {
+            if (operators[textOperator] !== undefined && typeof operators[textOperator] !== 'string')
+                return false;
         }
     }
-    return hasRange;
+    return true;
 }
-function rdf3xNumericRangeValue(value) {
+function isRdf3xObjectRangeValue(value) {
     if (typeof value === 'number') {
-        return Number.isFinite(value) ? value : undefined;
+        return Number.isFinite(value);
     }
     if (typeof value === 'string') {
-        const parsed = Number(value);
-        return Number.isFinite(parsed) ? parsed : undefined;
+        return true;
     }
     if ((0, types_1.isTerm)(value)) {
-        return (0, RdfTermSemantics_1.isRdfNumericTerm)(value) ? (0, RdfTermSemantics_1.rdfNumericValue)(value.value) : undefined;
+        return true;
     }
-    return undefined;
+    return false;
 }
 function bindTextSearchResult(binding, pattern, result) {
     const next = { ...binding };
@@ -2702,4 +3179,7 @@ function aggregatePlan(aggregates, grouped) {
         ? 'Aggregate(count-multi-distinct)'
         : 'Aggregate(count-multi)';
 }
+function uniquePatternKeys(values) {
+    return TERM_KEYS.filter((key) => values.includes(key));
+}
 //# sourceMappingURL=RdfLocalQueryEngine.js.map