Put BIND requests back in query when required

lib/sparql.ts

@@ -1,6 +1,6 @@
 import { isomorphic } from 'rdf-isomorphic';
 import * as RDF from '@rdfjs/types'
-import { termToString } from 'rdf-string';
+import { stringToTerm, termToString } from 'rdf-string';
 import {
     AggregateExpression,
     BgpPattern,
@@ -483,7 +483,7 @@ function translateProject(op: Algebra.Project | Algebra.Ask | Algebra.Describe,
         aggregators[translateTerm(agg.variable)] = translateExpression(agg);
 
     // do these in reverse order since variables in one extend might apply to an expression in an other extend
-    let extensions: any = {};
+    let extensions: Record<string, any> = {};
     for (let i = context.extend.length-1; i >= 0; --i)
     {
         let e = context.extend[i];
@@ -514,17 +514,35 @@ function translateProject(op: Algebra.Project | Algebra.Ask | Algebra.Describe,
     {
         select.variables = variables.map((term): Variable => {
             let v = translateTerm(term);
-            if (extensions[v])
+            if (extensions[v]) {
+                let result = extensions[v];
+                delete extensions[v]; // remove used extensions so only unused ones remain
                 return {
-                    variable  : term,
-                    expression: extensions[v]
+                    variable: term,
+                    expression: result,
                 };
+            }
             return term;
         });
         // if the * didn't match any variables this would be empty
         if (select.variables.length === 0)
             select.variables = [new Wildcard()];
     }
+
+    // It is possible that at this point some extensions have not yet been resolved.
+    // These would be bind operations that are not used in a GROUP BY or SELECT body.
+    // We still need to add them though, as they could be relevant to the other extensions.
+    const extensionEntries = Object.entries(extensions);
+    if (extensionEntries.length > 0) {
+        select.where = select.where || [];
+        for (const [ key, value ] of extensionEntries) {
+            select.where.push({
+                type: 'bind',
+                variable: stringToTerm(key) as RDF.Variable,
+                expression: value
+            });
+        }
+    }
 
 
     // convert filter to 'having' if it contains an aggregator variable

test/algebra/sparql11-query/unused-extend.json

@@ -0,0 +1,99 @@
+{
+  "type": "project",
+  "input": {
+    "type": "extend",
+    "input": {
+      "type": "extend",
+      "input": {
+        "type": "bgp",
+        "patterns": [
+          {
+            "type": "pattern",
+            "termType": "Quad",
+            "subject": {
+              "termType": "Variable",
+              "value": "a"
+            },
+            "predicate": {
+              "termType": "NamedNode",
+              "value": "http://mydom#startTime"
+            },
+            "object": {
+              "termType": "Variable",
+              "value": "st"
+            },
+            "graph": {
+              "termType": "DefaultGraph",
+              "value": ""
+            }
+          },
+          {
+            "type": "pattern",
+            "termType": "Quad",
+            "subject": {
+              "termType": "Variable",
+              "value": "a"
+            },
+            "predicate": {
+              "termType": "NamedNode",
+              "value": "http://mydom#endTime"
+            },
+            "object": {
+              "termType": "Variable",
+              "value": "et"
+            },
+            "graph": {
+              "termType": "DefaultGraph",
+              "value": ""
+            }
+          }
+        ]
+      },
+      "variable": {
+        "termType": "Variable",
+        "value": "duration"
+      },
+      "expression": {
+        "type": "expression",
+        "expressionType": "operator",
+        "operator": "-",
+        "args": [
+          {
+            "type": "expression",
+            "expressionType": "term",
+            "term": {
+              "termType": "Variable",
+              "value": "et"
+            }
+          },
+          {
+            "type": "expression",
+            "expressionType": "term",
+            "term": {
+              "termType": "Variable",
+              "value": "st"
+            }
+          }
+        ]
+      }
+    },
+    "variable": {
+      "termType": "Variable",
+      "value": "d"
+    },
+    "expression": {
+      "type": "expression",
+      "expressionType": "term",
+      "term": {
+        "termType": "Variable",
+        "value": "duration"
+      }
+    }
+  },
+  "variables": [
+    {
+      "termType": "Variable",
+      "value": "d"
+    }
+  ]
+}

test/sparql/sparql11-query/unused-extend.sparql

@@ -0,0 +1,7 @@
+PREFIX : <http://mydom#>
+SELECT (?duration as ?d) WHERE {
+  ?a :startTime ?st;
+     :endTime ?et.
+
+  BIND( (?et - ?st) as ?duration)
+}