@comunica/bus-query-operation 1.21.1 → 2.0.1-alpha.6.0

package/lib/ActorQueryOperation.js

@@ -1,61 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMetadata = exports.ActorQueryOperation = exports.KEY_CONTEXT_READONLY = exports.KEY_CONTEXT_QUERY_TIMESTAMP = exports.KEY_CONTEXT_BASEIRI = exports.KEY_CONTEXT_PATTERN_PARENTMETADATA = exports.KEY_CONTEXT_BGP_PATTERNBINDINGS = exports.KEY_CONTEXT_BGP_PARENTMETADATA = exports.KEY_CONTEXT_BGP_CURRENTMETADATA = void 0;
+exports.ActorQueryOperation = void 0;
 const context_entries_1 = require("@comunica/context-entries");
 const core_1 = require("@comunica/core");
 const data_factory_1 = require("@comunica/data-factory");
 const Bindings_1 = require("./Bindings");
-/**
- * @type {string} Context entry for current metadata.
- *                I.e., the metadata that was used to determine the next BGP operation.
- * @value {any} A metadata hash.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_BGP_CURRENTMETADATA = context_entries_1.KeysQueryOperation.bgpCurrentMetadata;
-/**
- * @type {string} Context entry for an array of parent metadata.
- *                I.e., an array of the metadata that was present before materializing the current BGP operations.
- *                This can be passed in 'bgp' actions.
- *                The array entries should correspond to the pattern entries in the BGP.
- * @value {any} An array of metadata hashes.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_BGP_PARENTMETADATA = context_entries_1.KeysQueryOperation.bgpParentMetadata;
-/**
- * @type {string} Context entry for indicating which patterns were bound from variables.
- *                I.e., an array of the same length as the value of KeysQueryOperation.patternParentMetadata,
- *                where each array value corresponds to the pattern bindings for the corresponding pattern.
- * @value {any} An array of {@link PatternBindings}.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_BGP_PATTERNBINDINGS = context_entries_1.KeysQueryOperation.bgpPatternBindings;
-/**
- * @type {string} Context entry for parent metadata.
- *                I.e., the metadata that was present before materializing the current operation.
- *                This can be passed in 'pattern' actions.
- * @value {any} A metadata hash.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_PATTERN_PARENTMETADATA = context_entries_1.KeysQueryOperation.patternParentMetadata;
-/**
- * @type {string} Context entry for query's base IRI.
- * @value {any} A string.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_BASEIRI = context_entries_1.KeysInitSparql.baseIRI;
-/**
- * @type {string} A timestamp representing the current time.
- *                This is required for certain SPARQL operations such as NOW().
- * @value {any} a date.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_QUERY_TIMESTAMP = context_entries_1.KeysInitSparql.queryTimestamp;
-/**
- * @type {string} Context entry for indicating that only read operations are allowed, defaults to false.
- * @value {any} A boolean.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_READONLY = context_entries_1.KeysQueryOperation.readOnly;
 /**
  * A counter that keeps track blank node generated through BNODE() SPARQL
  * expressions.
@@ -72,17 +21,20 @@ let bnodeCounter = 0;
  * * Output: IActorQueryOperationOutput: A bindings stream.
  *
  * @see IActionQueryOperation
- * @see IActorQueryOperationOutput
+ * @see IQueryOperationResult
  */
 class ActorQueryOperation extends core_1.Actor {
+    /**
+     * @param args - @defaultNested {<default_bus> a <cc:components/Bus.jsonld#Bus>} bus
+     */
     constructor(args) {
         super(args);
     }
     /**
      * Safely cast a query operation output to a bindings output.
      * This will throw a runtime error if the output is of the incorrect type.
-     * @param {IActorQueryOperationOutput} output A query operation output.
-     * @return {IActorQueryOperationOutputBindings} A bindings query operation output.
+     * @param {IQueryOperationResult} output A query operation output.
+     * @return {IQueryOperationResultBindings} A bindings query operation output.
      */
     static getSafeBindings(output) {
         ActorQueryOperation.validateQueryOutput(output, 'bindings');
@@ -91,8 +43,8 @@ class ActorQueryOperation extends core_1.Actor {
     /**
      * Safely cast a query operation output to a quads output.
      * This will throw a runtime error if the output is of the incorrect type.
-     * @param {IActorQueryOperationOutput} output A query operation output.
-     * @return {IActorQueryOperationOutputQuads} A quads query operation output.
+     * @param {IQueryOperationResult} output A query operation output.
+     * @return {IQueryOperationResultQuads} A quads query operation output.
      */
     static getSafeQuads(output) {
         ActorQueryOperation.validateQueryOutput(output, 'quads');
@@ -101,36 +53,36 @@ class ActorQueryOperation extends core_1.Actor {
     /**
      * Safely cast a query operation output to a boolean output.
      * This will throw a runtime error if the output is of the incorrect type.
-     * @param {IActorQueryOperationOutput} output A query operation output.
-     * @return {IActorQueryOperationOutputBoolean} A boolean query operation output.
+     * @param {IQueryOperationResult} output A query operation output.
+     * @return {IQueryOperationResultBoolean} A boolean query operation output.
      */
     static getSafeBoolean(output) {
         ActorQueryOperation.validateQueryOutput(output, 'boolean');
         return output;
     }
     /**
-     * Safely cast a query operation output to an update output.
+     * Safely cast a query operation output to a void output.
      * This will throw a runtime error if the output is of the incorrect type.
-     * @param {IActorQueryOperationOutput} output A query operation output.
-     * @return {IActorQueryOperationOutputUpdate} An update query operation output.
+     * @param {IQueryOperationResult} output A query operation output.
+     * @return {IQueryOperationResultVoid} A void query operation output.
      */
-    static getSafeUpdate(output) {
-        ActorQueryOperation.validateQueryOutput(output, 'update');
+    static getSafeVoid(output) {
+        ActorQueryOperation.validateQueryOutput(output, 'void');
         return output;
     }
     /**
      * Convert a metadata callback to a lazy callback where the response value is cached.
-     * @param {() => Promise<{[p: string]: any}>} metadata A metadata callback
+     * @param {() => Promise<IMetadata>} metadata A metadata callback
      * @return {() => Promise<{[p: string]: any}>} The callback where the response will be cached.
      */
     static cachifyMetadata(metadata) {
         let lastReturn;
         // eslint-disable-next-line no-return-assign,@typescript-eslint/no-misused-promises
-        return (metadata && (() => (lastReturn || (lastReturn = metadata()))));
+        return () => (lastReturn || (lastReturn = metadata()));
     }
     /**
      * Throw an error if the output type does not match the expected type.
-     * @param {IActorQueryOperationOutput} output A query operation output.
+     * @param {IQueryOperationResult} output A query operation output.
      * @param {string} expectedType The expected output type.
      */
     static validateQueryOutput(output, expectedType) {
@@ -139,12 +91,21 @@ class ActorQueryOperation extends core_1.Actor {
         }
     }
     static getBaseExpressionContext(context) {
-        if (context) {
-            const now = context.get(context_entries_1.KeysInitSparql.queryTimestamp);
-            const baseIRI = context.get(context_entries_1.KeysInitSparql.baseIRI);
-            return { now, baseIRI };
+        const now = context.get(context_entries_1.KeysInitQuery.queryTimestamp);
+        const baseIRI = context.get(context_entries_1.KeysInitQuery.baseIRI);
+        // Handle two variants of providing extension functions
+        if (context.has(context_entries_1.KeysInitQuery.extensionFunctionCreator) && context.has(context_entries_1.KeysInitQuery.extensionFunctions)) {
+            throw new Error('Illegal simultaneous usage of extensionFunctionCreator and extensionFunctions in context');
+        }
+        let extensionFunctionCreator = context
+            .get(context_entries_1.KeysInitQuery.extensionFunctionCreator);
+        // Convert dictionary-based variant to callback
+        const extensionFunctions = context
+            .get(context_entries_1.KeysInitQuery.extensionFunctions);
+        if (extensionFunctions) {
+            extensionFunctionCreator = functionNamedNode => extensionFunctions[functionNamedNode.value];
         }
-        return {};
+        return { now, baseIRI, extensionFunctionCreator };
     }
     /**
      * Create an options object that can be used to construct a sparqlee synchronous evaluator.
@@ -153,7 +114,10 @@ class ActorQueryOperation extends core_1.Actor {
      *                               If defined, the existence resolver will be defined as `exists`.
      */
     static getExpressionContext(context, mediatorQueryOperation) {
-        return Object.assign(Object.assign({}, this.getBaseExpressionContext(context)), { bnode: (input) => new data_factory_1.BlankNodeBindingsScoped(input || `BNODE_${bnodeCounter++}`) });
+        return {
+            ...this.getBaseExpressionContext(context),
+            bnode: (input) => new data_factory_1.BlankNodeBindingsScoped(input || `BNODE_${bnodeCounter++}`),
+        };
     }
     /**
      * Create an options object that can be used to construct a sparqlee asynchronous evaluator.
@@ -162,8 +126,11 @@ class ActorQueryOperation extends core_1.Actor {
      *                               If defined, the existence resolver will be defined as `exists`.
      */
     static getAsyncExpressionContext(context, mediatorQueryOperation) {
-        const expressionContext = Object.assign(Object.assign({}, this.getBaseExpressionContext(context)), { bnode: (input) => Promise.resolve(new data_factory_1.BlankNodeBindingsScoped(input || `BNODE_${bnodeCounter++}`)) });
-        if (context && mediatorQueryOperation) {
+        const expressionContext = {
+            ...this.getBaseExpressionContext(context),
+            bnode: (input) => Promise.resolve(new data_factory_1.BlankNodeBindingsScoped(input || `BNODE_${bnodeCounter++}`)),
+        };
+        if (mediatorQueryOperation) {
             expressionContext.exists = ActorQueryOperation.createExistenceResolver(context, mediatorQueryOperation);
         }
         return expressionContext;
@@ -175,7 +142,7 @@ class ActorQueryOperation extends core_1.Actor {
      */
     static createExistenceResolver(context, mediatorQueryOperation) {
         return async (expr, bindings) => {
-            const operation = Bindings_1.materializeOperation(expr.input, bindings);
+            const operation = (0, Bindings_1.materializeOperation)(expr.input, bindings);
             const outputRaw = await mediatorQueryOperation.mediate({ operation, context });
             const output = ActorQueryOperation.getSafeBindings(outputRaw);
             return new Promise((resolve, reject) => {
@@ -196,22 +163,10 @@ class ActorQueryOperation extends core_1.Actor {
      * @param context An action context.
      */
     static throwOnReadOnly(context) {
-        if (context && context.get(exports.KEY_CONTEXT_READONLY)) {
+        if (context.get(context_entries_1.KeysQueryOperation.readOnly)) {
             throw new Error(`Attempted a write operation in read-only mode`);
         }
     }
 }
 exports.ActorQueryOperation = ActorQueryOperation;
-/**
- * Helper function to get the metadata of an action output.
- * @param actionOutput An action output, with an optional metadata function.
- * @return The metadata.
- */
-function getMetadata(actionOutput) {
-    if (!actionOutput.metadata) {
-        return Promise.resolve({});
-    }
-    return actionOutput.metadata();
-}
-exports.getMetadata = getMetadata;
 //# sourceMappingURL=ActorQueryOperation.js.map

package/lib/ActorQueryOperationTyped.d.ts

@@ -1,21 +1,16 @@
-import { KeysQueryOperation } from '@comunica/context-entries';
-import type { ActionContext, IActorArgs, IActorTest } from '@comunica/core';
-import type { IActionQueryOperation, IActorQueryOperationOutput } from '@comunica/types';
+import type { IActorTest } from '@comunica/core';
+import type { IQueryOperationResult, IActionContext } from '@comunica/types';
 import type { Algebra } from 'sparqlalgebrajs';
+import type { IActionQueryOperation, IActorQueryOperationArgs } from './ActorQueryOperation';
 import { ActorQueryOperation } from './ActorQueryOperation';
-/**
- * @type {string} Context entry for the current query operation.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-export declare const KEY_CONTEXT_QUERYOPERATION = KeysQueryOperation.operation;
 /**
  * A base implementation for query operation actors for a specific operation type.
  */
 export declare abstract class ActorQueryOperationTyped<O extends Algebra.Operation> extends ActorQueryOperation {
     readonly operationName: string;
-    protected constructor(args: IActorArgs<IActionQueryOperation, IActorTest, IActorQueryOperationOutput>, operationName: string);
+    protected constructor(args: IActorQueryOperationArgs, operationName: string);
     test(action: IActionQueryOperation): Promise<IActorTest>;
-    run(action: IActionQueryOperation): Promise<IActorQueryOperationOutput>;
-    protected abstract testOperation(operation: O, context: ActionContext | undefined): Promise<IActorTest>;
-    protected abstract runOperation(operation: O, context: ActionContext | undefined): Promise<IActorQueryOperationOutput>;
+    run(action: IActionQueryOperation): Promise<IQueryOperationResult>;
+    protected abstract testOperation(operation: O, context: IActionContext): Promise<IActorTest>;
+    protected abstract runOperation(operation: O, context: IActionContext): Promise<IQueryOperationResult>;
 }

package/lib/ActorQueryOperationTyped.js

@@ -1,19 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ActorQueryOperationTyped = exports.KEY_CONTEXT_QUERYOPERATION = void 0;
+exports.ActorQueryOperationTyped = void 0;
 const context_entries_1 = require("@comunica/context-entries");
 const ActorQueryOperation_1 = require("./ActorQueryOperation");
-/**
- * @type {string} Context entry for the current query operation.
- * @deprecated Import this constant from @comunica/context-entries.
- */
-exports.KEY_CONTEXT_QUERYOPERATION = context_entries_1.KeysQueryOperation.operation;
 /**
  * A base implementation for query operation actors for a specific operation type.
  */
 class ActorQueryOperationTyped extends ActorQueryOperation_1.ActorQueryOperation {
     constructor(args, operationName) {
-        super(Object.assign(Object.assign({}, args), { operationName }));
+        super({ ...args, operationName });
         if (!this.operationName) {
             throw new Error('A valid "operationName" argument must be provided.');
         }
@@ -29,12 +24,19 @@ class ActorQueryOperationTyped extends ActorQueryOperation_1.ActorQueryOperation
         return this.testOperation(operation, action.context);
     }
     async run(action) {
+        // Log to physical plan
+        const physicalQueryPlanLogger = action.context
+            .get(context_entries_1.KeysInitQuery.physicalQueryPlanLogger);
+        if (physicalQueryPlanLogger) {
+            physicalQueryPlanLogger.logOperation(action.operation.type, undefined, action.operation, action.context.get(context_entries_1.KeysInitQuery.physicalQueryPlanNode), this.name, {});
+            action.context = action.context.set(context_entries_1.KeysInitQuery.physicalQueryPlanNode, action.operation);
+        }
         const operation = action.operation;
-        const subContext = action.context && action.context.set(context_entries_1.KeysQueryOperation.operation, operation);
+        const subContext = action.context.set(context_entries_1.KeysQueryOperation.operation, operation);
         const output = await this.runOperation(operation, subContext);
-        if (output.metadata) {
-            output.metadata =
-                ActorQueryOperation_1.ActorQueryOperation.cachifyMetadata(output.metadata);
+        if ('metadata' in output) {
+            output.metadata = ActorQueryOperation_1.ActorQueryOperation
+                .cachifyMetadata(output.metadata);
         }
         return output;
     }

package/lib/ActorQueryOperationTypedMediated.d.ts

@@ -1,14 +1,13 @@
-import type { Actor, IActorArgs, IActorTest, Mediator } from '@comunica/core';
-import type { IActionQueryOperation, IActorQueryOperationOutput } from '@comunica/types';
 import type { Algebra } from 'sparqlalgebrajs';
+import type { IActorQueryOperationArgs, MediatorQueryOperation } from './ActorQueryOperation';
 import { ActorQueryOperationTyped } from './ActorQueryOperationTyped';
 /**
  * A base implementation for query operation actors for a specific operation type that have a query operation mediator.
  */
 export declare abstract class ActorQueryOperationTypedMediated<O extends Algebra.Operation> extends ActorQueryOperationTyped<O> implements IActorQueryOperationTypedMediatedArgs {
-    readonly mediatorQueryOperation: Mediator<Actor<IActionQueryOperation, IActorTest, IActorQueryOperationOutput>, IActionQueryOperation, IActorTest, IActorQueryOperationOutput>;
+    readonly mediatorQueryOperation: MediatorQueryOperation;
     constructor(args: IActorQueryOperationTypedMediatedArgs, operationName: string);
 }
-export interface IActorQueryOperationTypedMediatedArgs extends IActorArgs<IActionQueryOperation, IActorTest, IActorQueryOperationOutput> {
-    mediatorQueryOperation: Mediator<Actor<IActionQueryOperation, IActorTest, IActorQueryOperationOutput>, IActionQueryOperation, IActorTest, IActorQueryOperationOutput>;
+export interface IActorQueryOperationTypedMediatedArgs extends IActorQueryOperationArgs {
+    mediatorQueryOperation: MediatorQueryOperation;
 }

package/lib/Bindings.d.ts

@@ -1,28 +1,6 @@
-import type { Bindings as _Bindings, BindingsStream } from '@comunica/types';
-import type * as RDF from 'rdf-js';
+import type { Bindings } from '@comunica/types';
+import type * as RDF from '@rdfjs/types';
 import type { Algebra } from 'sparqlalgebrajs';
-export declare type Bindings = _Bindings;
-export type { BindingsStream };
-/**
- * A convenience constructor for bindings based on a given hash.
- * @param {{[p: string]: RDF.Term}} hash A hash that maps variable names to terms.
- * @return {Bindings} The immutable bindings from the hash.
- * @constructor
- */
-export declare function Bindings(hash: Record<string, RDF.Term>): Bindings;
-/**
- * Check if the given object is a bindings object.
- * @param maybeBindings Any object.
- * @return {boolean} If the object is a bindings object.
- */
-export declare function isBindings(maybeBindings: any): boolean;
-/**
- * Convert the given object to a bindings object if it is not a bindings object yet.
- * If it already is a bindings object, return the object as-is.
- * @param maybeBindings Any object.
- * @return {Bindings} A bindings object.
- */
-export declare function ensureBindings(maybeBindings: any): Bindings;
 /**
  * Materialize a term with the given binding.
  *
@@ -42,7 +20,16 @@ export declare function materializeTerm(term: RDF.Term, bindings: Bindings): RDF
  * by the terms bound to the variables in the given bindings.
  * @param {Operation} operation SPARQL algebra operation.
  * @param {Bindings} bindings A bindings object.
- * @param {boolean} strictTargetVariables If target variable bindings (such as on SELECT or BIND) should not be allowed.
+ * @param options Options for materializations.
  * @return Algebra.Operation A new operation materialized with the given bindings.
  */
-export declare function materializeOperation(operation: Algebra.Operation, bindings: Bindings, strictTargetVariables?: boolean): Algebra.Operation;
+export declare function materializeOperation(operation: Algebra.Operation, bindings: Bindings, options?: {
+    /**
+     * If target variable bindings (such as on SELECT or BIND) should not be allowed.
+     */
+    strictTargetVariables?: boolean;
+    /**
+     * If filter expressions should be materialized
+     */
+    bindFilter?: boolean;
+}): Algebra.Operation;

package/lib/Bindings.js

@@ -1,39 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.materializeOperation = exports.materializeTerm = exports.ensureBindings = exports.isBindings = exports.Bindings = void 0;
-const immutable_1 = require("immutable");
+exports.materializeOperation = exports.materializeTerm = void 0;
+const bindings_factory_1 = require("@comunica/bindings-factory");
 const rdf_string_1 = require("rdf-string");
 const sparqlalgebrajs_1 = require("sparqlalgebrajs");
-/**
- * A convenience constructor for bindings based on a given hash.
- * @param {{[p: string]: RDF.Term}} hash A hash that maps variable names to terms.
- * @return {Bindings} The immutable bindings from the hash.
- * @constructor
- */
-// eslint-disable-next-line no-redeclare
-function Bindings(hash) {
-    return immutable_1.Map(hash);
-}
-exports.Bindings = Bindings;
-/**
- * Check if the given object is a bindings object.
- * @param maybeBindings Any object.
- * @return {boolean} If the object is a bindings object.
- */
-function isBindings(maybeBindings) {
-    return immutable_1.Map.isMap(maybeBindings);
-}
-exports.isBindings = isBindings;
-/**
- * Convert the given object to a bindings object if it is not a bindings object yet.
- * If it already is a bindings object, return the object as-is.
- * @param maybeBindings Any object.
- * @return {Bindings} A bindings object.
- */
-function ensureBindings(maybeBindings) {
-    return isBindings(maybeBindings) ? maybeBindings : Bindings(maybeBindings);
-}
-exports.ensureBindings = ensureBindings;
+const BF = new bindings_factory_1.BindingsFactory();
 /**
  * Materialize a term with the given binding.
  *
@@ -48,7 +19,7 @@ exports.ensureBindings = ensureBindings;
  */
 function materializeTerm(term, bindings) {
     if (term.termType === 'Variable') {
-        const value = bindings.get(rdf_string_1.termToString(term));
+        const value = bindings.get(term);
         if (value) {
             return value;
         }
@@ -62,10 +33,14 @@ exports.materializeTerm = materializeTerm;
  * by the terms bound to the variables in the given bindings.
  * @param {Operation} operation SPARQL algebra operation.
  * @param {Bindings} bindings A bindings object.
- * @param {boolean} strictTargetVariables If target variable bindings (such as on SELECT or BIND) should not be allowed.
+ * @param options Options for materializations.
  * @return Algebra.Operation A new operation materialized with the given bindings.
  */
-function materializeOperation(operation, bindings, strictTargetVariables = false) {
+function materializeOperation(operation, bindings, options = {}) {
+    options = {
+        strictTargetVariables: 'strictTargetVariables' in options ? options.strictTargetVariables : false,
+        bindFilter: 'bindFilter' in options ? options.bindFilter : true,
+    };
     return sparqlalgebrajs_1.Util.mapOperation(operation, {
         path(op, factory) {
             // Materialize variables in a path expression.
@@ -86,14 +61,14 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
             // Materialize an extend operation.
             // If strictTargetVariables is true, we throw if the extension target variable is attempted to be bound.
             // Otherwise, we remove the extend operation.
-            if (bindings.has(rdf_string_1.termToString(op.variable))) {
-                if (strictTargetVariables) {
-                    throw new Error(`Tried to bind variable ${rdf_string_1.termToString(op.variable)} in a BIND operator.`);
+            if (bindings.has(op.variable)) {
+                if (options.strictTargetVariables) {
+                    throw new Error(`Tried to bind variable ${(0, rdf_string_1.termToString)(op.variable)} in a BIND operator.`);
                 }
                 else {
                     return {
                         recurse: true,
-                        result: materializeOperation(op.input, bindings, strictTargetVariables),
+                        result: materializeOperation(op.input, bindings, options),
                     };
                 }
             }
@@ -106,10 +81,10 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
             // Materialize a group operation.
             // If strictTargetVariables is true, we throw if the group target variable is attempted to be bound.
             // Otherwise, we just filter out the bound variables.
-            if (strictTargetVariables) {
+            if (options.strictTargetVariables) {
                 for (const variable of op.variables) {
-                    if (bindings.has(rdf_string_1.termToString(variable))) {
-                        throw new Error(`Tried to bind variable ${rdf_string_1.termToString(variable)} in a GROUP BY operator.`);
+                    if (bindings.has(variable)) {
+                        throw new Error(`Tried to bind variable ${(0, rdf_string_1.termToString)(variable)} in a GROUP BY operator.`);
                     }
                 }
                 return {
@@ -117,7 +92,7 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
                     result: op,
                 };
             }
-            const variables = op.variables.filter(variable => !bindings.has(rdf_string_1.termToString(variable)));
+            const variables = op.variables.filter(variable => !bindings.has(variable));
             return {
                 recurse: true,
                 result: factory.createGroup(op.input, variables, op.aggregates),
@@ -127,10 +102,10 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
             // Materialize a project operation.
             // If strictTargetVariables is true, we throw if the project target variable is attempted to be bound.
             // Otherwise, we just filter out the bound variables.
-            if (strictTargetVariables) {
+            if (options.strictTargetVariables) {
                 for (const variable of op.variables) {
-                    if (bindings.has(rdf_string_1.termToString(variable))) {
-                        throw new Error(`Tried to bind variable ${rdf_string_1.termToString(variable)} in a SELECT operator.`);
+                    if (bindings.has(variable)) {
+                        throw new Error(`Tried to bind variable ${(0, rdf_string_1.termToString)(variable)} in a SELECT operator.`);
                     }
                 }
                 return {
@@ -138,30 +113,50 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
                     result: op,
                 };
             }
-            const variables = op.variables.filter(variable => !bindings.has(rdf_string_1.termToString(variable)));
+            const variables = op.variables.filter(variable => !bindings.has(variable));
+            // Only include projected variables in the sub-bindings that will be passed down recursively.
+            // If we don't do this, we may be binding variables that may have the same label, but are not considered equal.
+            const subBindings = BF.bindings(op.variables.map(variable => {
+                const binding = bindings.get(variable);
+                if (binding) {
+                    return [variable, binding];
+                }
+                // eslint-disable-next-line no-useless-return
+                return;
+            }).filter(entry => Boolean(entry)));
             return {
-                recurse: true,
-                result: factory.createProject(op.input, variables),
+                recurse: false,
+                result: factory.createProject(materializeOperation(op.input, subBindings, options), variables),
             };
         },
         values(op, factory) {
             // Materialize a values operation.
             // If strictTargetVariables is true, we throw if the values target variable is attempted to be bound.
             // Otherwise, we just filter out the bound variables and their bindings.
-            if (strictTargetVariables) {
+            if (options.strictTargetVariables) {
                 for (const variable of op.variables) {
-                    if (bindings.has(rdf_string_1.termToString(variable))) {
-                        throw new Error(`Tried to bind variable ${rdf_string_1.termToString(variable)} in a VALUES operator.`);
+                    if (bindings.has(variable)) {
+                        throw new Error(`Tried to bind variable ${(0, rdf_string_1.termToString)(variable)} in a VALUES operator.`);
                     }
                 }
             }
             else {
-                const variables = op.variables.filter(variable => !bindings.has(rdf_string_1.termToString(variable)));
+                const variables = op.variables.filter(variable => !bindings.has(variable));
                 const valueBindings = op.bindings.map(binding => {
-                    const newBinding = Object.assign({}, binding);
-                    bindings.forEach((value, key) => delete newBinding[key]);
-                    return newBinding;
-                });
+                    const newBinding = { ...binding };
+                    let valid = true;
+                    bindings.forEach((value, key) => {
+                        const keyString = (0, rdf_string_1.termToString)(key);
+                        if (keyString in newBinding) {
+                            if (!value.equals(newBinding[keyString])) {
+                                // If the value of the binding is not equal, remove this binding completely from the VALUES clause
+                                valid = false;
+                            }
+                            delete newBinding[keyString];
+                        }
+                    });
+                    return valid ? newBinding : undefined;
+                }).filter(Boolean);
                 return {
                     recurse: true,
                     result: factory.createValues(variables, valueBindings),
@@ -173,6 +168,12 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
             };
         },
         expression(op, factory) {
+            if (!options.bindFilter) {
+                return {
+                    recurse: false,
+                    result: op,
+                };
+            }
             if (op.expressionType === 'term') {
                 // Materialize a term expression
                 return {
@@ -182,12 +183,12 @@ function materializeOperation(operation, bindings, strictTargetVariables = false
             }
             if (op.expressionType === 'aggregate' &&
                 'variable' in op &&
-                bindings.has(rdf_string_1.termToString(op.variable))) {
+                bindings.has(op.variable)) {
                 // Materialize a bound aggregate operation.
                 // If strictTargetVariables is true, we throw if the expression target variable is attempted to be bound.
                 // Otherwise, we ignore this operation.
-                if (strictTargetVariables) {
-                    throw new Error(`Tried to bind ${rdf_string_1.termToString(op.variable)} in a ${op.aggregator} aggregate.`);
+                if (options.strictTargetVariables) {
+                    throw new Error(`Tried to bind ${(0, rdf_string_1.termToString)(op.variable)} in a ${op.aggregator} aggregate.`);
                 }
                 else {
                     return {

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ActorQueryOperation';
+export * from './ActorQueryOperationTyped';
+export * from './ActorQueryOperationTypedMediated';
+export * from './Bindings';

package/{index.js → lib/index.js}

@@ -10,8 +10,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./lib/ActorQueryOperation"), exports);
-__exportStar(require("./lib/ActorQueryOperationTyped"), exports);
-__exportStar(require("./lib/ActorQueryOperationTypedMediated"), exports);
-__exportStar(require("./lib/Bindings"), exports);
+__exportStar(require("./ActorQueryOperation"), exports);
+__exportStar(require("./ActorQueryOperationTyped"), exports);
+__exportStar(require("./ActorQueryOperationTypedMediated"), exports);
+__exportStar(require("./Bindings"), exports);
 //# sourceMappingURL=index.js.map