@undefineds.co/xpod 0.3.17 → 0.3.22

package/dist/storage/rdf/models-benchmark.js

@@ -371,6 +371,7 @@ exports.rdfModelsLocalQueryBenchmarkCases = [
         query: {
             patterns: [
                 {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
                     subject: { variable: 'message' },
                     predicate: namedNode(SIOC_HAS_MEMBER),
                     object: namedNode('https://pod.example/alice/.data/chat/default/index.ttl#thread_1'),
@@ -513,6 +514,7 @@ exports.rdfModelsLocalQueryBenchmarkCases = [
         query: {
             patterns: [
                 {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
                     subject: { variable: 'message' },
                     predicate: namedNode(SIOC_HAS_MEMBER),
                     object: { variable: 'thread' },
@@ -542,6 +544,70 @@ exports.rdfModelsLocalQueryBenchmarkCases = [
         },
         expectedPlan: ['group-count-index', 'having-pushdown', 'order', 'limit'],
     },
+    {
+        name: 'message score by thread numeric aggregate',
+        resource: 'message',
+        purpose: 'grouped numeric message score aggregate stays inside SQL/RDF-3X GROUP BY',
+        minScale: 'small',
+        minReturnedRows: 1,
+        query: {
+            patterns: [
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
+                    subject: { variable: 'message' },
+                    predicate: namedNode(SIOC_HAS_MEMBER),
+                    object: { variable: 'thread' },
+                },
+                {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
+                    subject: { variable: 'message' },
+                    predicate: namedNode(`${UDFS}score`),
+                    object: { variable: 'score' },
+                },
+            ],
+            filters: [
+                {
+                    variable: 'score',
+                    operator: '$termType',
+                    value: 'numeric',
+                },
+            ],
+            groupBy: ['thread'],
+            aggregates: [
+                {
+                    type: 'count',
+                    as: 'count',
+                    variable: 'message',
+                },
+                {
+                    type: 'sum',
+                    as: 'scoreTotal',
+                    variable: 'score',
+                },
+                {
+                    type: 'avg',
+                    as: 'scoreAvg',
+                    variable: 'score',
+                },
+            ],
+            having: [
+                {
+                    variable: 'scoreTotal',
+                    operator: '$gt',
+                    value: literal('4', namedNode('http://www.w3.org/2001/XMLSchema#integer')),
+                },
+            ],
+            select: ['thread', 'count', 'scoreTotal', 'scoreAvg'],
+            orderBy: [
+                {
+                    variable: 'scoreTotal',
+                    direction: 'desc',
+                },
+            ],
+            limit: 1,
+        },
+        expectedPlan: ['group-aggregate-index', 'having-pushdown', 'order', 'limit'],
+    },
     {
         name: 'message join count distinct',
         resource: 'message',
@@ -550,11 +616,13 @@ exports.rdfModelsLocalQueryBenchmarkCases = [
         query: {
             patterns: [
                 {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
                     subject: { variable: 'message' },
                     predicate: namedNode(RDF_TYPE),
                     object: namedNode(`${MEETING}Message`),
                 },
                 {
+                    graph: { $startsWith: 'https://pod.example/alice/.data/chat/default/' },
                     subject: { variable: 'message' },
                     predicate: namedNode(SIOC_HAS_MEMBER),
                     object: { variable: 'thread' },
@@ -621,6 +689,7 @@ function runRdfModelsBenchmark(engine, options = {}) {
         generatedAt: new Date().toISOString(),
         planMatched: failedPlanCases.length === 0,
         failedPlanCases,
+        storage: engine.storageStats(),
         cases: results,
         localQueryCases: localQueryResults,
     };
@@ -674,6 +743,10 @@ function runRdfModelsRdf3xShadowBenchmark(engine, options = {}) {
     const joinResults = localQueryCases.map((testCase) => runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations));
     const supportedResults = results.filter((result) => result.supported);
     const supportedJoinResults = joinResults.filter((result) => result.supported);
+    const failedPlanCases = [
+        ...supportedResults.filter((result) => !result.planMatched).map((result) => result.name),
+        ...supportedJoinResults.filter((result) => !result.planMatched).map((result) => result.name),
+    ];
     return {
         engine: 'rdf3x-shadow',
         primaryEngine: 'solid-rdf',
@@ -685,13 +758,16 @@ function runRdfModelsRdf3xShadowBenchmark(engine, options = {}) {
             && supportedJoinResults.every((result) => result.matched),
         orderedMatched: supportedResults.every((result) => result.orderedMatch)
             && supportedJoinResults.every((result) => result.orderedMatch),
+        planMatched: failedPlanCases.length === 0,
         skippedCases: results.filter((result) => !result.supported).map((result) => result.name),
         skippedJoinCases: joinResults.filter((result) => !result.supported).map((result) => result.name),
         failedCases: supportedResults.filter((result) => !result.matched || !result.orderedMatch).map((result) => result.name),
         failedJoinCases: supportedJoinResults
             .filter((result) => !result.matched || !result.orderedMatch)
             .map((result) => result.name),
+        failedPlanCases,
         rebuild,
+        storage: engine.storageStats(),
         cases: results,
         joinCases: joinResults,
     };
@@ -761,7 +837,7 @@ function runLocalQueryBenchmarkCase(engine, testCase, iterations) {
         filtersApplied: 0,
         filtersPushedDown: 0,
     };
-    const missingPlan = missingExpectedLocalQueryPlan(testCase, finalMetrics);
+    const missingPlan = missingExpectedLocalQueryPlan(testCase, finalMetrics, keys.length);
     return {
         name: testCase.name,
         resource: testCase.resource,
@@ -793,6 +869,8 @@ function runRdf3xShadowBenchmarkCase(engine, testCase, iterations) {
             ...baseResult,
             supported: false,
             unsupportedReason,
+            planMatched: false,
+            missingPlan: [unsupportedReason],
             matched: false,
             orderedMatch: false,
             diff: {
@@ -840,10 +918,14 @@ function runRdf3xShadowBenchmarkCase(engine, testCase, iterations) {
         returnedRows: 0,
         durationMs: 0,
     };
+    const missingPlan = missingExpectedRdf3xPlan(testCase, finalRdf3xMetrics);
+    const planMatched = missingPlan.length === 0;
     return {
         ...baseResult,
         supported: true,
-        matched: diff.missingFromPrimary.length === 0 && diff.extraInPrimary.length === 0,
+        planMatched,
+        missingPlan,
+        matched: planMatched && diff.missingFromPrimary.length === 0 && diff.extraInPrimary.length === 0,
         orderedMatch,
         diff,
         solidRdf: {
@@ -867,6 +949,8 @@ function runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations) {
             ...baseRdf3xShadowJoinBenchmarkResult(testCase),
             supported: false,
             unsupportedReason,
+            planMatched: false,
+            missingPlan: [unsupportedReason],
             matched: false,
             orderedMatch: false,
             diff: {
@@ -885,12 +969,12 @@ function runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations) {
     let rdf3xMetrics;
     for (let i = 0; i < iterations; i += 1) {
         let start = Date.now();
-        const solidRdfResult = engine.index.joinPatterns(joinShape.patterns, joinShape.options);
+        const solidRdfResult = runSolidRdfJoinShape(engine, joinShape);
         solidRdfDurationsMs.push(Math.max(0, Date.now() - start));
         solidRdfBindings = solidRdfResult.bindings;
         solidRdfMetrics = solidRdfResult.metrics;
         start = Date.now();
-        const rdf3xResult = engine.rdf3xIndex.joinPatterns(joinShape.patterns, joinShape.options);
+        const rdf3xResult = runRdf3xJoinShape(engine, joinShape);
         rdf3xDurationsMs.push(Math.max(0, Date.now() - start));
         rdf3xBindings = rdf3xResult.bindings;
         rdf3xMetrics = rdf3xResult.metrics;
@@ -898,7 +982,7 @@ function runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations) {
     const solidRdfKeys = solidRdfBindings.map(bindingKey);
     const rdf3xKeys = rdf3xBindings.map(bindingKey);
     const diff = diffBindingKeys(solidRdfKeys, rdf3xKeys);
-    const orderedMatch = isSemanticallyOrderedJoin(joinShape.options)
+    const orderedMatch = isSemanticallyOrderedRdf3xJoinShape(joinShape)
         ? rdf3xKeys.join('\n') === solidRdfKeys.join('\n')
         : true;
     const finalSolidRdfMetrics = solidRdfMetrics ?? {
@@ -915,10 +999,19 @@ function runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations) {
         returnedRows: 0,
         durationMs: 0,
     };
+    const missingPlan = [
+        ...missingExpectedRdf3xJoinPlan(testCase, finalRdf3xMetrics, rdf3xKeys.length),
+        ...unresolvedPlanFailures(finalSolidRdfMetrics.queryPlan ?? []).map((label) => `solid-rdf:${label}`),
+    ];
+    const planMatched = missingPlan.length === 0;
     return {
         ...baseRdf3xShadowJoinBenchmarkResult(testCase),
         supported: true,
-        matched: diff.missingFromPrimary.length === 0 && diff.extraInPrimary.length === 0,
+        planMatched,
+        missingPlan,
+        matched: planMatched
+            && diff.missingFromPrimary.length === 0
+            && diff.extraInPrimary.length === 0,
         orderedMatch,
         diff,
         solidRdf: {
@@ -935,6 +1028,42 @@ function runRdf3xShadowJoinBenchmarkCase(engine, testCase, iterations) {
         },
     };
 }
+function runSolidRdfJoinShape(engine, shape) {
+    switch (shape.kind) {
+        case 'join':
+            return engine.index.joinPatterns(shape.patterns, shape.options);
+        case 'join-count':
+            return engine.index.countJoinPatterns(shape.patterns, shape.options);
+        case 'join-aggregate':
+            return engine.index.aggregateJoinPatterns(shape.patterns, shape.options);
+        case 'group-count':
+            return engine.index.groupCountJoinPatterns(shape.patterns, shape.options);
+        case 'group-aggregate':
+            return engine.index.groupAggregateJoinPatterns(shape.patterns, shape.options);
+        default: {
+            const exhaustive = shape;
+            throw new Error(`Unsupported RDF-3X benchmark shape: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+function runRdf3xJoinShape(engine, shape) {
+    switch (shape.kind) {
+        case 'join':
+            return engine.rdf3xIndex.joinPatterns(shape.patterns, shape.options);
+        case 'join-count':
+            return engine.rdf3xIndex.countJoinPatterns(shape.patterns, shape.options);
+        case 'join-aggregate':
+            return engine.rdf3xIndex.aggregateJoinPatterns(shape.patterns, shape.options);
+        case 'group-count':
+            return engine.rdf3xIndex.groupCountJoinPatterns(shape.patterns, shape.options);
+        case 'group-aggregate':
+            return engine.rdf3xIndex.groupAggregateJoinPatterns(shape.patterns, shape.options);
+        default: {
+            const exhaustive = shape;
+            throw new Error(`Unsupported RDF-3X benchmark shape: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
 function baseRdf3xShadowBenchmarkResult(testCase) {
     return {
         name: testCase.name,
@@ -945,6 +1074,7 @@ function baseRdf3xShadowBenchmarkResult(testCase) {
             pattern: serializePattern(testCase.query.pattern),
             ...(testCase.query.options ? { options: testCase.query.options } : {}),
         },
+        expectedPlan: [...testCase.expectedPlan],
     };
 }
 function emptySolidRdfBenchmarkSide(engine) {
@@ -1058,6 +1188,7 @@ function baseRdf3xShadowJoinBenchmarkResult(testCase) {
         purpose: testCase.purpose,
         minScale: testCase.minScale,
         query: serializeLocalQuery(testCase.query),
+        expectedPlan: [...testCase.expectedPlan],
     };
 }
 function unsupportedRdf3xJoinQueryReason(query) {
@@ -1073,24 +1204,64 @@ function unsupportedRdf3xJoinQueryReason(query) {
     if (query.unions?.length || query.minus?.length || query.exists?.length || query.optional?.length) {
         return 'RDF-3X join shadow only supports required BGP queries';
     }
-    if (query.binds?.length || query.filters?.length || query.having?.length) {
-        return 'RDF-3X join shadow does not support local query filters or BIND yet';
+    if (query.binds?.length) {
+        return 'RDF-3X join shadow does not support BIND yet';
     }
-    if (query.groupBy?.length || query.aggregate || query.aggregates?.length) {
-        return 'RDF-3X join shadow does not support aggregate queries yet';
+    const aggregates = queryAggregates(query);
+    const visibleVariables = new Set(query.patterns.flatMap((pattern) => variablesInLocalPattern(pattern)));
+    const compiled = rdf3xJoinPatternsFor(query, aggregates);
+    if (compiled.unsupportedReason) {
+        return compiled.unsupportedReason;
     }
-    for (const pattern of query.patterns) {
-        const joinPattern = rdf3xJoinPatternFor(pattern);
-        const unsupportedPattern = unsupportedRdf3xPatternReason(joinPattern.pattern);
-        if (unsupportedPattern) {
-            return unsupportedPattern;
+    if ((query.filters?.length ?? 0) > 0 && compiled.pushedFilterIndexes.size < (query.filters?.length ?? 0)) {
+        return 'RDF-3X join shadow only supports filters that can be fully pushed into RDF-3X patterns';
+    }
+    if (aggregates.length > 0) {
+        const aggregateReason = unsupportedRdf3xAggregateReason(query, aggregates, visibleVariables);
+        if (aggregateReason) {
+            return aggregateReason;
         }
     }
+    if (aggregates.length === 0 && (query.groupBy?.length ?? 0) > 0) {
+        return 'RDF-3X join shadow does not support GROUP BY without aggregates';
+    }
+    if (aggregates.length === 0 && (query.having?.length ?? 0) > 0) {
+        return 'RDF-3X join shadow does not support HAVING without aggregates';
+    }
     return undefined;
 }
 function rdf3xJoinShapeFor(query) {
+    const aggregates = queryAggregates(query);
+    const compiled = rdf3xJoinPatternsFor(query, aggregates);
+    if (!compiled.patterns) {
+        throw new Error(compiled.unsupportedReason ?? 'RDF-3X join shadow cannot compile query shape');
+    }
+    if ((query.groupBy?.length ?? 0) > 0) {
+        const aggregateAliases = new Set(aggregates.map((aggregate) => aggregate.as));
+        const having = rdf3xGroupAggregateHaving(query.having ?? [], aggregateAliases);
+        return {
+            kind: aggregates.every((aggregate) => aggregate.type === 'count') ? 'group-count' : 'group-aggregate',
+            patterns: compiled.patterns,
+            options: {
+                groupBy: query.groupBy ?? [],
+                aggregates,
+                ...(having.length > 0 ? { having } : {}),
+                ...(query.orderBy ? { orderBy: query.orderBy } : {}),
+                ...(query.limit !== undefined ? { limit: query.limit } : {}),
+                ...(query.offset !== undefined ? { offset: query.offset } : {}),
+            },
+        };
+    }
+    if (aggregates.length > 0) {
+        return {
+            kind: aggregates.every((aggregate) => aggregate.type === 'count') ? 'join-count' : 'join-aggregate',
+            patterns: compiled.patterns,
+            options: { aggregates },
+        };
+    }
     return {
-        patterns: query.patterns.map(rdf3xJoinPatternFor),
+        kind: 'join',
+        patterns: compiled.patterns,
         options: {
             ...(query.select ? { project: query.select } : {}),
             ...(query.distinct ? { distinct: true } : {}),
@@ -1100,9 +1271,63 @@ function rdf3xJoinShapeFor(query) {
         },
     };
 }
-function rdf3xJoinPatternFor(pattern) {
+function unsupportedRdf3xAggregateReason(query, aggregates, visibleVariables) {
+    if ((query.groupBy?.length ?? 0) > 0) {
+        if ((query.groupBy ?? []).some((variableName) => !visibleVariables.has(variableName))) {
+            return 'RDF-3X join shadow cannot group by variables outside required BGP';
+        }
+        const aggregateAliases = new Set(aggregates.map((aggregate) => aggregate.as));
+        if ((query.orderBy ?? []).some((entry) => !(query.groupBy ?? []).includes(entry.variable) && !aggregateAliases.has(entry.variable))) {
+            return 'RDF-3X join shadow cannot order grouped aggregates by unbound variables';
+        }
+        if (!canCompileRdf3xGroupAggregateHaving(query.having ?? [], aggregateAliases)) {
+            return 'RDF-3X join shadow cannot push this grouped HAVING shape';
+        }
+    }
+    else if ((query.having?.length ?? 0) > 0) {
+        return 'RDF-3X join shadow does not support non-grouped HAVING yet';
+    }
+    else if (query.orderBy?.length || query.limit !== undefined || query.offset !== undefined || query.distinct) {
+        return 'RDF-3X join shadow does not support ORDER/LIMIT/DISTINCT around non-grouped aggregates yet';
+    }
+    for (const aggregate of aggregates) {
+        if (aggregate.variable && !visibleVariables.has(aggregate.variable)) {
+            return 'RDF-3X join shadow aggregate variable must be bound by required BGP';
+        }
+        if (aggregate.type !== 'count' && (!aggregate.variable || aggregate.distinct)) {
+            return 'RDF-3X join shadow only supports non-distinct numeric aggregates over bound variables';
+        }
+    }
+    return undefined;
+}
+function rdf3xJoinPatternsFor(query, aggregates) {
+    const patterns = [];
+    const pushedFilterIndexes = new Set();
+    const numericAggregateVariables = new Set(aggregates
+        .filter((aggregate) => aggregate.type !== 'count')
+        .map((aggregate) => aggregate.variable)
+        .filter((variableName) => Boolean(variableName)));
+    for (const pattern of query.patterns) {
+        const compiled = rdf3xJoinPatternFor(pattern, query.filters ?? [], numericAggregateVariables);
+        const unsupportedPattern = unsupportedRdf3xPatternReason(compiled.pattern);
+        if (unsupportedPattern) {
+            return {
+                pushedFilterIndexes,
+                unsupportedReason: unsupportedPattern,
+            };
+        }
+        compiled.pushedFilterIndexes.forEach((index) => pushedFilterIndexes.add(index));
+        patterns.push({
+            pattern: compiled.pattern,
+            variables: compiled.variables,
+        });
+    }
+    return { patterns, pushedFilterIndexes };
+}
+function rdf3xJoinPatternFor(pattern, filters, numericAggregateVariables) {
     const compiledPattern = {};
     const variables = {};
+    const pushedFilterIndexes = new Set();
     for (const key of ['graph', 'subject', 'predicate', 'object']) {
         const value = pattern[key];
         if (!value) {
@@ -1110,6 +1335,13 @@ function rdf3xJoinPatternFor(pattern) {
         }
         if (isQueryVariable(value)) {
             variables[key] = value.variable;
+            const pushdown = rdf3xBenchmarkPushdownFilter(value.variable, filters, numericAggregateVariables);
+            if (pushdown) {
+                if (pushdown.pattern !== undefined) {
+                    compiledPattern[key] = pushdown.pattern;
+                }
+                pushdown.filterIndexes.forEach((index) => pushedFilterIndexes.add(index));
+            }
         }
         else {
             compiledPattern[key] = value;
@@ -1118,8 +1350,105 @@ function rdf3xJoinPatternFor(pattern) {
     return {
         pattern: compiledPattern,
         variables,
+        pushedFilterIndexes: [...pushedFilterIndexes],
     };
 }
+function rdf3xBenchmarkPushdownFilter(variableName, filters, numericAggregateVariables) {
+    const operators = {};
+    const filterIndexes = [];
+    for (let index = 0; index < filters.length; index += 1) {
+        const filter = filters[index];
+        if (filter.variable !== variableName || filter.variable2 || filter.operand) {
+            continue;
+        }
+        switch (filter.operator) {
+            case '$eq':
+            case '$sameTerm':
+                if (filter.value === undefined || !(0, types_1.isTerm)(filter.value)) {
+                    return undefined;
+                }
+                return { pattern: filter.value, filterIndexes: [index] };
+            case '$in':
+                if (!filter.values?.length || filter.values.some((value) => !(0, types_1.isTerm)(value))) {
+                    return undefined;
+                }
+                return { pattern: { $in: filter.values }, filterIndexes: [index] };
+            case '$notIn':
+                if (!filter.values?.length || filter.values.some((value) => !(0, types_1.isTerm)(value))) {
+                    return undefined;
+                }
+                return { pattern: { $notIn: filter.values }, filterIndexes: [index] };
+            case '$gt':
+            case '$gte':
+            case '$lt':
+            case '$lte':
+                if (filter.value === undefined) {
+                    return undefined;
+                }
+                operators[filter.operator] = filter.value;
+                filterIndexes.push(index);
+                break;
+            case '$termType':
+                if (filter.value !== 'numeric' || !numericAggregateVariables.has(variableName)) {
+                    return undefined;
+                }
+                filterIndexes.push(index);
+                break;
+            default:
+                return undefined;
+        }
+    }
+    if (Object.keys(operators).length > 0) {
+        return { pattern: operators, filterIndexes };
+    }
+    return filterIndexes.length > 0
+        ? { filterIndexes }
+        : undefined;
+}
+function queryAggregates(query) {
+    return query.aggregates && query.aggregates.length > 0
+        ? query.aggregates
+        : query.aggregate
+            ? [query.aggregate]
+            : [];
+}
+function variablesInLocalPattern(pattern) {
+    return ['graph', 'subject', 'predicate', 'object']
+        .map((key) => pattern[key])
+        .filter(isQueryVariable)
+        .map((value) => value.variable);
+}
+function canCompileRdf3xGroupAggregateHaving(having, aggregateAliases) {
+    return having.every((filter) => (aggregateAliases.has(filter.variable)
+        && !filter.operand
+        && !filter.variable2
+        && filter.value !== undefined
+        && isGroupAggregateHavingOperator(filter.operator)
+        && numericRangeValue(filter.value) !== undefined));
+}
+function rdf3xGroupAggregateHaving(having, aggregateAliases) {
+    return having.map((filter) => {
+        const value = filter.value === undefined ? undefined : numericRangeValue(filter.value);
+        if (!aggregateAliases.has(filter.variable)
+            || !isGroupAggregateHavingOperator(filter.operator)
+            || value === undefined) {
+            throw new Error('RDF-3X join shadow cannot compile grouped HAVING');
+        }
+        return {
+            aggregate: filter.variable,
+            operator: filter.operator,
+            value,
+        };
+    });
+}
+function isGroupAggregateHavingOperator(operator) {
+    return operator === '$eq'
+        || operator === '$ne'
+        || operator === '$gt'
+        || operator === '$gte'
+        || operator === '$lt'
+        || operator === '$lte';
+}
 function isQueryVariable(value) {
     return value !== null
         && typeof value === 'object'
@@ -1136,7 +1465,13 @@ function unsupportedRdf3xPatternReason(pattern) {
         if (key === 'graph' && isGraphPrefixPattern(value)) {
             continue;
         }
-        if (key === 'object' && isSupportedRdf3xNumericObjectRangePattern(value)) {
+        if (isRdf3xTermInPattern(value)) {
+            continue;
+        }
+        if (isRdf3xTermNotInPattern(value)) {
+            continue;
+        }
+        if (key === 'object' && isSupportedRdf3xObjectOperatorPattern(value)) {
             continue;
         }
         return `unsupported ${key} pattern for RDF-3X shadow`;
@@ -1154,7 +1489,15 @@ function rdf3xPatternFor(pattern) {
             result.graph = { $startsWith: value.$startsWith };
             continue;
         }
-        if (key === 'object' && isSupportedRdf3xNumericObjectRangePattern(value)) {
+        if (isRdf3xTermInPattern(value)) {
+            result[key] = value;
+            continue;
+        }
+        if (isRdf3xTermNotInPattern(value)) {
+            result[key] = value;
+            continue;
+        }
+        if (key === 'object' && isSupportedRdf3xObjectOperatorPattern(value)) {
             result.object = value;
             continue;
         }
@@ -1165,30 +1508,70 @@ function rdf3xPatternFor(pattern) {
     }
     return result;
 }
+function isRdf3xTermInPattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !('termType' in value)
+        && Object.keys(value).length === 1
+        && Array.isArray(value.$in)
+        && (value.$in).length > 0
+        && (value.$in).every((entry) => (0, types_1.isTerm)(entry));
+}
+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 isGraphPrefixPattern(value) {
     return value !== null
         && typeof value === 'object'
         && '$startsWith' in value
         && typeof value.$startsWith === 'string';
 }
-function isSupportedRdf3xNumericObjectRangePattern(value) {
+function isSupportedRdf3xObjectOperatorPattern(value) {
     if (value === null || typeof value !== 'object' || 'termType' in value) {
         return false;
     }
-    let hasRange = false;
+    let hasOperator = false;
     for (const operator of ['$gt', '$gte', '$lt', '$lte']) {
         const rangeValue = value[operator];
         if (rangeValue === undefined) {
             continue;
         }
-        hasRange = true;
-        if (numericRangeValue(rangeValue) === undefined) {
+        hasOperator = true;
+        if (!isSupportedRdf3xObjectRangeValue(rangeValue)) {
+            return false;
+        }
+    }
+    for (const operator of ['$contains', '$endsWith']) {
+        const textValue = value[operator];
+        if (textValue === undefined) {
+            continue;
+        }
+        hasOperator = true;
+        if (typeof textValue !== 'string') {
             return false;
         }
     }
-    return hasRange;
+    return hasOperator;
+}
+function isSupportedRdf3xObjectRangeValue(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    if (typeof value === 'string') {
+        return true;
+    }
+    return (0, types_1.isTerm)(value);
 }
 function numericRangeValue(value) {
+    if (typeof value === 'boolean') {
+        return undefined;
+    }
     if (typeof value === 'number') {
         return Number.isFinite(value) ? value : undefined;
     }
@@ -1205,8 +1588,20 @@ function numericRangeValue(value) {
 function isSemanticallyOrdered(options) {
     return Boolean(options?.order && options.order.length > 0);
 }
-function isSemanticallyOrderedJoin(options) {
-    return Boolean(options?.orderBy && options.orderBy.length > 0);
+function isSemanticallyOrderedRdf3xJoinShape(shape) {
+    switch (shape.kind) {
+        case 'join':
+        case 'group-count':
+        case 'group-aggregate':
+            return Boolean(shape.options?.orderBy && shape.options.orderBy.length > 0);
+        case 'join-count':
+        case 'join-aggregate':
+            return false;
+        default: {
+            const exhaustive = shape;
+            throw new Error(`Unsupported RDF-3X benchmark shape: ${JSON.stringify(exhaustive)}`);
+        }
+    }
 }
 function benchmarkSide(keys, durationsMs) {
     return {
@@ -1271,7 +1666,10 @@ function ratio(candidate, baseline) {
     return candidate / baseline;
 }
 function missingExpectedPlan(testCase, metrics) {
-    return testCase.expectedPlan.filter((label) => !matchesExpectedPlanLabel(label, testCase, metrics));
+    return [
+        ...testCase.expectedPlan.filter((label) => !matchesExpectedPlanLabel(label, testCase, metrics)),
+        ...unresolvedPlanFailures(metrics.queryPlan ?? []),
+    ];
 }
 function matchesExpectedPlanLabel(label, testCase, metrics) {
     const pattern = testCase.query.pattern;
@@ -1311,21 +1709,102 @@ function matchesExpectedPlanLabel(label, testCase, metrics) {
             return false;
     }
 }
-function missingExpectedLocalQueryPlan(testCase, metrics) {
-    return testCase.expectedPlan.filter((label) => !matchesExpectedLocalQueryPlanLabel(label, metrics));
+function missingExpectedRdf3xPlan(testCase, metrics) {
+    return [
+        ...testCase.expectedPlan.filter((label) => !matchesExpectedRdf3xPlanLabel(label, testCase, metrics)),
+        ...unresolvedPlanFailures(metrics.queryPlan ?? []),
+    ];
+}
+function matchesExpectedRdf3xPlanLabel(label, testCase, metrics) {
+    const pattern = testCase.query.pattern;
+    const planText = (metrics.queryPlan ?? []).join('\n');
+    switch (label) {
+        case 'graph-scope':
+            return Boolean(pattern.graph)
+                && (metrics.indexChoice === 'source-membership'
+                    || planText.includes('GraphPrefixMembershipFilter')
+                    || planText.includes('GraphMembershipFilter'));
+        case 'type-filter':
+            return (0, types_1.isTerm)(pattern.predicate)
+                && (0, n3_2.termToId)(pattern.predicate) === RDF_TYPE
+                && Boolean(pattern.object)
+                && metrics.indexChoice !== 'none';
+        case 'predicate-filter':
+            return Boolean(pattern.predicate) && metrics.indexChoice !== 'none';
+        case 'predicate-object-filter':
+            return Boolean(pattern.predicate) && Boolean(pattern.object) && metrics.indexChoice !== 'none';
+        case 'predicate-object-range-filter':
+            return Boolean(pattern.predicate)
+                && (planText.includes('NumericRange(') || planText.includes('LexicalRange('));
+        case 'limit':
+            return testCase.query.options?.limit !== undefined
+                && (planText.includes('Pagination') || planText.includes('LIMIT'));
+        case 'order':
+            return Boolean(testCase.query.options?.order?.length)
+                && (planText.includes('ORDER BY') || planText.includes('Rdf3xJoinOrder('));
+        case 'text-index':
+            return planText.includes('TextSearch(');
+        case 'rdf-subject-join':
+            return planText.includes('TextSearch(')
+                && metrics.indexChoice !== 'none'
+                && metrics.matchedRows >= metrics.returnedRows;
+        case 'SPOG':
+            return matchesRdf3xPermutation(metrics, 'SPO');
+        case 'POSG':
+            return matchesRdf3xPermutation(metrics, 'POS');
+        case 'OSPG':
+            return matchesRdf3xPermutation(metrics, 'OSP');
+        case 'GSPO':
+            return matchesExpectedRdf3xPlanLabel('graph-scope', testCase, metrics)
+                && matchesRdf3xPermutation(metrics, 'SPO');
+        case 'GPOS':
+            return matchesExpectedRdf3xPlanLabel('graph-scope', testCase, metrics)
+                && matchesRdf3xPermutation(metrics, 'POS');
+        default:
+            return false;
+    }
+}
+function matchesRdf3xPermutation(metrics, permutation) {
+    const planText = (metrics.queryPlan ?? []).join('\n');
+    return metrics.indexChoice === permutation || planText.includes(`Rdf3xPermutationScan(${permutation})`);
+}
+function missingExpectedLocalQueryPlan(testCase, metrics, returnedRows) {
+    return [
+        ...testCase.expectedPlan.filter((label) => !matchesExpectedLocalQueryPlanLabel(label, metrics)),
+        ...unresolvedPlanFailures(metrics.plan),
+        ...minimumReturnedRowsFailures(testCase, returnedRows),
+    ];
+}
+function unresolvedPlanFailures(plan) {
+    return hasUnresolvedPlan(plan) ? ['resolved-terms'] : [];
+}
+function hasUnresolvedPlan(plan) {
+    return plan.some((entry) => /\bunresolved\b/i.test(entry));
+}
+function minimumReturnedRowsFailures(testCase, returnedRows) {
+    const minimum = testCase.minReturnedRows ?? 0;
+    return returnedRows >= minimum ? [] : [`min-rows:${minimum}`];
 }
 function matchesExpectedLocalQueryPlanLabel(label, metrics) {
     const planText = metrics.plan.join('\n');
     switch (label) {
         case 'group-count-index':
             return planText.includes('Aggregate(group-count-index)');
+        case 'group-aggregate-index':
+            return planText.includes('Aggregate(group-basic-multi-index)')
+                || planText.includes('Aggregate(group-basic-index)');
         case 'having-pushdown':
-            return planText.includes('IndexGroupCountHaving(')
+            return (planText.includes('IndexGroupCountHaving(')
+                || planText.includes('IndexGroupAggregateHaving('))
                 && !planText.includes('\nHaving(');
         case 'order':
-            return planText.includes('IndexGroupCountOrder(') && !planText.includes('\nSort');
+            return (planText.includes('IndexGroupCountOrder(')
+                || planText.includes('IndexGroupAggregateOrder('))
+                && !planText.includes('\nSort');
         case 'limit':
-            return planText.includes('IndexGroupCountLimit') && !planText.includes('\nLimit');
+            return (planText.includes('IndexGroupCountLimit')
+                || planText.includes('IndexGroupAggregateLimit'))
+                && !planText.includes('\nLimit');
         case 'join-index':
             return planText.includes('IndexJoin(')
                 && !planText.includes('\nIndexScan(');
@@ -1346,6 +1825,44 @@ function matchesExpectedLocalQueryPlanLabel(label, metrics) {
             return false;
     }
 }
+function missingExpectedRdf3xJoinPlan(testCase, metrics, returnedRows) {
+    return [
+        ...testCase.expectedPlan.filter((label) => !matchesExpectedRdf3xJoinPlanLabel(label, metrics)),
+        ...unresolvedPlanFailures(metrics.queryPlan ?? []),
+        ...minimumReturnedRowsFailures(testCase, returnedRows),
+    ];
+}
+function matchesExpectedRdf3xJoinPlanLabel(label, metrics) {
+    const planText = (metrics.queryPlan ?? []).join('\n');
+    switch (label) {
+        case 'group-count-index':
+            return planText.includes('Rdf3xJoinGroupCount(');
+        case 'group-aggregate-index':
+            return planText.includes('Rdf3xJoinGroupAggregate(')
+                || planText.includes('Rdf3xJoinGroupAggregateNumeric(');
+        case 'having-pushdown':
+            return planText.includes('Rdf3xJoinGroupCountHaving(')
+                || planText.includes('Rdf3xJoinGroupAggregateHaving(');
+        case 'order':
+            return planText.includes('Rdf3xJoinGroupCountOrder(')
+                || planText.includes('Rdf3xJoinGroupAggregateOrder(');
+        case 'limit':
+            return planText.includes('Rdf3xJoinGroupCountLimit')
+                || planText.includes('Rdf3xJoinGroupAggregateLimit');
+        case 'join-index':
+            return planText.includes('Rdf3xJoinBGP(');
+        case 'join-order-pushdown':
+            return planText.includes('Rdf3xJoinOrder(');
+        case 'join-limit-pushdown':
+            return planText.includes('Rdf3xJoinLimit');
+        case 'range-filter-pushdown':
+            return planText.includes('LexicalRange(') || planText.includes('NumericRange(');
+        case 'join-count-index':
+            return planText.includes('Rdf3xJoinCount(');
+        default:
+            return false;
+    }
+}
 function bindingKey(binding) {
     return Object.keys(binding)
         .sort()