@undefineds.co/xpod 0.3.18 → 0.3.23

package/dist/storage/rdf/RdfSparqlAdapter.js

@@ -68,13 +68,14 @@ class RdfSparqlAdapter {
             describeTargets,
         };
     }
-    compileUpdateDelta(query, basePath) {
+    compileUpdateDelta(query, basePath, options = {}) {
         const parsed = typeof query === 'string'
             ? new sparqljs_1.Parser({ baseIRI: basePath }).parse(query)
             : query;
         if (parsed.type !== 'update') {
             throw new UnsupportedSparqlQueryError('Only SPARQL UPDATE can compile into update delta');
         }
+        const defaultGraph = this.compileUpdateDefaultGraph(options.defaultGraph, basePath);
         const operations = [];
         for (const update of parsed.updates) {
             if (!('updateType' in update)) {
@@ -87,7 +88,7 @@ class RdfSparqlAdapter {
                     }
                     operations.push({
                         type: 'insert',
-                        quads: this.compileUpdateGraphQuads(update.insert, basePath),
+                        quads: this.compileUpdateGraphQuads(update.insert, basePath, defaultGraph),
                     });
                     break;
                 case 'delete':
@@ -96,17 +97,17 @@ class RdfSparqlAdapter {
                     }
                     operations.push({
                         type: 'delete',
-                        quads: this.compileUpdateGraphQuads(update.delete, basePath),
+                        quads: this.compileUpdateGraphQuads(update.delete, basePath, defaultGraph),
                     });
                     break;
                 case 'deletewhere':
                     if (update.graph) {
                         throw new UnsupportedSparqlQueryError('SPARQL UPDATE WITH/default graph scope fallback to compatibility engine');
                     }
-                    operations.push(this.compileDeleteWhere(update.delete, basePath));
+                    operations.push(this.compileDeleteWhere(update.delete, basePath, defaultGraph));
                     break;
                 case 'insertdelete':
-                    operations.push(this.compileInsertDeleteWhere(update, basePath));
+                    operations.push(this.compileInsertDeleteWhere(update, basePath, defaultGraph));
                     break;
                 default:
                     throw new UnsupportedSparqlQueryError('Unsupported SPARQL UPDATE operation fallback to compatibility engine');
@@ -136,15 +137,15 @@ class RdfSparqlAdapter {
         }
         return { operations, inserts, deletes };
     }
-    compileDeleteWhere(items, basePath) {
-        const template = this.compileGraphQuadsTemplate(items, basePath, 'DELETE WHERE');
+    compileDeleteWhere(items, basePath, defaultGraph) {
+        const template = this.compileGraphQuadsTemplate(items, basePath, 'DELETE WHERE', defaultGraph);
         return {
             type: 'deleteWhere',
             query: this.queryFromUpdateTemplate(template, 'DELETE WHERE'),
             template,
         };
     }
-    compileInsertDeleteWhere(update, basePath) {
+    compileInsertDeleteWhere(update, basePath, defaultGraph) {
         const hasInsertTemplate = (update.insert?.length ?? 0) > 0;
         const hasDeleteTemplate = (update.delete?.length ?? 0) > 0;
         if (!hasInsertTemplate && !hasDeleteTemplate) {
@@ -155,7 +156,7 @@ class RdfSparqlAdapter {
             : hasInsertTemplate
                 ? 'INSERT WHERE'
                 : 'DELETE WHERE';
-        const withGraph = this.compileWithGraph(update.graph, basePath, label);
+        const withGraph = this.compileWithGraph(update.graph, basePath, label) ?? defaultGraph;
         const using = this.compileUsingDatasetScope(update.using, basePath, label);
         const queryDefaultGraph = using.hasUsing
             ? using.defaultGraph ?? this.impossibleGraph(basePath)
@@ -167,14 +168,15 @@ class RdfSparqlAdapter {
             defaultGraph: queryDefaultGraph,
             namedGraph: queryNamedGraph,
         });
+        const graphVariables = this.safeUpdateTemplateGraphVariables(query);
         const inserts = hasInsertTemplate
-            ? this.compileGraphQuadsTemplate(update.insert ?? [], basePath, 'INSERT template', withGraph)
+            ? 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`);
         }
         const deletes = hasDeleteTemplate
-            ? this.compileGraphQuadsTemplate(update.delete ?? [], basePath, 'DELETE template', withGraph)
+            ? 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`);
@@ -230,7 +232,9 @@ class RdfSparqlAdapter {
     }
     compileQueryDatasetScope(from, basePath) {
         if (!from) {
-            return {};
+            return {
+                defaultGraph: this.compileImplicitQueryDefaultGraph(basePath),
+            };
         }
         const defaultGraphs = from.default ?? [];
         const namedGraphs = from.named ?? [];
@@ -239,12 +243,15 @@ class RdfSparqlAdapter {
                 ? this.compileQueryDatasetGraphs(defaultGraphs, basePath, 'FROM')
                 : namedGraphs.length > 0
                     ? this.impossibleGraph(basePath)
-                    : undefined,
+                    : this.compileImplicitQueryDefaultGraph(basePath),
             namedGraph: namedGraphs.length > 0
                 ? this.compileQueryDatasetGraphs(namedGraphs, basePath, 'FROM NAMED')
                 : undefined,
         };
     }
+    compileImplicitQueryDefaultGraph(basePath) {
+        return implicitQueryDefaultGraph(basePath);
+    }
     compileQueryDatasetGraphs(graphs, basePath, clause) {
         const compiledGraphs = graphs.map((graph) => {
             const compiled = this.compileGraphTerm(graph, basePath);
@@ -287,6 +294,7 @@ class RdfSparqlAdapter {
         state.assertBindVariablesSafe();
         state.assertValuesVariablesBoundByRequiredPatterns();
         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`);
         }
@@ -307,24 +315,32 @@ class RdfSparqlAdapter {
             filters: [],
         };
     }
-    compileGraphQuadsTemplate(items, basePath, label, defaultGraph) {
+    compileGraphQuadsTemplate(items, basePath, label, defaultGraph, options = {}) {
         const template = [];
         for (const item of items) {
             let graph = defaultGraph;
             if (item.type === 'graph') {
-                if (item.name.termType !== 'NamedNode') {
+                if (item.name.termType === 'Variable') {
+                    if (!options.graphVariables?.has(item.name.value)) {
+                        throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
+                    }
+                    graph = (0, RdfLocalQueryEngine_1.variable)(item.name.value);
+                }
+                else if (item.name.termType !== 'NamedNode') {
                     throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
                 }
-                graph = this.compileGraphTerm(item.name, basePath) ?? undefined;
+                else {
+                    graph = this.compileGraphTerm(item.name, basePath) ?? undefined;
+                }
             }
             else if (!graph) {
                 throw new UnsupportedSparqlQueryError(`${label} default graph fallback to compatibility engine`);
             }
-            if (!graph || graph === null || isCompiledVariable(graph)) {
+            if (!graph || graph === null) {
                 throw new UnsupportedSparqlQueryError(`${label} graph outside basePath fallback to compatibility engine`);
             }
             const state = new CompileState(basePath);
-            for (const triple of item.triples) {
+            for (const triple of this.updateTemplateTriples(item)) {
                 if (!isSimpleTerm(triple.predicate)) {
                     throw new UnsupportedSparqlQueryError(`${label} property path templates fallback to compatibility engine`);
                 }
@@ -344,6 +360,75 @@ class RdfSparqlAdapter {
         }
         return template;
     }
+    safeUpdateTemplateGraphVariables(query) {
+        const graphVariables = new Set();
+        this.collectQueryGraphVariables(query, graphVariables);
+        if (graphVariables.size === 0) {
+            return graphVariables;
+        }
+        const constrainedVariables = new Set();
+        this.collectFiniteGraphFilterVariables(query, graphVariables, constrainedVariables);
+        return constrainedVariables;
+    }
+    collectQueryGraphVariables(query, graphVariables) {
+        for (const pattern of query.patterns) {
+            if (pattern.graph && isCompiledVariable(pattern.graph)) {
+                graphVariables.add(pattern.graph.variable);
+            }
+        }
+        for (const optional of query.optional ?? []) {
+            this.collectQueryGraphVariables(Array.isArray(optional) ? { patterns: optional } : optional, graphVariables);
+        }
+        for (const union of query.unions ?? []) {
+            for (const branch of union.branches) {
+                this.collectQueryGraphVariables(branch, graphVariables);
+            }
+        }
+        for (const minus of query.minus ?? []) {
+            this.collectQueryGraphVariables(minus, graphVariables);
+        }
+        for (const exists of query.exists ?? []) {
+            this.collectQueryGraphVariables(exists, graphVariables);
+        }
+    }
+    collectFiniteGraphFilterVariables(query, graphVariables, constrainedVariables) {
+        this.collectFiniteGraphValueVariables(query.values ?? [], graphVariables, constrainedVariables, (value) => (this.isNamedNodeFilterValue(value)));
+        for (const filter of query.filters ?? []) {
+            if (!graphVariables.has(filter.variable)) {
+                continue;
+            }
+            const values = filter.values ?? (filter.value ? [filter.value] : []);
+            if ((filter.operator === '$eq' || filter.operator === '$sameTerm' || filter.operator === '$in')
+                && values.length > 0
+                && values.every((value) => this.isNamedNodeFilterValue(value))) {
+                constrainedVariables.add(filter.variable);
+            }
+        }
+        for (const optional of query.optional ?? []) {
+            this.collectFiniteGraphFilterVariables(Array.isArray(optional) ? { patterns: optional } : optional, graphVariables, constrainedVariables);
+        }
+        for (const union of query.unions ?? []) {
+            for (const branch of union.branches) {
+                this.collectFiniteGraphFilterVariables(branch, graphVariables, constrainedVariables);
+            }
+        }
+        for (const minus of query.minus ?? []) {
+            this.collectFiniteGraphFilterVariables(minus, graphVariables, constrainedVariables);
+        }
+        for (const exists of query.exists ?? []) {
+            this.collectFiniteGraphFilterVariables(exists, graphVariables, constrainedVariables);
+        }
+    }
+    isNamedNodeFilterValue(value) {
+        return Boolean(value && typeof value === 'object' && 'termType' in value && value.termType === 'NamedNode');
+    }
+    updateTemplateTriples(item) {
+        if ('triples' in item && Array.isArray(item.triples)) {
+            return item.triples;
+        }
+        const patterns = item.patterns ?? [];
+        return patterns.flatMap((pattern) => pattern.type === 'bgp' ? pattern.triples : []);
+    }
     assertSafeUpdateTemplatePattern(pattern, label) {
         const terms = [pattern.subject, pattern.predicate, pattern.object];
         if (terms.some((term) => term && 'termType' in term && term.termType === 'BlankNode')) {
@@ -358,9 +443,6 @@ class RdfSparqlAdapter {
             switch (pattern.type) {
                 case 'graph':
                     if (pattern.name.termType === 'Variable') {
-                        if (!namedGraph) {
-                            throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
-                        }
                     }
                     else if (pattern.name.termType !== 'NamedNode') {
                         throw new UnsupportedSparqlQueryError(`${label} GRAPH variables fallback to compatibility engine`);
@@ -395,11 +477,76 @@ class RdfSparqlAdapter {
             }
         }
     }
-    compileUpdateGraphQuads(items, basePath) {
+    assertFiniteUpdateGraphVariables(query, basePath, label) {
+        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`);
+        }
+    }
+    collectUnboundedUpdateGraphVariables(query, basePath, inheritedFiniteVariables, unboundedVariables) {
+        const finiteVariables = new Set(inheritedFiniteVariables);
+        this.collectFiniteGraphValueVariables(query.values ?? [], undefined, finiteVariables, (value) => (this.isBasePathNamedNodeFilterValue(value, basePath)));
+        this.collectFiniteGraphFilterVariablesFromFilters(query.filters ?? [], finiteVariables, basePath);
+        for (const pattern of query.patterns) {
+            if (pattern.graph && isCompiledVariable(pattern.graph) && !finiteVariables.has(pattern.graph.variable)) {
+                unboundedVariables.add(pattern.graph.variable);
+            }
+        }
+        for (const optional of query.optional ?? []) {
+            this.collectUnboundedUpdateGraphVariables(Array.isArray(optional) ? { patterns: optional } : optional, basePath, finiteVariables, unboundedVariables);
+        }
+        for (const union of query.unions ?? []) {
+            for (const branch of union.branches) {
+                this.collectUnboundedUpdateGraphVariables(branch, basePath, finiteVariables, unboundedVariables);
+            }
+        }
+        for (const minus of query.minus ?? []) {
+            this.collectUnboundedUpdateGraphVariables(minus, basePath, finiteVariables, unboundedVariables);
+        }
+        for (const exists of query.exists ?? []) {
+            this.collectUnboundedUpdateGraphVariables(exists, basePath, finiteVariables, unboundedVariables);
+        }
+    }
+    collectFiniteGraphFilterVariablesFromFilters(filters, finiteVariables, basePath) {
+        for (const filter of filters) {
+            const values = filter.values ?? (filter.value ? [filter.value] : []);
+            if ((filter.operator === '$eq' || filter.operator === '$sameTerm' || filter.operator === '$in')
+                && values.length > 0
+                && values.every((value) => this.isBasePathNamedNodeFilterValue(value, basePath))) {
+                finiteVariables.add(filter.variable);
+            }
+        }
+    }
+    isBasePathNamedNodeFilterValue(value, basePath) {
+        return this.isNamedNodeFilterValue(value) && value.value.startsWith(basePath);
+    }
+    collectFiniteGraphValueVariables(sources, graphVariables, finiteVariables, isSafeValue) {
+        for (const source of sources) {
+            if (source.rows.length === 0) {
+                continue;
+            }
+            for (const variable of source.variables) {
+                if (graphVariables && !graphVariables.has(variable)) {
+                    continue;
+                }
+                if (source.rows.every((row) => isSafeValue(row[variable]))) {
+                    finiteVariables.add(variable);
+                }
+            }
+        }
+    }
+    compileUpdateGraphQuads(items, basePath, defaultGraph) {
         const quads = [];
         for (const item of items) {
             if (item.type !== 'graph') {
-                throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph fallback to compatibility engine');
+                if (!defaultGraph) {
+                    throw new UnsupportedSparqlQueryError('SPARQL UPDATE default graph fallback to compatibility engine');
+                }
+                for (const triple of item.triples) {
+                    quads.push(this.compileUpdateTriple(triple, defaultGraph));
+                }
+                continue;
             }
             if (item.name.termType !== 'NamedNode') {
                 throw new UnsupportedSparqlQueryError('SPARQL UPDATE GRAPH variables fallback to compatibility engine');
@@ -407,12 +554,24 @@ class RdfSparqlAdapter {
             if (!item.name.value.startsWith(basePath)) {
                 throw new UnsupportedSparqlQueryError('SPARQL UPDATE graph outside basePath fallback to compatibility engine');
             }
-            for (const triple of item.triples) {
+            for (const triple of this.updateTemplateTriples(item)) {
                 quads.push(this.compileUpdateTriple(triple, item.name));
             }
         }
         return quads;
     }
+    compileUpdateDefaultGraph(defaultGraph, basePath) {
+        if (!defaultGraph) {
+            return undefined;
+        }
+        const graph = typeof defaultGraph === 'string'
+            ? 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');
+        }
+        return graph;
+    }
     compileUpdateTriple(triple, graph) {
         const subject = this.compileUpdateNamedNode(triple.subject, 'subject');
         const predicate = this.compileUpdateNamedNode(triple.predicate, 'predicate');
@@ -523,15 +682,13 @@ class RdfSparqlAdapter {
         this.compilePatterns(this.unionBranchPatterns(branch), graph, branchState, false, namedGraphScope);
         branchState.assertBindVariablesSafe();
         branchState.assertValuesVariablesBoundByRequiredPatterns();
-        if (branchState.query.unions?.length) {
-            throw new UnsupportedSparqlQueryError('Nested UNION fallback to compatibility engine');
-        }
-        if (branchState.query.patterns.length === 0) {
+        if (branchState.query.patterns.length === 0 && (branchState.query.unions?.length ?? 0) === 0) {
             throw new UnsupportedSparqlQueryError('UNION branch without required BGP fallback to compatibility engine');
         }
         return [{
                 patterns: branchState.query.patterns,
                 ...(branchState.query.values?.length ? { values: branchState.query.values } : {}),
+                ...(branchState.query.unions?.length ? { unions: branchState.query.unions } : {}),
                 ...(branchState.query.optional?.length ? { optional: branchState.query.optional } : {}),
                 ...(branchState.query.binds?.length ? { binds: branchState.query.binds } : {}),
                 ...(branchState.query.filters?.length ? { filters: branchState.query.filters } : {}),
@@ -623,22 +780,22 @@ class RdfSparqlAdapter {
             return;
         }
         if (pattern.name.termType === 'Variable') {
-            if (optional) {
-                throw new UnsupportedSparqlQueryError('OPTIONAL GRAPH variable scope fallback to compatibility engine');
-            }
-            if (namedGraphScope) {
-                state.query.filters?.push({
+            const graphScopeFilter = namedGraphScope
+                ? {
                     variable: pattern.name.value,
                     operator: '$in',
                     values: this.graphScopeFilterValues(namedGraphScope),
-                });
-            }
-            else {
-                state.query.filters?.push({
+                }
+                : {
                     variable: pattern.name.value,
                     operator: '$startsWith',
                     value: state.basePath,
-                });
+                };
+            if (optional) {
+                state.addOptionalFilters([graphScopeFilter]);
+            }
+            else {
+                state.query.filters?.push(graphScopeFilter);
             }
         }
         this.compilePatterns(pattern.patterns, graph, state, optional, namedGraphScope);
@@ -730,6 +887,20 @@ class RdfSparqlAdapter {
                 expression: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
             };
         }
+        if (operator === 'coalesce') {
+            return {
+                type: 'coalesce',
+                expressions: normalized.args.map((arg) => (this.compileBindExpression(this.expressionArg(arg), basePath))),
+            };
+        }
+        if (operator === 'if') {
+            return {
+                type: 'if',
+                condition: this.compileFilter(this.expressionArg(normalized.args[0])),
+                then: this.compileBindExpression(this.expressionArg(normalized.args[1]), basePath),
+                else: this.compileBindExpression(this.expressionArg(normalized.args[2]), basePath),
+            };
+        }
         if (operator === 'substr' || operator === 'substring') {
             return {
                 type: 'substring',
@@ -753,6 +924,20 @@ class RdfSparqlAdapter {
                 base: basePath,
             };
         }
+        if (operator === 'strdt') {
+            return {
+                type: 'strdt',
+                lexical: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
+                datatype: this.compileBindExpression(this.expressionArg(normalized.args[1]), basePath),
+            };
+        }
+        if (operator === 'strlang') {
+            return {
+                type: 'strlang',
+                lexical: this.compileBindExpression(this.expressionArg(normalized.args[0]), basePath),
+                language: this.compileBindExpression(this.expressionArg(normalized.args[1]), basePath),
+            };
+        }
         throw new UnsupportedSparqlQueryError(`${label} ${operator} fallback to compatibility engine`);
     }
     compileTriple(triple, graph, state) {
@@ -1014,6 +1199,7 @@ class RdfSparqlAdapter {
         }
         const variables = [];
         const visibleVariables = visibleSelectVariables(query);
+        state.setVisibleSolutionVariables(visibleVariables);
         for (const variable of query.variables) {
             if (isSelectVariableTerm(variable)) {
                 variables.push(variable.value);
@@ -1065,6 +1251,9 @@ class RdfSparqlAdapter {
             as,
             variable,
             distinct: aggregate.distinct,
+            ...(type === 'count' && aggregate.distinct && !variable
+                ? { distinctVariables: state.visibleSolutionVariables }
+                : {}),
         };
     }
     aggregateType(aggregation) {
@@ -1204,6 +1393,9 @@ class RdfSparqlAdapter {
             as: state.nextHavingAggregateVariable(),
             variable,
             distinct: expression.distinct,
+            ...(type === 'count' && expression.distinct && !variable
+                ? { distinctVariables: state.visibleSolutionVariables }
+                : {}),
         };
         localQuery.aggregates = [...(localQuery.aggregates ?? []), hiddenAggregate];
         return hiddenAggregate.as;
@@ -1317,6 +1509,10 @@ class RdfSparqlAdapter {
             if (!Array.isArray(values)) {
                 throw new UnsupportedSparqlQueryError('FILTER IN tuple fallback to compatibility engine');
             }
+            const functionFilter = this.compileFunctionInFilter(this.expressionArg(expression.args[0]), values, operator === 'notin');
+            if (functionFilter) {
+                return [functionFilter];
+            }
             const operand = this.stringOperandVariable(this.expressionArg(expression.args[0]));
             return [{
                     variable: operand.variable,
@@ -1578,6 +1774,31 @@ class RdfSparqlAdapter {
         }
         return null;
     }
+    compileFunctionInFilter(functionExpression, values, negated) {
+        if (!isOperationExpression(functionExpression)) {
+            return null;
+        }
+        const functionOperator = functionExpression.operator.toLowerCase();
+        if (functionOperator === 'lang') {
+            return {
+                variable: this.expressionVariable(this.expressionArg(functionExpression.args[0])),
+                operator: negated ? '$notLangIn' : '$langIn',
+                values: values.map((value) => this.literalString(value)),
+            };
+        }
+        if (functionOperator === 'datatype') {
+            const datatypeValues = values.map((value) => this.filterValue(value));
+            if (datatypeValues.some((value) => !isNamedNodeTerm(value))) {
+                throw new UnsupportedSparqlQueryError('DATATYPE FILTER values must be IRIs locally');
+            }
+            return {
+                variable: this.expressionVariable(this.expressionArg(functionExpression.args[0])),
+                operator: negated ? '$notDatatypeIn' : '$datatypeIn',
+                values: datatypeValues,
+            };
+        }
+        return null;
+    }
     stringLengthVariableOrUndefined(expression) {
         const normalized = this.normalizeFunctionCallExpression(expression);
         if (!isOperationExpression(normalized) || normalized.operator.toLowerCase() !== 'strlen') {
@@ -1686,6 +1907,17 @@ class RdfSparqlAdapter {
                     value: false,
                 }];
         }
+        const termTest = this.compileTermTestFilter(operator, expression);
+        if (termTest) {
+            return [this.negateTermTestFilter(termTest)];
+        }
+        if (operator === 'langmatches') {
+            const filter = this.compileLangMatchesFilter(expression);
+            return [{
+                    ...filter,
+                    operator: '$notLangMatches',
+                }];
+        }
         if (operator === '||') {
             const filter = this.compileOrFilter(expression);
             return [{
@@ -1702,6 +1934,10 @@ class RdfSparqlAdapter {
             if (!Array.isArray(values)) {
                 throw new UnsupportedSparqlQueryError('FILTER negated IN tuple fallback to compatibility engine');
             }
+            const functionFilter = this.compileFunctionInFilter(this.expressionArg(expression.args[0]), values, operator === 'in');
+            if (functionFilter) {
+                return [functionFilter];
+            }
             const operand = this.stringOperandVariable(this.expressionArg(expression.args[0]));
             return [{
                     variable: operand.variable,
@@ -1710,6 +1946,18 @@ class RdfSparqlAdapter {
                     values: values.map((value) => this.filterValue(value)),
                 }];
         }
+        const stringOperator = this.stringFilter(operator);
+        if (stringOperator) {
+            const [left, right, flags] = expression.args;
+            const leftOperand = this.stringOperandVariable(this.expressionArg(left));
+            return [{
+                    variable: leftOperand.variable,
+                    operator: this.negatedStringFilter(stringOperator),
+                    operand: leftOperand.operand,
+                    value: this.literalString(this.expressionArg(right)),
+                    flags: operator === 'regex' && flags ? this.literalString(this.expressionArg(flags)) : undefined,
+                }];
+        }
         throw new UnsupportedSparqlQueryError(`FILTER !${operator} fallback to compatibility engine`);
     }
     expressionArg(value) {
@@ -1806,6 +2054,36 @@ class RdfSparqlAdapter {
                 return null;
         }
     }
+    negatedStringFilter(operator) {
+        switch (operator) {
+            case '$startsWith':
+                return '$notStartsWith';
+            case '$contains':
+                return '$notContains';
+            case '$endsWith':
+                return '$notEndsWith';
+            case '$regex':
+                return '$notRegex';
+            default:
+                throw new UnsupportedSparqlQueryError(`FILTER !${operator} fallback to compatibility engine`);
+        }
+    }
+    negateTermTestFilter(filter) {
+        switch (filter.operator) {
+            case '$termType':
+                return {
+                    ...filter,
+                    operator: '$notTermType',
+                };
+            case '$sameTerm':
+                return {
+                    ...filter,
+                    operator: '$notSameTerm',
+                };
+            default:
+                throw new UnsupportedSparqlQueryError(`FILTER !${filter.operator} fallback to compatibility engine`);
+        }
+    }
     normalizeFunctionCallExpression(expression) {
         if (!isFunctionCallExpression(expression)) {
             return expression;
@@ -1875,6 +2153,9 @@ class CompileState {
         this.orderVariableIndex = 0;
         this.havingAggregateVariableIndex = 0;
     }
+    setVisibleSolutionVariables(variables) {
+        this.visibleSolutionVariables = variables;
+    }
     addPattern(pattern, optional) {
         if (optional) {
             this.currentOptionalFrame().patterns.push(this.scopePattern(pattern));
@@ -2012,6 +2293,9 @@ class CompileState {
                 for (const variableName of variablesInPatterns(branch.patterns)) {
                     bound.add(variableName);
                 }
+                for (const variableName of variablesInUnionGroups(branch.unions ?? [])) {
+                    bound.add(variableName);
+                }
                 for (const bind of branch.binds ?? []) {
                     for (const dependency of variablesInBindExpression(bind.expression)) {
                         if (!bound.has(dependency)) {
@@ -2061,7 +2345,7 @@ class CompileState {
         return queryBindsVariableInRequiredShape(this.query, variableName);
     }
     scopePattern(pattern) {
-        return pattern.graph ? pattern : { ...pattern, graph: { $startsWith: this.basePath } };
+        return pattern.graph ? pattern : { ...pattern, graph: implicitQueryDefaultGraph(this.basePath) };
     }
     currentOptionalFrame() {
         const frame = this.peekOptionalFrame();
@@ -2074,6 +2358,11 @@ class CompileState {
         return this.optionalStack[this.optionalStack.length - 1];
     }
 }
+function implicitQueryDefaultGraph(basePath) {
+    return basePath.endsWith('/')
+        ? { $startsWith: basePath }
+        : n3_1.DataFactory.namedNode(basePath);
+}
 function isVariableTerm(value) {
     return Boolean(value && 'termType' in value && value.termType === 'Variable');
 }
@@ -2284,6 +2573,7 @@ function variablesInUnionGroups(unions) {
     return unique(unions.flatMap((unionGroup) => (unionGroup.branches.flatMap((branch) => [
         ...variablesInPatterns(branch.patterns),
         ...variablesInValuesSources(branch.values ?? []),
+        ...variablesInUnionGroups(branch.unions ?? []),
         ...((branch.binds ?? []).map((bind) => bind.variable)),
     ]))));
 }
@@ -2326,6 +2616,14 @@ function variablesInBindExpression(expression) {
         case 'lowerCase':
         case 'upperCase':
             return variablesInBindExpression(expression.expression);
+        case 'coalesce':
+            return unique(expression.expressions.flatMap((item) => variablesInBindExpression(item)));
+        case 'if':
+            return unique([
+                ...variablesInFilters(expression.condition),
+                ...variablesInBindExpression(expression.then),
+                ...variablesInBindExpression(expression.else),
+            ]);
         case 'substring':
             return unique([
                 ...variablesInBindExpression(expression.expression),
@@ -2336,12 +2634,28 @@ function variablesInBindExpression(expression) {
             return unique(expression.expressions.flatMap((item) => variablesInBindExpression(item)));
         case 'iri':
             return variablesInBindExpression(expression.expression);
+        case 'strdt':
+            return unique([
+                ...variablesInBindExpression(expression.lexical),
+                ...variablesInBindExpression(expression.datatype),
+            ]);
+        case 'strlang':
+            return unique([
+                ...variablesInBindExpression(expression.lexical),
+                ...variablesInBindExpression(expression.language),
+            ]);
         default: {
             const exhaustive = expression;
             return exhaustive;
         }
     }
 }
+function variablesInFilters(filters) {
+    return unique(filters.flatMap((filter) => [
+        filter.variable,
+        filter.variable2,
+    ].filter((value) => Boolean(value))));
+}
 function assertOptionalBindVariablesSafe(rawOptionalGroup, outerBound) {
     const optionalGroup = normalizeOptionalGroupForAdapter(rawOptionalGroup);
     const optionalBound = new Set(outerBound);
@@ -2360,6 +2674,9 @@ function assertOptionalBindVariablesSafe(rawOptionalGroup, outerBound) {
             for (const variableName of variablesInValuesSources(branch.values ?? [])) {
                 branchBound.add(variableName);
             }
+            for (const variableName of variablesInUnionGroups(branch.unions ?? [])) {
+                branchBound.add(variableName);
+            }
             for (const bind of branch.binds ?? []) {
                 assertBindDependenciesBound(bind, branchBound);
                 branchBound.add(bind.variable);
@@ -2412,7 +2729,14 @@ function queryBindsVariableInRequiredShape(query, variableName) {
     if ((query.unions?.length ?? 0) === 0) {
         return false;
     }
-    return (query.unions ?? []).every((group) => (group.branches.every((branch) => patternsBindVariable(branch.patterns, variableName))));
+    return (query.unions ?? []).every((group) => (group.branches.every((branch) => unionBranchBindsVariable(branch, variableName))));
+}
+function unionBranchBindsVariable(branch, variableName) {
+    if (patternsBindVariable(branch.patterns, variableName)) {
+        return true;
+    }
+    const unions = branch.unions ?? [];
+    return unions.length > 0 && unions.every((group) => (group.branches.every((nestedBranch) => unionBranchBindsVariable(nestedBranch, variableName))));
 }
 function normalizeOptionalGroupForAdapter(group) {
     return Array.isArray(group) ? { patterns: group } : group;