@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Algebra-CGG4oae3.mjs

@@ -0,0 +1,433 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, it as variable, q as isVariable, rt as triple } from "./Term-CFLG1qu4.mjs";
+import { a as setOf, r as emptySet } from "./stringMap-D5YIpYtR.mjs";
+import * as Arr from "effect/Array";
+import * as Match from "effect/Match";
+// src/sparql/Algebra.ts
+/**
+* The SPARQL algebra (SPARQL 1.1 §18): the operator tree that queries are
+* translated to and that the engine (or a storage backend) evaluates.
+*
+* Operators are plain immutable objects discriminated by `_tag`. Blank nodes
+* of query patterns are replaced by internal variables (whose names start
+* with `@` and therefore cannot clash with user variables); aggregates are
+* computed by `Group` nodes and referenced through internal variables.
+*
+* Storage backends that evaluate (parts of) the algebra natively — such as a
+* SQL backend translating SPARQL to SQL — pattern-match on these types; see
+* `Store.QueryCapability`.
+*
+* @since 0.1.0
+*/
+var Algebra_exports = /* @__PURE__ */ __exportAll({
+	bgp: () => bgp,
+	certainVariables: () => certainVariables,
+	containsExists: () => containsExists,
+	expressionVariables: () => expressionVariables,
+	extend: () => extend,
+	filter: () => filter,
+	format: () => format,
+	formatExpression: () => formatExpression,
+	internalVariable: () => internalVariable,
+	isInternalVariable: () => isInternalVariable,
+	join: () => join,
+	leftJoin: () => leftJoin,
+	mapChildren: () => mapChildren,
+	mapExpressionPatterns: () => mapExpressionPatterns,
+	minus: () => minus,
+	prebind: () => prebind,
+	project: () => project,
+	transform: () => transform,
+	union: () => union,
+	unit: () => unit,
+	variables: () => variables
+});
+/**
+* The empty BGP: the join identity.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const unit = {
+	_tag: "Bgp",
+	patterns: []
+};
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const bgp = (patterns) => ({
+	_tag: "Bgp",
+	patterns
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const join = (left, right) => ({
+	_tag: "Join",
+	left,
+	right
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const leftJoin = (left, right, expression) => expression === void 0 ? {
+	_tag: "LeftJoin",
+	left,
+	right
+} : {
+	_tag: "LeftJoin",
+	left,
+	right,
+	expression
+};
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const filter = (expression, input) => ({
+	_tag: "Filter",
+	expression,
+	input
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const union = (left, right) => ({
+	_tag: "Union",
+	left,
+	right
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const minus = (left, right) => ({
+	_tag: "Minus",
+	left,
+	right
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const extend = (input, variable, expression) => ({
+	_tag: "Extend",
+	input,
+	variable,
+	expression
+});
+/**
+* @since 0.1.0
+* @category constructors
+*/
+const project = (input, variables) => ({
+	_tag: "Project",
+	input,
+	variables
+});
+/**
+* Whether a variable name is internal (introduced by translation for blank
+* nodes, property path sequences, group keys and aggregates).
+*
+* @since 0.1.0
+* @category utils
+*/
+const isInternalVariable = (name) => name.startsWith("@");
+/**
+* The public, native `ReadonlySet` of a variable set: the helpers below
+* return `ReadonlySet` by contract, and only `new Set` makes one.
+*/
+const toReadonlySet = (vars) => new Set(vars.keys());
+const termVariables = (t, out) => {
+	if (isVariable(t)) out.set(t.value, true);
+	else if (isTriple(t)) {
+		termVariables(t.subject, out);
+		termVariables(t.predicate, out);
+		termVariables(t.object, out);
+	}
+};
+/**
+* The variables that may be bound by solutions of an operator ("in-scope"
+* variables, including internal ones).
+*
+* @since 0.1.0
+* @category utils
+*/
+const variables = (op) => toReadonlySet(variableSet(op));
+const variableSet = (op) => {
+	const out = emptySet();
+	collectVariables(op, out);
+	return out;
+};
+const collectVariables = (op, out) => {
+	Match.value(op).pipe(Match.tag("Bgp", (o) => o.patterns.forEach((p) => {
+		termVariables(p.subject, out);
+		termVariables(p.predicate, out);
+		termVariables(p.object, out);
+	})), Match.tag("Path", (o) => {
+		termVariables(o.subject, out);
+		termVariables(o.object, out);
+	}), Match.tag("Join", "LeftJoin", "Union", (o) => {
+		collectVariables(o.left, out);
+		collectVariables(o.right, out);
+	}), Match.tag("Minus", (o) => collectVariables(o.left, out)), Match.tag("Filter", "OrderBy", "Distinct", "Reduced", "Slice", (o) => collectVariables(o.input, out)), Match.tag("Graph", "Service", (o) => {
+		termVariables(o.name, out);
+		collectVariables(o.input, out);
+	}), Match.tag("Extend", (o) => {
+		collectVariables(o.input, out);
+		out.set(o.variable.value, true);
+	}), Match.tag("Group", (o) => {
+		o.keys.forEach((k) => out.set(k.variable.value, true));
+		o.aggregates.forEach((a) => out.set(a.variable.value, true));
+	}), Match.tag("Project", "Values", (o) => o.variables.forEach((v) => out.set(v.value, true))), Match.exhaustive);
+};
+/**
+* The variables that are bound in every solution of an operator (as far as
+* can be determined statically).
+*
+* @since 0.1.0
+* @category utils
+*/
+const certainVariables = (op) => toReadonlySet(certainSet(op));
+const certainSet = (op) => {
+	return Match.value(op).pipe(Match.tag("Bgp", "Path", (o) => variableSet(o)), Match.tag("Join", (o) => {
+		const out = certainSet(o.left);
+		certainSet(o.right).forEach((_, v) => out.set(v, true));
+		return out;
+	}), Match.tag("LeftJoin", "Minus", (o) => certainSet(o.left)), Match.tag("Union", (o) => {
+		const right = certainSet(o.right);
+		return setOf(Array.from(certainSet(o.left).keys()).filter((v) => right.has(v)));
+	}), Match.tag("Filter", "OrderBy", "Distinct", "Reduced", "Slice", "Extend", (o) => certainSet(o.input)), Match.tag("Graph", "Service", (o) => {
+		const out = certainSet(o.input);
+		if (isVariable(o.name)) out.set(o.name.value, true);
+		return out;
+	}), Match.tag("Group", () => emptySet()), Match.tag("Project", (o) => {
+		const inner = certainSet(o.input);
+		return setOf(o.variables.map((v) => v.value).filter((v) => inner.has(v)));
+	}), Match.tag("Values", (o) => setOf(o.variables.map((v) => v.value).filter((v) => o.bindings.every((b) => b.map.has(v))))), Match.exhaustive);
+};
+/**
+* The variables mentioned by an expression (not looking into `EXISTS`).
+*
+* @since 0.1.0
+* @category utils
+*/
+const expressionVariables = (expression) => {
+	const out = emptySet();
+	const go = (e) => {
+		Match.value(e).pipe(Match.tag("Variable", "Triple", (t) => termVariables(t, out)), Match.tag("Operation", "FunctionCall", (call) => call.args.forEach(go)), Match.orElse(() => void 0));
+	};
+	go(expression);
+	return toReadonlySet(out);
+};
+/**
+* Whether an expression contains `EXISTS` / `NOT EXISTS`.
+*
+* @since 0.1.0
+* @category utils
+*/
+const containsExists = (expression) => {
+	return Match.value(expression).pipe(Match.tag("Exists", () => true), Match.tag("Operation", "FunctionCall", (call) => call.args.some(containsExists)), Match.orElse(() => false));
+};
+/**
+* Rewrites an operator tree bottom-up: `f` is applied to every node after
+* its children have been rewritten.
+*
+* @since 0.1.0
+* @category utils
+*/
+const transform = (op, f) => {
+	const go = (o) => f(mapChildren(o, go));
+	return go(op);
+};
+/**
+* Applies `f` to the direct children of an operator.
+*
+* @since 0.1.0
+* @category utils
+*/
+const mapChildren = (op, f) => {
+	return Match.value(op).pipe(Match.tag("Bgp", "Path", "Values", (o) => o), Match.tag("Join", "Union", "Minus", (o) => ({
+		...o,
+		left: f(o.left),
+		right: f(o.right)
+	})), Match.tag("LeftJoin", (o) => ({
+		...o,
+		left: f(o.left),
+		right: f(o.right)
+	})), Match.tag("Filter", "Graph", "Extend", "Group", "OrderBy", "Project", "Distinct", "Reduced", "Slice", "Service", (o) => ({
+		...o,
+		input: f(o.input)
+	})), Match.exhaustive);
+};
+const termText = (t) => isTriple(t) ? `<<( ${termText(t.subject)} ${termText(t.predicate)} ${termText(t.object)} )>>` : t.toString();
+const pathText = (p) => {
+	return Match.value(p).pipe(Match.tag("PathLink", (l) => termText(l.iri)), Match.tag("PathInverse", (i) => `(inv ${pathText(i.path)})`), Match.tag("PathSequence", (s) => `(seq ${s.paths.map(pathText).join(" ")})`), Match.tag("PathAlternative", (a) => `(alt ${a.paths.map(pathText).join(" ")})`), Match.tag("PathZeroOrMore", (z) => `(path* ${pathText(z.path)})`), Match.tag("PathOneOrMore", (o) => `(path+ ${pathText(o.path)})`), Match.tag("PathZeroOrOne", (z) => `(path? ${pathText(z.path)})`), Match.tag("PathNegated", (n) => `(notoneof ${[...n.iris.map(termText), ...n.inverse.map((i) => `^${termText(i)}`)].join(" ")})`), Match.exhaustive);
+};
+/**
+* Formats an expression as an S-expression (for debugging and logging).
+*
+* @since 0.1.0
+* @category formatting
+*/
+const formatExpression = (e) => {
+	return Match.value(e).pipe(Match.tag("Operation", (o) => `(${o.operator.toLowerCase()} ${o.args.map(formatExpression).join(" ")})`), Match.tag("FunctionCall", (c) => `(${termText(c.function)} ${c.args.map(formatExpression).join(" ")})`), Match.tag("Exists", (x) => `(${x.negated ? "notexists" : "exists"} ${format(x.input)})`), Match.orElse((t) => termText(t)));
+};
+/**
+* Formats an operator tree as an S-expression in the style of the SPARQL
+* Algebra notation (for debugging and logging).
+*
+* @since 0.1.0
+* @category formatting
+*/
+const format = (op, indent = "") => {
+	const next = `${indent}  `;
+	const sub = (o) => `\n${next}${format(o, next)}`;
+	return Match.value(op).pipe(Match.tag("Bgp", (o) => `(bgp${o.patterns.map((p) => ` (triple ${termText(p.subject)} ${termText(p.predicate)} ${termText(p.object)})`).join("")})`), Match.tag("Path", (o) => `(path ${termText(o.subject)} ${pathText(o.path)} ${termText(o.object)})`), Match.tag("Join", (o) => `(join${sub(o.left)}${sub(o.right)})`), Match.tag("LeftJoin", (o) => `(leftjoin${sub(o.left)}${sub(o.right)}${o.expression !== void 0 ? `\n${next}${formatExpression(o.expression)}` : ""})`), Match.tag("Filter", (o) => `(filter ${formatExpression(o.expression)}${sub(o.input)})`), Match.tag("Union", (o) => `(union${sub(o.left)}${sub(o.right)})`), Match.tag("Graph", (o) => `(graph ${termText(o.name)}${sub(o.input)})`), Match.tag("Extend", (o) => `(extend ((${termText(o.variable)} ${formatExpression(o.expression)}))${sub(o.input)})`), Match.tag("Minus", (o) => `(minus${sub(o.left)}${sub(o.right)})`), Match.tag("Group", (o) => `(group (${o.keys.map((k) => `(${termText(k.variable)} ${formatExpression(k.expression)})`).join(" ")}) (${o.aggregates.map((a) => `(${termText(a.variable)} (${a.aggregate.name.toLowerCase()}${a.aggregate.distinct ? " distinct" : ""} ${a.aggregate.expression === "*" ? "*" : formatExpression(a.aggregate.expression)}))`).join(" ")})${sub(o.input)})`), Match.tag("OrderBy", (o) => `(order (${o.conditions.map((c) => c.descending ? `(desc ${formatExpression(c.expression)})` : formatExpression(c.expression)).join(" ")})${sub(o.input)})`), Match.tag("Project", (o) => `(project (${o.variables.map(termText).join(" ")})${sub(o.input)})`), Match.tag("Distinct", (o) => `(distinct${sub(o.input)})`), Match.tag("Reduced", (o) => `(reduced${sub(o.input)})`), Match.tag("Slice", (o) => `(slice ${o.offset} ${o.limit ?? "_"}${sub(o.input)})`), Match.tag("Values", (o) => `(table (vars ${o.variables.map(termText).join(" ")}) ${o.bindings.length} rows)`), Match.tag("Service", (o) => `(service ${o.silent ? "silent " : ""}${termText(o.name)}${sub(o.input)})`), Match.exhaustive);
+};
+/**
+* Creates an internal variable.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const internalVariable = (name) => variable(`@${name}`);
+/**
+* Applies `f` to every graph pattern nested in an expression (the patterns
+* of `EXISTS` / `NOT EXISTS`).
+*
+* @since 0.1.0
+* @category utils
+*/
+const mapExpressionPatterns = (expression, f) => {
+	return Match.value(expression).pipe(Match.tag("Exists", (x) => ({
+		...x,
+		input: f(x.input)
+	})), Match.tag("Operation", (o) => ({
+		...o,
+		args: o.args.map((a) => mapExpressionPatterns(a, f))
+	})), Match.tag("FunctionCall", (c) => ({
+		...c,
+		args: c.args.map((a) => mapExpressionPatterns(a, f))
+	})), Match.orElse((e) => e));
+};
+/**
+* Pre-binds variables in an algebra expression, following the "values
+* insertion" definition of SHACL-SPARQL (Appendix "Pre-binding of
+* Variables", aligned with the SPARQL `EXISTS` errata): every basic graph
+* pattern, property path and `GRAPH ?var` pattern `Y` — including those
+* nested in `EXISTS` — is replaced by `Join(Table(μ), Y)`, where `Table(μ)`
+* is a one-row `VALUES` table holding the pre-bound solution `μ`.
+*
+* The pre-bound values are also substituted into the replaced patterns,
+* which does not change the result (the join restores the bindings) but lets
+* the optimizer and the store use them as constants.
+*
+* Unlike a trailing `VALUES` clause, pre-bound values are visible to every
+* `FILTER` and `BIND`, including those of groups that never match the
+* variable: `SELECT $this WHERE { FILTER ($this = ex:a) }` has one solution
+* when `this` is pre-bound to `ex:a`. Queries using `MINUS`, `VALUES` or
+* `SERVICE`, rebinding a pre-bound variable with `AS`, or with sub-queries
+* that do not project the pre-bound variables, have no well-defined meaning
+* under pre-binding.
+*
+* @since 0.1.0
+* @category utils
+*/
+const prebind = (op, bindings) => {
+	if (bindings.map.size === 0) return op;
+	const table = {
+		_tag: "Values",
+		variables: Array.from(bindings.map.keys(), (v) => variable(v)),
+		bindings: [bindings]
+	};
+	const term = (t) => {
+		if (isVariable(t)) return bindings.map.get(t.value) ?? t;
+		if (isTriple(t)) {
+			const s = term(t.subject);
+			const p = term(t.predicate);
+			const o = term(t.object);
+			return s === t.subject && p === t.predicate && o === t.object ? t : triple(s, p, o);
+		}
+		return t;
+	};
+	const predicate = (p) => {
+		if (!isVariable(p)) return p;
+		const v = bindings.map.get(p.value);
+		return isNamedNode(v) ? v : p;
+	};
+	const expr = (e) => mapExpressionPatterns(e, go);
+	const go = (o) => {
+		return Match.value(o).pipe(Match.tag("Bgp", (b) => Arr.isReadonlyArrayEmpty(b.patterns) ? table : join(table, bgp(b.patterns.map((p) => ({
+			_tag: "TriplePattern",
+			subject: term(p.subject),
+			predicate: predicate(p.predicate),
+			object: term(p.object)
+		}))))), Match.tag("Path", (p) => join(table, {
+			...p,
+			subject: term(p.subject),
+			object: term(p.object)
+		})), Match.tag("Graph", (g) => {
+			const input = go(g.input);
+			const value = isVariable(g.name) ? bindings.map.get(g.name.value) : void 0;
+			if (value === void 0) return {
+				...g,
+				input
+			};
+			return join(table, isNamedNode(value) ? {
+				...g,
+				name: value,
+				input
+			} : {
+				...g,
+				input
+			});
+		}), Match.tag("Filter", (x) => ({
+			...x,
+			expression: expr(x.expression),
+			input: go(x.input)
+		})), Match.tag("LeftJoin", (l) => l.expression === void 0 ? {
+			...l,
+			left: go(l.left),
+			right: go(l.right)
+		} : {
+			...l,
+			left: go(l.left),
+			right: go(l.right),
+			expression: expr(l.expression)
+		}), Match.tag("Extend", (x) => ({
+			...x,
+			expression: expr(x.expression),
+			input: go(x.input)
+		})), Match.tag("OrderBy", (x) => ({
+			...x,
+			input: go(x.input),
+			conditions: x.conditions.map((c) => ({
+				...c,
+				expression: expr(c.expression)
+			}))
+		})), Match.tag("Group", (x) => ({
+			...x,
+			input: go(x.input),
+			keys: x.keys.map((k) => ({
+				...k,
+				expression: expr(k.expression)
+			})),
+			aggregates: x.aggregates.map((a) => ({
+				...a,
+				aggregate: a.aggregate.expression === "*" ? a.aggregate : {
+					...a.aggregate,
+					expression: expr(a.aggregate.expression)
+				}
+			}))
+		})), Match.orElse((x) => mapChildren(x, go)));
+	};
+	return go(op);
+};
+export { variables as S, prebind as _, expressionVariables as a, union as b, format as c, isInternalVariable as d, join as f, minus as g, mapExpressionPatterns as h, containsExists as i, formatExpression as l, mapChildren as m, bgp as n, extend as o, leftJoin as p, certainVariables as r, filter as s, Algebra_exports as t, internalVariable as u, project as v, unit as x, transform as y };
+
+//# sourceMappingURL=Algebra-CGG4oae3.mjs.map

