@lde/pipeline 0.39.0 → 0.39.1

package/dist/sparql/values.d.ts

@@ -10,7 +10,10 @@ export declare function findSubSelect(patterns: Pattern[]): QuerySelect | undefi
  *
  * Each row's keys become SPARQL variables; NamedNode values become IRIs in the
  * VALUES block. The VALUES clause is injected into the innermost subquery so
- * that SPARQL engines can constrain scans early.
+ * that SPARQL engines can constrain scans early. When that WHERE clause is a
+ * single UNION whose branches all bind the VALUES variables in a required
+ * triple pattern, the VALUES goes into each branch instead: engines such as
+ * QLever plan and evaluate each branch without the outer VALUES otherwise.
  *
  * The caller owns parsing and stringifying; this function operates on the AST.
  */

package/dist/sparql/values.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/sparql/values.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,OAAO,EAGZ,KAAK,cAAc,EACnB,KAAK,WAAW,EAEjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,WAAW,GAAG,SAAS,CAW1E;AA0DD;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,gBAAgB,EAAE,GAC3B,cAAc,CAoBhB"}
+{"version":3,"file":"values.d.ts","sourceRoot":"","sources":["../../src/sparql/values.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,OAAO,EAIZ,KAAK,cAAc,EACnB,KAAK,WAAW,EAEjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAIpD;;;GAGG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,WAAW,GAAG,SAAS,CAW1E;AA0GD;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,cAAc,EACrB,QAAQ,EAAE,gBAAgB,EAAE,GAC3B,cAAc,CAoBhB"}

package/dist/sparql/values.js

@@ -47,8 +47,9 @@ function mapSubSelect(patterns, replacer) {
  * clause into the innermost WHERE clause. This ensures that SPARQL engines
  * constrain scans at the deepest level rather than only at the outer scope.
  *
- * For flat queries (no SubSelect), the base case injects directly — identical
- * to the previous behavior.
+ * For flat queries (no SubSelect), the base case injects directly: in front of
+ * the WHERE clause, or into each branch when it is a single UNION whose branches
+ * all qualify (see {@link bindsAllVariables}).
  */
 function injectIntoInnermost(where, valuesPattern) {
     const mapped = mapSubSelect(where.patterns, (subSelect) => ({
@@ -56,17 +57,54 @@ function injectIntoInnermost(where, valuesPattern) {
         where: injectIntoInnermost(subSelect.where, valuesPattern),
     }));
     if (!mapped) {
-        // Base case: no SubSelect — inject here.
+        // Base case: no SubSelect – inject here, into each UNION branch if safe.
+        const branches = where.patterns.length === 1 && F.isPatternUnion(where.patterns[0])
+            ? where.patterns[0].patterns
+            : [];
+        if (branches.length > 0 &&
+            branches.every((branch) => bindsAllVariables(branch, valuesPattern))) {
+            return F.patternGroup([
+                F.patternUnion(branches.map((branch) => F.patternGroup([valuesPattern, ...branch.patterns], F.gen())), F.gen()),
+            ], F.gen());
+        }
         return F.patternGroup([valuesPattern, ...where.patterns], F.gen());
     }
     return F.patternGroup(mapped, F.gen());
 }
+/**
+ * Whether a UNION branch binds every VALUES variable in a triple pattern of a
+ * top-level BGP that precedes the branch’s first OPTIONAL, MINUS, BIND or other
+ * non-FILTER pattern. Those apply to the solutions before them, so only then
+ * does joining the VALUES first in the branch return the same solutions as
+ * joining it outside the UNION. FILTERs apply to the whole group, wherever they are.
+ */
+function bindsAllVariables(branch, valuesPattern) {
+    const bound = new Set();
+    for (const pattern of branch.patterns) {
+        if (pattern.subType === 'filter')
+            continue;
+        if (!F.isPatternBgp(pattern))
+            break;
+        for (const triple of pattern.triples) {
+            if (triple.type !== 'triple')
+                continue;
+            for (const term of [triple.subject, triple.predicate, triple.object]) {
+                if (F.isTermVariable(term))
+                    bound.add(term.value);
+            }
+        }
+    }
+    return valuesPattern.variables.every((variable) => bound.has(variable.value));
+}
 /**
  * Inject a VALUES clause into a parsed CONSTRUCT query for the given binding rows.
  *
  * Each row's keys become SPARQL variables; NamedNode values become IRIs in the
  * VALUES block. The VALUES clause is injected into the innermost subquery so
- * that SPARQL engines can constrain scans early.
+ * that SPARQL engines can constrain scans early. When that WHERE clause is a
+ * single UNION whose branches all bind the VALUES variables in a required
+ * triple pattern, the VALUES goes into each branch instead: engines such as
+ * QLever plan and evaluate each branch without the outer VALUES otherwise.
  *
  * The caller owns parsing and stringifying; this function operates on the AST.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lde/pipeline",
-  "version": "0.39.0",
+  "version": "0.39.1",
   "repository": {
     "url": "git+https://github.com/ldelements/lde.git",
     "directory": "packages/pipeline"