@thomasfosterau/effect-rdf 0.0.0 → 0.1.0

package/dist/Translation-DC9rLm2y.mjs

@@ -0,0 +1,1535 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, I as isGround, K as isTriple, P as isDefaultGraph, T as blankNode, Y as literal, Z as namedNode, o as Literal, q as isVariable, w as XSD_STRING, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { S as toValue, _ as isValidLexical, g as isNumericDatatype, h as isKnownDatatype } from "./Xsd-Cdgx5zRB.mjs";
+import { i as equals, r as effectiveBooleanValue } from "./Expression-BIMMvduQ.mjs";
+import { n as StoreError } from "./Store-DH3Ow1GO.mjs";
+import * as Arr from "effect/Array";
+import * as Equal from "effect/Equal";
+import * as MutableHashMap from "effect/MutableHashMap";
+import * as MutableHashSet from "effect/MutableHashSet";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+import * as Result from "effect/Result";
+import * as BigDecimal from "effect/BigDecimal";
+// src/sparql/sql/internal/encoding.ts
+/**
+* The encoding of RDF terms as rows of the term dictionary.
+*
+* @internal
+*/
+/** Term kinds stored in the `kind` column. */
+const Kind = {
+	NamedNode: 1,
+	BlankNode: 2,
+	Literal: 3,
+	Triple: 4
+};
+/**
+* Comparison classes stored in the `cls` column. They let the SQL
+* translation of SPARQL comparisons decide, per row, which comparison rule
+* applies (numeric, string, boolean, …) — and tell the store which rules the
+* data could need that SQL cannot evaluate exactly.
+*/
+const Cls = {
+	/** IRIs and blank nodes. */
+	Resource: 0,
+	/** Integers and decimals whose double value is exact and order preserving. */
+	SafeNumber: 1,
+	/** Finite `xsd:double`. */
+	Double: 2,
+	/** Finite `xsd:float` (`num` holds the float value). */
+	Float: 3,
+	/** `xsd:string`. */
+	String: 4,
+	/** Language-tagged strings (with or without a base direction). */
+	LangString: 5,
+	/** Valid `xsd:boolean` (`num` is 0 or 1). */
+	Boolean: 6,
+	/** Valid date/time and duration literals. */
+	Temporal: 7,
+	/** Integers and decimals that do not fit a double exactly. */
+	UnsafeNumber: 8,
+	/** Literals of datatypes unknown to the engine. */
+	Unknown: 9,
+	/** Triple terms. */
+	Triple: 10,
+	/** `NaN` and infinite doubles and floats. */
+	SpecialFloat: 11,
+	/** Ill-formed literals of numeric datatypes. */
+	IllFormedNumeric: 12,
+	/** Other well-formed literals of known datatypes (e.g. `xsd:anyURI`). */
+	OtherKnown: 13,
+	/** Other ill-formed literals of known datatypes. */
+	IllFormed: 14
+};
+Array.from({ length: 15 }, (_, i) => i);
+/** Classes of literals that are well-formed and of a known datatype. */
+const WELL_FORMED_KNOWN = [
+	1,
+	2,
+	3,
+	4,
+	6,
+	7,
+	8,
+	11,
+	13
+];
+const XSD$1 = "http://www.w3.org/2001/XMLSchema#";
+const TEMPORAL = MutableHashSet.fromIterable([
+	"dateTime",
+	"dateTimeStamp",
+	"date",
+	"time",
+	"gYear",
+	"gYearMonth",
+	"gMonth",
+	"gMonthDay",
+	"gDay",
+	"duration",
+	"dayTimeDuration",
+	"yearMonthDuration"
+].map((l) => XSD$1 + l));
+const MAX_SAFE = 2n ** 53n;
+const decimalDigits = (d) => {
+	const n = BigDecimal.normalize(d);
+	return (n.value < 0n ? -n.value : n.value).toString().length;
+};
+const noNumber = (cls) => ({
+	cls,
+	num: Option.none()
+});
+const withNumber = (cls, num) => ({
+	cls,
+	num: Option.some(num)
+});
+const numericClass = Match.type().pipe(Match.withReturnType(), Match.tag("Integer", (v) => v.value <= MAX_SAFE && v.value >= -MAX_SAFE ? withNumber(Cls.SafeNumber, Number(v.value)) : withNumber(Cls.UnsafeNumber, Number(v.value))), Match.tag("Decimal", (v) => decimalDigits(v.value) <= 15 ? withNumber(Cls.SafeNumber, Number(BigDecimal.format(v.value))) : withNumber(Cls.UnsafeNumber, BigDecimal.toNumberUnsafe(v.value))), Match.tag("Float", (v) => Number.isFinite(v.value) ? withNumber(Cls.Float, v.value) : noNumber(Cls.SpecialFloat)), Match.tag("Double", (v) => Number.isFinite(v.value) ? withNumber(Cls.Double, v.value) : noNumber(Cls.SpecialFloat)), Match.orElse(() => noNumber(Cls.IllFormedNumeric)));
+const RESOURCE = noNumber(Cls.Resource);
+const TRIPLE = noNumber(Cls.Triple);
+const LANG_STRING = noNumber(Cls.LangString);
+const STRING = noNumber(Cls.String);
+const UNKNOWN = noNumber(Cls.Unknown);
+const ILL_FORMED_NUMERIC = noNumber(Cls.IllFormedNumeric);
+const ILL_FORMED = noNumber(Cls.IllFormed);
+const TEMPORAL_CLASS = noNumber(Cls.Temporal);
+const OTHER_KNOWN = noNumber(Cls.OtherKnown);
+const classifyTerm = Match.type().pipe(Match.withReturnType(), Match.tag("NamedNode", "BlankNode", () => RESOURCE), Match.tag("Triple", () => TRIPLE), Match.tag("Literal", (term) => {
+	if (term.language !== "") return LANG_STRING;
+	const dt = term.datatype.value;
+	if (dt === "http://www.w3.org/2001/XMLSchema#string") return STRING;
+	if (!isKnownDatatype(dt)) return UNKNOWN;
+	const valid = isValidLexical(dt, term.value);
+	if (isNumericDatatype(dt)) {
+		if (!valid) return ILL_FORMED_NUMERIC;
+		const v = toValue(term);
+		return numericClass(v);
+	}
+	if (!valid) return ILL_FORMED;
+	if (dt === `${XSD$1}boolean`) return withNumber(Cls.Boolean, term.value === "true" || term.value === "1" ? 1 : 0);
+	if (MutableHashSet.has(TEMPORAL, dt)) return TEMPORAL_CLASS;
+	return OTHER_KNOWN;
+}), Match.exhaustive);
+/** The comparison class and numeric value of a term. */
+const classify = (term) => classifyTerm(term);
+const encodeRow = Match.fn((term, _class, _componentIds) => term).pipe(Match.withReturnType(), Match.tag("NamedNode", (term, _term, { cls, num }) => ({
+	kind: Kind.NamedNode,
+	value: term.value,
+	datatype: "",
+	lang: "",
+	dir: "",
+	sub: Option.none(),
+	pre: Option.none(),
+	obj: Option.none(),
+	cls,
+	num
+})), Match.tag("BlankNode", (term, _term, { cls, num }) => ({
+	kind: Kind.BlankNode,
+	value: term.value,
+	datatype: "",
+	lang: "",
+	dir: "",
+	sub: Option.none(),
+	pre: Option.none(),
+	obj: Option.none(),
+	cls,
+	num
+})), Match.tag("Literal", (term, _term, { cls, num }) => ({
+	kind: Kind.Literal,
+	value: term.value,
+	datatype: term.datatype.value,
+	lang: term.language,
+	dir: term.direction ?? "",
+	sub: Option.none(),
+	pre: Option.none(),
+	obj: Option.none(),
+	cls,
+	num
+})), Match.tag("Triple", (_triple, _term, { cls, num }, componentIds) => {
+	if (componentIds === void 0) throw new StoreError({ message: "Triple terms need component ids" });
+	return {
+		kind: Kind.Triple,
+		value: componentIds.join(" "),
+		datatype: "",
+		lang: "",
+		dir: "",
+		sub: Option.some(componentIds[0]),
+		pre: Option.some(componentIds[1]),
+		obj: Option.some(componentIds[2]),
+		cls,
+		num
+	};
+}), Match.exhaustive);
+/**
+* The dictionary row of a term. Triple terms store the ids of their
+* components in `value` (`"s p o"`), so that `(value, kind, datatype, lang,
+* dir)` is a unique key for every term.
+*/
+const encode = (term, componentIds) => encodeRow(term, classify(term), componentIds);
+/** The unique key of a dictionary row. */
+const rowKey = (row) => `${row.kind}\u0000${row.value}\u0000${row.datatype}\u0000${row.lang}\u0000${row.dir}`;
+const datatypes = MutableHashMap.empty();
+const datatype = (iri) => Option.getOrElse(MutableHashMap.get(datatypes, iri), () => {
+	const n = namedNode(iri);
+	if (MutableHashMap.size(datatypes) < 1e4) MutableHashMap.set(datatypes, iri, n);
+	return n;
+});
+const decodeRow = Match.fn((kind, _value, _dt, _lang, _dir) => kind).pipe(Match.withReturnType(), Match.when(Kind.NamedNode, (_kind, _k, value) => namedNode(value)), Match.when(Kind.BlankNode, (_kind, _k, value) => blankNode(value)), Match.when(Kind.Literal, (_kind, _k, value, dt, lang, dir) => new Literal(value, datatype(dt), lang, dir === "ltr" || dir === "rtl" ? dir : void 0)), Match.orElse((_kind, _k, value) => {
+	const [s = NaN, p = NaN, o = NaN] = value.split(" ").map(Number);
+	return [
+		s,
+		p,
+		o
+	];
+}));
+/** Whether a decoded row is the component ids of a triple term. */
+const isComponentIds = (decoded) => Array.isArray(decoded);
+/**
+* Decodes a non-triple dictionary row; returns the component ids for triple
+* terms.
+*/
+const decode = (kind, value, dt, lang, dir) => decodeRow(kind, value, dt, lang, dir);
+// src/sparql/sql/Translation.ts
+/**
+* SPARQL algebra to SQL translation.
+*
+* `compile` translates an algebra tree into a single SQL `SELECT` over the
+* store's tables (term dictionary + quads of term ids), or reports that the
+* tree is not (exactly) translatable — the store then lets the generic engine
+* evaluate that node and offers its children again.
+*
+* Solutions are rows whose columns hold term ids (`NULL` = unbound). Terms
+* that are not in the dictionary but are needed by the query (constants of
+* `VALUES`, `BIND`, …) get negative, query-local ids. Integer results of
+* `COUNT` are carried as plain integers. The final `SELECT` joins the
+* dictionary to decode the ids.
+*
+* Translated: BGPs (self-joins of the quads table, triple term patterns
+* through the dictionary), `Join`, `LeftJoin` (with the filter in the `ON`
+* clause), `Union` (`UNION ALL` with `NULL` padding), `Minus` and
+* `[NOT] EXISTS` (correlated `NOT EXISTS` / `EXISTS`), `Filter`, `Graph`
+* (constant and variable), `Extend` with term-valued expressions, `Values`,
+* `Project`, `Distinct`, `Reduced`, `Slice` and `Group` with `COUNT` /
+* `SAMPLE`. Expressions: `&&`, `||`, `!`, `=`, `!=`, `<`, `>`, `<=`, `>=`,
+* `IN`, `NOT IN`, `BOUND`, `sameTerm`, `isIRI`, `isBlank`, `isLiteral`,
+* `isNumeric`, `isTriple`, `hasLang`, `hasLangDir`, `STR`, `LANG`,
+* `DATATYPE`, `STRLEN`, `STRSTARTS`, `STRENDS`, `CONTAINS`, `LANGMATCHES`,
+* `IF`, `COALESCE` and `EXISTS`, with SPARQL's error semantics (an error is
+* SQL `NULL`; SPARQL's `&&`/`||`/`!` coincide with SQL's three-valued logic).
+*
+* Comparisons are evaluated per row by the comparison class of the terms
+* (stored in the dictionary). Combinations of classes that SQL cannot compare
+* exactly (e.g. dates, arbitrary-precision decimals, float/double promotion)
+* are reported as `risks`: before running the query the store checks which
+* classes exist and falls back to the engine if a risk can occur.
+*
+* @since 0.1.0
+*/
+var Translation_exports = /* @__PURE__ */ __exportAll({
+	compile: () => compile,
+	constants: () => constants,
+	isRisky: () => isRisky,
+	supports: () => supports
+});
+/**
+* Whether the risks of a compiled query can occur, given the comparison
+* classes present in the store.
+*
+* @since 0.1.0
+* @category utils
+*/
+const isRisky = (compiled, storeClasses) => {
+	const present = (c) => storeClasses.has(c) || compiled.localClasses.has(c);
+	return compiled.risks.some((r) => (r.aStatic || present(r.a)) && (r.bStatic || present(r.b)));
+};
+var Unsupported = class {
+	reason;
+	constructor(reason) {
+		this.reason = reason;
+	}
+};
+const unsupported = (reason) => {
+	throw new Unsupported(reason);
+};
+/** Whether a term (pattern) is a triple term with no variables. */
+const isGroundTriple = (t) => isTriple(t) && isGround(t);
+const collectTerm = (term, out) => {
+	return Match.value(term).pipe(Match.tag("NamedNode", "Literal", (t) => {
+		MutableHashMap.set(out, t.key, t);
+	}), Match.tag("Triple", (t) => {
+		if (isGroundTriple(t)) MutableHashMap.set(out, t.key, t);
+		else {
+			collectTerm(t.subject, out);
+			collectTerm(t.predicate, out);
+			collectTerm(t.object, out);
+		}
+	}), Match.orElse(() => void 0));
+};
+const collectExpression = (e, out) => {
+	Match.value(e).pipe(Match.tag("Operation", "FunctionCall", (call) => call.args.forEach((a) => collectExpression(a, out))), Match.tag("Exists", (x) => collectOperation(x.input, out)), Match.orElse((t) => collectTerm(t, out)));
+};
+const collectOperation = (operation, out) => {
+	return Match.value(operation).pipe(Match.tag("Bgp", (op) => op.patterns.forEach((p) => {
+		collectTerm(p.subject, out);
+		collectTerm(p.predicate, out);
+		collectTerm(p.object, out);
+	})), Match.tag("Path", () => void 0), Match.tag("Join", "Union", "Minus", (op) => {
+		collectOperation(op.left, out);
+		collectOperation(op.right, out);
+	}), Match.tag("LeftJoin", (op) => {
+		collectOperation(op.left, out);
+		collectOperation(op.right, out);
+		if (op.expression !== void 0) collectExpression(op.expression, out);
+	}), Match.tag("Filter", (op) => {
+		collectExpression(op.expression, out);
+		collectOperation(op.input, out);
+	}), Match.tag("Extend", (op) => {
+		collectExpression(op.expression, out);
+		collectOperation(op.input, out);
+	}), Match.tag("Graph", (op) => {
+		collectTerm(op.name, out);
+		collectOperation(op.input, out);
+	}), Match.tag("Values", (op) => op.bindings.forEach((b) => Arr.forEach(b, ([, t]) => collectTerm(t, out)))), Match.tag("Group", "OrderBy", "Project", "Distinct", "Reduced", "Slice", "Service", (op) => {
+		collectOperation(op.input, out);
+	}), Match.exhaustive);
+};
+/**
+* The constant terms of an algebra tree (and of the dataset) whose
+* dictionary ids the translation needs.
+*
+* @since 0.1.0
+* @category utils
+*/
+const constants = (op, context) => {
+	const out = MutableHashMap.empty();
+	collectOperation(op, out);
+	const { defaultGraph, namedGraphs } = context.dataset;
+	if (!Predicate.isString(defaultGraph)) defaultGraph.forEach((g) => {
+		if (!isDefaultGraph(g)) MutableHashMap.set(out, g.key, g);
+	});
+	if (!Predicate.isString(namedGraphs)) namedGraphs.forEach((g) => MutableHashMap.set(out, g.key, g));
+	if (Predicate.isTagged(context.activeGraph, "NamedGraph")) MutableHashMap.set(out, context.activeGraph.graph.key, context.activeGraph.graph);
+	MutableHashMap.set(out, TRUE.key, TRUE);
+	MutableHashMap.set(out, FALSE.key, FALSE);
+	return Arr.fromIterable(MutableHashMap.values(out));
+};
+/** A FROM item joined unconditionally. */
+const inner = (source, alias) => ({
+	source,
+	alias,
+	left: Option.none()
+});
+const EMPTY = {
+	items: [],
+	where: [],
+	cols: MutableHashMap.empty()
+};
+/** Whether a block is the unit (no items, conditions or columns). */
+const isUnit = (block) => Arr.isReadonlyArrayEmpty(block.items) && Arr.isReadonlyArrayEmpty(block.where) && MutableHashMap.isEmpty(block.cols);
+const isHidden = (name) => name.startsWith("#");
+/** The distinct values of `items`, in order of first occurrence. */
+const distinct = (items) => Arr.fromIterable(MutableHashSet.fromIterable(items));
+const XSD = "http://www.w3.org/2001/XMLSchema#";
+const TRUE = new Literal("true", namedNode(`${XSD}boolean`));
+const FALSE = new Literal("false", namedNode(`${XSD}boolean`));
+/** The term id of a term-valued operand. */
+const operandId = (o) => o.tag === "term" || o.tag === "const" ? Option.some(o.id) : Option.none();
+const S = (s) => ({ s: Option.some(s) });
+const SO = (s) => ({ s });
+const SNULL = { s: Option.none() };
+const Q = (q) => ({ q });
+const isStatic = (f) => "s" in f;
+/** The statically known number of a field. */
+const staticNumber = (f) => isStatic(f) ? Option.filter(f.s, Predicate.isNumber) : Option.none();
+/** Whether a field is statically the value `v`. */
+const isStaticValue = (f, v) => isStatic(f) && Option.exists(f.s, (s) => s === v);
+const RISK_ORDER = [
+	[1, 3],
+	[2, 3],
+	[8, 1],
+	[8, 2],
+	[8, 3],
+	[8, 8],
+	[11, 1],
+	[11, 2],
+	[11, 3],
+	[11, 8],
+	[11, 11],
+	[7, 7]
+];
+const RISK_EQUAL = [...RISK_ORDER, [10, 10]];
+/** The SQL conditions of `cs` (dropping the statically known ones). */
+const conditions = (cs) => cs.filter(Predicate.isString);
+const and = (...cs) => {
+	if (cs.includes(false)) return false;
+	const parts = conditions(cs);
+	return Arr.match(parts, {
+		onEmpty: () => true,
+		onNonEmpty: ([first, ...rest]) => Arr.isReadonlyArrayEmpty(rest) ? first : `(${parts.join(" AND ")})`
+	});
+};
+const or = (...cs) => {
+	if (cs.includes(true)) return true;
+	const parts = conditions(cs);
+	return Arr.match(parts, {
+		onEmpty: () => false,
+		onNonEmpty: ([first, ...rest]) => Arr.isReadonlyArrayEmpty(rest) ? first : `(${parts.join(" OR ")})`
+	});
+};
+const condSql = (c) => c === true ? "TRUE" : c === false ? "FALSE" : c;
+const isLive = (branch) => Predicate.isString(branch[0]);
+/**
+* A `CASE` of the branches up to the first that always holds (whose value is
+* then the `ELSE`), dropping the branches that never hold.
+*/
+const caseOf = (branches, otherwise) => {
+	const fallback = Option.match(Arr.findFirst(branches, ([c]) => c === true), {
+		onNone: () => otherwise,
+		onSome: ([, v]) => v
+	});
+	const live = Arr.takeWhile(branches, ([c]) => c !== true).filter(isLive);
+	if (Arr.isReadonlyArrayEmpty(live)) return fallback;
+	return `(CASE ${live.map(([w, r]) => `WHEN ${w} THEN ${r}`).join(" ")} ELSE ${fallback} END)`;
+};
+var Compiler = class {
+	dialect;
+	T;
+	Q;
+	G;
+	counter = 0;
+	colNames = MutableHashMap.empty();
+	params = [];
+	paramIndex = MutableHashMap.empty();
+	risks = [];
+	localClasses = /* @__PURE__ */ new Set();
+	context;
+	resolve;
+	/** Query-local terms, by key (stable across the two compilation passes). */
+	locals;
+	/** Whether the query-local terms are complete (second pass). */
+	localsKnown;
+	constructor(context, resolve, locals, localsKnown) {
+		this.context = context;
+		this.resolve = resolve;
+		this.locals = locals;
+		this.localsKnown = localsKnown;
+		this.dialect = context.dialect;
+		this.T = context.tables.terms;
+		this.Q = context.tables.quads;
+		this.G = context.tables.graphs;
+	}
+	alias(prefix) {
+		return `${prefix}${this.counter++}`;
+	}
+	col(name) {
+		return Option.getOrElse(MutableHashMap.get(this.colNames, name), () => {
+			const c = `c${MutableHashMap.size(this.colNames)}`;
+			MutableHashMap.set(this.colNames, name, c);
+			return c;
+		});
+	}
+	param(value) {
+		const i = Option.getOrElse(MutableHashMap.get(this.paramIndex, value), () => {
+			this.params.push(value);
+			const n = this.params.length;
+			MutableHashMap.set(this.paramIndex, value, n);
+			return n;
+		});
+		return this.dialect.castText(`\ue000${i}\ue000`);
+	}
+	lit(v) {
+		if (Predicate.isBoolean(v)) return v ? "TRUE" : "FALSE";
+		if (Predicate.isNumber(v)) {
+			if (!Number.isFinite(v)) return "NULL";
+			return Number.isInteger(v) && Math.abs(v) < 0x38d7ea4c68000 ? String(v) : this.dialect.castDouble(String(v));
+		}
+		return this.param(v);
+	}
+	/** A statically known value as SQL (none is `NULL`). */
+	litOf(v) {
+		return Option.match(v, {
+			onNone: () => "NULL",
+			onSome: (s) => this.lit(s)
+		});
+	}
+	f(field) {
+		return isStatic(field) ? this.litOf(field.s) : field.q;
+	}
+	/** The id of a constant term (a query-local negative id if it is not in the dictionary). */
+	idOf(term) {
+		if (isDefaultGraph(term)) return 0;
+		return Option.getOrElse(this.resolve(term), () => this.localId(term));
+	}
+	/** The query-local id of a term that is not in the dictionary. */
+	localId(term) {
+		const local = Option.getOrElse(MutableHashMap.get(this.locals, term.key), () => {
+			const created = {
+				id: -(MutableHashMap.size(this.locals) + 1),
+				term
+			};
+			MutableHashMap.set(this.locals, term.key, created);
+			return created;
+		});
+		this.localClasses.add(classify(term).cls);
+		return local.id;
+	}
+	from(items) {
+		if (!Arr.isReadonlyArrayNonEmpty(items)) return "";
+		const [first, ...rest] = items;
+		const joins = rest.map((it) => Option.match(it.left, {
+			onNone: () => ` JOIN ${it.source} ${it.alias} ON TRUE`,
+			onSome: (on) => ` LEFT JOIN ${it.source} ${it.alias} ON ${on}`
+		}));
+		return ` FROM ${first.source} ${first.alias}${joins.join("")}`;
+	}
+	whereClause(where) {
+		return Arr.isReadonlyArrayEmpty(where) ? "" : ` WHERE ${where.join(" AND ")}`;
+	}
+	nullCol(type) {
+		return type === "id" ? this.dialect.nullId : this.dialect.castId("NULL");
+	}
+	render(block, names = Arr.fromIterable(MutableHashMap.keys(block.cols)), options = {}) {
+		const { types } = options;
+		const select = names.map((n) => {
+			return `${Option.match(MutableHashMap.get(block.cols, n), {
+				onNone: () => this.nullCol(types === void 0 ? "id" : Option.getOrElse(MutableHashMap.get(types, n), () => "id")),
+				onSome: (c) => c.sql
+			})} AS ${this.col(n)}`;
+		});
+		return `SELECT ${options.distinct === true ? "DISTINCT " : ""}${Arr.isReadonlyArrayEmpty(select) ? "1 AS one" : select.join(", ")}${this.from(block.items)}${this.whereClause(block.where)}`;
+	}
+	/** Wraps SQL as a subquery item. */
+	wrapSql(sql, cols) {
+		const alias = this.alias("s");
+		const out = MutableHashMap.empty();
+		MutableHashMap.forEach(cols, (c, n) => {
+			MutableHashMap.set(out, n, {
+				...c,
+				sql: `${alias}.${this.col(n)}`
+			});
+		});
+		return {
+			items: [inner(`(${sql})`, alias)],
+			where: [],
+			cols: out
+		};
+	}
+	wrap(block, options = {}) {
+		return this.wrapSql(this.render(block, void 0, options), block.cols);
+	}
+	compat(a, b) {
+		if (a.type !== b.type) return unsupported("Joining integer and term columns");
+		if (!a.nullable && !b.nullable) return {
+			cond: `${a.sql} = ${b.sql}`,
+			merged: a
+		};
+		if (!a.nullable) return {
+			cond: `(${b.sql} IS NULL OR ${b.sql} = ${a.sql})`,
+			merged: a
+		};
+		if (!b.nullable) return {
+			cond: `(${a.sql} IS NULL OR ${a.sql} = ${b.sql})`,
+			merged: b
+		};
+		return {
+			cond: `(${a.sql} IS NULL OR ${b.sql} IS NULL OR ${a.sql} = ${b.sql})`,
+			merged: {
+				sql: `COALESCE(${a.sql}, ${b.sql})`,
+				nullable: true,
+				type: a.type
+			}
+		};
+	}
+	join(a, b) {
+		if (isUnit(b)) return a;
+		if (isUnit(a)) return b;
+		const cols = MutableHashMap.fromIterable(a.cols);
+		const where = [...a.where, ...b.where];
+		MutableHashMap.forEach(b.cols, (cb, n) => Option.match(MutableHashMap.get(cols, n), {
+			onNone: () => {
+				MutableHashMap.set(cols, n, cb);
+			},
+			onSome: (ca) => {
+				const { cond, merged } = this.compat(ca, cb);
+				where.push(cond);
+				MutableHashMap.set(cols, n, merged);
+			}
+		}));
+		return {
+			items: [...a.items, ...b.items],
+			where,
+			cols
+		};
+	}
+	/** Ensures a block has a FROM item (so that a LEFT JOIN can be appended). */
+	anchored(block) {
+		if (Arr.isReadonlyArrayNonEmpty(block.items)) return block;
+		return {
+			...block,
+			items: [inner("(SELECT 1 AS one)", this.alias("u"))]
+		};
+	}
+	op(operation, g, unit) {
+		return Match.value(operation).pipe(Match.tag("Bgp", (op) => Arr.isReadonlyArrayEmpty(op.patterns) ? unit : this.bgp(op.patterns, g)), Match.tag("Join", (op) => this.join(this.op(op.left, g, unit), this.op(op.right, g, unit))), Match.tag("LeftJoin", (op) => this.leftJoin(op, g, unit)), Match.tag("Filter", (op) => {
+			const input = this.op(op.input, g, unit);
+			const cond = this.ebv(this.operand(op.expression, {
+				cols: input.cols,
+				graph: g
+			}));
+			if (cond === "TRUE") return input;
+			return {
+				...input,
+				where: [...input.where, cond]
+			};
+		}), Match.tag("Union", (op) => this.union(this.op(op.left, g, unit), this.op(op.right, g, unit))), Match.tag("Graph", (op) => this.graph(op, g, unit)), Match.tag("Extend", (op) => {
+			const input = this.op(op.input, g, unit);
+			if (MutableHashMap.has(input.cols, op.variable.value)) return unsupported("BIND to a bound variable");
+			const col = this.termValued(this.operand(op.expression, {
+				cols: input.cols,
+				graph: g
+			}));
+			const cols = MutableHashMap.fromIterable(input.cols);
+			MutableHashMap.set(cols, op.variable.value, col);
+			return {
+				...input,
+				cols
+			};
+		}), Match.tag("Minus", (op) => this.minus(this.op(op.left, g, unit), this.op(op.right, g, unit))), Match.tag("Group", (op) => this.group(op, g, unit)), Match.tag("Project", (op) => {
+			const input = this.op(op.input, g, unit);
+			const keep = MutableHashSet.fromIterable(op.variables.map((v) => v.value));
+			const cols = MutableHashMap.empty();
+			MutableHashMap.forEach(input.cols, (c, n) => {
+				if (MutableHashSet.has(keep, n) || isHidden(n)) MutableHashMap.set(cols, n, c);
+			});
+			return {
+				...input,
+				cols
+			};
+		}), Match.tag("Distinct", (op) => this.wrap(this.op(op.input, g, unit), { distinct: true })), Match.tag("Reduced", (op) => this.op(op.input, g, unit)), Match.tag("Slice", (op) => {
+			if (g.kind === "var") return unsupported("Slice inside GRAPH ?var");
+			const input = this.op(op.input, g, unit);
+			return this.wrapSql(`${this.render(input)}${this.dialect.limitOffset(op.limit, op.offset)}`, input.cols);
+		}), Match.tag("Values", (op) => {
+			return this.values(op);
+		}), Match.tag("OrderBy", () => unsupported("ORDER BY is evaluated by the engine")), Match.tag("Path", () => unsupported("Property paths are evaluated by the engine")), Match.tag("Service", () => unsupported("SERVICE is evaluated by the engine")), Match.exhaustive);
+	}
+	bgp(patterns, ctx) {
+		const items = [];
+		const where = [];
+		const cols = MutableHashMap.empty();
+		const bind = (name, sql) => Option.match(MutableHashMap.get(cols, name), {
+			onNone: () => {
+				MutableHashMap.set(cols, name, {
+					sql,
+					nullable: false,
+					type: "id"
+				});
+			},
+			onSome: (c) => {
+				where.push(`${c.sql} = ${sql}`);
+			}
+		});
+		const position = (t, sql, bound) => {
+			return Match.value(t).pipe(Match.tag("Variable", (pattern) => {
+				bind(pattern.value, sql);
+			}), Match.tag("BlankNode", () => unsupported("Blank node in a pattern")), Match.tag("NamedNode", "Literal", (pattern) => {
+				bound.push(`${sql} = ${this.idOf(pattern)}`);
+			}), Match.tag("Triple", (pattern) => {
+				if (isGroundTriple(pattern)) {
+					bound.push(`${sql} = ${this.idOf(pattern)}`);
+					return;
+				}
+				const ta = this.alias("t");
+				items.push(inner(this.T, ta));
+				where.push(`${ta}.id = ${sql}`, `${ta}.kind = ${Kind.Triple}`);
+				position(pattern.subject, `${ta}.sub`, where);
+				position(pattern.predicate, `${ta}.pre`, where);
+				position(pattern.object, `${ta}.obj`, where);
+			}), Match.exhaustive);
+		};
+		const { defaultGraph } = this.context.dataset;
+		patterns.forEach((p) => {
+			const a = this.alias("q");
+			if (ctx.kind === "default" && (defaultGraph === "union" || Array.isArray(defaultGraph) && defaultGraph.length > 1)) {
+				const conds = [];
+				if (!Predicate.isString(defaultGraph)) conds.push(`g IN (${defaultGraph.map((x) => this.idOf(x)).join(", ")})`);
+				const deferred = [];
+				const positionIn = (t, column) => {
+					if (isVariable(t) || isTriple(t) && !isGround(t)) deferred.push(() => position(t, `${a}.${column}`, where));
+					else position(t, column, conds);
+				};
+				positionIn(p.subject, "s");
+				positionIn(p.predicate, "p");
+				positionIn(p.object, "o");
+				items.push(inner(`(SELECT DISTINCT s, p, o FROM ${this.Q}${Arr.isReadonlyArrayNonEmpty(conds) ? ` WHERE ${conds.join(" AND ")}` : ""})`, a));
+				deferred.forEach((f) => f());
+				return;
+			}
+			items.push(inner(this.Q, a));
+			Match.value(ctx).pipe(Match.when({ kind: "default" }, () => {
+				if (defaultGraph === "default") where.push(`${a}.g = 0`);
+				else if (!Predicate.isString(defaultGraph) && Predicate.isTupleOf(defaultGraph, 1)) where.push(`${a}.g = ${this.idOf(defaultGraph[0])}`);
+				else where.push("1 = 0");
+			}), Match.when({ kind: "const" }, (graph) => {
+				where.push(`${a}.g = ${graph.id}`);
+			}), Match.when({ kind: "var" }, (graph) => {
+				bind(graph.hidden, `${a}.g`);
+				where.push(this.namedGraphCond(`${a}.g`));
+			}), Match.exhaustive);
+			position(p.subject, `${a}.s`, where);
+			position(p.predicate, `${a}.p`, where);
+			position(p.object, `${a}.o`, where);
+		});
+		return {
+			items,
+			where,
+			cols
+		};
+	}
+	/** The condition that the graph id column `g` of a quad is a named graph of the dataset. */
+	namedGraphCond(g) {
+		const named = this.context.dataset.namedGraphs;
+		if (named === "all") return `${g} <> 0`;
+		if (Arr.isReadonlyArrayEmpty(named)) return "1 = 0";
+		return `${g} IN (${named.map((n) => this.idOf(n)).join(", ")})`;
+	}
+	/** A subquery listing the named graphs of the dataset (column `g`). */
+	namedGraphsSource() {
+		const named = this.context.dataset.namedGraphs;
+		if (named === "all") return `(SELECT id AS g FROM ${this.G} UNION SELECT DISTINCT g FROM ${this.Q} WHERE g <> 0)`;
+		if (Arr.isReadonlyArrayEmpty(named)) return `(SELECT ${this.dialect.nullId} AS g WHERE 1 = 0)`;
+		const alias = this.alias("n");
+		return `(SELECT column1 AS g FROM (VALUES ${named.map((n) => `(${this.idOf(n)})`).join(", ")}) AS ${alias})`;
+	}
+	values(op) {
+		const vars = op.variables.map((v) => v.value);
+		if (Arr.isReadonlyArrayEmpty(op.bindings)) return {
+			items: [],
+			where: ["1 = 0"],
+			cols: MutableHashMap.fromIterable(vars.map((v) => [v, {
+				sql: this.dialect.nullId,
+				nullable: true,
+				type: "id"
+			}]))
+		};
+		const rows = op.bindings.map((b) => Arr.isReadonlyArrayEmpty(vars) ? "(1)" : `(${vars.map((v) => {
+			const t = b.map.get(v);
+			return t === void 0 ? this.dialect.nullId : String(this.idOf(t));
+		}).join(", ")})`);
+		const a = this.alias("v");
+		const select = Arr.isReadonlyArrayEmpty(vars) ? "column1 AS one" : vars.map((v, i) => `column${i + 1} AS ${this.col(v)}`);
+		const cols = MutableHashMap.fromIterable(vars.map((v) => [v, {
+			sql: `${a}.${this.col(v)}`,
+			nullable: !op.bindings.every((b) => b.map.has(v)),
+			type: "id"
+		}]));
+		return {
+			items: [inner(`(SELECT ${Predicate.isString(select) ? select : select.join(", ")} FROM (VALUES ${rows.join(", ")}) AS ${a}_rows)`, a)],
+			where: [],
+			cols
+		};
+	}
+	leftJoin(op, g, unit) {
+		const left = this.op(op.left, g, unit);
+		const right = this.op(op.right, g, unit);
+		MutableHashMap.forEach(right.cols, (c, n) => {
+			const leftNullable = Option.match(MutableHashMap.get(left.cols, n), {
+				onNone: () => true,
+				onSome: (l) => l.nullable
+			});
+			if (isHidden(n) && leftNullable && !c.nullable) unsupported("OPTIONAL graph-dependent pattern under GRAPH ?var");
+		});
+		if (op.expression === void 0 && isUnit(right)) return left;
+		const a = this.anchored(left);
+		const r = this.wrap(right);
+		const conds = [];
+		const merged = MutableHashMap.fromIterable(a.cols);
+		const out = MutableHashMap.fromIterable(a.cols);
+		MutableHashMap.forEach(r.cols, (cr, n) => Option.match(MutableHashMap.get(a.cols, n), {
+			onNone: () => {
+				MutableHashMap.set(merged, n, cr);
+				MutableHashMap.set(out, n, {
+					...cr,
+					nullable: true
+				});
+			},
+			onSome: (ca) => {
+				const { cond, merged: m } = this.compat(ca, cr);
+				conds.push(cond);
+				MutableHashMap.set(merged, n, m);
+				MutableHashMap.set(out, n, ca.nullable ? {
+					sql: `COALESCE(${ca.sql}, ${cr.sql})`,
+					nullable: true,
+					type: ca.type
+				} : ca);
+			}
+		}));
+		if (op.expression !== void 0) {
+			const e = this.ebv(this.operand(op.expression, {
+				cols: merged,
+				graph: g
+			}));
+			if (e !== "TRUE") conds.push(e);
+		}
+		const on = Arr.isReadonlyArrayEmpty(conds) ? "TRUE" : conds.join(" AND ");
+		const [item] = r.items;
+		return {
+			items: [...a.items, {
+				source: item.source,
+				alias: item.alias,
+				left: Option.some(on)
+			}],
+			where: a.where,
+			cols: out
+		};
+	}
+	union(a, b) {
+		const names = distinct([...MutableHashMap.keys(a.cols), ...MutableHashMap.keys(b.cols)]);
+		const cols = MutableHashMap.empty();
+		const types = MutableHashMap.empty();
+		names.forEach((n) => {
+			const ca = MutableHashMap.get(a.cols, n);
+			const cb = MutableHashMap.get(b.cols, n);
+			if (Option.isSome(ca) && Option.isSome(cb) && ca.value.type !== cb.value.type) unsupported("UNION of integer and term columns");
+			const nullable = Option.isNone(ca) || Option.isNone(cb) || ca.value.nullable || cb.value.nullable;
+			if (isHidden(n) && nullable) unsupported("UNION of graph-dependent and independent patterns under GRAPH ?var");
+			const type = Option.isSome(ca) ? ca.value.type : Option.isSome(cb) ? cb.value.type : "id";
+			MutableHashMap.set(types, n, type);
+			MutableHashMap.set(cols, n, {
+				nullable,
+				type
+			});
+		});
+		const sql = `${this.render(a, names, { types })} UNION ALL ${this.render(b, names, { types })}`;
+		return this.wrapSql(sql, cols);
+	}
+	minus(a, b) {
+		const bNames = Arr.fromIterable(MutableHashMap.keys(b.cols));
+		const shared = bNames.filter((n) => MutableHashMap.has(a.cols, n));
+		if (bNames.some((n) => isHidden(n) && !MutableHashMap.has(a.cols, n))) return unsupported("MINUS of a graph-dependent pattern under GRAPH ?var");
+		const overlap = shared.filter((n) => !isHidden(n));
+		if (Arr.isReadonlyArrayEmpty(overlap)) return a;
+		const m = this.wrap(b);
+		const pairs = Arr.filterMap(shared, (name) => {
+			const left = MutableHashMap.get(a.cols, name);
+			const right = MutableHashMap.get(m.cols, name);
+			return Option.isSome(left) && Option.isSome(right) ? Result.succeed({
+				name,
+				left: left.value,
+				right: right.value
+			}) : Result.failVoid;
+		});
+		const conds = pairs.map(({ left, right }) => this.compat(left, right).cond);
+		const overlapCond = or(...pairs.filter(({ name }) => !isHidden(name)).map(({ left, right }) => and(left.nullable ? `${left.sql} IS NOT NULL` : true, right.nullable ? `${right.sql} IS NOT NULL` : true)));
+		if (overlapCond === false) return a;
+		if (overlapCond !== true) conds.push(overlapCond);
+		const [item] = m.items;
+		return {
+			...a,
+			where: [...a.where, `NOT EXISTS (SELECT 1 FROM ${item.source} ${item.alias} WHERE ${conds.join(" AND ")})`]
+		};
+	}
+	graph(op, g, unit) {
+		const name = op.name;
+		if (isNamedNode(name)) {
+			const id = this.idOf(name);
+			const input = this.op(op.input, {
+				kind: "const",
+				id
+			}, unit);
+			const named = this.context.dataset.namedGraphs;
+			const cond = named === "all" ? `(EXISTS (SELECT 1 FROM ${this.G} WHERE id = ${id}) OR EXISTS (SELECT 1 FROM ${this.Q} WHERE g = ${id}))` : named.some((n) => n.key === name.key) ? "TRUE" : "1 = 0";
+			return cond === "TRUE" ? input : {
+				...input,
+				where: [...input.where, cond]
+			};
+		}
+		const hidden = `#${this.alias("g")}`;
+		const body = this.op(op.input, {
+			kind: "var",
+			hidden
+		}, unit);
+		const bound = MutableHashMap.get(body.cols, hidden);
+		if (Option.isSome(bound) && bound.value.nullable) return unsupported("Graph-independent solutions under GRAPH ?var");
+		const { input, gcol } = Option.match(bound, {
+			onSome: (c) => ({
+				input: body,
+				gcol: c
+			}),
+			onNone: () => {
+				const alias = this.alias("n");
+				return {
+					input: {
+						...body,
+						items: [...body.items, inner(this.namedGraphsSource(), alias)]
+					},
+					gcol: {
+						sql: `${alias}.g`,
+						nullable: false,
+						type: "id"
+					}
+				};
+			}
+		});
+		const cols = MutableHashMap.fromIterable(input.cols);
+		MutableHashMap.remove(cols, hidden);
+		const where = [...input.where];
+		Option.match(MutableHashMap.get(cols, name.value), {
+			onNone: () => void 0,
+			onSome: (existing) => {
+				where.push(this.compat(existing, gcol).cond);
+			}
+		});
+		MutableHashMap.set(cols, name.value, gcol);
+		return {
+			items: input.items,
+			where,
+			cols
+		};
+	}
+	group(op, g, unit) {
+		if (g.kind === "var") return unsupported("GROUP inside GRAPH ?var");
+		const input = this.op(op.input, g, unit);
+		const needed = MutableHashSet.empty();
+		const keyVars = op.keys.map((k) => {
+			const e = k.expression;
+			if (!isVariable(e)) return unsupported("Non-variable group key");
+			const col = Option.getOrElse(MutableHashMap.get(input.cols, e.value), () => unsupported("Group key is never bound"));
+			MutableHashSet.add(needed, e.value);
+			return {
+				source: e.value,
+				target: k.variable.value,
+				col
+			};
+		});
+		const aggs = op.aggregates.map(({ variable, aggregate }) => {
+			const e = aggregate.expression;
+			if (aggregate.name === "COUNT") {
+				if (e === "*") {
+					if (aggregate.distinct) return unsupported("COUNT(DISTINCT *)");
+					return {
+						target: variable.value,
+						sql: () => "COUNT(*)",
+						col: {
+							nullable: false,
+							type: "int"
+						}
+					};
+				}
+				if (!isVariable(e)) return unsupported("COUNT of an expression");
+				const name = e.value;
+				if (!MutableHashMap.has(input.cols, name)) return {
+					target: variable.value,
+					sql: () => "0",
+					col: {
+						nullable: false,
+						type: "int"
+					}
+				};
+				MutableHashSet.add(needed, name);
+				return {
+					target: variable.value,
+					sql: (s) => `COUNT(${aggregate.distinct ? "DISTINCT " : ""}${s}.${this.col(name)})`,
+					col: {
+						nullable: false,
+						type: "int"
+					}
+				};
+			}
+			if (aggregate.name === "SAMPLE" && isVariable(e)) {
+				const name = e.value;
+				return Option.match(MutableHashMap.get(input.cols, name), {
+					onNone: () => ({
+						target: variable.value,
+						sql: () => this.dialect.nullId,
+						col: {
+							nullable: true,
+							type: "id"
+						}
+					}),
+					onSome: (c) => {
+						MutableHashSet.add(needed, name);
+						return {
+							target: variable.value,
+							sql: (s) => `MIN(${s}.${this.col(name)})`,
+							col: {
+								nullable: true,
+								type: c.type
+							}
+						};
+					}
+				});
+			}
+			return unsupported(`Aggregate ${aggregate.name}`);
+		});
+		const s = this.alias("a");
+		const cols = MutableHashMap.empty();
+		const select = [...keyVars.map((k) => {
+			const sql = `${s}.${this.col(k.source)} AS ${this.col(k.target)}`;
+			MutableHashMap.set(cols, k.target, {
+				nullable: k.col.nullable,
+				type: k.col.type
+			});
+			return sql;
+		}), ...aggs.map((agg) => {
+			const sql = `${agg.sql(s)} AS ${this.col(agg.target)}`;
+			MutableHashMap.set(cols, agg.target, agg.col);
+			return sql;
+		})];
+		const innerSql = this.render(input, Arr.fromIterable(needed));
+		const groupBy = Arr.isReadonlyArrayEmpty(keyVars) ? "" : ` GROUP BY ${distinct(keyVars.map((k) => `${s}.${this.col(k.source)}`)).join(", ")}`;
+		const sql = `SELECT ${Arr.isReadonlyArrayEmpty(select) ? "1 AS one" : select.join(", ")} FROM (${innerSql}) ${s}${groupBy}`;
+		return this.wrapSql(sql, cols);
+	}
+	/** A dictionary attribute of a term id expression. */
+	attr(id, field) {
+		const lookup = `(SELECT ${field} FROM ${this.T} WHERE id = ${id})`;
+		if (MutableHashMap.isEmpty(this.locals)) return lookup;
+		if (!this.localsKnown) return lookup;
+		return `(CASE WHEN ${id} < 0 THEN (CASE ${id} ${Arr.fromIterable(MutableHashMap.values(this.locals)).map(({ id: localId, term }) => {
+			const row = encode(term, [
+				0,
+				0,
+				0
+			]);
+			const v = field === "num" ? this.litOf(row.num) : this.lit(row[field]);
+			return `WHEN ${localId} THEN ${field === "num" ? this.dialect.castDouble(v) : field === "kind" || field === "cls" ? this.dialect.castInt(v) : this.dialect.castText(v)}`;
+		}).join(" ")} END) ELSE ${lookup} END)`;
+	}
+	termOperand(id, nullable) {
+		return {
+			tag: "term",
+			classes: Option.none(),
+			isNull: nullable ? Q(`${id} IS NULL`) : S(false),
+			cls: Q(this.attr(id, "cls")),
+			kind: Q(this.attr(id, "kind")),
+			value: Q(this.attr(id, "value")),
+			datatype: Q(this.attr(id, "datatype")),
+			lang: Q(this.attr(id, "lang")),
+			dir: Q(this.attr(id, "dir")),
+			num: Q(this.attr(id, "num")),
+			id: Q(id)
+		};
+	}
+	constOperand(constant) {
+		const { cls, num } = classify(constant);
+		const base = {
+			tag: "const",
+			classes: Option.some([cls]),
+			isNull: S(false),
+			cls: S(cls),
+			num: SO(num),
+			id: S(this.idOf(constant)),
+			term: constant
+		};
+		return Match.value(constant).pipe(Match.withReturnType(), Match.tag("NamedNode", "BlankNode", (term) => ({
+			...base,
+			kind: S(isNamedNode(term) ? Kind.NamedNode : Kind.BlankNode),
+			value: S(term.value),
+			datatype: S(""),
+			lang: S(""),
+			dir: S("")
+		})), Match.tag("Literal", (term) => ({
+			...base,
+			kind: S(Kind.Literal),
+			value: S(term.value),
+			datatype: S(term.datatype.value),
+			lang: S(term.language),
+			dir: S(term.direction ?? "")
+		})), Match.tag("Triple", () => ({
+			...base,
+			kind: S(Kind.Triple),
+			value: SNULL,
+			datatype: S(""),
+			lang: S(""),
+			dir: S("")
+		})), Match.exhaustive);
+	}
+	intOperand(sql, nullable) {
+		return {
+			tag: "int",
+			classes: Option.some([Cls.SafeNumber]),
+			isNull: nullable ? Q(`${sql} IS NULL`) : S(false),
+			cls: S(Cls.SafeNumber),
+			kind: S(Kind.Literal),
+			value: Q(this.dialect.castText(sql)),
+			datatype: S(`${XSD}integer`),
+			lang: S(""),
+			dir: S(""),
+			num: Q(sql)
+		};
+	}
+	strOperand(sql) {
+		return {
+			tag: "str",
+			classes: Option.some([Cls.String]),
+			isNull: Q(`${sql} IS NULL`),
+			cls: S(Cls.String),
+			kind: S(Kind.Literal),
+			value: Q(sql),
+			datatype: S(XSD_STRING),
+			lang: S(""),
+			dir: S(""),
+			num: SNULL
+		};
+	}
+	boolOperand(sql) {
+		if (sql === "TRUE" || sql === "FALSE") return this.constOperand(sql === "TRUE" ? TRUE : FALSE);
+		return {
+			tag: "bool",
+			classes: Option.some([Cls.Boolean]),
+			isNull: Q(`${sql} IS NULL`),
+			cls: S(Cls.Boolean),
+			kind: S(Kind.Literal),
+			value: Q(`(CASE WHEN ${sql} THEN 'true' WHEN NOT ${sql} THEN 'false' END)`),
+			datatype: S(`${XSD}boolean`),
+			lang: S(""),
+			dir: S(""),
+			num: Q(`(CASE WHEN ${sql} THEN 1 WHEN NOT ${sql} THEN 0 END)`),
+			bool: sql
+		};
+	}
+	iriOperand(sql) {
+		return {
+			tag: "iri",
+			classes: Option.some([Cls.Resource]),
+			isNull: Q(`${sql} IS NULL`),
+			cls: S(Cls.Resource),
+			kind: S(Kind.NamedNode),
+			value: Q(sql),
+			datatype: S(""),
+			lang: S(""),
+			dir: S(""),
+			num: SNULL
+		};
+	}
+	NULL = {
+		tag: "null",
+		classes: Option.some([]),
+		isNull: S(true),
+		cls: SNULL,
+		kind: SNULL,
+		value: SNULL,
+		datatype: SNULL,
+		lang: SNULL,
+		dir: SNULL,
+		num: SNULL
+	};
+	/** A term-valued expression as a column (for `BIND`). */
+	termValued(operand) {
+		return Match.value(operand).pipe(Match.withReturnType(), Match.when({ tag: "term" }, (o) => ({
+			sql: this.f(o.id),
+			nullable: !isStaticValue(o.isNull, false),
+			type: "id"
+		})), Match.when({ tag: "const" }, (o) => ({
+			sql: String(this.idOf(o.term)),
+			nullable: false,
+			type: "id"
+		})), Match.when({ tag: "int" }, (o) => ({
+			sql: this.f(o.num),
+			nullable: !isStaticValue(o.isNull, false),
+			type: "int"
+		})), Match.when({ tag: "bool" }, (o) => ({
+			sql: `(CASE WHEN ${o.bool} THEN ${this.idOf(TRUE)} WHEN NOT ${o.bool} THEN ${this.idOf(FALSE)} END)`,
+			nullable: true,
+			type: "id"
+		})), Match.when({ tag: "null" }, () => ({
+			sql: this.dialect.nullId,
+			nullable: true,
+			type: "id"
+		})), Match.orElse(() => unsupported("Expression value is not a stored term")));
+	}
+	/** Compiles an expression to an operand. */
+	operand(expr, env) {
+		return Match.value(expr).pipe(Match.tag("Variable", (e) => Option.match(MutableHashMap.get(env.cols, e.value), {
+			onNone: () => this.NULL,
+			onSome: (c) => c.type === "int" ? this.intOperand(c.sql, c.nullable) : this.termOperand(c.sql, c.nullable)
+		})), Match.tag("NamedNode", "Literal", (e) => this.constOperand(e)), Match.tag("BlankNode", () => unsupported("Blank node in an expression")), Match.tag("Triple", (e) => isGroundTriple(e) ? this.constOperand(e) : unsupported("Triple term pattern in an expression")), Match.tag("FunctionCall", (e) => unsupported(`Function <${e.function.value}>`)), Match.tag("Exists", (e) => this.boolOperand(this.exists(e, env))), Match.tag("Operation", (e) => this.operation(e, env)), Match.exhaustive);
+	}
+	operation(expr, env) {
+		const args = expr.args;
+		const arg = (i) => Option.match(Arr.get(args, i), {
+			onNone: () => unsupported(`Operator ${expr.operator} without argument ${i + 1}`),
+			onSome: (a) => this.operand(a, env)
+		});
+		const bool = (sql) => this.boolOperand(sql);
+		return Match.value(expr).pipe(Match.when({ operator: "&&" }, () => bool(`(${this.ebv(arg(0))} AND ${this.ebv(arg(1))})`)), Match.when({ operator: "||" }, () => bool(`(${this.ebv(arg(0))} OR ${this.ebv(arg(1))})`)), Match.when({ operator: "!" }, () => bool(`(NOT ${this.ebv(arg(0))})`)), Match.when({ operator: "=" }, () => bool(this.equals(arg(0), arg(1)))), Match.when({ operator: "!=" }, () => bool(`(NOT ${this.equals(arg(0), arg(1))})`)), Match.when({ operator: Match.is("<", ">", "<=", ">=") }, (e) => bool(this.compare(arg(0), arg(1), e.operator))), Match.when({ operator: Match.is("IN", "NOT IN") }, (e) => {
+			const value = arg(0);
+			const tests = args.slice(1).map((_, i) => this.equals(value, arg(i + 1)));
+			const any = Arr.isReadonlyArrayEmpty(tests) ? "FALSE" : `(${tests.join(" OR ")})`;
+			return bool(e.operator === "IN" ? any : `(NOT ${any})`);
+		}), Match.when({ operator: "BOUND" }, () => {
+			const v = args[0];
+			if (!isVariable(v)) return unsupported("BOUND of a non-variable");
+			return bool(Option.match(MutableHashMap.get(env.cols, v.value), {
+				onNone: () => "FALSE",
+				onSome: (c) => c.nullable ? `(${c.sql} IS NOT NULL)` : "TRUE"
+			}));
+		}), Match.when({ operator: "SAMETERM" }, () => {
+			const a = arg(0);
+			const b = arg(1);
+			if (a.tag === "null" || b.tag === "null") return bool("NULL");
+			const ia = operandId(a);
+			const ib = operandId(b);
+			if (Option.isNone(ia) || Option.isNone(ib)) return unsupported("sameTerm of computed values");
+			return bool(`(${this.f(ia.value)} = ${this.f(ib.value)})`);
+		}), Match.when({ operator: Match.is("ISIRI", "ISURI") }, () => bool(this.kindTest(arg(0), Kind.NamedNode))), Match.when({ operator: "ISBLANK" }, () => bool(this.kindTest(arg(0), Kind.BlankNode))), Match.when({ operator: "ISLITERAL" }, () => bool(this.kindTest(arg(0), Kind.Literal))), Match.when({ operator: "ISTRIPLE" }, () => bool(this.kindTest(arg(0), Kind.Triple))), Match.when({ operator: "ISNUMERIC" }, () => {
+			const a = arg(0);
+			return bool(this.guard(a, condSql(this.clsIn(a, [
+				1,
+				2,
+				3,
+				8,
+				11
+			]))));
+		}), Match.when({ operator: "HASLANG" }, () => {
+			const a = arg(0);
+			return bool(this.guard(a, condSql(this.clsIn(a, [Cls.LangString]))));
+		}), Match.when({ operator: "HASLANGDIR" }, () => {
+			const a = arg(0);
+			return bool(this.guard(a, condSql(and(this.clsIn(a, [Cls.LangString]), this.ne(a.dir, S(""))))));
+		}), Match.when({ operator: "STR" }, () => {
+			const a = arg(0);
+			if (a.tag === "const") {
+				const t = a.term;
+				if (isNamedNode(t) || isLiteral(t)) return this.constOperand(literal(t.value));
+				return this.NULL;
+			}
+			if (a.tag === "str" || a.tag === "null") return a;
+			return this.strOperand(caseOf([[this.isNullC(a), "NULL"], [or(this.eqC(a.kind, Kind.NamedNode), this.eqC(a.kind, Kind.Literal)), this.f(a.value)]], "NULL"));
+		}), Match.when({ operator: "LANG" }, () => {
+			const a = arg(0);
+			if (a.tag === "const") {
+				const t = a.term;
+				return isLiteral(t) ? this.constOperand(literal(t.language)) : this.NULL;
+			}
+			if (a.tag === "null") return a;
+			return this.strOperand(caseOf([[this.isNullC(a), "NULL"], [this.eqC(a.kind, Kind.Literal), this.f(a.lang)]], "NULL"));
+		})).pipe(Match.when({ operator: "DATATYPE" }, () => {
+			const a = arg(0);
+			if (a.tag === "const") {
+				const t = a.term;
+				return isLiteral(t) ? this.constOperand(t.datatype) : this.NULL;
+			}
+			if (a.tag === "null") return a;
+			return this.iriOperand(caseOf([[this.isNullC(a), "NULL"], [this.eqC(a.kind, Kind.Literal), this.f(a.datatype)]], "NULL"));
+		}), Match.when({ operator: "STRLEN" }, () => {
+			const a = arg(0);
+			if (a.tag === "null") return a;
+			return this.intOperand(caseOf([[this.clsIn(a, [Cls.String, Cls.LangString]), this.dialect.length(this.f(a.value))]], "NULL"), true);
+		}), Match.when({ operator: Match.is("STRSTARTS", "STRENDS", "CONTAINS") }, (e) => {
+			const a = arg(0);
+			const b = arg(1);
+			const fn = e.operator === "STRSTARTS" ? this.dialect.startsWith : e.operator === "STRENDS" ? this.dialect.endsWith : this.dialect.contains;
+			const strings = [Cls.String, Cls.LangString];
+			const ok = and(this.clsIn(a, strings), this.clsIn(b, strings), or(this.clsIn(b, [Cls.String]), and(this.eqFF(a.lang, b.lang), this.eqFF(a.dir, b.dir))));
+			return bool(caseOf([[ok, fn(this.f(a.value), this.f(b.value))]], "NULL"));
+		}), Match.when({ operator: "LANGMATCHES" }, () => {
+			const a = arg(0);
+			const b = arg(1);
+			if (b.tag !== "const") return unsupported("LANGMATCHES with a non-constant range");
+			const range = b.term;
+			if (!isLiteral(range) || classify(range).cls !== Cls.String) return bool("NULL");
+			if (!/^[\x00-\x7f]*$/.test(range.value)) return unsupported("Non-ASCII language range");
+			const r = range.value.toLowerCase();
+			const tag = `lower(${this.f(a.value)})`;
+			const test = r === "*" ? `(${this.f(a.value)} <> '')` : `(${tag} = ${this.lit(r)} OR ${this.dialect.startsWith(tag, this.lit(`${r}-`))})`;
+			return bool(caseOf([[this.clsIn(a, [Cls.String]), test]], "NULL"));
+		}), Match.when({ operator: "IF" }, () => {
+			const c = this.ebv(arg(0));
+			const a = arg(1);
+			const b = arg(2);
+			const ca = this.termValued(a);
+			const cb = this.termValued(b);
+			if (ca.type !== cb.type) return unsupported("IF of integer and term values");
+			const sql = `(CASE WHEN ${c} THEN ${ca.sql} WHEN NOT ${c} THEN ${cb.sql} END)`;
+			return ca.type === "int" ? this.intOperand(sql, true) : this.termOperand(sql, true);
+		}), Match.when({ operator: "COALESCE" }, () => {
+			const parts = args.map((_, i) => arg(i)).filter((o) => o.tag !== "null");
+			if (!Arr.isReadonlyArrayNonEmpty(parts)) return this.NULL;
+			const cols = Arr.map(parts, (o) => this.termValued(o));
+			const [first, ...rest] = cols;
+			const type = first.type;
+			if (rest.some((c) => c.type !== type)) return unsupported("COALESCE of integer and term values");
+			const sql = Arr.isReadonlyArrayEmpty(rest) ? first.sql : `COALESCE(${cols.map((c) => c.sql).join(", ")})`;
+			const nullable = cols.every((c) => c.nullable);
+			return type === "int" ? this.intOperand(sql, nullable) : this.termOperand(sql, nullable);
+		}), Match.orElse((e) => unsupported(`Operator ${e.operator}`)));
+	}
+	isNullC(o) {
+		return isStatic(o.isNull) ? Option.exists(o.isNull.s, (s) => s === true) : o.isNull.q;
+	}
+	eqC(f, v) {
+		if (isStatic(f)) return Option.exists(f.s, (s) => s === v);
+		return `${f.q} = ${this.lit(v)}`;
+	}
+	clsIn(o, classes) {
+		const f = o.cls;
+		if (isStatic(f)) return Option.exists(f.s, (s) => Predicate.isNumber(s) && classes.includes(s));
+		return classes.length === 1 ? `${f.q} = ${classes[0]}` : `${f.q} IN (${classes.join(", ")})`;
+	}
+	eqFF(a, b) {
+		if (isStatic(a) && isStatic(b)) return Equal.equals(a.s, b.s);
+		return `${this.f(a)} = ${this.f(b)}`;
+	}
+	ne(a, b) {
+		if (isStatic(a) && isStatic(b)) return !Equal.equals(a.s, b.s);
+		return `${this.f(a)} <> ${this.f(b)}`;
+	}
+	/** `NULL` if the operand is unbound, otherwise the test. */
+	guard(o, test) {
+		return caseOf([[this.isNullC(o), "NULL"]], test);
+	}
+	kindTest(o, kind) {
+		return this.guard(o, condSql(this.eqC(o.kind, kind)));
+	}
+	/** Records the class combinations of a comparison that SQL cannot evaluate exactly. */
+	risk(pairs, a, b, handled = MutableHashSet.empty()) {
+		const possible = (o, c) => Option.match(o.classes, {
+			onNone: () => true,
+			onSome: (classes) => classes.includes(c)
+		});
+		pairs.forEach(([x, y]) => {
+			(x === y ? [[x, y]] : [[x, y], [y, x]]).forEach(([p, q]) => {
+				if (!possible(a, p) || !possible(b, q) || MutableHashSet.has(handled, `${p},${q}`)) return;
+				const r = {
+					a: p,
+					aStatic: Option.isSome(a.classes),
+					b: q,
+					bStatic: Option.isSome(b.classes)
+				};
+				if (r.aStatic && r.bStatic) unsupported("Comparison that SQL cannot evaluate exactly");
+				this.risks.push(r);
+			});
+		});
+	}
+	/**
+	* Exact comparisons of a float-or-double term with a numeric constant,
+	* following SPARQL's type promotion (integers and decimals are promoted to
+	* float, floats to double). Returns the branches and the class pairs they
+	* handle.
+	*/
+	promoted(a, b, op) {
+		const branches = [];
+		const handled = MutableHashSet.empty();
+		const one = (t, c, flip) => {
+			if (c.tag !== "const" || t.tag === "const") return;
+			const value = staticNumber(c.num);
+			const constClass = staticNumber(c.cls);
+			if (Option.isNone(value) || Option.isNone(constClass)) return;
+			const v = value.value;
+			const cc = constClass.value;
+			const add = (cls, n) => {
+				if (!Number.isFinite(n)) return;
+				const cmp = flip ? `${this.lit(n)} ${op} ${this.f(t.num)}` : `${this.f(t.num)} ${op} ${this.lit(n)}`;
+				branches.push([this.clsIn(t, [cls]), cmp]);
+				MutableHashSet.add(handled, flip ? `${cc},${cls}` : `${cls},${cc}`);
+			};
+			if (cc === Cls.SafeNumber) add(Cls.Float, Math.fround(v));
+			else if (cc === Cls.Double) add(Cls.Float, v);
+			else if (cc === Cls.Float) add(Cls.Double, v);
+		};
+		one(a, b, false);
+		one(b, a, true);
+		return {
+			branches,
+			handled
+		};
+	}
+	/**
+	* The branches comparing two numbers of the same SQL-comparable kind
+	* (integers, decimals and doubles together; floats with floats) by `num`.
+	*/
+	numericBranches(a, b, num) {
+		return [[and(this.clsIn(a, [1, 2]), this.clsIn(b, [1, 2])), num], [and(this.clsIn(a, [3]), this.clsIn(b, [3])), num]];
+	}
+	/** SPARQL `=` (value equality, with errors as `NULL`). */
+	equals(a, b) {
+		if (a.tag === "null" || b.tag === "null") return "NULL";
+		if (a.tag === "const" && b.tag === "const") {
+			const r = equals(a.term, b.term);
+			return Result.isSuccess(r) ? r.success ? "TRUE" : "FALSE" : "NULL";
+		}
+		const promoted = this.promoted(a, b, "=");
+		this.risk(RISK_EQUAL, a, b, promoted.handled);
+		const ia = operandId(a);
+		const ib = operandId(b);
+		const bothIds = Option.isSome(ia) && Option.isSome(ib);
+		const sameId = Option.isSome(ia) && Option.isSome(ib) ? this.eqFF(ia.value, ib.value) : false;
+		const num = `${this.f(a.num)} = ${this.f(b.num)}`;
+		return caseOf([
+			[or(this.isNullC(a), this.isNullC(b)), "NULL"],
+			[sameId, "TRUE"],
+			...promoted.branches,
+			...this.numericBranches(a, b, num),
+			[and(this.clsIn(a, [6]), this.clsIn(b, [6])), num],
+			[and(this.clsIn(a, [4]), this.clsIn(b, [4])), `${this.f(a.value)} = ${this.f(b.value)}`],
+			[and(this.clsIn(a, [0]), this.clsIn(b, [0])), bothIds ? "FALSE" : condSql(and(this.eqFF(a.kind, b.kind), this.eqFF(a.value, b.value)))],
+			[or(this.clsIn(a, [0, 10]), this.clsIn(b, [0, 10])), "FALSE"],
+			[or(this.clsIn(a, [5]), this.clsIn(b, [5])), "FALSE"],
+			[and(this.clsIn(a, WELL_FORMED_KNOWN), this.clsIn(b, WELL_FORMED_KNOWN), this.ne(a.datatype, b.datatype)), "FALSE"]
+		], "NULL");
+	}
+	/** SPARQL `<`, `>`, `<=`, `>=`. */
+	compare(a, b, op) {
+		if (a.tag === "null" || b.tag === "null") return "NULL";
+		const promoted = this.promoted(a, b, op);
+		this.risk(RISK_ORDER, a, b, promoted.handled);
+		const num = `${this.f(a.num)} ${op} ${this.f(b.num)}`;
+		const str = `${this.dialect.binary(this.f(a.value))} ${op} ${this.dialect.binary(this.f(b.value))}`;
+		return caseOf([
+			[or(this.isNullC(a), this.isNullC(b)), "NULL"],
+			...promoted.branches,
+			...this.numericBranches(a, b, num),
+			[and(this.clsIn(a, [4]), this.clsIn(b, [4])), str],
+			[and(this.clsIn(a, [5]), this.clsIn(b, [5]), this.eqFF(a.lang, b.lang), this.eqFF(a.dir, b.dir)), str],
+			[and(this.clsIn(a, [6]), this.clsIn(b, [6])), num]
+		], "NULL");
+	}
+	/** The effective boolean value (SQL boolean, `NULL` = error). */
+	ebv(operand) {
+		return Match.value(operand).pipe(Match.when({ tag: "bool" }, (o) => o.bool), Match.when({ tag: Match.is("null", "iri") }, () => "NULL"), Match.when({ tag: "const" }, (o) => {
+			const r = effectiveBooleanValue(o.term);
+			return Result.isSuccess(r) ? r.success ? "TRUE" : "FALSE" : "NULL";
+		}), Match.when({ tag: "int" }, (o) => `(${this.f(o.num)} <> 0)`), Match.when({ tag: "str" }, (o) => `(${this.f(o.value)} <> '')`), Match.when({ tag: "term" }, (o) => {
+			const num = `${this.f(o.num)} <> 0`;
+			const value = this.f(o.value);
+			return caseOf([
+				[this.clsIn(o, [
+					6,
+					1,
+					2,
+					3
+				]), num],
+				[this.clsIn(o, [4]), `${value} <> ''`],
+				[this.clsIn(o, [8]), this.dialect.hasNonZeroDigit(value)],
+				[this.clsIn(o, [11]), `${value} <> 'NaN'`],
+				[this.clsIn(o, [12]), "FALSE"]
+			], "NULL");
+		}), Match.exhaustive);
+	}
+	/** `EXISTS` / `NOT EXISTS` as a correlated subquery. */
+	exists(e, env) {
+		const context = {
+			items: [],
+			where: [],
+			cols: env.cols
+		};
+		const body = this.op(e.input, env.graph, context);
+		const where = [...body.where];
+		if (env.graph.kind === "var") {
+			const hidden = env.graph.hidden;
+			const ic = MutableHashMap.get(body.cols, hidden);
+			const oc = MutableHashMap.get(env.cols, hidden);
+			if (Option.isSome(ic)) {
+				if (Option.isNone(oc) || oc.value.nullable) return unsupported("EXISTS in a graph-independent pattern");
+				if (ic.value.sql !== oc.value.sql) where.push(`${ic.value.sql} = ${oc.value.sql}`);
+			}
+		}
+		const sql = `EXISTS (SELECT 1${this.from(body.items)}${this.whereClause(where)})`;
+		return e.negated ? `(NOT ${sql})` : sql;
+	}
+};
+const compileOnce = (op, context, resolve, locals, localsKnown) => {
+	const c = new Compiler(context, resolve, locals, localsKnown);
+	const g = Predicate.isTagged(context.activeGraph, "NamedGraph") ? {
+		kind: "const",
+		id: c.idOf(context.activeGraph.graph)
+	} : { kind: "default" };
+	const block = c.op(op, g, EMPTY);
+	const visible = Arr.fromIterable(block.cols).filter(([n]) => !isHidden(n));
+	const names = visible.map(([n]) => n);
+	const innerSql = c.render(block, names);
+	const select = [];
+	const joins = [];
+	const columns = [];
+	visible.forEach(([n, col], i) => {
+		const name = `r.${c.col(n)}`;
+		columns.push({
+			variable: n,
+			type: col.type
+		});
+		if (col.type === "int") {
+			select.push(name);
+			return;
+		}
+		const t = `d${i}`;
+		select.push(name, `${t}.kind`, `${t}.value`, `${t}.datatype`, `${t}.lang`, `${t}.dir`);
+		joins.push(` LEFT JOIN ${c.T} ${t} ON ${t}.id = ${name}`);
+	});
+	const marked = `SELECT ${Arr.isReadonlyArrayEmpty(select) ? "1 AS one" : select.join(", ")} FROM (${innerSql}) r${joins.join("")}`;
+	const params = [];
+	const numbering = MutableHashMap.empty();
+	return {
+		sql: marked.replace(/\ue000(\d+)\ue000/g, (_, i) => {
+			if (context.dialect.anonymousParameters) {
+				params.push(c.params[Number(i) - 1]);
+				return context.dialect.placeholder(params.length);
+			}
+			const n = Option.getOrElse(MutableHashMap.get(numbering, i), () => {
+				params.push(c.params[Number(i) - 1]);
+				MutableHashMap.set(numbering, i, params.length);
+				return params.length;
+			});
+			return context.dialect.placeholder(n);
+		}),
+		params,
+		columns,
+		locals: new Map(Arr.fromIterable(MutableHashMap.values(locals)).map(({ id, term }) => [id, term])),
+		localClasses: c.localClasses,
+		risks: c.risks
+	};
+};
+/**
+* Translates an algebra tree to SQL. `resolve` gives the dictionary ids of
+* constant terms (see `constants`); terms it does not know get query-local
+* ids. Fails with a reason if the tree is not translatable.
+*
+* @since 0.1.0
+* @category compilation
+*/
+const compile = (op, context, resolve) => {
+	const resolveId = (term) => Option.fromNullishOr(resolve(term));
+	return Result.try({
+		try: () => {
+			const locals = MutableHashMap.empty();
+			const first = compileOnce(op, context, resolveId, locals, false);
+			if (MutableHashMap.isEmpty(locals)) return first;
+			return compileOnce(op, context, resolveId, locals, true);
+		},
+		catch: (err) => {
+			if (err instanceof Unsupported) return err.reason;
+			throw err;
+		}
+	});
+};
+/**
+* Whether an algebra tree is translatable to SQL (independent of the data).
+*
+* @since 0.1.0
+* @category compilation
+*/
+const supports = (op, context) => Result.isSuccess(compile(op, context, () => void 0));
+export { supports as a, isComponentIds as c, isRisky as i, rowKey as l, compile as n, decode as o, constants as r, encode as s, Translation_exports as t };
+
+//# sourceMappingURL=Translation-DC9rLm2y.mjs.map