@undefineds.co/xpod 0.3.75 → 0.4.0-rc.140

package/dist/storage/rdf/RdfSparqlAdapter.js

@@ -1,30 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RdfSparqlAdapter = exports.NativeSparqlExecutionError = exports.DisabledSparqlFeatureError = exports.UnsupportedSparqlQueryError = void 0;
+exports.RdfSparqlAdapter = exports.DisabledSparqlFeatureError = exports.UnsupportedSparqlQueryError = void 0;
 exports.sparqlCorrectionForCapability = sparqlCorrectionForCapability;
 const n3_1 = require("n3");
 const sparqljs_1 = require("sparqljs");
 const RdfQueryExecutor_1 = require("./RdfQueryExecutor");
 const PATH_JOIN_VARIABLE_PREFIX = '__rdf_path';
 const XPATH_FUNCTION_NS = 'http://www.w3.org/2005/xpath-functions#';
-const XSD_NUMERIC_DATATYPES = new Set([
-    'http://www.w3.org/2001/XMLSchema#decimal',
-    'http://www.w3.org/2001/XMLSchema#double',
-    'http://www.w3.org/2001/XMLSchema#float',
-    'http://www.w3.org/2001/XMLSchema#integer',
-    'http://www.w3.org/2001/XMLSchema#long',
-    'http://www.w3.org/2001/XMLSchema#int',
-    'http://www.w3.org/2001/XMLSchema#short',
-    'http://www.w3.org/2001/XMLSchema#byte',
-    'http://www.w3.org/2001/XMLSchema#nonNegativeInteger',
-    'http://www.w3.org/2001/XMLSchema#positiveInteger',
-    'http://www.w3.org/2001/XMLSchema#unsignedLong',
-    'http://www.w3.org/2001/XMLSchema#unsignedInt',
-    'http://www.w3.org/2001/XMLSchema#unsignedShort',
-    'http://www.w3.org/2001/XMLSchema#unsignedByte',
-    'http://www.w3.org/2001/XMLSchema#nonPositiveInteger',
-    'http://www.w3.org/2001/XMLSchema#negativeInteger',
-]);
 function assertNoExternalService(value) {
     if (Array.isArray(value)) {
         for (const item of value) {
@@ -43,67 +25,6 @@ function assertNoExternalService(value) {
         assertNoExternalService(child);
     }
 }
-function nativeQueryShapeRejection(value, root = true) {
-    if (Array.isArray(value)) {
-        for (const item of value) {
-            const rejection = nativeQueryShapeRejection(item, false);
-            if (rejection) {
-                return rejection;
-            }
-        }
-        return undefined;
-    }
-    if (value === null || typeof value !== 'object') {
-        return undefined;
-    }
-    const record = value;
-    if (!root && record.type === 'query') {
-        return 'Subqueries require the embedded compatibility path';
-    }
-    if (record.type === 'query' && Array.isArray(record.order) && record.order.length > 1) {
-        return 'Multi-column ORDER BY requires the embedded compatibility path';
-    }
-    if (record.type === 'optional' || record.type === 'union' || record.type === 'minus') {
-        return `${String(record.type).toUpperCase()} query shapes require the embedded compatibility path`;
-    }
-    if (record.type === 'path') {
-        return 'Property paths require the embedded compatibility path';
-    }
-    if (record.type === 'filter') {
-        const expression = record.expression;
-        if (expression?.termType === 'Variable') {
-            return 'Variable effective-boolean-value filters require the embedded compatibility path';
-        }
-    }
-    if (record.type === 'operation') {
-        const operator = String(record.operator ?? '').toLowerCase();
-        if (operator === 'exists' || operator === 'notexists') {
-            return 'EXISTS query shapes require the embedded compatibility path';
-        }
-        if (['>', '>=', '<', '<='].includes(operator)) {
-            const args = Array.isArray(record.args) ? record.args : [];
-            const hasNumericLiteral = args.some((arg) => {
-                if (!arg || typeof arg !== 'object') {
-                    return typeof arg === 'number';
-                }
-                const term = arg;
-                const datatype = term.datatype;
-                return term.termType === 'Literal'
-                    && XSD_NUMERIC_DATATYPES.has(String(datatype?.value ?? ''));
-            });
-            if (hasNumericLiteral) {
-                return 'Numeric range filters require the embedded compatibility path';
-            }
-        }
-    }
-    for (const child of Object.values(record)) {
-        const rejection = nativeQueryShapeRejection(child, false);
-        if (rejection) {
-            return rejection;
-        }
-    }
-    return undefined;
-}
 class UnsupportedSparqlQueryError extends Error {
     constructor(message, options = {}) {
         const normalizedMessage = normalizeUnsupportedSparqlMessage(message);
@@ -123,26 +44,11 @@ class DisabledSparqlFeatureError extends Error {
     }
 }
 exports.DisabledSparqlFeatureError = DisabledSparqlFeatureError;
-class NativeSparqlExecutionError extends Error {
-    constructor(message) {
-        super(message.startsWith('Native SPARQL engine failed:') ? message : `Native SPARQL engine failed: ${message}`);
-        this.code = 'rdf.sparql.native_execution_error';
-        this.name = 'NativeSparqlExecutionError';
-    }
-}
-exports.NativeSparqlExecutionError = NativeSparqlExecutionError;
 function normalizeUnsupportedSparqlMessage(message) {
-    const noFallbackMatch = /^No compatibility SPARQL fallback configured for ([^:]+):\s*(.+)$/i.exec(message);
-    if (noFallbackMatch) {
-        return `Embedded SPARQL engine cannot execute ${noFallbackMatch[1]}: ${normalizeEmbeddedUnsupportedReason(noFallbackMatch[2])}`;
-    }
     return normalizeEmbeddedUnsupportedReason(message);
 }
 function normalizeEmbeddedUnsupportedReason(reason) {
-    let normalized = reason
-        .replace(/\s+fallback to compatibility engine\b/gi, ' is not supported by the embedded RDF engine')
-        .replace(/\bis handled by the compatibility engine\b/gi, 'is not supported by the embedded RDF engine')
-        .replace(/\bcompatibility fallback\b/gi, 'embedded RDF engine');
+    let normalized = reason;
     if (/^unsupported shape$/i.test(normalized.trim())) {
         normalized = 'Query shape is not supported by the embedded RDF engine';
     }
@@ -328,10 +234,6 @@ class RdfSparqlAdapter {
         assertNoExternalService(parsed);
         if (parsed.type !== 'update') {
             this.compileQueryDatasetScope(this.queryFromClause(parsed), basePath);
-            const rejection = nativeQueryShapeRejection(parsed);
-            if (rejection) {
-                throw new UnsupportedSparqlQueryError(rejection);
-            }
         }
     }
     compile(query, basePath) {
@@ -339,7 +241,7 @@ class RdfSparqlAdapter {
             ? new sparqljs_1.Parser({ baseIRI: basePath }).parse(query)
             : query;
         if (parsed.type === 'update') {
-            throw new UnsupportedSparqlQueryError('SPARQL UPDATE is handled by the compatibility engine');
+            throw new UnsupportedSparqlQueryError('SPARQL UPDATEis not supported by the embedded RDF engine');
         }
         const datasetScope = this.compileQueryDatasetScope(this.queryFromClause(parsed), basePath);
         const state = new CompileState(basePath);
@@ -392,12 +294,12 @@ class RdfSparqlAdapter {
         const operations = [];
         for (const update of parsed.updates) {
             if (!('updateType' in update)) {
-                throw new UnsupportedSparqlQueryError('SPARQL UPDATE management operations fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE management operations');
             }
             switch (update.updateType) {
                 case 'insert':
                     if (update.graph) {
-                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
+                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope');
                     }
                     operations.push({
                         type: 'insert',
@@ -406,7 +308,7 @@ class RdfSparqlAdapter {
                     break;
                 case 'delete':
                     if (update.graph) {
-                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
+                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope');
                     }
                     operations.push({
                         type: 'delete',
@@ -415,7 +317,7 @@ class RdfSparqlAdapter {
                     break;
                 case 'deletewhere':
                     if (update.graph) {
-                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
+                        throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope');
                     }
                     operations.push(this.compileDeleteWhere(update.delete, basePath, defaultGraph));
                     break;
@@ -423,7 +325,7 @@ class RdfSparqlAdapter {
                     operations.push(this.compileInsertDeleteWhere(update, basePath, defaultGraph));
                     break;
                 default:
-                    throw new UnsupportedSparqlQueryError('Unsupported SPARQL UPDATE operation fallback to compatibility engine');
+                    throw new UnsupportedSparqlQueryError('Unsupported SPARQL UPDATE operation');
             }
         }
         const inserts = operations
@@ -446,7 +348,7 @@ class RdfSparqlAdapter {
             return sum;
         }, 0);
         if (inserts.length + deletes.length + deleteWhereCount === 0) {
-            throw new UnsupportedSparqlQueryError('SPARQL UPDATE without data quads fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('SPARQL UPDATE without data quads');
         }
         return { operations, inserts, deletes };
     }
@@ -462,7 +364,7 @@ class RdfSparqlAdapter {
         const hasInsertTemplate = (update.insert?.length ?? 0) > 0;
         const hasDeleteTemplate = (update.delete?.length ?? 0) > 0;
         if (!hasInsertTemplate && !hasDeleteTemplate) {
-            throw new UnsupportedSparqlQueryError('DELETE/INSERT WHERE without DELETE or INSERT template fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('DELETE/INSERT WHERE without DELETE or INSERT template');
         }
         const label = hasInsertTemplate && hasDeleteTemplate
             ? 'DELETE/INSERT WHERE'
@@ -486,13 +388,13 @@ class RdfSparqlAdapter {
             ? this.compileGraphQuadsTemplate(update.insert ?? [], basePath, 'INSERT template', withGraph, { graphVariables })
             : [];
         if (hasInsertTemplate && inserts.length === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without INSERT template fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without INSERT template`);
         }
         const deletes = hasDeleteTemplate
             ? this.compileGraphQuadsTemplate(update.delete ?? [], basePath, 'DELETE template', withGraph, { graphVariables })
             : [];
         if (hasDeleteTemplate && deletes.length === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without DELETE template fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without DELETE template`);
         }
         if (hasInsertTemplate && !hasDeleteTemplate) {
             return {
@@ -534,7 +436,7 @@ class RdfSparqlAdapter {
         const compiledGraphs = graphs.map((graph) => {
             const compiled = this.compileGraphTerm(graph, basePath);
             if (compiled === null || isCompiledVariable(compiled)) {
-                throw new UnsupportedSparqlQueryError(`${label} ${clause} graph outside basePath fallback to compatibility engine`);
+                throw new UnsupportedSparqlQueryError(`${label} ${clause} graph outside basePath`);
             }
             return compiled;
         });
@@ -590,7 +492,7 @@ class RdfSparqlAdapter {
         }
         const compiled = this.compileGraphTerm(graph, basePath);
         if (compiled === null || isCompiledVariable(compiled)) {
-            throw new UnsupportedSparqlQueryError(`${label} WITH graph outside basePath fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} WITH graph outside basePath`);
         }
         return compiled;
     }
@@ -599,7 +501,7 @@ class RdfSparqlAdapter {
     }
     queryFromUpdateWhere(patterns, basePath, label, dataset = {}) {
         if (patterns.length === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns`);
         }
         const state = new CompileState(basePath);
         this.assertScopedUpdateWherePatterns(patterns, basePath, label, Boolean(dataset.defaultGraph), dataset.namedGraph);
@@ -609,13 +511,13 @@ class RdfSparqlAdapter {
         state.assertDependentGroupsShareRequiredVariables();
         this.assertFiniteUpdateGraphVariables(state.query, basePath, label);
         if (state.query.patterns.length === 0 && (state.query.unions?.length ?? 0) === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without required graph BGP patterns fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without required graph BGP patterns`);
         }
         return state.query;
     }
     queryFromUpdateTemplate(template, label) {
         if (template.length === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns`);
         }
         return {
             patterns: template.map((pattern) => ({
@@ -635,31 +537,31 @@ class RdfSparqlAdapter {
             if (item.type === 'graph') {
                 if (item.name.termType === 'Variable') {
                     if (!options.graphVariables?.has(item.name.value)) {
-                        throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                        throw new UnsupportedSparqlQueryError(`${label} GRAPH variables`);
                     }
                     graph = (0, RdfQueryExecutor_1.variable)(item.name.value);
                 }
                 else if (item.name.termType !== 'NamedNode') {
-                    throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                    throw new UnsupportedSparqlQueryError(`${label} GRAPH variables`);
                 }
                 else {
                     graph = this.compileGraphTerm(item.name, basePath) ?? undefined;
                 }
             }
             else if (!graph) {
-                throw new UnsupportedSparqlQueryError(`${label} default graph fallback to compatibility engine`);
+                throw new UnsupportedSparqlQueryError(`${label} default graph`);
             }
             if (!graph || graph === null) {
-                throw new UnsupportedSparqlQueryError(`${label} graph outside basePath fallback to compatibility engine`);
+                throw new UnsupportedSparqlQueryError(`${label} graph outside basePath`);
             }
             const state = new CompileState(basePath);
             for (const triple of this.updateTemplateTriples(item)) {
                 if (!isSimpleTerm(triple.predicate)) {
-                    throw new UnsupportedSparqlQueryError(`${label} property path templates fallback to compatibility engine`);
+                    throw new UnsupportedSparqlQueryError(`${label} property path templates`);
                 }
                 const patterns = this.compileTriple(triple, graph, state);
                 if (patterns.length !== 1) {
-                    throw new UnsupportedSparqlQueryError(`${label} property path templates fallback to compatibility engine`);
+                    throw new UnsupportedSparqlQueryError(`${label} property path templates`);
                 }
                 const pattern = patterns[0];
                 this.assertSafeUpdateTemplatePattern(pattern, label);
@@ -745,12 +647,12 @@ class RdfSparqlAdapter {
     assertSafeUpdateTemplatePattern(pattern, label) {
         const terms = [pattern.subject, pattern.predicate, pattern.object];
         if (terms.some((term) => term && 'termType' in term && term.termType === 'BlankNode')) {
-            throw new UnsupportedSparqlQueryError(`${label} blank node templates fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} blank node templates`);
         }
     }
     assertScopedUpdateWherePatterns(patterns, basePath, label, inGraph, namedGraph) {
         if (patterns.length === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without WHERE patterns`);
         }
         for (const pattern of patterns) {
             switch (pattern.type) {
@@ -758,16 +660,16 @@ class RdfSparqlAdapter {
                     if (pattern.name.termType === 'Variable') {
                     }
                     else if (pattern.name.termType !== 'NamedNode') {
-                        throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                        throw new UnsupportedSparqlQueryError(`${label} GRAPH variables`);
                     }
                     else if (!pattern.name.value.startsWith(basePath)) {
-                        throw new UnsupportedSparqlQueryError(`${label} graph outside basePath fallback to compatibility engine`);
+                        throw new UnsupportedSparqlQueryError(`${label} graph outside basePath`);
                     }
                     this.assertScopedUpdateWherePatterns(pattern.patterns, basePath, label, true, namedGraph);
                     break;
                 case 'bgp':
                     if (!inGraph) {
-                        throw new UnsupportedSparqlQueryError(`${label} default graph fallback to compatibility engine`);
+                        throw new UnsupportedSparqlQueryError(`${label} default graph`);
                     }
                     break;
                 case 'optional':
@@ -784,7 +686,7 @@ class RdfSparqlAdapter {
                     break;
                 default:
                     if ('queryType' in pattern) {
-                        throw new UnsupportedSparqlQueryError(`${label} subqueries fallback to compatibility engine`);
+                        throw new UnsupportedSparqlQueryError(`${label} subqueries`);
                     }
                     break;
             }
@@ -794,7 +696,7 @@ class RdfSparqlAdapter {
         const unboundedVariables = new Set();
         this.collectUnboundedUpdateGraphVariables(query, basePath, new Set(), unboundedVariables);
         if (unboundedVariables.size > 0) {
-            throw new UnsupportedSparqlQueryError(`${label} GRAPH variables require finite named graph filters fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} GRAPH variables require finite named graph filters`);
         }
     }
     collectUnboundedUpdateGraphVariables(query, basePath, inheritedFiniteVariables, unboundedVariables) {
@@ -854,7 +756,7 @@ class RdfSparqlAdapter {
         for (const item of items) {
             if (item.type !== 'graph') {
                 if (!defaultGraph) {
-                    throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph fallback to compatibility engine');
+                    throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph');
                 }
                 for (const triple of item.triples) {
                     quads.push(this.compileUpdateTriple(triple, defaultGraph));
@@ -862,10 +764,10 @@ class RdfSparqlAdapter {
                 continue;
             }
             if (item.name.termType !== 'NamedNode') {
-                throw new UnsupportedSparqlQueryError('SPARQL UPDATE GRAPH variables fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE GRAPH variables');
             }
             if (!item.name.value.startsWith(basePath)) {
-                throw new UnsupportedSparqlQueryError('SPARQL UPDATE graph outside basePath fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('SPARQL UPDATE graph outside basePath');
             }
             for (const triple of this.updateTemplateTriples(item)) {
                 quads.push(this.compileUpdateTriple(triple, item.name));
@@ -881,7 +783,7 @@ class RdfSparqlAdapter {
             ? n3_1.DataFactory.namedNode(defaultGraph)
             : defaultGraph;
         if (basePath && !graph.value.startsWith(basePath)) {
-            throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph outside basePath fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph outside basePath');
         }
         return graph;
     }
@@ -981,7 +883,7 @@ class RdfSparqlAdapter {
                     break;
                 default:
                     if ('queryType' in pattern) {
-                        throw new UnsupportedSparqlQueryError('Subqueries fallback to compatibility engine');
+                        throw new UnsupportedSparqlQueryError('Subqueries');
                     }
                     throw new UnsupportedSparqlQueryError(`Unsupported SPARQL pattern: ${pattern.type ?? 'unknown'}`);
             }
@@ -1006,7 +908,7 @@ class RdfSparqlAdapter {
         branchState.assertBindVariablesSafe();
         branchState.assertValuesVariablesBoundByRequiredPatterns();
         if (branchState.query.patterns.length === 0 && (branchState.query.unions?.length ?? 0) === 0) {
-            throw new UnsupportedSparqlQueryError('UNION branch without required BGP fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('UNION branch without required BGP');
         }
         return [{
                 patterns: branchState.query.patterns,
@@ -1026,10 +928,10 @@ class RdfSparqlAdapter {
         minusState.assertBindVariablesSafe();
         minusState.assertValuesVariablesBoundByRequiredPatterns();
         if (minusState.query.minus?.length || minusState.query.exists?.length) {
-            throw new UnsupportedSparqlQueryError(`Nested ${label} fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`Nested ${label}`);
         }
         if (minusState.query.patterns.length === 0 && (minusState.query.unions?.length ?? 0) === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without required BGP fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without required BGP`);
         }
         return {
             patterns: minusState.query.patterns,
@@ -1046,10 +948,10 @@ class RdfSparqlAdapter {
         existsState.assertBindVariablesSafe();
         existsState.assertValuesVariablesBoundByRequiredPatterns();
         if (existsState.query.minus?.length || existsState.query.exists?.length) {
-            throw new UnsupportedSparqlQueryError(`Nested ${label} fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`Nested ${label}`);
         }
         if (existsState.query.patterns.length === 0 && (existsState.query.unions?.length ?? 0) === 0) {
-            throw new UnsupportedSparqlQueryError(`${label} without required BGP fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} without required BGP`);
         }
         return {
             patterns: existsState.query.patterns,
@@ -1066,7 +968,7 @@ class RdfSparqlAdapter {
         }
         const pattern = expression.args[0];
         if (!pattern || !isPattern(pattern)) {
-            throw new UnsupportedSparqlQueryError('FILTER NOT EXISTS without graph pattern fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('FILTER NOT EXISTS without graph pattern');
         }
         return pattern.type === 'group'
             ? pattern.patterns
@@ -1078,7 +980,7 @@ class RdfSparqlAdapter {
         }
         const pattern = expression.args[0];
         if (!pattern || !isPattern(pattern)) {
-            throw new UnsupportedSparqlQueryError('FILTER EXISTS without graph pattern fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('FILTER EXISTS without graph pattern');
         }
         return pattern.type === 'group'
             ? pattern.patterns
@@ -1148,7 +1050,7 @@ class RdfSparqlAdapter {
     }
     graphScopeFilterValues(scope) {
         if (isCompiledVariable(scope)) {
-            throw new UnsupportedSparqlQueryError('GRAPH variable dataset scope fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('GRAPH variable dataset scope');
         }
         if (isRdfJsTerm(scope)) {
             return [scope];
@@ -1157,7 +1059,7 @@ class RdfSparqlAdapter {
         if (Array.isArray(values) && values.every((value) => value && typeof value === 'object' && 'termType' in value)) {
             return values;
         }
-        throw new UnsupportedSparqlQueryError('GRAPH variable dataset scope fallback to compatibility engine');
+        throw new UnsupportedSparqlQueryError('GRAPH variable dataset scope');
     }
     compileBind(pattern, basePath) {
         return {
@@ -1183,7 +1085,7 @@ class RdfSparqlAdapter {
             };
         }
         if (!isOperationExpression(normalized)) {
-            throw new UnsupportedSparqlQueryError(`${label} expression fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${label} expression`);
         }
         const operator = normalized.operator.toLowerCase();
         if (operator === 'str') {
@@ -1261,7 +1163,7 @@ class RdfSparqlAdapter {
                 language: this.compileBindExpression(this.expressionArg(normalized.args[1]), basePath),
             };
         }
-        throw new UnsupportedSparqlQueryError(`${label} ${operator} fallback to compatibility engine`);
+        throw new UnsupportedSparqlQueryError(`${label} ${operator}`);
     }
     compileTriple(triple, graph, state) {
         const subject = this.compileTerm(triple.subject);
@@ -1271,7 +1173,7 @@ class RdfSparqlAdapter {
             return pathPatterns;
         }
         if (!isSimpleTerm(triple.predicate)) {
-            throw new UnsupportedSparqlQueryError('Property paths fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('Property paths');
         }
         return [{
                 graph,
@@ -1305,10 +1207,10 @@ class RdfSparqlAdapter {
         }
         const segments = this.flattenFixedLengthPath(predicate);
         if (!segments) {
-            throw new UnsupportedSparqlQueryError('Property paths fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('Property paths');
         }
         if (segments.length === 0) {
-            throw new UnsupportedSparqlQueryError('Empty property paths fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('Empty property paths');
         }
         const patterns = [];
         let currentSubject = subject;
@@ -1412,7 +1314,7 @@ class RdfSparqlAdapter {
             return (0, RdfQueryExecutor_1.variable)(term.value);
         }
         if (term.termType === 'Quad') {
-            throw new UnsupportedSparqlQueryError('RDF-star terms fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('RDF-star terms');
         }
         return term;
     }
@@ -1461,11 +1363,11 @@ class RdfSparqlAdapter {
     }
     compileConstructTemplate(query) {
         if (!query.template || query.template.length === 0) {
-            throw new UnsupportedSparqlQueryError('CONSTRUCT without template fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('CONSTRUCT without template');
         }
         return query.template.map((triple) => {
             if (!isSimpleTerm(triple.predicate)) {
-                throw new UnsupportedSparqlQueryError('CONSTRUCT property paths fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('CONSTRUCT property paths');
             }
             if (triple.predicate.termType !== 'NamedNode' && triple.predicate.termType !== 'Variable') {
                 throw new UnsupportedSparqlQueryError('CONSTRUCT predicates must be IRIs or variables');
@@ -1481,7 +1383,7 @@ class RdfSparqlAdapter {
         if (query.variables.length === 1 && query.variables[0] instanceof sparqljs_1.Wildcard) {
             const variables = visibleSelectVariables(query);
             if (variables.length === 0) {
-                throw new UnsupportedSparqlQueryError('DESCRIBE wildcard without visible variables fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('DESCRIBE wildcard without visible variables');
             }
             const unboundVariable = variables.find((variable) => !queryBindsVariableInRequiredShape(rdfQuery, variable));
             if (unboundVariable) {
@@ -1502,7 +1404,7 @@ class RdfSparqlAdapter {
             throw new UnsupportedSparqlQueryError('DESCRIBE targets must be IRIs or bound variables locally');
         });
         if (targets.length === 0) {
-            throw new UnsupportedSparqlQueryError('DESCRIBE without targets fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('DESCRIBE without targets');
         }
         return targets;
     }
@@ -1516,7 +1418,7 @@ class RdfSparqlAdapter {
         const rdfQuery = state.query;
         if (query.variables.length === 1 && query.variables[0] instanceof sparqljs_1.Wildcard) {
             if ((rdfQuery.groupBy?.length ?? 0) > 0) {
-                throw new UnsupportedSparqlQueryError('Wildcard grouped SELECT fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('Wildcard grouped SELECT');
             }
             return visibleSelectVariables(query);
         }
@@ -1529,11 +1431,11 @@ class RdfSparqlAdapter {
                 continue;
             }
             if (!isVariableExpression(variable)) {
-                throw new UnsupportedSparqlQueryError('Wildcard mixed with explicit SELECT projections fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('Wildcard mixed with explicit SELECT projections');
             }
             if (!isAggregateExpression(variable.expression)) {
                 if ((rdfQuery.groupBy?.length ?? 0) > 0) {
-                    throw new UnsupportedSparqlQueryError('Grouped SELECT expression projection fallback to compatibility engine');
+                    throw new UnsupportedSparqlQueryError('Grouped SELECT expression projection');
                 }
                 const alias = variable.variable.value;
                 if (variables.includes(alias)
@@ -1562,7 +1464,7 @@ class RdfSparqlAdapter {
         const type = this.aggregateType(aggregate.aggregation);
         const aggregateExpression = aggregate.expression;
         if (type !== 'count' && isWildcardTerm(aggregateExpression)) {
-            throw new UnsupportedSparqlQueryError(`${type.toUpperCase()}(*) fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`${type.toUpperCase()}(*)`);
         }
         const variable = isWildcardTerm(aggregateExpression)
             ? undefined
@@ -1589,7 +1491,7 @@ class RdfSparqlAdapter {
             case 'max':
                 return aggregation.toLowerCase();
             default:
-                throw new UnsupportedSparqlQueryError(`Aggregate ${aggregation} fallback to compatibility engine`);
+                throw new UnsupportedSparqlQueryError(`Aggregate ${aggregation}`);
         }
     }
     assertNumericAggregateSafe(variable, state) {
@@ -1645,7 +1547,7 @@ class RdfSparqlAdapter {
         }
         const rdfQuery = state.query;
         if ((rdfQuery.aggregates?.length ?? 0) === 0 && !rdfQuery.aggregate) {
-            throw new UnsupportedSparqlQueryError('HAVING without aggregate fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('HAVING without aggregate');
         }
         const filters = having.flatMap((expression) => this.compileHavingFilter(expression, state));
         return filters.length > 0 ? filters : undefined;
@@ -1661,7 +1563,7 @@ class RdfSparqlAdapter {
         }
         const binary = this.binaryFilter(operator);
         if (!binary) {
-            throw new UnsupportedSparqlQueryError(`HAVING ${operator} fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`HAVING ${operator}`);
         }
         return [this.compileHavingBinaryFilter(binary, normalized.args[0], normalized.args[1], state)];
     }
@@ -1731,7 +1633,7 @@ class RdfSparqlAdapter {
         }
         const aggregates = rdfQuery.aggregates ?? (rdfQuery.aggregate ? [rdfQuery.aggregate] : []);
         if (aggregates.length === 0) {
-            throw new UnsupportedSparqlQueryError('GROUP BY without aggregate fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('GROUP BY without aggregate');
         }
         const groupableVariables = new Set([
             ...rdfQuery.patterns.flatMap((pattern) => variablesInPattern(pattern)),
@@ -1761,7 +1663,7 @@ class RdfSparqlAdapter {
             throw new UnsupportedSparqlQueryError('Grouped local queries require aggregate projections to be aggregate aliases');
         }
         if (variables.some((variableName) => !groupVariables.has(variableName) && !aggregateAliases.has(variableName))) {
-            throw new UnsupportedSparqlQueryError('Grouped SELECT projection fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('Grouped SELECT projection');
         }
     }
     compileOrder(order, state) {
@@ -1841,7 +1743,7 @@ class RdfSparqlAdapter {
         if (operator === 'in' || operator === 'notin') {
             const values = expression.args[1];
             if (!Array.isArray(values)) {
-                throw new UnsupportedSparqlQueryError('FILTER IN tuple fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('FILTER IN tuple');
             }
             const functionFilter = this.compileFunctionInFilter(this.expressionArg(expression.args[0]), values, operator === 'notin');
             if (functionFilter) {
@@ -1867,7 +1769,7 @@ class RdfSparqlAdapter {
                     flags: operator === 'regex' && flags ? this.literalString(this.expressionArg(flags)) : undefined,
                 }];
         }
-        throw new UnsupportedSparqlQueryError(`FILTER ${operator} fallback to compatibility engine`);
+        throw new UnsupportedSparqlQueryError(`FILTER ${operator}`);
     }
     compileDisjunctiveFilterBranches(expression) {
         const normalized = this.normalizeFunctionCallExpression(expression);
@@ -1917,7 +1819,7 @@ class RdfSparqlAdapter {
                 ? filter.value === undefined ? [] : [filter.value]
                 : filter.values ?? [];
             if (branchValues.length === 0) {
-                throw new UnsupportedSparqlQueryError('FILTER OR branch without values fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('FILTER OR branch without values');
             }
             for (const value of branchValues) {
                 const key = this.filterValueKey(value);
@@ -1928,7 +1830,7 @@ class RdfSparqlAdapter {
             }
         }
         if (!variable || values.length === 0) {
-            throw new UnsupportedSparqlQueryError('FILTER OR without equality branches fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('FILTER OR without equality branches');
         }
         return {
             variable,
@@ -2285,7 +2187,7 @@ class RdfSparqlAdapter {
         if (operator === 'in' || operator === 'notin') {
             const values = expression.args[1];
             if (!Array.isArray(values)) {
-                throw new UnsupportedSparqlQueryError('FILTER negated IN tuple fallback to compatibility engine');
+                throw new UnsupportedSparqlQueryError('FILTER negated IN tuple');
             }
             const functionFilter = this.compileFunctionInFilter(this.expressionArg(expression.args[0]), values, operator === 'in');
             if (functionFilter) {
@@ -2311,7 +2213,7 @@ class RdfSparqlAdapter {
                     flags: operator === 'regex' && flags ? this.literalString(this.expressionArg(flags)) : undefined,
                 }];
         }
-        throw new UnsupportedSparqlQueryError(`FILTER !${operator} fallback to compatibility engine`);
+        throw new UnsupportedSparqlQueryError(`FILTER !${operator}`);
     }
     expressionArg(value) {
         if (!value || value.type === 'bgp') {
@@ -2418,7 +2320,7 @@ class RdfSparqlAdapter {
             case '$regex':
                 return '$notRegex';
             default:
-                throw new UnsupportedSparqlQueryError(`FILTER !${operator} fallback to compatibility engine`);
+                throw new UnsupportedSparqlQueryError(`FILTER !${operator}`);
         }
     }
     negateTermTestFilter(filter) {
@@ -2434,7 +2336,7 @@ class RdfSparqlAdapter {
                     operator: '$notSameTerm',
                 };
             default:
-                throw new UnsupportedSparqlQueryError(`FILTER !${filter.operator} fallback to compatibility engine`);
+                throw new UnsupportedSparqlQueryError(`FILTER !${filter.operator}`);
         }
     }
     normalizeFunctionCallExpression(expression) {
@@ -2442,14 +2344,14 @@ class RdfSparqlAdapter {
             return expression;
         }
         if (expression.distinct) {
-            throw new UnsupportedSparqlQueryError('DISTINCT function calls fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('DISTINCT function calls');
         }
         const functionIri = typeof expression.function === 'string'
             ? expression.function
             : expression.function.value;
         const operator = this.xpathFunctionOperator(functionIri);
         if (!operator) {
-            throw new UnsupportedSparqlQueryError(`Unsupported SPARQL function ${functionIri} fallback to compatibility engine`);
+            throw new UnsupportedSparqlQueryError(`Unsupported SPARQL function ${functionIri}`);
         }
         return {
             type: 'operation',
@@ -2535,7 +2437,7 @@ class CompileState {
     finishOptional() {
         const frame = this.optionalStack.pop();
         if (!frame) {
-            throw new UnsupportedSparqlQueryError('OPTIONAL scope fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('OPTIONAL scope');
         }
         if (frame.patterns.length > 0
             || frame.filters.length > 0
@@ -2719,7 +2621,7 @@ class CompileState {
     currentOptionalFrame() {
         const frame = this.peekOptionalFrame();
         if (!frame) {
-            throw new UnsupportedSparqlQueryError('OPTIONAL scope fallback to compatibility engine');
+            throw new UnsupportedSparqlQueryError('OPTIONAL scope');
         }
         return frame;
     }