@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/Translate-gzWPq0Ia.mjs

@@ -0,0 +1,308 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { 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 { b as union, f as join, g as minus, n as bgp, o as extend, p as leftJoin, s as filter, u as internalVariable, v as project, x as unit, y as transform } from "./Algebra-CGG4oae3.mjs";
+import { O as operation, R as triplePattern, a as bgp$1, h as functionCall, j as projectedVariables, l as containsAggregate, n as aggregate, v as inScopeVariables } from "./Ast-CPRZmBvk.mjs";
+import { o as fromEntries } from "./Bindings-Ck3m7JRC.mjs";
+import * as Arr from "effect/Array";
+import * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+import * as Cause from "effect/Cause";
+// src/sparql/Translate.ts
+/**
+* Translation of the SPARQL AST to the SPARQL algebra, following SPARQL 1.1
+* §18.2 (with the SPARQL 1.2 clarifications): blank nodes become fresh
+* internal variables, property paths are expanded to triple patterns where
+* possible, filters apply to their whole group, `OPTIONAL { … FILTER }`
+* becomes a `LeftJoin` with a condition, and grouping, aggregation,
+* `HAVING`, `VALUES`, select expressions and solution modifiers are applied
+* at the query level. The empty-BGP simplification is applied after the
+* whole translation (the "preferred reading" of the specification).
+*
+* @since 0.1.0
+*/
+var Translate_exports = /* @__PURE__ */ __exportAll({
+	simplify: () => simplify,
+	translateExpression: () => translateExpression,
+	translatePattern: () => translatePattern,
+	translateQuery: () => translateQuery
+});
+var Translator = class {
+	counter = 0;
+	fresh(kind) {
+		return internalVariable(`${kind}${this.counter++}`);
+	}
+	termPattern(t) {
+		return Match.value(t).pipe(Match.tag("BlankNode", (b) => internalVariable(`b:${b.value}`)), Match.tag("Triple", (x) => triple(this.termPattern(x.subject), this.termPattern(x.predicate), this.termPattern(x.object))), Match.orElse((x) => x));
+	}
+	/** Translates a group graph pattern (without simplification). */
+	group(g) {
+		const filters = [];
+		const elements = [];
+		g.patterns.forEach((p) => {
+			if (Predicate.isTagged(p, "Filter")) {
+				filters.push(p.expression);
+				return;
+			}
+			const last = elements[elements.length - 1];
+			if (Predicate.isTagged(p, "Bgp") && Predicate.isTagged(last, "Bgp")) elements[elements.length - 1] = bgp$1([...last.triples, ...p.triples]);
+			else elements.push(p);
+		});
+		let result = elements.reduce((acc, e) => Match.value(e).pipe(Match.tag("Optional", (o) => {
+			const a = this.group(o.pattern);
+			return Predicate.isTagged(a, "Filter") ? leftJoin(acc, a.input, a.expression) : leftJoin(acc, a);
+		}), Match.tag("Minus", (m) => minus(acc, this.group(m.pattern))), Match.tag("Bind", (b) => extend(acc, b.variable, this.expression(b.expression))), Match.orElse((p) => join(acc, this.pattern(p)))), unit);
+		if (Arr.isReadonlyArrayNonEmpty(filters)) {
+			const conjunction = filters.map((f) => this.expression(f)).reduce((a, b) => ({
+				_tag: "Operation",
+				operator: "&&",
+				args: [a, b]
+			}));
+			result = filter(conjunction, result);
+		}
+		return result;
+	}
+	pattern(p) {
+		return Match.value(p).pipe(Match.tag("Bgp", (b) => this.triples(b.triples)), Match.tag("Group", (g) => this.group(g)), Match.tag("Union", (u) => u.patterns.map((g) => this.group(g)).reduce((a, b) => union(a, b))), Match.tag("Graph", (g) => ({
+			_tag: "Graph",
+			name: g.name,
+			input: this.group(g.pattern)
+		})), Match.tag("Service", (s) => ({
+			_tag: "Service",
+			name: s.name,
+			silent: s.silent,
+			input: this.group(s.pattern),
+			pattern: s.pattern,
+			prefixes: {}
+		})), Match.tag("Values", (v) => values(v)), Match.tag("SubSelect", (s) => this.query(s.query).input), Match.tag("Optional", (o) => leftJoin(unit, this.group(o.pattern))), Match.tag("Minus", (m) => minus(unit, this.group(m.pattern))), Match.tag("Filter", (f) => filter(this.expression(f.expression), unit)), Match.tag("Bind", (b) => extend(unit, b.variable, this.expression(b.expression))), Match.exhaustive);
+	}
+	triples(triples) {
+		const parts = [];
+		let current = [];
+		const flush = () => {
+			if (Arr.isReadonlyArrayNonEmpty(current)) parts.push(bgp(current));
+			current = [];
+		};
+		const emitPath = (s, path, o) => {
+			if (Match.value(path).pipe(Match.tag("PathLink", (link) => {
+				current.push(triplePattern(s, link.iri, o));
+				return true;
+			}), Match.tag("PathInverse", (inv) => {
+				if (!Predicate.isTagged(inv.path, "PathLink")) return false;
+				current.push(triplePattern(o, inv.path.iri, s));
+				return true;
+			}), Match.tag("PathSequence", (seq) => {
+				let from = s;
+				seq.paths.forEach((step, i) => {
+					const to = i === seq.paths.length - 1 ? o : this.fresh("p");
+					emitPath(from, step, to);
+					from = to;
+				});
+				return true;
+			}), Match.orElse(() => false))) return;
+			flush();
+			parts.push({
+				_tag: "Path",
+				subject: s,
+				path,
+				object: o
+			});
+		};
+		triples.forEach((t) => {
+			const s = this.termPattern(t.subject);
+			const o = this.termPattern(t.object);
+			if (Predicate.isTagged(t, "TriplePattern")) current.push(triplePattern(s, t.predicate, o));
+			else emitPath(s, t.path, o);
+		});
+		flush();
+		if (Arr.isReadonlyArrayEmpty(parts)) return unit;
+		return parts.reduce((a, b) => join(a, b));
+	}
+	expression(e, aggregates) {
+		return Match.value(e).pipe(Match.tag("Variable", "NamedNode", "Literal", "BlankNode", "Triple", (t) => t), Match.tag("Operation", (o) => ({
+			_tag: "Operation",
+			operator: o.operator,
+			args: o.args.map((a) => this.expression(a, aggregates))
+		})), Match.tag("FunctionCall", (c) => ({
+			_tag: "FunctionCall",
+			function: c.function,
+			args: c.args.map((a) => this.expression(a, aggregates))
+		})), Match.tag("Exists", (x) => ({
+			_tag: "Exists",
+			negated: x.negated,
+			input: this.group(x.pattern)
+		})), Match.tag("Aggregate", (a) => {
+			if (aggregates === void 0) throw new Cause.IllegalArgumentError("Aggregate outside of an aggregation context");
+			return aggregates(a);
+		}), Match.exhaustive);
+	}
+	query(q) {
+		let op = this.group(q.where);
+		const selectExpressions = (Predicate.isTagged(q, "Select") && q.projection !== "*" ? q.projection : []).filter((p) => Predicate.isTagged(p, "Projection"));
+		const grouped = Arr.isReadonlyArrayNonEmpty(q.groupBy) || selectExpressions.some((p) => containsAggregate(p.expression)) || q.having.some(containsAggregate) || q.orderBy.some((o) => containsAggregate(o.expression));
+		let translateLevel = (e) => this.expression(e);
+		if (grouped) {
+			const keys = q.groupBy.map((g) => ({
+				expression: this.expression(g.expression),
+				variable: g.variable ?? (isVariable(g.expression) ? g.expression : this.fresh("g"))
+			}));
+			const keyNames = setOf([...keys.map((k) => k.variable.value), ...q.values?.variables.map((v) => v.value) ?? []]);
+			const aggregates = [];
+			const aggregateVariable = (a) => {
+				const unseparated = {
+					name: a.name,
+					distinct: a.distinct,
+					expression: a.expression === "*" ? "*" : this.expression(a.expression)
+				};
+				const aggregate = a.separator === void 0 ? unseparated : {
+					...unseparated,
+					separator: a.separator
+				};
+				const variable = this.fresh("agg");
+				aggregates.push({
+					variable,
+					aggregate
+				});
+				return variable;
+			};
+			const sampleVariables = (e, aliases) => {
+				return Match.value(e).pipe(Match.tag("Variable", (v) => keyNames.has(v.value) || aliases.has(v.value) ? v : aggregate("SAMPLE", v)), Match.tag("Operation", (o) => operation(o.operator, ...o.args.map((a) => sampleVariables(a, aliases)))), Match.tag("FunctionCall", (c) => functionCall(c.function, c.args.map((a) => sampleVariables(a, aliases)), c.distinct)), Match.orElse((x) => x));
+			};
+			translateLevel = (e, aliases) => this.expression(sampleVariables(e, aliases), aggregateVariable);
+			const having = q.having.map((h) => translateLevel(h, emptySet()));
+			const aliases = emptySet();
+			const extensions = selectExpressions.map((p) => {
+				const e = translateLevel(p.expression, aliases);
+				aliases.set(p.variable.value, true);
+				return {
+					variable: p.variable,
+					expression: e
+				};
+			});
+			const order = q.orderBy.map((o) => ({
+				expression: translateLevel(o.expression, aliases),
+				descending: o.descending
+			}));
+			const group = {
+				_tag: "Group",
+				input: op,
+				keys,
+				aggregates
+			};
+			op = having.reduce((acc, h) => filter(h, acc), group);
+			if (q.values !== void 0) op = join(op, values(q.values));
+			op = extensions.reduce((acc, x) => extend(acc, x.variable, x.expression), op);
+			if (Arr.isReadonlyArrayNonEmpty(order)) op = {
+				_tag: "OrderBy",
+				input: op,
+				conditions: order
+			};
+		} else {
+			op = q.having.reduce((acc, h) => filter(this.expression(h), acc), op);
+			if (q.values !== void 0) op = join(op, values(q.values));
+			op = selectExpressions.reduce((acc, p) => extend(acc, p.variable, translateLevel(p.expression, emptySet())), op);
+			if (Arr.isReadonlyArrayNonEmpty(q.orderBy)) op = {
+				_tag: "OrderBy",
+				input: op,
+				conditions: q.orderBy.map((o) => ({
+					expression: this.expression(o.expression),
+					descending: o.descending
+				}))
+			};
+		}
+		const slice = (input) => q.offset !== void 0 || q.limit !== void 0 ? {
+			_tag: "Slice",
+			input,
+			offset: q.offset ?? 0,
+			limit: q.limit
+		} : input;
+		const dataset = q.dataset !== void 0 ? { dataset: q.dataset } : {};
+		return Match.value(q).pipe(Match.tag("Select", (s) => {
+			const variables = projectedVariables(s).map((v) => variable(v));
+			op = project(op, variables);
+			if (s.distinct) op = {
+				_tag: "Distinct",
+				input: op
+			};
+			else if (s.reduced) op = {
+				_tag: "Reduced",
+				input: op
+			};
+			return {
+				_tag: "Select",
+				input: slice(op),
+				variables,
+				...dataset
+			};
+		}), Match.tag("Ask", () => ({
+			_tag: "Ask",
+			input: slice(op),
+			...dataset
+		})), Match.tag("Construct", (c) => ({
+			_tag: "Construct",
+			input: slice(op),
+			template: c.template,
+			...dataset
+		})), Match.tag("Describe", (d) => {
+			const terms = d.terms === "*" ? inScopeVariables(d.where).map((v) => variable(v)) : d.terms;
+			const vars = terms.filter(isVariable);
+			return {
+				_tag: "Describe",
+				input: slice(project(op, vars)),
+				terms,
+				...dataset
+			};
+		}), Match.exhaustive);
+	}
+};
+const values = (p) => ({
+	_tag: "Values",
+	variables: p.variables,
+	bindings: p.rows.map((row) => fromEntries(p.variables.map((v, i) => [v.value, row[i]])))
+});
+const isUnit = (op) => Predicate.isTagged(op, "Bgp") && Arr.isReadonlyArrayEmpty(op.patterns);
+/**
+* Removes joins with the empty BGP (`Join(Z, A)` → `A`).
+*
+* @since 0.1.0
+* @category simplification
+*/
+const simplify = (op) => transform(op, (o) => {
+	if (Predicate.isTagged(o, "Join")) {
+		if (isUnit(o.left)) return o.right;
+		if (isUnit(o.right)) return o.left;
+	}
+	return o;
+});
+/**
+* Translates a query to the algebra.
+*
+* @since 0.1.0
+* @category translation
+*/
+const translateQuery = (query) => {
+	const q = new Translator().query(query);
+	return {
+		...q,
+		input: simplify(q.input)
+	};
+};
+/**
+* Translates a group graph pattern (e.g. the `WHERE` clause of an update) to
+* the algebra.
+*
+* @since 0.1.0
+* @category translation
+*/
+const translatePattern = (pattern) => simplify(new Translator().group(pattern));
+/**
+* Translates an expression (which must not contain aggregates) to the
+* algebra.
+*
+* @since 0.1.0
+* @category translation
+*/
+const translateExpression = (expression) => new Translator().expression(expression);
+export { translateQuery as a, translatePattern as i, simplify as n, translateExpression as r, Translate_exports as t };
+
+//# sourceMappingURL=Translate-gzWPq0Ia.mjs.map

package/dist/Translate-gzWPq0Ia.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Translate-gzWPq0Ia.mjs","names":["Algebra.internalVariable","Term.triple","Ast.bgp","Algebra.leftJoin","Algebra.minus","Algebra.extend","Algebra.join","Algebra.unit","Algebra.filter","Algebra.union","Algebra.bgp","Ast.triplePattern","Ast.containsAggregate","Term.isVariable","StringMap.setOf","Ast.aggregate","Ast.operation","Ast.functionCall","StringMap.emptySet","Ast.projectedVariables","Term.variable","Algebra.project","Ast.inScopeVariables","Bindings.fromEntries","Algebra.transform"],"sources":["../src/sparql/Translate.ts"],"sourcesContent":["/**\n * Translation of the SPARQL AST to the SPARQL algebra, following SPARQL 1.1\n * §18.2 (with the SPARQL 1.2 clarifications): blank nodes become fresh\n * internal variables, property paths are expanded to triple patterns where\n * possible, filters apply to their whole group, `OPTIONAL { … FILTER }`\n * becomes a `LeftJoin` with a condition, and grouping, aggregation,\n * `HAVING`, `VALUES`, select expressions and solution modifiers are applied\n * at the query level. The empty-BGP simplification is applied after the\n * whole translation (the \"preferred reading\" of the specification).\n *\n * @since 0.1.0\n */\nimport * as Arr from 'effect/Array';\nimport * as Cause from 'effect/Cause';\nimport * as Match from 'effect/Match';\nimport * as Predicate from 'effect/Predicate';\nimport * as Term from '../Term.ts';\nimport * as Algebra from './Algebra.ts';\nimport * as Ast from './Ast.ts';\nimport * as Bindings from './Bindings.ts';\nimport * as StringMap from './internal/stringMap.ts';\n\n/** Variable names, as a string set. */\ntype Names = ReadonlyMap<string, true>;\n\nclass Translator {\n  private counter = 0;\n\n  fresh(kind: string): Term.Variable {\n    return Algebra.internalVariable(`${kind}${this.counter++}`);\n  }\n\n  // --- terms ----------------------------------------------------------------\n\n  termPattern(t: Ast.TermPattern): Ast.TermPattern {\n    return Match.value(t).pipe(\n      Match.tag('BlankNode', (b): Ast.TermPattern => Algebra.internalVariable(`b:${b.value}`)),\n      Match.tag('Triple', (x) =>\n        Term.triple<any, any, any>(\n          this.termPattern(x.subject),\n          this.termPattern(x.predicate),\n          this.termPattern(x.object),\n        ),\n      ),\n      Match.orElse((x) => x),\n    );\n  }\n\n  // --- graph patterns -------------------------------------------------------\n\n  /** Translates a group graph pattern (without simplification). */\n  group(g: Ast.GroupPattern): Algebra.Operation {\n    const filters: Array<Ast.Expression> = [];\n    // Merge adjacent triple blocks (filters do not separate BGPs).\n    const elements: Array<Ast.Pattern> = [];\n    g.patterns.forEach((p) => {\n      if (Predicate.isTagged(p, 'Filter')) {\n        filters.push(p.expression);\n        return;\n      }\n      const last = elements[elements.length - 1];\n      if (Predicate.isTagged(p, 'Bgp') && Predicate.isTagged(last, 'Bgp')) {\n        elements[elements.length - 1] = Ast.bgp([...last.triples, ...p.triples]);\n      } else elements.push(p);\n    });\n    let result = elements.reduce<Algebra.Operation>(\n      (acc, e) =>\n        Match.value(e).pipe(\n          Match.tag('Optional', (o): Algebra.Operation => {\n            const a = this.group(o.pattern);\n            return Predicate.isTagged(a, 'Filter')\n              ? Algebra.leftJoin(acc, a.input, a.expression)\n              : Algebra.leftJoin(acc, a);\n          }),\n          Match.tag('Minus', (m) => Algebra.minus(acc, this.group(m.pattern))),\n          Match.tag('Bind', (b) => Algebra.extend(acc, b.variable, this.expression(b.expression))),\n          Match.orElse((p) => Algebra.join(acc, this.pattern(p))),\n        ),\n      Algebra.unit,\n    );\n    if (Arr.isReadonlyArrayNonEmpty(filters)) {\n      const conjunction = filters\n        .map((f) => this.expression(f))\n        .reduce((a, b) => ({ _tag: 'Operation', operator: '&&', args: [a, b] }));\n      result = Algebra.filter(conjunction, result);\n    }\n    return result;\n  }\n\n  pattern(p: Ast.Pattern): Algebra.Operation {\n    return Match.value(p).pipe(\n      Match.tag('Bgp', (b): Algebra.Operation => this.triples(b.triples)),\n      Match.tag('Group', (g) => this.group(g)),\n      Match.tag('Union', (u) =>\n        u.patterns.map((g) => this.group(g)).reduce((a, b) => Algebra.union(a, b)),\n      ),\n      Match.tag('Graph', (g): Algebra.Operation => ({\n        _tag: 'Graph',\n        name: g.name,\n        input: this.group(g.pattern),\n      })),\n      Match.tag('Service', (s): Algebra.Operation => ({\n        _tag: 'Service',\n        name: s.name,\n        silent: s.silent,\n        input: this.group(s.pattern),\n        pattern: s.pattern,\n        prefixes: {},\n      })),\n      Match.tag('Values', (v) => values(v)),\n      Match.tag('SubSelect', (s) => this.query(s.query).input),\n      Match.tag('Optional', (o) => Algebra.leftJoin(Algebra.unit, this.group(o.pattern))),\n      Match.tag('Minus', (m) => Algebra.minus(Algebra.unit, this.group(m.pattern))),\n      Match.tag('Filter', (f) => Algebra.filter(this.expression(f.expression), Algebra.unit)),\n      Match.tag('Bind', (b) =>\n        Algebra.extend(Algebra.unit, b.variable, this.expression(b.expression)),\n      ),\n      Match.exhaustive,\n    );\n  }\n\n  triples(triples: ReadonlyArray<Ast.TriplePattern | Ast.PathPattern>): Algebra.Operation {\n    const parts: Array<Algebra.Operation> = [];\n    let current: Array<Ast.TriplePattern> = [];\n    const flush = () => {\n      if (Arr.isReadonlyArrayNonEmpty(current)) parts.push(Algebra.bgp(current));\n      current = [];\n    };\n    const emitPath = (s: Ast.TermPattern, path: Ast.Path, o: Ast.TermPattern): void => {\n      const emitted = Match.value(path).pipe(\n        Match.tag('PathLink', (link) => {\n          current.push(Ast.triplePattern(s, link.iri, o));\n          return true;\n        }),\n        Match.tag('PathInverse', (inv) => {\n          if (!Predicate.isTagged(inv.path, 'PathLink')) return false;\n          current.push(Ast.triplePattern(o, inv.path.iri, s));\n          return true;\n        }),\n        Match.tag('PathSequence', (seq) => {\n          let from = s;\n          seq.paths.forEach((step, i) => {\n            const to = i === seq.paths.length - 1 ? o : this.fresh('p');\n            emitPath(from, step, to);\n            from = to;\n          });\n          return true;\n        }),\n        Match.orElse(() => false),\n      );\n      if (emitted) return;\n      flush();\n      parts.push({ _tag: 'Path', subject: s, path, object: o });\n    };\n    triples.forEach((t) => {\n      const s = this.termPattern(t.subject);\n      const o = this.termPattern(t.object);\n      if (Predicate.isTagged(t, 'TriplePattern'))\n        current.push(Ast.triplePattern(s, t.predicate, o));\n      else emitPath(s, t.path, o);\n    });\n    flush();\n    if (Arr.isReadonlyArrayEmpty(parts)) return Algebra.unit;\n    return parts.reduce((a, b) => Algebra.join(a, b));\n  }\n\n  // --- expressions ----------------------------------------------------------\n\n  expression(\n    e: Ast.Expression,\n    aggregates?: (a: Ast.AggregateExpression) => Term.Variable,\n  ): Algebra.Expression {\n    return Match.value(e).pipe(\n      Match.tag(\n        'Variable',\n        'NamedNode',\n        'Literal',\n        'BlankNode',\n        'Triple',\n        (t): Algebra.Expression => t,\n      ),\n      Match.tag('Operation', (o): Algebra.Expression => ({\n        _tag: 'Operation',\n        operator: o.operator,\n        args: o.args.map((a) => this.expression(a, aggregates)),\n      })),\n      Match.tag('FunctionCall', (c): Algebra.Expression => ({\n        _tag: 'FunctionCall',\n        function: c.function,\n        args: c.args.map((a) => this.expression(a, aggregates)),\n      })),\n      // Not simplified: the empty BGPs at the start of each group are the\n      // \"ContextSolution\" through which the current solution flows into\n      // the pattern (SPARQL 1.2 §18.6).\n      Match.tag('Exists', (x): Algebra.Expression => ({\n        _tag: 'Exists',\n        negated: x.negated,\n        input: this.group(x.pattern),\n      })),\n      Match.tag('Aggregate', (a) => {\n        if (aggregates === undefined)\n          throw new Cause.IllegalArgumentError('Aggregate outside of an aggregation context');\n        return aggregates(a);\n      }),\n      Match.exhaustive,\n    );\n  }\n\n  // --- queries --------------------------------------------------------------\n\n  query(q: Ast.Query): Algebra.Query {\n    let op = this.group(q.where);\n    const projection =\n      Predicate.isTagged(q, 'Select') && q.projection !== '*' ? q.projection : ([] as const);\n    const selectExpressions = projection.filter((p): p is Ast.Projection =>\n      Predicate.isTagged(p, 'Projection'),\n    );\n    const grouped =\n      Arr.isReadonlyArrayNonEmpty(q.groupBy) ||\n      selectExpressions.some((p) => Ast.containsAggregate(p.expression)) ||\n      q.having.some(Ast.containsAggregate) ||\n      q.orderBy.some((o) => Ast.containsAggregate(o.expression));\n\n    let translateLevel: (e: Ast.Expression, aliases: Names) => Algebra.Expression = (e) =>\n      this.expression(e);\n\n    if (grouped) {\n      const keys: Array<Algebra.GroupKey> = q.groupBy.map((g) => ({\n        expression: this.expression(g.expression),\n        variable: g.variable ?? (Term.isVariable(g.expression) ? g.expression : this.fresh('g')),\n      }));\n      const keyNames = StringMap.setOf([\n        ...keys.map((k) => k.variable.value),\n        ...(q.values?.variables.map((v) => v.value) ?? []),\n      ]);\n      const aggregates: Array<{ variable: Term.Variable; aggregate: Algebra.Aggregate }> = [];\n      const aggregateVariable = (a: Ast.AggregateExpression): Term.Variable => {\n        const unseparated: Algebra.Aggregate = {\n          name: a.name,\n          distinct: a.distinct,\n          expression: a.expression === '*' ? '*' : this.expression(a.expression),\n        };\n        const aggregate: Algebra.Aggregate =\n          a.separator === undefined ? unseparated : { ...unseparated, separator: a.separator };\n        const variable = this.fresh('agg');\n        aggregates.push({ variable, aggregate });\n        return variable;\n      };\n      // Variables outside aggregates that are not group keys are sampled.\n      const sampleVariables = (e: Ast.Expression, aliases: Names): Ast.Expression => {\n        return Match.value(e).pipe(\n          Match.tag('Variable', (v): Ast.Expression =>\n            keyNames.has(v.value) || aliases.has(v.value) ? v : Ast.aggregate('SAMPLE', v),\n          ),\n          Match.tag('Operation', (o) =>\n            Ast.operation(o.operator, ...o.args.map((a) => sampleVariables(a, aliases))),\n          ),\n          Match.tag('FunctionCall', (c) =>\n            Ast.functionCall(\n              c.function,\n              c.args.map((a) => sampleVariables(a, aliases)),\n              c.distinct,\n            ),\n          ),\n          Match.orElse((x) => x),\n        );\n      };\n      translateLevel = (e, aliases) =>\n        this.expression(sampleVariables(e, aliases), aggregateVariable);\n      // Translate expressions now so that the aggregates are collected before\n      // the Group node is built.\n      const having = q.having.map((h) => translateLevel(h, StringMap.emptySet()));\n      const aliases = StringMap.emptySet();\n      const extensions = selectExpressions.map((p) => {\n        const e = translateLevel(p.expression, aliases);\n        aliases.set(p.variable.value, true);\n        return { variable: p.variable, expression: e };\n      });\n      const order = q.orderBy.map((o) => ({\n        expression: translateLevel(o.expression, aliases),\n        descending: o.descending,\n      }));\n      const group: Algebra.Operation = { _tag: 'Group', input: op, keys, aggregates };\n      op = having.reduce<Algebra.Operation>((acc, h) => Algebra.filter(h, acc), group);\n      if (q.values !== undefined) op = Algebra.join(op, values(q.values));\n      op = extensions.reduce<Algebra.Operation>(\n        (acc, x) => Algebra.extend(acc, x.variable, x.expression),\n        op,\n      );\n      if (Arr.isReadonlyArrayNonEmpty(order))\n        op = { _tag: 'OrderBy', input: op, conditions: order };\n    } else {\n      op = q.having.reduce<Algebra.Operation>(\n        (acc, h) => Algebra.filter(this.expression(h), acc),\n        op,\n      );\n      if (q.values !== undefined) op = Algebra.join(op, values(q.values));\n      op = selectExpressions.reduce<Algebra.Operation>(\n        (acc, p) =>\n          Algebra.extend(acc, p.variable, translateLevel(p.expression, StringMap.emptySet())),\n        op,\n      );\n      if (Arr.isReadonlyArrayNonEmpty(q.orderBy)) {\n        op = {\n          _tag: 'OrderBy',\n          input: op,\n          conditions: q.orderBy.map((o) => ({\n            expression: this.expression(o.expression),\n            descending: o.descending,\n          })),\n        };\n      }\n    }\n\n    const slice = (input: Algebra.Operation): Algebra.Operation =>\n      q.offset !== undefined || q.limit !== undefined\n        ? { _tag: 'Slice', input, offset: q.offset ?? 0, limit: q.limit }\n        : input;\n    const dataset = q.dataset !== undefined ? { dataset: q.dataset } : {};\n\n    return Match.value(q).pipe(\n      Match.tag('Select', (s): Algebra.Query => {\n        const variables = Ast.projectedVariables(s).map((v) => Term.variable(v));\n        op = Algebra.project(op, variables);\n        if (s.distinct) op = { _tag: 'Distinct', input: op };\n        else if (s.reduced) op = { _tag: 'Reduced', input: op };\n        return { _tag: 'Select', input: slice(op), variables, ...dataset };\n      }),\n      Match.tag('Ask', (): Algebra.Query => ({ _tag: 'Ask', input: slice(op), ...dataset })),\n      Match.tag('Construct', (c): Algebra.Query => ({\n        _tag: 'Construct',\n        input: slice(op),\n        template: c.template,\n        ...dataset,\n      })),\n      Match.tag('Describe', (d): Algebra.Query => {\n        const terms =\n          d.terms === '*' ? Ast.inScopeVariables(d.where).map((v) => Term.variable(v)) : d.terms;\n        const vars = terms.filter(Term.isVariable);\n        return {\n          _tag: 'Describe',\n          input: slice(Algebra.project(op, vars)),\n          terms,\n          ...dataset,\n        };\n      }),\n      Match.exhaustive,\n    );\n  }\n}\n\nconst values = (p: Ast.ValuesPattern): Algebra.Values => ({\n  _tag: 'Values',\n  variables: p.variables,\n  bindings: p.rows.map((row) =>\n    Bindings.fromEntries(p.variables.map((v, i) => [v.value, row[i]] as const)),\n  ),\n});\n\nconst isUnit = (op: Algebra.Operation): boolean =>\n  Predicate.isTagged(op, 'Bgp') && Arr.isReadonlyArrayEmpty(op.patterns);\n\n/**\n * Removes joins with the empty BGP (`Join(Z, A)` → `A`).\n *\n * @since 0.1.0\n * @category simplification\n */\nexport const simplify = (op: Algebra.Operation): Algebra.Operation =>\n  Algebra.transform(op, (o) => {\n    if (Predicate.isTagged(o, 'Join')) {\n      if (isUnit(o.left)) return o.right;\n      if (isUnit(o.right)) return o.left;\n    }\n    return o;\n  });\n\n/**\n * Translates a query to the algebra.\n *\n * @since 0.1.0\n * @category translation\n */\nexport const translateQuery = (query: Ast.Query): Algebra.Query => {\n  const q = new Translator().query(query);\n  return { ...q, input: simplify(q.input) };\n};\n\n/**\n * Translates a group graph pattern (e.g. the `WHERE` clause of an update) to\n * the algebra.\n *\n * @since 0.1.0\n * @category translation\n */\nexport const translatePattern = (pattern: Ast.GroupPattern): Algebra.Operation =>\n  simplify(new Translator().group(pattern));\n\n/**\n * Translates an expression (which must not contain aggregates) to the\n * algebra.\n *\n * @since 0.1.0\n * @category translation\n */\nexport const translateExpression = (expression: Ast.Expression): Algebra.Expression =>\n  new Translator().expression(expression);\n"],"mappings":"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"}