rdf-dataset-fragmenter/lib/strategy/FragmentationStrategyDatasetSummary.js

Fragments an RDF dataset into multiple parts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.FragmentationStrategyDatasetSummary = void 0;
const FragmentationStrategyStreamAdapter_1 = require("./FragmentationStrategyStreamAdapter");
/**
 * Fragmentation strategy that collects dataset summaries per dataset.
 */
class FragmentationStrategyDatasetSummary extends FragmentationStrategyStreamAdapter_1.FragmentationStrategyStreamAdapter {
    constructor(options) {
        super();
        this.summaries = new Map();
        this.blankNodeQuads = new Map();
        this.blankNodeDatasets = new Map();
        this.datasetPatterns = options.datasetPatterns.map(exp => new RegExp(exp, 'u'));
    }
    subjectToDatasets(subject) {
        const mappings = new Set();
        for (const exp of this.datasetPatterns) {
            const matches = exp.exec(subject);
            if (matches) {
                for (const match of matches) {
                    mappings.add(match);
                }
            }
        }
        return mappings;
    }
    async handleQuad(quad) {
        if (quad.subject.termType === 'NamedNode') {
            const datasets = this.subjectToDatasets(quad.subject.value);
            for (const dataset of datasets) {
                let summary = this.summaries.get(dataset);
                if (!summary) {
                    summary = this.createSummary(dataset);
                    this.summaries.set(dataset, summary);
                }
                summary.register(quad);
                if (quad.object.termType === 'BlankNode') {
                    let blankNodeDatasets = this.blankNodeDatasets.get(quad.object.value);
                    if (!blankNodeDatasets) {
                        blankNodeDatasets = new Set();
                        this.blankNodeDatasets.set(quad.object.value, blankNodeDatasets);
                    }
                    blankNodeDatasets.add(dataset);
                }
            }
        }
        else if (quad.subject.termType === 'BlankNode') {
            let blanks = this.blankNodeQuads.get(quad.subject.value);
            if (!blanks) {
                blanks = [];
                this.blankNodeQuads.set(quad.subject.value, blanks);
            }
            blanks.push(quad);
        }
    }
    async flush(quadSink) {
        const blankNodeQueue = [...this.blankNodeDatasets.keys()];
        const processedBlankNodes = new Set();
        while (blankNodeQueue.length > 0) {
            const blankNode = blankNodeQueue.shift();
            if (blankNode && !processedBlankNodes.has(blankNode)) {
                processedBlankNodes.add(blankNode);
                const quads = this.blankNodeQuads.get(blankNode);
                if (quads) {
                    const datasets = this.blankNodeDatasets.get(blankNode);
                    for (const quad of quads) {
                        for (const dataset of datasets) {
                            this.summaries.get(dataset).register(quad);
                            if (quad.object.termType === 'BlankNode' &&
                                !this.blankNodeDatasets.has(quad.object.value) &&
                                !processedBlankNodes.has(quad.object.value)) {
                                this.blankNodeDatasets.set(quad.object.value, new Set([dataset]));
                                blankNodeQueue.push(quad.object.value);
                            }
                        }
                    }
                }
            }
        }
        this.blankNodeQuads.clear();
        this.blankNodeDatasets.clear();
        for (const [key, summary] of this.summaries) {
            const output = summary.serialize();
            for (const quad of output.quads) {
                await quadSink.push(output.iri, quad);
            }
            this.summaries.delete(key);
        }
        await super.flush(quadSink);
    }
}
exports.FragmentationStrategyDatasetSummary = FragmentationStrategyDatasetSummary;
//# sourceMappingURL=FragmentationStrategyDatasetSummary.js.map