@comake/skl-js-engine/dist/storage/query-adapter/sparql/query-executor/InMemorySparqlQueryExecutor.js

Standard Knowledge Language Javascript Engine

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.InMemorySparqlQueryExecutor = void 0;
const query_sparql_rdfjs_1 = require("@comunica/query-sparql-rdfjs");
const n3_1 = require("n3");
const sparqljs_1 = require("sparqljs");
class InMemorySparqlQueryExecutor {
    constructor() {
        this.sparqlGenerator = new sparqljs_1.Generator();
        this.store = new n3_1.Store();
        this.engine = new query_sparql_rdfjs_1.QueryEngine();
        this.queryContext = {
            sources: [this.store],
            unionDefaultGraph: true,
        };
    }
    async executeSparqlSelectAndGetData(query) {
        const generatedQuery = this.sparqlGenerator.stringify(query);
        if (query.queryType === 'CONSTRUCT') {
            return (await this.executeSparqlConstructAndGetDataRaw(generatedQuery));
        }
        return (await this.executeSparqlSelectAndGetDataRaw(generatedQuery));
    }
    async executeSparqlSelectAndGetDataRaw(query) {
        const stream = await this.engine.queryBindings(query, this.queryContext);
        return this.getDataFromStream(stream, (row, data) => {
            if (row.entries.size > 0) {
                const bindingRow = {};
                for (const [key, value] of row.entries) {
                    bindingRow[key] = value;
                }
                data.push(bindingRow);
            }
        });
    }
    async executeSparqlConstructAndGetDataRaw(query) {
        const stream = await this.engine.queryQuads(query, this.queryContext);
        return this.getDataFromStream(stream, (row, data) => {
            data.push(row);
        });
    }
    async getDataFromStream(stream, dataCallback) {
        return new Promise((resolve, reject) => {
            const data = [];
            stream.on('data', (row) => {
                dataCallback(row, data);
            });
            stream.on('end', () => {
                resolve(data);
            });
            stream.on('error', (error) => {
                reject(error);
            });
        });
    }
    async executeSparqlUpdate(query) {
        if ((query?.updates?.length ?? 0) > 0) {
            const generatedQuery = this.sparqlGenerator.stringify(query);
            await this.executeRawSparqlUpdate(generatedQuery);
        }
    }
    async executeRawSparqlUpdate(query) {
        await this.engine.queryVoid(query, this.queryContext);
    }
    async executeAskQueryAndGetResponse(query) {
        const generatedQuery = this.sparqlGenerator.stringify(query);
        return await this.engine.queryBoolean(generatedQuery, this.queryContext);
    }
    async executeSelectCountAndGetResponse(query) {
        const generatedQuery = this.sparqlGenerator.stringify(query);
        const stream = await this.engine.queryBindings(generatedQuery, this.queryContext);
        return new Promise((resolve, reject) => {
            let countValue;
            stream.on('data', (row) => {
                if (row.entries.has('count')) {
                    const countLiteral = row.entries.get('count');
                    countValue = Number.parseInt(countLiteral.value, 10);
                }
            });
            stream.on('end', () => {
                resolve(countValue);
            });
            stream.on('error', (error) => {
                reject(error);
            });
        });
    }
}
exports.InMemorySparqlQueryExecutor = InMemorySparqlQueryExecutor;
//# sourceMappingURL=InMemorySparqlQueryExecutor.js.map