@comunica/actor-abstract-path 2.3.1-alpha.28.0 → 2.3.1-alpha.29.0

package/lib/ActorAbstractPath.d.ts

@@ -24,17 +24,17 @@ export declare abstract class ActorAbstractPath extends ActorQueryOperationTyped
     }>;
     private predicateStarGraphVariable;
     /**
-       * Returns an iterator with Bindings of the query subject predicate* ?o
-       * If graph is a variable, it will also be in those bindings
-       * @param {Term} subject Term of where we start the predicate* search.
-       * @param {Variable} object Variable of the zeroOrMore-query.
-       * @param {Term} objectVal
-       * @param {Algebra.PropertyPathSymbol} predicate Predicate of the *-path.
-       * @param {Term} graph The graph in which we search for the pattern. (Possibly a variable)
-       * @param {ActionContext} context
-       * @return {Promise<AsyncIterator<Bindings>} Iterator to where all bindings of query should have been pushed.
-       */
-    getObjectsPredicateStarEval(subject: RDF.Term, object: RDF.Variable, predicate: Algebra.PropertyPathSymbol, graph: RDF.Term, context: IActionContext): Promise<IPathResultStream>;
+     * Returns an iterator with Bindings of the query subject predicate* ?o or subject predicate+ ?o
+     * If graph is a variable, it will also be in those bindings
+     * @param {Term} subject Term of where we start the predicate* search.
+     * @param {Algebra.PropertyPathSymbol} predicate Predicate of the *-path.
+     * @param {Variable} object Variable of the zeroOrMore-query.
+     * @param {Term} graph The graph in which we search for the pattern. (Possibly a variable)
+     * @param {ActionContext} context The context to pass to sub-opertations
+     * @param emitFirstSubject If the path operation is predicate*, otherwise it is predicate+.
+     * @return {Promise<AsyncIterator<Bindings>} Iterator to where all bindings of query should have been pushed.
+     */
+    getObjectsPredicateStarEval(subject: RDF.Term, predicate: Algebra.PropertyPathSymbol, object: RDF.Variable, graph: RDF.Term, context: IActionContext, emitFirstSubject: boolean): Promise<IPathResultStream>;
     /**
        * Pushes all terms to iterator `it` that are a solution of object predicate* ?o.
        * @param {Term} object Term of where we start the predicate* search.

package/lib/ActorAbstractPath.js

@@ -8,6 +8,7 @@ const asynciterator_1 = require("asynciterator");
 const rdf_data_factory_1 = require("rdf-data-factory");
 const rdf_string_1 = require("rdf-string");
 const sparqlalgebrajs_1 = require("sparqlalgebrajs");
+const PathVariableObjectIterator_1 = require("./PathVariableObjectIterator");
 const DF = new rdf_data_factory_1.DataFactory();
 const BF = new bindings_factory_1.BindingsFactory();
 /**
@@ -53,8 +54,10 @@ class ActorAbstractPath extends bus_query_operation_1.ActorQueryOperationTypedMe
         return { context, operation: undefined };
     }
     async predicateStarGraphVariable(subject, object, predicate, graph, context) {
+        // TODO: refactor this with an iterator just like PathVariableObjectIterator so we handle backpressure correctly
         // Construct path to obtain all graphs where subject exists
-        const predVar = this.generateVariable(ActorAbstractPath.FACTORY.createPath(subject, predicate, object, graph));
+        const predVar = this.generateVariable(ActorAbstractPath.FACTORY
+            .createPath(subject, predicate, object, graph));
         const findGraphs = ActorAbstractPath.FACTORY.createUnion([
             ActorAbstractPath.FACTORY.createPattern(subject, predVar, object, graph),
             ActorAbstractPath.FACTORY.createPattern(object, predVar, subject, graph),
@@ -91,26 +94,23 @@ class ActorAbstractPath extends bus_query_operation_1.ActorQueryOperationTypedMe
         };
     }
     /**
-       * Returns an iterator with Bindings of the query subject predicate* ?o
-       * If graph is a variable, it will also be in those bindings
-       * @param {Term} subject Term of where we start the predicate* search.
-       * @param {Variable} object Variable of the zeroOrMore-query.
-       * @param {Term} objectVal
-       * @param {Algebra.PropertyPathSymbol} predicate Predicate of the *-path.
-       * @param {Term} graph The graph in which we search for the pattern. (Possibly a variable)
-       * @param {ActionContext} context
-       * @return {Promise<AsyncIterator<Bindings>} Iterator to where all bindings of query should have been pushed.
-       */
-    async getObjectsPredicateStarEval(subject, object, predicate, graph, context) {
+     * Returns an iterator with Bindings of the query subject predicate* ?o or subject predicate+ ?o
+     * If graph is a variable, it will also be in those bindings
+     * @param {Term} subject Term of where we start the predicate* search.
+     * @param {Algebra.PropertyPathSymbol} predicate Predicate of the *-path.
+     * @param {Variable} object Variable of the zeroOrMore-query.
+     * @param {Term} graph The graph in which we search for the pattern. (Possibly a variable)
+     * @param {ActionContext} context The context to pass to sub-opertations
+     * @param emitFirstSubject If the path operation is predicate*, otherwise it is predicate+.
+     * @return {Promise<AsyncIterator<Bindings>} Iterator to where all bindings of query should have been pushed.
+     */
+    async getObjectsPredicateStarEval(subject, predicate, object, graph, context, emitFirstSubject) {
         if (graph.termType === 'Variable') {
             return this.predicateStarGraphVariable(subject, object, predicate, graph, context);
         }
-        const it = new asynciterator_1.BufferedIterator();
-        // We can safely ignore undefs because termHashes is empty
-        // eslint-disable-next-line @typescript-eslint/non-nullable-type-assertion-style
-        const metadata = await this
-            .getObjectsPredicateStar(subject, predicate, graph, context, {}, it, { count: 0 });
+        const it = new PathVariableObjectIterator_1.PathVariableObjectIterator(subject, predicate, graph, context, this.mediatorQueryOperation, emitFirstSubject);
         const bindingsStream = it.transform({
+            autoStart: false,
             transform(item, next, push) {
                 push(BF.bindings([[object, item]]));
                 next();
@@ -118,7 +118,7 @@ class ActorAbstractPath extends bus_query_operation_1.ActorQueryOperationTypedMe
         });
         return {
             bindingsStream,
-            metadata,
+            metadata: () => new Promise(resolve => it.getProperty('metadata', (metadata) => resolve(metadata()))),
         };
     }
     /**

package/lib/PathVariableObjectIterator.d.ts

@@ -0,0 +1,24 @@
+import type { MediatorQueryOperation } from '@comunica/bus-query-operation';
+import type { IActionContext } from '@comunica/types';
+import type * as RDF from '@rdfjs/types';
+import { BufferedIterator } from 'asynciterator';
+import type { Algebra } from 'sparqlalgebrajs';
+/**
+ * An iterator that implements the multi-length property path operation (* and +)
+ * for a fixed subject and predicate, and a variable object.
+ */
+export declare class PathVariableObjectIterator extends BufferedIterator<RDF.Term> {
+    private readonly subject;
+    private readonly predicate;
+    private readonly graph;
+    private readonly context;
+    private readonly mediatorQueryOperation;
+    private readonly maxRunningOperations;
+    private readonly termHashes;
+    private readonly runningOperations;
+    private readonly pendingOperations;
+    constructor(subject: RDF.Term, predicate: Algebra.PropertyPathSymbol, graph: RDF.Term, context: IActionContext, mediatorQueryOperation: MediatorQueryOperation, emitFirstSubject: boolean, maxRunningOperations?: number);
+    protected _end(destroy?: boolean): void;
+    protected _push(item: RDF.Term, pushAsResult?: boolean): void;
+    protected _read(count: number, done: () => void): void;
+}

package/lib/PathVariableObjectIterator.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathVariableObjectIterator = void 0;
+const bus_query_operation_1 = require("@comunica/bus-query-operation");
+const asynciterator_1 = require("asynciterator");
+const rdf_data_factory_1 = require("rdf-data-factory");
+const rdf_string_1 = require("rdf-string");
+const sparqlalgebrajs_1 = require("sparqlalgebrajs");
+const DF = new rdf_data_factory_1.DataFactory();
+const FACTORY = new sparqlalgebrajs_1.Factory();
+/**
+ * An iterator that implements the multi-length property path operation (* and +)
+ * for a fixed subject and predicate, and a variable object.
+ */
+class PathVariableObjectIterator extends asynciterator_1.BufferedIterator {
+    constructor(subject, predicate, graph, context, mediatorQueryOperation, emitFirstSubject, maxRunningOperations = 16) {
+        // The autoStart flag must be true to kickstart metadata collection
+        super({ autoStart: true });
+        this.subject = subject;
+        this.predicate = predicate;
+        this.graph = graph;
+        this.context = context;
+        this.mediatorQueryOperation = mediatorQueryOperation;
+        this.maxRunningOperations = maxRunningOperations;
+        this.termHashes = new Map();
+        this.runningOperations = [];
+        this.pendingOperations = [];
+        // Push the subject as starting point
+        this._push(this.subject, emitFirstSubject);
+    }
+    _end(destroy) {
+        // Close all running iterators
+        for (const it of this.runningOperations) {
+            it.destroy();
+        }
+        super._end(destroy);
+    }
+    _push(item, pushAsResult = true) {
+        let termString;
+        if (pushAsResult) {
+            // Don't push if this subject was already found
+            termString = (0, rdf_string_1.termToString)(item);
+            if (this.termHashes.has(termString)) {
+                return;
+            }
+        }
+        // Add a pending path operation for this item
+        const variable = DF.variable('b');
+        this.pendingOperations.push({
+            variable,
+            operation: FACTORY.createPath(item, this.predicate, variable, this.graph),
+        });
+        // Otherwise, push the subject
+        if (termString) {
+            this.termHashes.set(termString, item);
+            super._push(item);
+        }
+    }
+    _read(count, done) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias,consistent-this
+        const self = this;
+        (async function () {
+            // Open as many operations as possible
+            while (self.runningOperations.length < self.maxRunningOperations) {
+                if (self.pendingOperations.length === 0) {
+                    break;
+                }
+                const pendingOperation = self.pendingOperations.pop();
+                const results = bus_query_operation_1.ActorQueryOperation.getSafeBindings(await self.mediatorQueryOperation.mediate({ operation: pendingOperation.operation, context: self.context }));
+                const runningOperation = results.bindingsStream.transform({
+                    autoStart: false,
+                    transform(bindings, next, push) {
+                        const newTerm = bindings.get(pendingOperation.variable);
+                        push(newTerm);
+                        next();
+                    },
+                });
+                if (!runningOperation.done) {
+                    self.runningOperations.push(runningOperation);
+                    runningOperation.on('error', error => self.destroy(error));
+                    runningOperation.on('readable', () => {
+                        self.readable = true;
+                        self._fillBufferAsync();
+                    });
+                    runningOperation.on('end', () => {
+                        self.runningOperations.splice(self.runningOperations.indexOf(runningOperation), 1);
+                        self.readable = true;
+                        self._fillBufferAsync();
+                    });
+                }
+                self.setProperty('metadata', results.metadata);
+            }
+            // Try to read `count` items (based on UnionIterator)
+            let lastCount = 0;
+            let item;
+            // eslint-disable-next-line no-cond-assign
+            while (lastCount !== (lastCount = count)) {
+                // Prioritize the operations that have been added first
+                for (let i = 0; i < self.runningOperations.length && count > 0; i++) {
+                    // eslint-disable-next-line no-cond-assign
+                    if ((item = self.runningOperations[i].read()) !== null) {
+                        count--;
+                        self._push(item);
+                    }
+                }
+            }
+            // Close if everything has been read
+            if (self.runningOperations.length === 0 && self.pendingOperations.length === 0) {
+                self.close();
+            }
+        })().then(() => {
+            done();
+        }, error => this.destroy(error));
+    }
+}
+exports.PathVariableObjectIterator = PathVariableObjectIterator;
+//# sourceMappingURL=PathVariableObjectIterator.js.map

package/lib/index.d.ts

@@ -1 +1,2 @@
 export * from './ActorAbstractPath';
+export * from './PathVariableObjectIterator';

package/lib/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ActorAbstractPath"), exports);
+__exportStar(require("./PathVariableObjectIterator"), exports);
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comunica/actor-abstract-path",
-  "version": "2.3.1-alpha.28.0",
+  "version": "2.3.1-alpha.29.0",
   "description": "An abstract actor for handling mediatypes",
   "lsd:module": true,
   "main": "lib/index.js",
@@ -31,11 +31,11 @@
     "lib/**/*.js"
   ],
   "dependencies": {
-    "@comunica/bindings-factory": "2.3.1-alpha.28.0",
-    "@comunica/bus-query-operation": "2.3.1-alpha.28.0",
-    "@comunica/context-entries": "2.3.1-alpha.28.0",
-    "@comunica/core": "2.3.1-alpha.28.0",
-    "@comunica/types": "2.3.1-alpha.28.0",
+    "@comunica/bindings-factory": "2.3.1-alpha.29.0",
+    "@comunica/bus-query-operation": "2.3.1-alpha.29.0",
+    "@comunica/context-entries": "2.3.1-alpha.29.0",
+    "@comunica/core": "2.3.1-alpha.29.0",
+    "@comunica/types": "2.3.1-alpha.29.0",
     "@rdfjs/types": "*",
     "asynciterator": "^3.4.2",
     "rdf-data-factory": "^1.0.3",
@@ -47,5 +47,5 @@
     "build:ts": "node \"../../node_modules/typescript/bin/tsc\"",
     "build:components": "componentsjs-generator"
   },
-  "gitHead": "a6b2907780c1607eceb10e7f12ef6978f79e4aba"
+  "gitHead": "0ad833f8f32f7e3c2de1b22a0424da027656bf6a"
 }