@jahed/sparql-engine/dist/engine/plan-builder.d.ts

SPARQL query engine for servers and web browsers.

import type { Pattern, Query, SparqlQuery } from "sparqljs";
import type { PipelineStage } from "../engine/pipeline/pipeline-engine.ts";
import type { CustomFunctions } from "../operators/expressions/sparql-expression.ts";
import Optimizer from "../optimizer/optimizer.ts";
import { Bindings } from "../rdf/bindings.ts";
import Dataset from "../rdf/dataset.ts";
import type { EngineTriple } from "../types.ts";
import type { BGPCache } from "./cache/types.ts";
import ExecutionContext from "./context/execution-context.ts";
import StageBuilder from "./stages/stage-builder.ts";
export type QueryOutput = Bindings | EngineTriple | boolean;
export type SparqlOperation = number;
export declare const SPARQL_OPERATION: {
    AGGREGATE: number;
    BGP: number;
    BIND: number;
    DISTINCT: number;
    FILTER: number;
    GRAPH: number;
    MINUS: number;
    OPTIONAL: number;
    ORDER_BY: number;
    PROPERTY_PATH: number;
    SERVICE: number;
    UPDATE: number;
    UNION: number;
};
export declare class PlanBuilder {
    private _optimizer;
    private _stageBuilders;
    _currentCache: BGPCache | null;
    private _dataset;
    private _customFunctions?;
    constructor(dataset: Dataset, customFunctions?: CustomFunctions);
    set optimizer(opt: Optimizer);
    use(kind: SparqlOperation, stageBuilder: StageBuilder): void;
    useCache(cache: BGPCache): Promise<void>;
    disableCache(): void;
    build(query: SparqlQuery, context?: ExecutionContext): Promise<PipelineStage<QueryOutput>>;
    _buildQueryPlan(query: Query, context: ExecutionContext, source?: PipelineStage<Bindings>): Promise<PipelineStage<Bindings>>;
    _buildWhere(source: PipelineStage<Bindings>, groups: Pattern[], context: ExecutionContext): Promise<PipelineStage<Bindings>>;
    /**
     * Build a physical plan for a SPARQL group clause
     * @param  source  - Input {@link PipelineStage}
     * @param  group   - SPARQL Group
     * @param  options - Execution options
     * @return A {@link PipelineStage} used to evaluate the SPARQL Group
     */
    _buildGroup(source: PipelineStage<Bindings>, group: Pattern, context: ExecutionContext): Promise<PipelineStage<Bindings>>;
    /**
     * Build a {@link PipelineStage} which evaluates a SPARQL query with VALUES clause(s).
     * It rely on a query rewritiing approach:
     * ?s ?p ?o . VALUES ?s { :1 :2 } becomes {:1 ?p ?o BIND(:1 AS ?s)} UNION {:2 ?p ?o BIND(:2 AS ?s)}
     * @param source  - Input {@link PipelineStage}
     * @param groups  - Query body, i.e., WHERE clause
     * @param options - Execution options
     * @return A {@link PipelineStage} which evaluates a SPARQL query with VALUES clause(s)
     */
    _buildValues(source: PipelineStage<Bindings>, groups: Pattern[], context: ExecutionContext): Promise<PipelineStage<Bindings>>;
}