package/dist/Algebra-CGG4oae3.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Algebra-CGG4oae3.mjs","names":["Term.isVariable","Term.isTriple","StringMap.emptySet","StringMap.setOf","Term.variable","Term.triple","Term.isNamedNode"],"sources":["../src/sparql/Algebra.ts"],"sourcesContent":["/**\n * The SPARQL algebra (SPARQL 1.1 §18): the operator tree that queries are\n * translated to and that the engine (or a storage backend) evaluates.\n *\n * Operators are plain immutable objects discriminated by `_tag`. Blank nodes\n * of query patterns are replaced by internal variables (whose names start\n * with `@` and therefore cannot clash with user variables); aggregates are\n * computed by `Group` nodes and referenced through internal variables.\n *\n * Storage backends that evaluate (parts of) the algebra natively — such as a\n * SQL backend translating SPARQL to SQL — pattern-match on these types; see\n * `Store.QueryCapability`.\n *\n * @since 0.1.0\n */\nimport * as Term from '../Term.ts';\nimport type * as Ast from './Ast.ts';\nimport type { Bindings } from './Bindings.ts';\nimport * as Arr from 'effect/Array';\nimport * as Match from 'effect/Match';\nimport * as StringMap from './internal/stringMap.ts';\n\n// -----------------------------------------------------------------------------\n// Expressions\n// -----------------------------------------------------------------------------\n\n/**\n * An algebra expression: like `Ast.Expression`, but `EXISTS` patterns are\n * translated to algebra and aggregates have been replaced by variables.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Expression =\n  | Term.Variable\n  | Term.NamedNode\n  | Term.Literal\n  | Term.BlankNode\n  | Term.Triple<any, any, any>\n  | OperationExpression\n  | FunctionCallExpression\n  | ExistsExpression;\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface OperationExpression {\n  readonly _tag: 'Operation';\n  readonly operator: Ast.Operator;\n  readonly args: ReadonlyArray<Expression>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface FunctionCallExpression {\n  readonly _tag: 'FunctionCall';\n  readonly function: Term.NamedNode;\n  readonly args: ReadonlyArray<Expression>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface ExistsExpression {\n  readonly _tag: 'Exists';\n  readonly negated: boolean;\n  readonly input: Operation;\n}\n\n/**\n * An aggregate computed by a `Group` operator.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Aggregate {\n  readonly name: Ast.AggregateName;\n  readonly distinct: boolean;\n  readonly expression: Expression | '*';\n  readonly separator?: string | undefined;\n}\n\n// -----------------------------------------------------------------------------\n// Operators\n// -----------------------------------------------------------------------------\n\n/**\n * An algebra operator.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Operation =\n  | Bgp\n  | Path\n  | Join\n  | LeftJoin\n  | Filter\n  | Union\n  | Graph\n  | Extend\n  | Minus\n  | Group\n  | OrderBy\n  | Project\n  | Distinct\n  | Reduced\n  | Slice\n  | Values\n  | Service;\n\n/**\n * A basic graph pattern. The empty BGP is the join identity (one empty\n * solution).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Bgp {\n  readonly _tag: 'Bgp';\n  readonly patterns: ReadonlyArray<Ast.TriplePattern>;\n}\n\n/**\n * A property path pattern that could not be expanded to triple patterns.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Path {\n  readonly _tag: 'Path';\n  readonly subject: Ast.TermPattern;\n  readonly path: Ast.Path;\n  readonly object: Ast.TermPattern;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Join {\n  readonly _tag: 'Join';\n  readonly left: Operation;\n  readonly right: Operation;\n}\n\n/**\n * `OPTIONAL`, with the filter of the optional group as `expression`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface LeftJoin {\n  readonly _tag: 'LeftJoin';\n  readonly left: Operation;\n  readonly right: Operation;\n  readonly expression?: Expression | undefined;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Filter {\n  readonly _tag: 'Filter';\n  readonly expression: Expression;\n  readonly input: Operation;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Union {\n  readonly _tag: 'Union';\n  readonly left: Operation;\n  readonly right: Operation;\n}\n\n/**\n * Evaluates `input` against a named graph (`GRAPH`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Graph {\n  readonly _tag: 'Graph';\n  readonly name: Term.NamedNode | Term.Variable;\n  readonly input: Operation;\n}\n\n/**\n * Binds `variable` to the value of `expression` (`BIND` and select\n * expressions).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Extend {\n  readonly _tag: 'Extend';\n  readonly input: Operation;\n  readonly variable: Term.Variable;\n  readonly expression: Expression;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Minus {\n  readonly _tag: 'Minus';\n  readonly left: Operation;\n  readonly right: Operation;\n}\n\n/**\n * A group key: the grouping expression and the variable it is bound to.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface GroupKey {\n  readonly expression: Expression;\n  readonly variable: Term.Variable;\n}\n\n/**\n * Grouping and aggregation (`Group` + `AggregateJoin`). Each output solution\n * binds the key variables and the aggregate variables of one group. With no\n * keys, all solutions form one group (which exists even if there are no\n * solutions).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Group {\n  readonly _tag: 'Group';\n  readonly input: Operation;\n  readonly keys: ReadonlyArray<GroupKey>;\n  readonly aggregates: ReadonlyArray<{\n    readonly variable: Term.Variable;\n    readonly aggregate: Aggregate;\n  }>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface OrderCondition {\n  readonly expression: Expression;\n  readonly descending: boolean;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface OrderBy {\n  readonly _tag: 'OrderBy';\n  readonly input: Operation;\n  readonly conditions: ReadonlyArray<OrderCondition>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Project {\n  readonly _tag: 'Project';\n  readonly input: Operation;\n  readonly variables: ReadonlyArray<Term.Variable>;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Distinct {\n  readonly _tag: 'Distinct';\n  readonly input: Operation;\n}\n\n/**\n * @since 0.1.0\n * @category models\n */\nexport interface Reduced {\n  readonly _tag: 'Reduced';\n  readonly input: Operation;\n}\n\n/**\n * `OFFSET` / `LIMIT`.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Slice {\n  readonly _tag: 'Slice';\n  readonly input: Operation;\n  readonly offset: number;\n  readonly limit?: number | undefined;\n}\n\n/**\n * Inline data (`VALUES`).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Values {\n  readonly _tag: 'Values';\n  readonly variables: ReadonlyArray<Term.Variable>;\n  readonly bindings: ReadonlyArray<Bindings>;\n}\n\n/**\n * A federated `SERVICE` pattern. `pattern` keeps the original syntax so that\n * the pattern can be sent to the remote endpoint.\n *\n * @since 0.1.0\n * @category models\n */\nexport interface Service {\n  readonly _tag: 'Service';\n  readonly name: Term.NamedNode | Term.Variable;\n  readonly silent: boolean;\n  readonly input: Operation;\n  readonly pattern: Ast.GroupPattern;\n  readonly prefixes: Readonly<Record<string, string>>;\n}\n\n// -----------------------------------------------------------------------------\n// Queries\n// -----------------------------------------------------------------------------\n\n/**\n * A translated query: the algebra of the WHERE clause plus solution\n * modifiers, the query form and the dataset clause.\n *\n * @since 0.1.0\n * @category models\n */\nexport type Query =\n  | {\n      readonly _tag: 'Select';\n      readonly input: Operation;\n      readonly variables: ReadonlyArray<Term.Variable>;\n      readonly dataset?: Ast.DatasetClause | undefined;\n    }\n  | {\n      readonly _tag: 'Construct';\n      readonly input: Operation;\n      readonly template: ReadonlyArray<Ast.TriplePattern>;\n      readonly dataset?: Ast.DatasetClause | undefined;\n    }\n  | {\n      readonly _tag: 'Ask';\n      readonly input: Operation;\n      readonly dataset?: Ast.DatasetClause | undefined;\n    }\n  | {\n      readonly _tag: 'Describe';\n      readonly input: Operation;\n      readonly terms: ReadonlyArray<Term.NamedNode | Term.Variable>;\n      readonly dataset?: Ast.DatasetClause | undefined;\n    };\n\n// -----------------------------------------------------------------------------\n// Constructors\n// -----------------------------------------------------------------------------\n\n/**\n * The empty BGP: the join identity.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const unit: Bgp = { _tag: 'Bgp', patterns: [] };\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const bgp = (patterns: ReadonlyArray<Ast.TriplePattern>): Bgp => ({ _tag: 'Bgp', patterns });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const join = (left: Operation, right: Operation): Join => ({ _tag: 'Join', left, right });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const leftJoin = (left: Operation, right: Operation, expression?: Expression): LeftJoin =>\n  expression === undefined\n    ? { _tag: 'LeftJoin', left, right }\n    : { _tag: 'LeftJoin', left, right, expression };\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const filter = (expression: Expression, input: Operation): Filter => ({\n  _tag: 'Filter',\n  expression,\n  input,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const union = (left: Operation, right: Operation): Union => ({ _tag: 'Union', left, right });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const minus = (left: Operation, right: Operation): Minus => ({ _tag: 'Minus', left, right });\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const extend = (\n  input: Operation,\n  variable: Term.Variable,\n  expression: Expression,\n): Extend => ({\n  _tag: 'Extend',\n  input,\n  variable,\n  expression,\n});\n\n/**\n * @since 0.1.0\n * @category constructors\n */\nexport const project = (input: Operation, variables: ReadonlyArray<Term.Variable>): Project => ({\n  _tag: 'Project',\n  input,\n  variables,\n});\n\n// -----------------------------------------------------------------------------\n// Utilities\n// -----------------------------------------------------------------------------\n\n/**\n * Whether a variable name is internal (introduced by translation for blank\n * nodes, property path sequences, group keys and aggregates).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const isInternalVariable = (name: string): boolean => name.startsWith('@');\n\n/** A string set of the type the variable helpers below return. */\ntype VariableSet = Map<string, true>;\n\n/**\n * The public, native `ReadonlySet` of a variable set: the helpers below\n * return `ReadonlySet` by contract, and only `new Set` makes one.\n */\nconst toReadonlySet = (vars: VariableSet): ReadonlySet<string> => new Set(vars.keys());\n\nconst termVariables = (t: Term.Term | Ast.TermPattern, out: VariableSet): void => {\n  if (Term.isVariable(t)) out.set(t.value, true);\n  else if (Term.isTriple(t)) {\n    termVariables(t.subject, out);\n    termVariables(t.predicate, out);\n    termVariables(t.object, out);\n  }\n};\n\n/**\n * The variables that may be bound by solutions of an operator (\"in-scope\"\n * variables, including internal ones).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const variables = (op: Operation): ReadonlySet<string> => toReadonlySet(variableSet(op));\n\nconst variableSet = (op: Operation): VariableSet => {\n  const out = StringMap.emptySet();\n  collectVariables(op, out);\n  return out;\n};\n\nconst collectVariables = (op: Operation, out: VariableSet): void => {\n  Match.value(op).pipe(\n    Match.tag('Bgp', (o) =>\n      o.patterns.forEach((p) => {\n        termVariables(p.subject, out);\n        termVariables(p.predicate, out);\n        termVariables(p.object, out);\n      }),\n    ),\n    Match.tag('Path', (o) => {\n      termVariables(o.subject, out);\n      termVariables(o.object, out);\n    }),\n    Match.tag('Join', 'LeftJoin', 'Union', (o) => {\n      collectVariables(o.left, out);\n      collectVariables(o.right, out);\n    }),\n    Match.tag('Minus', (o) => collectVariables(o.left, out)),\n    Match.tag('Filter', 'OrderBy', 'Distinct', 'Reduced', 'Slice', (o) =>\n      collectVariables(o.input, out),\n    ),\n    Match.tag('Graph', 'Service', (o) => {\n      termVariables(o.name, out);\n      collectVariables(o.input, out);\n    }),\n    Match.tag('Extend', (o) => {\n      collectVariables(o.input, out);\n      out.set(o.variable.value, true);\n    }),\n    Match.tag('Group', (o) => {\n      o.keys.forEach((k) => out.set(k.variable.value, true));\n      o.aggregates.forEach((a) => out.set(a.variable.value, true));\n    }),\n    Match.tag('Project', 'Values', (o) => o.variables.forEach((v) => out.set(v.value, true))),\n    Match.exhaustive,\n  );\n};\n\n/**\n * The variables that are bound in every solution of an operator (as far as\n * can be determined statically).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const certainVariables = (op: Operation): ReadonlySet<string> =>\n  toReadonlySet(certainSet(op));\n\nconst certainSet = (op: Operation): VariableSet => {\n  return Match.value(op).pipe(\n    Match.tag('Bgp', 'Path', (o): VariableSet => variableSet(o)),\n    Match.tag('Join', (o) => {\n      const out = certainSet(o.left);\n      certainSet(o.right).forEach((_, v) => out.set(v, true));\n      return out;\n    }),\n    Match.tag('LeftJoin', 'Minus', (o) => certainSet(o.left)),\n    Match.tag('Union', (o) => {\n      const right = certainSet(o.right);\n      return StringMap.setOf(Array.from(certainSet(o.left).keys()).filter((v) => right.has(v)));\n    }),\n    Match.tag('Filter', 'OrderBy', 'Distinct', 'Reduced', 'Slice', 'Extend', (o) =>\n      certainSet(o.input),\n    ),\n    Match.tag('Graph', 'Service', (o) => {\n      const out = certainSet(o.input);\n      if (Term.isVariable(o.name)) out.set(o.name.value, true);\n      return out;\n    }),\n    Match.tag('Group', () => StringMap.emptySet()),\n    Match.tag('Project', (o) => {\n      const inner = certainSet(o.input);\n      return StringMap.setOf(o.variables.map((v) => v.value).filter((v) => inner.has(v)));\n    }),\n    Match.tag('Values', (o) =>\n      StringMap.setOf(\n        o.variables.map((v) => v.value).filter((v) => o.bindings.every((b) => b.map.has(v))),\n      ),\n    ),\n    Match.exhaustive,\n  );\n};\n\n/**\n * The variables mentioned by an expression (not looking into `EXISTS`).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const expressionVariables = (expression: Expression): ReadonlySet<string> => {\n  const out = StringMap.emptySet();\n  const go = (e: Expression): void => {\n    Match.value(e).pipe(\n      Match.tag('Variable', 'Triple', (t) => termVariables(t, out)),\n      Match.tag('Operation', 'FunctionCall', (call) => call.args.forEach(go)),\n      Match.orElse(() => undefined),\n    );\n  };\n  go(expression);\n  return toReadonlySet(out);\n};\n\n/**\n * Whether an expression contains `EXISTS` / `NOT EXISTS`.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const containsExists = (expression: Expression): boolean => {\n  return Match.value(expression).pipe(\n    Match.tag('Exists', () => true),\n    Match.tag('Operation', 'FunctionCall', (call) => call.args.some(containsExists)),\n    Match.orElse(() => false),\n  );\n};\n\n/**\n * Rewrites an operator tree bottom-up: `f` is applied to every node after\n * its children have been rewritten.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const transform = (op: Operation, f: (op: Operation) => Operation): Operation => {\n  const go = (o: Operation): Operation => f(mapChildren(o, go));\n  return go(op);\n};\n\n/**\n * Applies `f` to the direct children of an operator.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const mapChildren = (op: Operation, f: (op: Operation) => Operation): Operation => {\n  return Match.value(op).pipe(\n    Match.tag('Bgp', 'Path', 'Values', (o): Operation => o),\n    Match.tag('Join', 'Union', 'Minus', (o) => ({ ...o, left: f(o.left), right: f(o.right) })),\n    Match.tag('LeftJoin', (o) => ({ ...o, left: f(o.left), right: f(o.right) })),\n    Match.tag(\n      'Filter',\n      'Graph',\n      'Extend',\n      'Group',\n      'OrderBy',\n      'Project',\n      'Distinct',\n      'Reduced',\n      'Slice',\n      'Service',\n      // SAFETY: every operator listed here has an `input`, and replacing it keeps the\n      // operator's own tag.\n      (o) => ({ ...o, input: f(o.input) }),\n    ),\n    Match.exhaustive,\n  );\n};\n\nconst termText = (t: Term.Term | Ast.TermPattern): string =>\n  Term.isTriple(t)\n    ? `<<( ${termText(t.subject)} ${termText(t.predicate)} ${termText(t.object)} )>>`\n    : t.toString();\n\nconst pathText = (p: Ast.Path): string => {\n  return Match.value(p).pipe(\n    Match.tag('PathLink', (l) => termText(l.iri)),\n    Match.tag('PathInverse', (i) => `(inv ${pathText(i.path)})`),\n    Match.tag('PathSequence', (s) => `(seq ${s.paths.map(pathText).join(' ')})`),\n    Match.tag('PathAlternative', (a) => `(alt ${a.paths.map(pathText).join(' ')})`),\n    Match.tag('PathZeroOrMore', (z) => `(path* ${pathText(z.path)})`),\n    Match.tag('PathOneOrMore', (o) => `(path+ ${pathText(o.path)})`),\n    Match.tag('PathZeroOrOne', (z) => `(path? ${pathText(z.path)})`),\n    Match.tag(\n      'PathNegated',\n      (n) =>\n        `(notoneof ${[...n.iris.map(termText), ...n.inverse.map((i) => `^${termText(i)}`)].join(' ')})`,\n    ),\n    Match.exhaustive,\n  );\n};\n\n/**\n * Formats an expression as an S-expression (for debugging and logging).\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const formatExpression = (e: Expression): string => {\n  return Match.value(e).pipe(\n    Match.tag(\n      'Operation',\n      (o) => `(${o.operator.toLowerCase()} ${o.args.map(formatExpression).join(' ')})`,\n    ),\n    Match.tag(\n      'FunctionCall',\n      (c) => `(${termText(c.function)} ${c.args.map(formatExpression).join(' ')})`,\n    ),\n    Match.tag('Exists', (x) => `(${x.negated ? 'notexists' : 'exists'} ${format(x.input)})`),\n    Match.orElse((t) => termText(t)),\n  );\n};\n\n/**\n * Formats an operator tree as an S-expression in the style of the SPARQL\n * Algebra notation (for debugging and logging).\n *\n * @since 0.1.0\n * @category formatting\n */\nexport const format = (op: Operation, indent = ''): string => {\n  const next = `${indent}  `;\n  const sub = (o: Operation) => `\\n${next}${format(o, next)}`;\n  return Match.value(op).pipe(\n    Match.tag(\n      'Bgp',\n      (o) =>\n        `(bgp${o.patterns.map((p) => ` (triple ${termText(p.subject)} ${termText(p.predicate)} ${termText(p.object)})`).join('')})`,\n    ),\n    Match.tag(\n      'Path',\n      (o) => `(path ${termText(o.subject)} ${pathText(o.path)} ${termText(o.object)})`,\n    ),\n    Match.tag('Join', (o) => `(join${sub(o.left)}${sub(o.right)})`),\n    Match.tag(\n      'LeftJoin',\n      (o) =>\n        `(leftjoin${sub(o.left)}${sub(o.right)}${o.expression !== undefined ? `\\n${next}${formatExpression(o.expression)}` : ''})`,\n    ),\n    Match.tag('Filter', (o) => `(filter ${formatExpression(o.expression)}${sub(o.input)})`),\n    Match.tag('Union', (o) => `(union${sub(o.left)}${sub(o.right)})`),\n    Match.tag('Graph', (o) => `(graph ${termText(o.name)}${sub(o.input)})`),\n    Match.tag(\n      'Extend',\n      (o) =>\n        `(extend ((${termText(o.variable)} ${formatExpression(o.expression)}))${sub(o.input)})`,\n    ),\n    Match.tag('Minus', (o) => `(minus${sub(o.left)}${sub(o.right)})`),\n    Match.tag(\n      'Group',\n      (o) =>\n        `(group (${o.keys.map((k) => `(${termText(k.variable)} ${formatExpression(k.expression)})`).join(' ')}) (${o.aggregates\n          .map(\n            (a) =>\n              `(${termText(a.variable)} (${a.aggregate.name.toLowerCase()}${a.aggregate.distinct ? ' distinct' : ''} ${a.aggregate.expression === '*' ? '*' : formatExpression(a.aggregate.expression)}))`,\n          )\n          .join(' ')})${sub(o.input)})`,\n    ),\n    Match.tag(\n      'OrderBy',\n      (o) =>\n        `(order (${o.conditions.map((c) => (c.descending ? `(desc ${formatExpression(c.expression)})` : formatExpression(c.expression))).join(' ')})${sub(o.input)})`,\n    ),\n    Match.tag(\n      'Project',\n      (o) => `(project (${o.variables.map(termText).join(' ')})${sub(o.input)})`,\n    ),\n    Match.tag('Distinct', (o) => `(distinct${sub(o.input)})`),\n    Match.tag('Reduced', (o) => `(reduced${sub(o.input)})`),\n    Match.tag('Slice', (o) => `(slice ${o.offset} ${o.limit ?? '_'}${sub(o.input)})`),\n    Match.tag(\n      'Values',\n      (o) => `(table (vars ${o.variables.map(termText).join(' ')}) ${o.bindings.length} rows)`,\n    ),\n    Match.tag(\n      'Service',\n      (o) => `(service ${o.silent ? 'silent ' : ''}${termText(o.name)}${sub(o.input)})`,\n    ),\n    Match.exhaustive,\n  );\n};\n\n/**\n * Creates an internal variable.\n *\n * @since 0.1.0\n * @category constructors\n */\nexport const internalVariable = (name: string): Term.Variable => Term.variable(`@${name}`);\n\n// -----------------------------------------------------------------------------\n// Pre-binding\n// -----------------------------------------------------------------------------\n\n/**\n * Applies `f` to every graph pattern nested in an expression (the patterns\n * of `EXISTS` / `NOT EXISTS`).\n *\n * @since 0.1.0\n * @category utils\n */\nexport const mapExpressionPatterns = (\n  expression: Expression,\n  f: (op: Operation) => Operation,\n): Expression => {\n  return Match.value(expression).pipe(\n    Match.tag('Exists', (x): Expression => ({ ...x, input: f(x.input) })),\n    Match.tag('Operation', (o) => ({\n      ...o,\n      args: o.args.map((a) => mapExpressionPatterns(a, f)),\n    })),\n    Match.tag('FunctionCall', (c) => ({\n      ...c,\n      args: c.args.map((a) => mapExpressionPatterns(a, f)),\n    })),\n    Match.orElse((e) => e),\n  );\n};\n\n/**\n * Pre-binds variables in an algebra expression, following the \"values\n * insertion\" definition of SHACL-SPARQL (Appendix \"Pre-binding of\n * Variables\", aligned with the SPARQL `EXISTS` errata): every basic graph\n * pattern, property path and `GRAPH ?var` pattern `Y` — including those\n * nested in `EXISTS` — is replaced by `Join(Table(μ), Y)`, where `Table(μ)`\n * is a one-row `VALUES` table holding the pre-bound solution `μ`.\n *\n * The pre-bound values are also substituted into the replaced patterns,\n * which does not change the result (the join restores the bindings) but lets\n * the optimizer and the store use them as constants.\n *\n * Unlike a trailing `VALUES` clause, pre-bound values are visible to every\n * `FILTER` and `BIND`, including those of groups that never match the\n * variable: `SELECT $this WHERE { FILTER ($this = ex:a) }` has one solution\n * when `this` is pre-bound to `ex:a`. Queries using `MINUS`, `VALUES` or\n * `SERVICE`, rebinding a pre-bound variable with `AS`, or with sub-queries\n * that do not project the pre-bound variables, have no well-defined meaning\n * under pre-binding.\n *\n * @since 0.1.0\n * @category utils\n */\nexport const prebind = (op: Operation, bindings: Bindings): Operation => {\n  if (bindings.map.size === 0) return op;\n  const table: Values = {\n    _tag: 'Values',\n    variables: Array.from(bindings.map.keys(), (v) => Term.variable(v)),\n    bindings: [bindings],\n  };\n  const term = (t: Ast.TermPattern): Ast.TermPattern => {\n    if (Term.isVariable(t)) return bindings.map.get(t.value) ?? t;\n    if (Term.isTriple(t)) {\n      const s = term(t.subject);\n      const p = term(t.predicate);\n      const o = term(t.object);\n      // Substituting ground terms into a triple pattern keeps each position's kind.\n      return s === t.subject && p === t.predicate && o === t.object\n        ? t\n        : Term.triple<any, any, any>(s, p, o);\n    }\n    return t;\n  };\n  const predicate = (p: Ast.VarOrIri): Ast.VarOrIri => {\n    if (!Term.isVariable(p)) return p;\n    const v = bindings.map.get(p.value);\n    return Term.isNamedNode(v) ? v : p;\n  };\n  const expr = (e: Expression): Expression => mapExpressionPatterns(e, go);\n  const go = (o: Operation): Operation => {\n    return Match.value(o).pipe(\n      Match.tag('Bgp', (b): Operation =>\n        Arr.isReadonlyArrayEmpty(b.patterns)\n          ? table\n          : join(\n              table,\n              bgp(\n                b.patterns.map((p): Ast.TriplePattern => ({\n                  _tag: 'TriplePattern',\n                  subject: term(p.subject),\n                  predicate: predicate(p.predicate),\n                  object: term(p.object),\n                })),\n              ),\n            ),\n      ),\n      Match.tag('Path', (p) =>\n        join(table, { ...p, subject: term(p.subject), object: term(p.object) }),\n      ),\n      Match.tag('Graph', (g) => {\n        const input = go(g.input);\n        const value = Term.isVariable(g.name) ? bindings.map.get(g.name.value) : undefined;\n        if (value === undefined) return { ...g, input };\n        return join(\n          table,\n          Term.isNamedNode(value) ? { ...g, name: value, input } : { ...g, input },\n        );\n      }),\n      Match.tag('Filter', (x) => ({ ...x, expression: expr(x.expression), input: go(x.input) })),\n      Match.tag('LeftJoin', (l) =>\n        l.expression === undefined\n          ? { ...l, left: go(l.left), right: go(l.right) }\n          : { ...l, left: go(l.left), right: go(l.right), expression: expr(l.expression) },\n      ),\n      Match.tag('Extend', (x) => ({ ...x, expression: expr(x.expression), input: go(x.input) })),\n      Match.tag('OrderBy', (x) => ({\n        ...x,\n        input: go(x.input),\n        conditions: x.conditions.map((c) => ({ ...c, expression: expr(c.expression) })),\n      })),\n      Match.tag('Group', (x) => ({\n        ...x,\n        input: go(x.input),\n        keys: x.keys.map((k) => ({ ...k, expression: expr(k.expression) })),\n        aggregates: x.aggregates.map((a) => ({\n          ...a,\n          aggregate:\n            a.aggregate.expression === '*'\n              ? a.aggregate\n              : { ...a.aggregate, expression: expr(a.aggregate.expression) },\n        })),\n      })),\n      Match.orElse((x) => mapChildren(x, go)),\n    );\n  };\n  return go(op);\n};\n"],"mappings":"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"}