@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/SqlStore-BBqFx-Wl.mjs

@@ -0,0 +1,684 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { B as isNamedNode, K as isTriple, O as defaultGraph, P as isDefaultGraph, Z as namedNode, d as Quad, o as Literal, rt as triple, z as isLiteral } from "./Term-CFLG1qu4.mjs";
+import { o as fromEntries } from "./Bindings-Ck3m7JRC.mjs";
+import { n as StoreError, t as QuadStore } from "./Store-DH3Ow1GO.mjs";
+import { o as tables, r as fromClient } from "./Dialect-CzVH38uo.mjs";
+import { c as isComponentIds, i as isRisky, l as rowKey, n as compile, o as decode, r as constants, s as encode } from "./Translation-DC9rLm2y.mjs";
+import * as Arr from "effect/Array";
+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 Effect from "effect/Effect";
+import * as Order from "effect/Order";
+import * as Context from "effect/Context";
+import * as Layer from "effect/Layer";
+import * as Stream from "effect/Stream";
+import * as Result from "effect/Result";
+import * as Migrator from "effect/sql/Migrator";
+import * as SqlClient from "effect/sql/SqlClient";
+import * as SqlError from "effect/sql/SqlError";
+// src/sparql/sql/SqlStore.ts
+/**
+* A SQL storage backend for the SPARQL engine, built on Effect's SQL
+* abstraction (`effect/sql`).
+*
+* The store keeps a dictionary of interned terms (RDF 1.2 triple terms
+* included, referencing their components) and a table of quads of term ids
+* indexed in four orders (`spog`, `posg`, `ospg`, `gspo`). It implements the
+* `QuadStore` service of `@thomasfosterau/effect-rdf/sparql` — streaming pattern
+* matching, statistics, updates, named graph management and transactions
+* (mapped to `SqlClient.withTransaction`) — and a `QueryCapability` that
+* translates SPARQL algebra to SQL (see `Translation`), so that the engine
+* runs whole queries (or the largest translatable subtrees) in the database.
+*
+* The store is driver-agnostic: `layer` runs over whichever `SqlClient`
+* the context provides, in the SQLite (3.35 or later) or PostgreSQL dialect
+* (`Dialect.fromClient`). A backend for one driver (a ready store layer that
+* also provides that driver's `SqlClient`) is a package of its own,
+* `@thomasfosterau/effect-sparql-<driver>`.
+*
+* @since 0.1.0
+*/
+var SqlStore_exports = /* @__PURE__ */ __exportAll({
+	SqlStore: () => SqlStore,
+	layer: () => layer,
+	make: () => make,
+	migrate: () => migrate,
+	migrations: () => migrations
+});
+/**
+* The SQL store service.
+*
+* @since 0.1.0
+* @category services
+*/
+var SqlStore = class extends Context.Service()("@thomasfosterau/effect-rdf/sparql/sql/SqlStore") {};
+const storeError = (message) => (cause) => cause instanceof StoreError ? cause : new StoreError({
+	message: `${message}: ${Predicate.isError(cause) ? cause.message : String(cause)}`,
+	cause
+});
+const chunks = (items, size) => Array.from({ length: Math.ceil(items.length / size) }, (_, i) => items.slice(i * size, (i + 1) * size));
+/** The distinct values of `items`, in order of first occurrence. */
+const distinct = (items) => Arr.fromIterable(MutableHashSet.fromIterable(items));
+const num = (v) => Predicate.isNumber(v) ? v : Number(v);
+const str = (v) => Predicate.isString(v) ? v : Predicate.isNumber(v) || Predicate.isBigInt(v) || Predicate.isBoolean(v) ? `${v}` : "";
+const depth = (t) => isTriple(t) ? 1 + Math.max(depth(t.subject), depth(t.predicate), depth(t.object)) : 0;
+const CACHE_LIMIT = 2e5;
+const DEFAULT_DATASET = {
+	defaultGraph: "default",
+	namedGraphs: "all"
+};
+/**
+* The schema migrations of the store (for `effect/sql/Migrator`): a record of
+* `<id>_<name>` to migration effect.
+*
+* @since 0.1.0
+* @category schema
+*/
+const migrations = (dialect, tables) => ({ "1_create_rdf_store": Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	yield* Effect.forEach(dialect.schema(tables), (statement) => sql.unsafe(statement), {
+		concurrency: 1,
+		discard: true
+	});
+}) });
+/**
+* Creates or migrates the store's schema.
+*
+* @since 0.1.0
+* @category schema
+*/
+const migrate = (options = {}) => Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const dialect = options.dialect ?? (yield* fromClient(sql));
+	const tables$2 = tables(options.tablePrefix);
+	yield* Migrator.make({})({
+		loader: Migrator.fromRecord(migrations(dialect, tables$2)),
+		table: tables$2.migrations
+	});
+}).pipe(Effect.mapError(storeError("Migration failed")));
+/**
+* The term with id `id` of a decode state that `complete` has filled: every
+* id is known, so a missing one is a defect.
+*/
+const termOf = (state, id) => {
+	const known = MutableHashMap.get(state.known, id);
+	if (Option.isSome(known)) return known.value;
+	const comps = MutableHashMap.get(state.triples, id);
+	if (Option.isNone(comps)) throw new StoreError({ message: `Unknown term id ${id}` });
+	const [s, p, o] = comps.value;
+	const t = triple(termAs(state, s, isSubject, "subject"), termAs(state, p, isNamedNode, "predicate"), termOf(state, o));
+	MutableHashMap.set(state.known, id, t);
+	return t;
+};
+/**
+* The term with id `id`, which the store only ever wrote in a position of
+* kind `T` (so another kind is a defect).
+*/
+const termAs = (state, id, is, position) => {
+	const t = termOf(state, id);
+	if (is(t)) return t;
+	throw new StoreError({ message: `Term id ${id} cannot be a ${position}` });
+};
+const isSubject = (t) => !isLiteral(t);
+const isGraphName = (t) => !isLiteral(t) && !isTriple(t);
+/** The dictionary key of a `id, kind, value, datatype, lang, dir` result row. */
+const rowKeyOf = (r) => rowKey({
+	kind: num(r[1]),
+	value: str(r[2]),
+	datatype: str(r[3]),
+	lang: str(r[4]),
+	dir: str(r[5])
+});
+const withKey = (term, row) => ({
+	term,
+	row,
+	key: rowKey(row)
+});
+/**
+* The dictionary rows of one depth level of terms; a triple term whose
+* components have no id yet is left out.
+*/
+const encodeLevel = (level, ids) => Arr.filterMap(MutableHashMap.values(level), (t) => {
+	if (!isTriple(t)) return Result.succeed(withKey(t, encode(t)));
+	const s = MutableHashMap.get(ids, t.subject.key);
+	const p = MutableHashMap.get(ids, t.predicate.key);
+	const o = MutableHashMap.get(ids, t.object.key);
+	return Option.isSome(s) && Option.isSome(p) && Option.isSome(o) ? Result.succeed(withKey(t, encode(t, [
+		s.value,
+		p.value,
+		o.value
+	]))) : Result.failVoid;
+});
+const newState = () => ({
+	known: MutableHashMap.empty(),
+	triples: MutableHashMap.empty()
+});
+const isResolved = (state, c) => Option.isSome(MutableHashMap.get(state.known, c)) || Option.isSome(MutableHashMap.get(state.triples, c));
+/** The id of a term or graph (`0` for the default graph), if it has one. */
+const idIn = (ids, t) => isDefaultGraph(t) ? Option.some(0) : MutableHashMap.get(ids, t.key);
+/** The `s, p, o, g` ids of a quad, if all its terms have one. */
+const quadRow = (ids, q) => {
+	const s = MutableHashMap.get(ids, q.subject.key);
+	const p = MutableHashMap.get(ids, q.predicate.key);
+	const o = MutableHashMap.get(ids, q.object.key);
+	const g = idIn(ids, q.graph);
+	return Option.isSome(s) && Option.isSome(p) && Option.isSome(o) && Option.isSome(g) ? Result.succeed([
+		s.value,
+		p.value,
+		o.value,
+		g.value
+	]) : Result.failVoid;
+};
+const INDEXES = [
+	[
+		"s",
+		"p",
+		"o",
+		"g"
+	],
+	[
+		"p",
+		"o",
+		"s",
+		"g"
+	],
+	[
+		"o",
+		"s",
+		"p",
+		"g"
+	],
+	[
+		"g",
+		"s",
+		"p",
+		"o"
+	]
+];
+/** The number of leading columns of an index that are bound. */
+const boundPrefix = (idx, bound) => {
+	const i = idx.findIndex((c) => !MutableHashSet.has(bound, c));
+	return i < 0 ? idx.length : i;
+};
+const indexFor = (bound) => {
+	const first = {
+		best: INDEXES[0],
+		prefix: -1
+	};
+	return Arr.reduce(INDEXES, first, (acc, idx) => {
+		const n = boundPrefix(idx, bound);
+		return n > acc.prefix ? {
+			best: idx,
+			prefix: n
+		} : acc;
+	}).best;
+};
+const columnLayout = (columns) => Arr.mapAccum(columns, 0, (at, column) => [at + (column.type === "int" ? 1 : 6), {
+	column,
+	at
+}])[1];
+/**
+* Creates a SQL store over the `SqlClient` service.
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (options = {}) => Effect.gen(function* () {
+	const sql = yield* SqlClient.SqlClient;
+	const dialect = options.dialect ?? (yield* Effect.mapError(fromClient(sql), storeError("Unsupported database")));
+	const tables$1 = tables(options.tablePrefix);
+	if (options.migrate !== false) yield* migrate({
+		dialect,
+		tablePrefix: options.tablePrefix
+	});
+	const T = tables$1.terms;
+	const Qt = tables$1.quads;
+	const Gt = tables$1.graphs;
+	const batchSize = Math.max(1, Math.min(options.batchSize ?? 500, 1e3));
+	const pageSize = Math.max(1, options.pageSize ?? 5e3);
+	const onQuery = options.onQuery;
+	const ph = dialect.placeholder;
+	const idCache = MutableHashMap.empty();
+	const termCache = MutableHashMap.empty();
+	const inTransaction = Effect.map(Effect.serviceOption(sql.transactionService), Option.isSome);
+	const run = (text, params = []) => sql.unsafe(text, params).values;
+	const exec = (text, params = []) => Effect.asVoid(sql.unsafe(text, params).raw);
+	const lookupRows = (rows) => {
+		const found = MutableHashMap.empty();
+		const values = distinct(rows.map((r) => r.row.value));
+		return Effect.as(Effect.forEach(chunks(values, 500), (chunk) => {
+			const list = chunk.map((_, i) => dialect.valueKey(dialect.castText(ph(i + 1)))).join(", ");
+			return Effect.map(run(`SELECT id, kind, value, datatype, lang, dir FROM ${T} WHERE ${dialect.valueKey("value")} IN (${list})`, chunk), (result) => result.forEach((r) => {
+				MutableHashMap.set(found, rowKeyOf(r), num(r[0]));
+			}));
+		}, {
+			concurrency: 1,
+			discard: true
+		}), found);
+	};
+	/** Inserts dictionary rows; returns the ids of the rows that were new. */
+	const insertRows = (rows) => Effect.gen(function* () {
+		const inserted = MutableHashMap.empty();
+		yield* Effect.forEach(chunks(rows, 500), Effect.fnUntraced(function* (chunk) {
+			const params = [];
+			const tuples = chunk.map(({ row: r }) => {
+				const base = params.length;
+				params.push(r.kind, r.value, r.datatype, r.lang, r.dir, Option.getOrNull(r.sub), Option.getOrNull(r.pre), Option.getOrNull(r.obj), r.cls, Option.getOrNull(r.num));
+				return `(${Array.from({ length: 10 }, (_, i) => {
+					const p = ph(base + i + 1);
+					return i >= 1 && i <= 4 ? dialect.castText(p) : i === 9 ? dialect.castDouble(p) : dialect.castId(p);
+				}).join(", ")})`;
+			});
+			(yield* run(`INSERT INTO ${T} (kind, value, datatype, lang, dir, sub, pre, obj, cls, num) VALUES ${tuples.join(", ")} ON CONFLICT DO NOTHING RETURNING id, kind, value, datatype, lang, dir`, params)).forEach((r) => {
+				MutableHashMap.set(inserted, rowKeyOf(r), num(r[0]));
+			});
+		}), {
+			concurrency: 1,
+			discard: true
+		});
+		const classes = distinct(rows.map((r) => r.row.cls));
+		if (Arr.isReadonlyArrayNonEmpty(classes)) yield* exec(`INSERT INTO ${tables$1.classes} (cls) VALUES ${classes.map((c) => `(${c})`).join(", ")} ON CONFLICT DO NOTHING`);
+		return inserted;
+	});
+	/**
+	* The ids of dictionary rows (none for a row not in the dictionary). With
+	* `create`, rows are inserted first (new rows come back with their ids) and
+	* the rest looked up.
+	*/
+	const findIds = (rows, create) => Effect.gen(function* () {
+		if (!create) {
+			const found = yield* lookupRows(rows);
+			return rows.map((encoded) => ({
+				encoded,
+				id: MutableHashMap.get(found, encoded.key)
+			}));
+		}
+		const inserted = yield* insertRows(rows);
+		const first = rows.map((encoded) => ({
+			encoded,
+			id: MutableHashMap.get(inserted, encoded.key)
+		}));
+		const existing = first.filter(({ id }) => Option.isNone(id)).map(({ encoded }) => encoded);
+		if (Arr.isReadonlyArrayEmpty(existing)) return first;
+		const more = yield* lookupRows(existing);
+		return first.map((f) => Option.isSome(f.id) ? f : {
+			encoded: f.encoded,
+			id: MutableHashMap.get(more, f.encoded.key)
+		});
+	});
+	/**
+	* The dictionary ids of terms (by key). With `create`, missing terms are
+	* interned; otherwise they are absent from the result.
+	*/
+	const resolveTerms = (terms, create) => Effect.gen(function* () {
+		const cacheable = !(yield* inTransaction);
+		const result = MutableHashMap.empty();
+		const levels = MutableHashMap.empty();
+		const levelAt = (d) => {
+			const found = MutableHashMap.get(levels, d);
+			if (Option.isSome(found)) return found.value;
+			const level = MutableHashMap.empty();
+			MutableHashMap.set(levels, d, level);
+			return level;
+		};
+		const add = (t) => {
+			if (Option.isSome(MutableHashMap.get(result, t.key))) return;
+			const cached = MutableHashMap.get(idCache, t.key);
+			if (Option.isSome(cached)) {
+				MutableHashMap.set(result, t.key, cached.value);
+				return;
+			}
+			const level = levelAt(depth(t));
+			if (Option.isSome(MutableHashMap.get(level, t.key))) return;
+			MutableHashMap.set(level, t.key, t);
+			if (isTriple(t)) {
+				add(t.subject);
+				add(t.predicate);
+				add(t.object);
+			}
+		};
+		Arr.fromIterable(terms).forEach((t) => add(t));
+		const depths = Arr.sort(MutableHashMap.keys(levels), Order.Number);
+		yield* Effect.forEach(depths, Effect.fnUntraced(function* (d) {
+			const rows = encodeLevel(levelAt(d), result);
+			if (Arr.isReadonlyArrayEmpty(rows)) return;
+			(yield* findIds(rows, create)).forEach(({ encoded: { term }, id }) => {
+				if (Option.isNone(id)) return;
+				MutableHashMap.set(result, term.key, id.value);
+				if (cacheable) {
+					if (MutableHashMap.size(idCache) >= CACHE_LIMIT) MutableHashMap.clear(idCache);
+					MutableHashMap.set(idCache, term.key, id.value);
+				}
+			});
+		}), {
+			concurrency: 1,
+			discard: true
+		});
+		return result;
+	});
+	/**
+	* Records the term with id `id` whose `kind, value, datatype, lang, dir`
+	* columns start at `row[at]` (`kind` is SQL `NULL` for an id with no term
+	* row).
+	*/
+	const addRow = (state, id, row, at) => {
+		if (isResolved(state, id)) return;
+		const cached = MutableHashMap.get(termCache, id);
+		if (Option.isSome(cached)) {
+			MutableHashMap.set(state.known, id, cached.value);
+			return;
+		}
+		const kind = row[at];
+		if (Predicate.isNullish(kind)) return;
+		const t = decode(num(kind), str(row[at + 1]), str(row[at + 2]), str(row[at + 3]), str(row[at + 4]));
+		if (isComponentIds(t)) MutableHashMap.set(state.triples, id, t);
+		else MutableHashMap.set(state.known, id, t);
+	};
+	/** Reads the dictionary rows of `ids` (one chunk) into a decode state. */
+	const fetchTerms = (state, ids) => Effect.map(run(`SELECT id, kind, value, datatype, lang, dir FROM ${T} WHERE id IN (${ids.join(", ")})`), (rows) => rows.forEach((r) => {
+		addRow(state, num(r[0]), r, 1);
+	}));
+	/** Fetches the components of the triple terms of a decode state, until none is missing. */
+	const complete = (state) => Effect.suspend(() => {
+		const missing = MutableHashSet.empty();
+		MutableHashMap.forEach(state.triples, (comps) => comps.forEach((c) => {
+			if (!isResolved(state, c)) MutableHashSet.add(missing, c);
+		}));
+		const unknown = Arr.filter(Arr.fromIterable(missing), (c) => Option.match(MutableHashMap.get(termCache, c), {
+			onNone: () => true,
+			onSome: (cached) => {
+				MutableHashMap.set(state.known, c, cached);
+				return false;
+			}
+		}));
+		if (Arr.isReadonlyArrayEmpty(unknown)) return Effect.void;
+		return Effect.forEach(chunks(unknown, 500), (chunk) => Effect.flatMap(fetchTerms(state, chunk), () => Option.match(Arr.findFirst(chunk, (c) => !isResolved(state, c)), {
+			onNone: () => Effect.void,
+			onSome: (c) => Effect.fail(new StoreError({ message: `Unknown term id ${c}` }))
+		})), {
+			concurrency: 1,
+			discard: true
+		}).pipe(Effect.flatMap(() => complete(state)));
+	});
+	const remember = (state) => Effect.map(inTransaction, (inTx) => {
+		if (inTx) return;
+		if (MutableHashMap.size(termCache) + MutableHashMap.size(state.known) > CACHE_LIMIT) MutableHashMap.clear(termCache);
+		MutableHashMap.forEach(state.known, (t, id) => {
+			MutableHashMap.set(termCache, id, t);
+		});
+	});
+	const patternConditions = (pattern) => Effect.gen(function* () {
+		const positions = [
+			["s", pattern.subject],
+			["p", pattern.predicate],
+			["o", pattern.object],
+			["g", pattern.graph]
+		];
+		const present = Arr.filterMap(positions, ([column, t]) => t === void 0 ? Result.failVoid : Result.succeed({
+			column,
+			t
+		}));
+		const ids = yield* resolveTerms(Arr.filterMap(present, ({ t }) => isDefaultGraph(t) ? Result.failVoid : Result.succeed(t)), false);
+		return Option.all(present.map(({ column, t }) => Option.map(idIn(ids, t), (id) => [column, id])));
+	});
+	const decodeQuads = (rows) => Effect.gen(function* () {
+		const state = newState();
+		rows.forEach((r) => {
+			addRow(state, num(r[0]), r, 4);
+			addRow(state, num(r[1]), r, 9);
+			addRow(state, num(r[2]), r, 14);
+			const g = num(r[3]);
+			if (g !== 0) addRow(state, g, r, 19);
+		});
+		yield* complete(state);
+		yield* remember(state);
+		return rows.map((r) => {
+			const g = num(r[3]);
+			return new Quad(termAs(state, num(r[0]), isSubject, "subject"), termAs(state, num(r[1]), isNamedNode, "predicate"), termOf(state, num(r[2])), g === 0 ? defaultGraph : termAs(state, g, isGraphName, "graph name"));
+		});
+	});
+	const match = (pattern) => Stream.unwrap(Effect.gen(function* () {
+		const conds = yield* patternConditions(pattern);
+		if (Option.isNone(conds)) return Stream.empty;
+		const bound = MutableHashSet.fromIterable(conds.value.map(([c]) => c));
+		const order = indexFor(bound);
+		const where = conds.value.map(([c, id]) => `${c} = ${id}`);
+		const attrs = [
+			"s",
+			"p",
+			"o",
+			"g"
+		].map((c) => `m${c}.kind, m${c}.value, m${c}.datatype, m${c}.lang, m${c}.dir`).join(", ");
+		const joins = [
+			"s",
+			"p",
+			"o",
+			"g"
+		].map((c) => ` LEFT JOIN ${T} m${c} ON m${c}.id = q.${c}`).join("");
+		const page = (after) => {
+			const w = Option.match(after, {
+				onNone: () => where,
+				onSome: (cursor) => [...where, `(${order.join(", ")}) > (${cursor.join(", ")})`]
+			});
+			return `SELECT q.s, q.p, q.o, q.g, ${attrs} FROM (SELECT s, p, o, g FROM ${Qt}${Arr.isReadonlyArrayNonEmpty(w) ? ` WHERE ${w.join(" AND ")}` : ""} ORDER BY ${order.join(", ")} LIMIT ${pageSize}) q${joins}`;
+		};
+		return Stream.paginate(Option.none(), (after) => Effect.gen(function* () {
+			const rows = yield* run(page(after));
+			return [yield* decodeQuads(rows), rows.length < pageSize ? Option.none() : Option.map(Arr.last(rows), (last) => Option.some(order.map((c) => num(last[[
+				"s",
+				"p",
+				"o",
+				"g"
+			].indexOf(c)]))))];
+		}));
+	})).pipe(Stream.mapError(storeError("match failed")));
+	const countWhere = (pattern, limit) => Effect.gen(function* () {
+		const conds = yield* patternConditions(pattern);
+		if (Option.isNone(conds)) return 0;
+		const where = conds.value.map(([c, id]) => `${c} = ${id}`);
+		const filter = Arr.isReadonlyArrayNonEmpty(where) ? ` WHERE ${where.join(" AND ")}` : "";
+		const rows = yield* run(Option.match(limit, {
+			onNone: () => `SELECT COUNT(*) FROM ${Qt}${filter}`,
+			onSome: (n) => `SELECT COUNT(*) FROM (SELECT 1 FROM ${Qt}${filter} LIMIT ${n}) x`
+		}));
+		return num(rows[0]?.[0] ?? 0);
+	}).pipe(Effect.mapError(storeError("count failed")));
+	const quadIds = (quads, create) => Effect.gen(function* () {
+		const list = Arr.fromIterable(quads);
+		const terms = [];
+		list.forEach((q) => {
+			terms.push(q.subject, q.predicate, q.object);
+			if (!isDefaultGraph(q.graph)) terms.push(q.graph);
+		});
+		const ids = yield* resolveTerms(terms, create);
+		return Arr.filterMap(list, (q) => quadRow(ids, q));
+	});
+	const tuples = (rows) => {
+		const params = [];
+		return {
+			text: rows.map((r) => {
+				const base = params.length;
+				params.push(...r);
+				return `(${r.map((_, i) => dialect.castId(ph(base + i + 1))).join(", ")})`;
+			}).join(", "),
+			params
+		};
+	};
+	/** Runs one statement per `batchSize` quad-id rows, `statement` building it from the tuples. */
+	const execBatches = (rows, statement) => Effect.forEach(chunks(rows, batchSize), (chunk) => {
+		const { text, params } = tuples(chunk);
+		return exec(statement(text), params);
+	}, {
+		concurrency: 1,
+		discard: true
+	});
+	const insert = (quads) => sql.withTransaction(Effect.gen(function* () {
+		const list = Array.from(quads);
+		yield* Effect.forEach(chunks(list, batchSize * 4), (batch) => Effect.flatMap(quadIds(batch, true), (rows) => execBatches(rows, (text) => `INSERT INTO ${Qt} (s, p, o, g) VALUES ${text} ON CONFLICT DO NOTHING`)), {
+			concurrency: 1,
+			discard: true
+		});
+	})).pipe(Effect.mapError(storeError("insert failed")));
+	const del = (quads) => sql.withTransaction(Effect.gen(function* () {
+		const rows = yield* quadIds(quads, false);
+		yield* execBatches(rows, (text) => `DELETE FROM ${Qt} WHERE (s, p, o, g) IN (VALUES ${text})`);
+	})).pipe(Effect.mapError(storeError("delete failed")));
+	const decodeIds = (ids) => Effect.gen(function* () {
+		const state = newState();
+		yield* Effect.forEach(chunks(ids, 500), (chunk) => fetchTerms(state, chunk), {
+			concurrency: 1,
+			discard: true
+		});
+		yield* complete(state);
+		yield* remember(state);
+		return ids.map((id) => termAs(state, id, isGraphName, "graph name"));
+	});
+	const graphs = Stream.unwrap(Effect.gen(function* () {
+		const rows = yield* run(`SELECT id FROM ${Gt} UNION SELECT DISTINCT g FROM ${Qt} WHERE g <> 0`);
+		return Stream.fromArray(yield* decodeIds(rows.map((r) => num(r[0]))));
+	})).pipe(Stream.mapError(storeError("graphs failed")));
+	const graphIdOf = (graph, create) => Effect.map(resolveTerms([graph], create), (ids) => MutableHashMap.get(ids, graph.key));
+	const hasGraph = (graph) => Effect.gen(function* () {
+		const found = yield* graphIdOf(graph, false);
+		if (Option.isNone(found)) return false;
+		const id = found.value;
+		const rows = yield* run(`SELECT 1 WHERE EXISTS (SELECT 1 FROM ${Gt} WHERE id = ${id}) OR EXISTS (SELECT 1 FROM ${Qt} WHERE g = ${id})`);
+		return Arr.isReadonlyArrayNonEmpty(rows);
+	}).pipe(Effect.mapError(storeError("hasGraph failed")));
+	const createGraph = (graph) => sql.withTransaction(Effect.gen(function* () {
+		const id = yield* graphIdOf(graph, true);
+		if (Option.isNone(id)) return;
+		yield* exec(`INSERT INTO ${Gt} (id) VALUES (${id.value}) ON CONFLICT DO NOTHING`);
+	})).pipe(Effect.mapError(storeError("createGraph failed")));
+	const dropGraph = (graph) => sql.withTransaction(Effect.gen(function* () {
+		const id = yield* graphIdOf(graph, false);
+		if (Option.isNone(id)) return;
+		yield* exec(`DELETE FROM ${Qt} WHERE g = ${id.value}`);
+		yield* exec(`DELETE FROM ${Gt} WHERE id = ${id.value}`);
+	})).pipe(Effect.mapError(storeError("dropGraph failed")));
+	const clear = (graph) => Effect.gen(function* () {
+		const id = isDefaultGraph(graph) ? Option.some(0) : yield* graphIdOf(graph, false);
+		if (Option.isNone(id)) return;
+		yield* exec(`DELETE FROM ${Qt} WHERE g = ${id.value}`);
+	}).pipe(Effect.mapError(storeError("clear failed")));
+	const transaction = (effect) => sql.withTransaction(effect).pipe(Effect.mapError((e) => SqlError.isSqlError(e) ? storeError("transaction failed")(e) : e));
+	const storeClasses = Effect.map(run(`SELECT cls FROM ${tables$1.classes}`), (rows) => new Set(rows.map((r) => num(r[0]))));
+	const translationContext = (context) => ({
+		dialect,
+		tables: tables$1,
+		dataset: context?.dataset ?? DEFAULT_DATASET,
+		activeGraph: context?.activeGraph ?? { _tag: "DefaultGraph" }
+	});
+	const compile$1 = (op, context) => Effect.gen(function* () {
+		const ctx = translationContext(context);
+		const ids = yield* resolveTerms(constants(op, ctx), false);
+		return compile(op, ctx, resolveIn(ids));
+	}).pipe(Effect.mapError(storeError("compile failed")));
+	const decodeSolutions = (compiled, rows) => Effect.gen(function* () {
+		const layout = columnLayout(compiled.columns);
+		const terms = layout.filter(({ column }) => column.type === "id");
+		const state = newState();
+		compiled.locals.forEach((t, id) => {
+			MutableHashMap.set(state.known, id, t);
+		});
+		rows.forEach((r) => terms.forEach(({ at }) => {
+			const v = r[at];
+			if (Predicate.isNullish(v)) return;
+			const id = num(v);
+			if (id > 0) addRow(state, id, r, at + 1);
+		}));
+		yield* complete(state);
+		compiled.locals.forEach((_, id) => {
+			MutableHashMap.remove(state.known, id);
+		});
+		yield* remember(state);
+		compiled.locals.forEach((t, id) => {
+			MutableHashMap.set(state.known, id, t);
+		});
+		return rows.map((r) => fromEntries(Arr.filterMap(layout, ({ column, at }) => {
+			const v = r[at];
+			if (Predicate.isNullish(v)) return Result.failVoid;
+			const term = column.type === "int" ? new Literal(str(v), INTEGER) : termOf(state, num(v));
+			return Result.succeed([column.variable, term]);
+		})));
+	});
+	const declined = /* @__PURE__ */ new WeakSet();
+	const capability = { evaluate: (op, context) => {
+		if (options.translate === false) return Option.none();
+		if (declined.has(op)) {
+			declined.delete(op);
+			return Option.none();
+		}
+		const ctx = translationContext(context);
+		const check = compile(op, ctx, () => void 0);
+		if (Result.isFailure(check)) {
+			onQuery?.({
+				_tag: "Declined",
+				operation: op,
+				reason: check.failure
+			});
+			return Option.none();
+		}
+		const stream = Stream.unwrap(Effect.gen(function* () {
+			const ids = yield* resolveTerms(constants(op, ctx), false);
+			const compiled = compile(op, ctx, resolveIn(ids));
+			if (Result.isFailure(compiled)) return yield* new StoreError({ message: compiled.failure });
+			const q = compiled.success;
+			if (Arr.isReadonlyArrayNonEmpty(q.risks) && isRisky(q, yield* storeClasses)) {
+				onQuery?.({
+					_tag: "Declined",
+					operation: op,
+					reason: "The data contains values SQL cannot compare exactly"
+				});
+				declined.add(op);
+				return Stream.mapError(context.evaluate(op), storeError("evaluation failed"));
+			}
+			const rows = yield* run(q.sql, q.params).pipe(Effect.withSpan("SqlStore.query", { attributes: { "db.query.text": q.sql } }));
+			onQuery?.({
+				_tag: "Executed",
+				operation: op,
+				sql: q.sql,
+				params: q.params,
+				rows: rows.length
+			});
+			return Stream.fromArray(yield* decodeSolutions(q, rows));
+		}).pipe(Effect.mapError(storeError("SQL query failed"))));
+		return Option.some(stream);
+	} };
+	return {
+		dialect,
+		tables: tables$1,
+		capability,
+		compile: compile$1,
+		termCount: Effect.map(run(`SELECT COUNT(*) FROM ${T}`), (rows) => num(rows[0]?.[0] ?? 0)).pipe(Effect.mapError(storeError("termCount failed"))),
+		match,
+		estimate: (pattern) => countWhere(pattern, Option.some(1e4)),
+		count: (pattern) => countWhere(pattern, Option.none()),
+		graphs,
+		hasGraph,
+		insert,
+		delete: del,
+		createGraph,
+		dropGraph,
+		clear,
+		transaction,
+		query: capability
+	};
+});
+/** The `resolve` of `Translation.compile` over resolved term ids. */
+const resolveIn = (ids) => (t) => Option.getOrUndefined(MutableHashMap.get(ids, t.key));
+const INTEGER = namedNode("http://www.w3.org/2001/XMLSchema#integer");
+/**
+* A layer providing the SQL store as both `SqlStore` and the engine's
+* `QuadStore` (whose `query` is the SPARQL-to-SQL `QueryCapability`), over
+* the `SqlClient` service.
+*
+* @since 0.1.0
+* @category layers
+*/
+const layer = (options = {}) => Layer.effectContext(Effect.map(make(options), (store) => Context.make(SqlStore, store).pipe(Context.add(QuadStore, store))));
+export { migrate as a, make as i, SqlStore_exports as n, migrations as o, layer as r, SqlStore as t };
+
+//# sourceMappingURL=SqlStore-BBqFx-Wl.mjs.map