@undefineds.co/xpod 0.3.25 → 0.3.27

package/dist/storage/rdf/PostgresRdfEngine.js

@@ -0,0 +1,2609 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresRdfEngine = void 0;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const node_os_1 = require("node:os");
+const n3_1 = require("n3");
+const pglite_1 = require("@electric-sql/pglite");
+const PostgresPoolManager_1 = require("../database/PostgresPoolManager");
+const RdfTermDictionary_1 = require("./RdfTermDictionary");
+const RdfTermSemantics_1 = require("./RdfTermSemantics");
+const SolidRdfEngine_1 = require("./SolidRdfEngine");
+const Rdf3xSchema_1 = require("./Rdf3xSchema");
+const types_1 = require("../quint/types");
+const { namedNode, quad } = n3_1.DataFactory;
+const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
+const XSD_INTEGER = 'http://www.w3.org/2001/XMLSchema#integer';
+const XSD_DECIMAL = 'http://www.w3.org/2001/XMLSchema#decimal';
+const RDF_LANG_STRING = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#langString';
+const POSTGRES_RDF_SCHEMA_VERSION = 1;
+const POSTGRES_RDF3X_SCHEMA_VERSION = 1;
+const PG_STRING_ESCAPE = '\u001f';
+const TERM_KEYS = ['subject', 'predicate', 'object'];
+const PATTERN_KEYS = ['graph', 'subject', 'predicate', 'object'];
+const RDF_FACTS_TABLE = 'rdf_quads';
+const TERM_COLUMN = {
+    graph: 'graph_id',
+    subject: 'subject_id',
+    predicate: 'predicate_id',
+    object: 'object_id',
+};
+const PERMUTATIONS = [
+    { name: 'SPO', indexName: 'rdf_quads_spog', columns: ['subject_id', 'predicate_id', 'object_id', 'graph_id'] },
+    { name: 'SOP', indexName: 'rdf_quads_sopg', columns: ['subject_id', 'object_id', 'predicate_id', 'graph_id'] },
+    { name: 'PSO', indexName: 'rdf_quads_psog', columns: ['predicate_id', 'subject_id', 'object_id', 'graph_id'] },
+    { name: 'POS', indexName: 'rdf_quads_posg', columns: ['predicate_id', 'object_id', 'subject_id', 'graph_id'] },
+    { name: 'OSP', indexName: 'rdf_quads_ospg', columns: ['object_id', 'subject_id', 'predicate_id', 'graph_id'] },
+    { name: 'OPS', indexName: 'rdf_quads_opsg', columns: ['object_id', 'predicate_id', 'subject_id', 'graph_id'] },
+];
+const PAIR_PROJECTIONS = [
+    { name: 'SP', table: Rdf3xSchema_1.RDF3X_PAIR_PROJECTION_TABLE_BY_NAME.SP, columns: ['subject_id', 'predicate_id'], remainder: 'object_id' },
+    { name: 'SO', table: Rdf3xSchema_1.RDF3X_PAIR_PROJECTION_TABLE_BY_NAME.SO, columns: ['subject_id', 'object_id'], remainder: 'predicate_id' },
+    { name: 'PS', table: Rdf3xSchema_1.RDF3X_PAIR_PROJECTION_TABLE_BY_NAME.PS, columns: ['predicate_id', 'subject_id'], remainder: 'object_id' },
+    { name: 'PO', table: Rdf3xSchema_1.RDF3X_PAIR_PROJECTION_TABLE_BY_NAME.PO, columns: ['predicate_id', 'object_id'], remainder: 'subject_id' },
+    { name: 'OS', table: Rdf3xSchema_1.RDF3X_PAIR_PROJECTION_TABLE_BY_NAME.OS, columns: ['object_id', 'subject_id'], remainder: 'predicate_id' },
+    { name: 'OP', table: Rdf3xSchema_1.RDF3X_PAIR_PROJECTION_TABLE_BY_NAME.OP, columns: ['object_id', 'predicate_id'], remainder: 'subject_id' },
+];
+const TERM_PROJECTIONS = [
+    { name: 'S', table: Rdf3xSchema_1.RDF3X_TERM_PROJECTION_TABLE_BY_NAME.S, column: 'subject_id' },
+    { name: 'P', table: Rdf3xSchema_1.RDF3X_TERM_PROJECTION_TABLE_BY_NAME.P, column: 'predicate_id' },
+    { name: 'O', table: Rdf3xSchema_1.RDF3X_TERM_PROJECTION_TABLE_BY_NAME.O, column: 'object_id' },
+];
+const OBJECT_RANGE_KINDS = ['iri', 'literal', 'blank'];
+function toPgSafe(value) {
+    return value
+        .replaceAll(PG_STRING_ESCAPE, `${PG_STRING_ESCAPE}${PG_STRING_ESCAPE}`)
+        .replaceAll('\u0000', `${PG_STRING_ESCAPE}0`);
+}
+function fromPgSafe(value) {
+    let result = '';
+    for (let i = 0; i < value.length; i += 1) {
+        const char = value[i];
+        if (char !== PG_STRING_ESCAPE) {
+            result += char;
+            continue;
+        }
+        const next = value[i + 1];
+        if (next === '0') {
+            result += '\u0000';
+            i += 1;
+        }
+        else if (next === PG_STRING_ESCAPE) {
+            result += PG_STRING_ESCAPE;
+            i += 1;
+        }
+        else {
+            // Legacy rows from the earlier direct replacement format used a bare
+            // separator as a null-byte placeholder.
+            result += '\u0000';
+        }
+    }
+    return result;
+}
+function normalizePgValue(value) {
+    if (typeof value === 'string') {
+        return toPgSafe(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizePgValue(item));
+    }
+    return value;
+}
+class PgliteExecutor {
+    constructor(db) {
+        this.db = db;
+    }
+    async query(sql, params = []) {
+        const result = await this.db.query(sql, params.map((value) => normalizePgValue(value)));
+        return result.rows.map((row) => restoreRow(row));
+    }
+    async exec(sql, params = []) {
+        await this.db.query(sql, params.map((value) => normalizePgValue(value)));
+    }
+    async transaction(fn) {
+        await this.db.query('BEGIN');
+        try {
+            const result = await fn(this);
+            await this.db.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await this.db.query('ROLLBACK');
+            throw error;
+        }
+    }
+    async close() {
+        await this.db.close();
+    }
+}
+class PgPoolExecutor {
+    constructor(pool, client) {
+        this.pool = pool;
+        this.client = client;
+    }
+    async query(sql, params = []) {
+        const result = this.client
+            ? await this.client.query(sql, params.map((value) => normalizePgValue(value)))
+            : await this.pool.query(sql, params.map((value) => normalizePgValue(value)));
+        return result.rows.map((row) => restoreRow(row));
+    }
+    async exec(sql, params = []) {
+        if (this.client) {
+            await this.client.query(sql, params.map((value) => normalizePgValue(value)));
+            return;
+        }
+        await this.pool.query(sql, params.map((value) => normalizePgValue(value)));
+    }
+    async transaction(fn) {
+        if (this.client) {
+            const result = await fn(this);
+            return result;
+        }
+        const client = await this.pool.connect();
+        const tx = new PgPoolExecutor(this.pool, client);
+        try {
+            await client.query('BEGIN');
+            const result = await fn(tx);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            try {
+                await client.query('ROLLBACK');
+            }
+            catch {
+            }
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async close() {
+        if (this.client) {
+            return;
+        }
+        await this.pool.end();
+    }
+}
+class PgSqlBuilder {
+    constructor(initialParams = []) {
+        this.params = [];
+        this.params = [...initialParams];
+    }
+    add(value) {
+        this.params.push(value);
+        return `$${this.params.length}`;
+    }
+    addAll(values) {
+        return values.map((value) => this.add(value)).join(', ');
+    }
+    snapshot() {
+        return [...this.params];
+    }
+}
+class PostgresRdfTermDictionary {
+    constructor(executor) {
+        this.executor = executor;
+        this.termCache = new Map();
+        this.idCache = new Map();
+    }
+    async initialize() {
+        await this.executor.exec(`
+      CREATE TABLE IF NOT EXISTS rdf_terms (
+        id BIGSERIAL PRIMARY KEY,
+        kind TEXT NOT NULL,
+        value TEXT NOT NULL,
+        value_head TEXT NOT NULL,
+        datatype_id BIGINT,
+        lang TEXT,
+        hash TEXT NOT NULL UNIQUE,
+        normalized_text TEXT,
+        numeric_value DOUBLE PRECISION,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+        await this.executor.exec(`
+      CREATE UNIQUE INDEX IF NOT EXISTS rdf_terms_identity_hash ON rdf_terms (hash)
+    `);
+        await this.executor.exec('CREATE INDEX IF NOT EXISTS rdf_terms_kind_value_head ON rdf_terms (kind, value_head)');
+        await this.executor.exec('CREATE INDEX IF NOT EXISTS rdf_terms_kind_datatype ON rdf_terms (kind, datatype_id)');
+        await this.executor.exec('CREATE INDEX IF NOT EXISTS rdf_terms_kind_lang ON rdf_terms (kind, lang)');
+        await this.executor.exec('CREATE INDEX IF NOT EXISTS rdf_terms_kind_numeric_value ON rdf_terms (kind, numeric_value)');
+    }
+    async getOrCreate(term) {
+        const identity = await this.toIdentity(term);
+        const cacheKey = this.identityCacheKey(identity);
+        const cached = this.termCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const row = await this.executor.query(`
+      INSERT INTO rdf_terms (
+        kind,
+        value,
+        value_head,
+        datatype_id,
+        lang,
+        hash,
+        normalized_text,
+        numeric_value
+      )
+      VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
+      ON CONFLICT (hash) DO UPDATE
+      SET hash = EXCLUDED.hash
+      RETURNING id
+    `, [
+            identity.kind,
+            identity.value,
+            identity.valueHead,
+            identity.datatypeId,
+            identity.lang,
+            identity.hash,
+            identity.normalizedText,
+            identity.numericValue,
+        ]);
+        const id = row[0]?.id;
+        if (id === undefined) {
+            throw new Error('Failed to insert RDF term');
+        }
+        this.termCache.set(cacheKey, id);
+        this.idCache.set(id, term);
+        return id;
+    }
+    async find(term) {
+        const identity = await this.toIdentity(term);
+        const cacheKey = this.identityCacheKey(identity);
+        const cached = this.termCache.get(cacheKey);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const rows = await this.executor.query('SELECT * FROM rdf_terms WHERE hash = $1', [identity.hash]);
+        const id = rows.find((row) => this.rowMatchesIdentity(row, identity))?.id;
+        if (id !== undefined) {
+            this.termCache.set(cacheKey, id);
+        }
+        return id;
+    }
+    async termForId(id) {
+        const cached = this.idCache.get(id);
+        if (cached) {
+            return cached;
+        }
+        const row = await this.executor.query('SELECT * FROM rdf_terms WHERE id = $1', [id]);
+        const termRow = row[0];
+        if (!termRow) {
+            throw new Error(`RDF term not found: ${id}`);
+        }
+        const term = await this.rowToTerm(termRow);
+        this.idCache.set(id, term);
+        return term;
+    }
+    async rowsForIds(ids) {
+        const result = new Map();
+        const uniqueIds = Array.from(new Set(ids));
+        if (uniqueIds.length === 0) {
+            return result;
+        }
+        const rows = await this.executor.query('SELECT * FROM rdf_terms WHERE id = ANY($1::bigint[])', [uniqueIds]);
+        for (const row of rows) {
+            const term = await this.rowToTerm(row);
+            this.idCache.set(row.id, term);
+            result.set(row.id, term);
+        }
+        return result;
+    }
+    async rowsByNormalizedTextRegex(kinds, pattern) {
+        if (kinds.length === 0) {
+            return [];
+        }
+        const rows = await this.executor.query(`
+      SELECT id, value
+      FROM rdf_terms
+      WHERE kind = ANY($1::text[])
+        AND normalized_text IS NOT NULL
+    `, [kinds]);
+        const regex = new RegExp(pattern);
+        return rows
+            .filter((row) => regex.test(row.value.toLowerCase()))
+            .map((row) => row.id);
+    }
+    async count() {
+        const row = await this.executor.query('SELECT COUNT(*) AS count FROM rdf_terms');
+        return row[0]?.count ?? 0;
+    }
+    async toIdentity(term) {
+        switch (term.termType) {
+            case 'NamedNode':
+                return this.identity('iri', term.value, null, null, term.value, null);
+            case 'BlankNode':
+                return this.identity('blank', term.value, null, null, term.value, null);
+            case 'DefaultGraph':
+                return this.identity('default_graph', '', null, null, null, null);
+            case 'Literal': {
+                const datatypeValue = term.datatype?.value || XSD_STRING;
+                const datatypeId = datatypeValue === XSD_STRING && !term.language
+                    ? null
+                    : await this.getOrCreate(namedNode(datatypeValue));
+                return this.identity('literal', term.value, datatypeId, term.language || null, term.value, this.numericValueForLiteral(term.value, datatypeValue));
+            }
+            case 'Variable':
+                throw new Error(`Variables cannot be indexed as RDF terms: ${term.value}`);
+            case 'Quad':
+                throw new Error('Nested RDF-star quads are not supported by the first PostgresRdfEngine index');
+            default: {
+                const exhaustive = term;
+                throw new Error(`Unsupported RDF term: ${String(exhaustive)}`);
+            }
+        }
+    }
+    identity(kind, value, datatypeId, lang, normalizedText, numericValue) {
+        const hash = (0, node_crypto_1.createHash)('sha256')
+            .update(kind)
+            .update('\0')
+            .update(value)
+            .update('\0')
+            .update(String(datatypeId ?? ''))
+            .update('\0')
+            .update(lang ?? '')
+            .digest('hex');
+        return {
+            kind,
+            value,
+            valueHead: (0, RdfTermDictionary_1.rdfTermValueHead)(value),
+            datatypeId,
+            lang,
+            normalizedText: normalizedText ? normalizedText.toLowerCase() : null,
+            numericValue,
+            hash,
+        };
+    }
+    numericValueForLiteral(value, datatypeValue) {
+        if (!(0, RdfTermSemantics_1.isRdfNumericDatatype)(datatypeValue)) {
+            return null;
+        }
+        const numeric = (0, RdfTermSemantics_1.rdfNumericValue)(value);
+        return Number.isFinite(numeric) ? numeric : null;
+    }
+    identityCacheKey(identity) {
+        return [
+            identity.kind,
+            identity.value,
+            identity.datatypeId ?? '',
+            identity.lang ?? '',
+        ].join('\u001f');
+    }
+    rowMatchesIdentity(row, identity) {
+        return row.kind === identity.kind
+            && row.value === identity.value
+            && row.datatype_id === identity.datatypeId
+            && row.lang === identity.lang;
+    }
+    async rowToTerm(row) {
+        switch (row.kind) {
+            case 'iri':
+                return n3_1.DataFactory.namedNode(row.value);
+            case 'blank':
+                return n3_1.DataFactory.blankNode(row.value);
+            case 'default_graph':
+                return n3_1.DataFactory.defaultGraph();
+            case 'literal': {
+                const value = row.value;
+                if (row.lang) {
+                    return n3_1.DataFactory.literal(value, row.lang);
+                }
+                if (row.datatype_id) {
+                    const datatype = await this.termForId(row.datatype_id);
+                    if (datatype.termType === 'NamedNode' && datatype.value !== XSD_STRING && datatype.value !== RDF_LANG_STRING) {
+                        return n3_1.DataFactory.literal(value, datatype);
+                    }
+                }
+                return n3_1.DataFactory.literal(value);
+            }
+            default:
+                throw new Error(`Unsupported RDF term kind in row: ${row.kind}`);
+        }
+    }
+}
+class PostgresRdfEngine {
+    constructor(options) {
+        this.executor = null;
+        this.termDictionary = null;
+        this.cacheEngine = null;
+        this.cacheDir = null;
+        this.cachePath = null;
+        this.factsDataVersion = 0;
+        this.cacheDirty = true;
+        this.initialized = false;
+        this.initializing = null;
+        this.sharedPoolConfig = null;
+        this.pglite = null;
+        this.pgPool = null;
+        this.rdf3xDataVersion = 0;
+        this.rdf3xDirty = true;
+        this.pgOptions = {
+            ...options,
+            driver: options.driver ?? (options.connectionString || options.pool ? 'pg' : 'pglite'),
+        };
+        if (options.autoOpen) {
+            void this.open();
+        }
+    }
+    async open() {
+        if (this.initialized) {
+            return;
+        }
+        this.initializing ??= Promise.resolve()
+            .then(async () => {
+            await this.openExecutor();
+            this.termDictionary = new PostgresRdfTermDictionary(this.requireExecutor());
+            await this.termDictionary.initialize();
+            await this.initializeSchema();
+            this.factsDataVersion = await this.readFactsDataVersion();
+            this.rdf3xDataVersion = await this.readRdf3xFactsDataVersion();
+            this.rdf3xDirty = this.rdf3xDataVersion !== this.factsDataVersion;
+            this.initialized = true;
+        })
+            .finally(() => {
+            this.initializing = null;
+        });
+        await this.initializing;
+    }
+    async close() {
+        if (this.initializing) {
+            await this.initializing.catch(() => { });
+        }
+        if (this.cacheEngine) {
+            await this.cacheEngine.close();
+            this.cacheEngine = null;
+        }
+        if (this.cacheDir) {
+            await (0, promises_1.rm)(this.cacheDir, { recursive: true, force: true });
+            this.cacheDir = null;
+            this.cachePath = null;
+        }
+        this.executor = null;
+        if (this.pglite) {
+            await this.pglite.close();
+            this.pglite = null;
+        }
+        if (this.pgPool) {
+            if (this.sharedPoolConfig) {
+                (0, PostgresPoolManager_1.releaseSharedPool)(this.sharedPoolConfig);
+            }
+            else {
+                await this.pgPool.end();
+            }
+            this.pgPool = null;
+            this.sharedPoolConfig = null;
+        }
+        this.termDictionary = null;
+        this.initialized = false;
+        this.cacheDirty = true;
+        this.factsDataVersion = 0;
+        this.rdf3xDataVersion = 0;
+        this.rdf3xDirty = true;
+    }
+    async put(quads, options) {
+        await this.ensureReady();
+        const quadList = Array.isArray(quads) ? quads : [quads];
+        const executor = this.requireExecutor();
+        try {
+            await executor.transaction(async (tx) => {
+                const scopedDictionary = new PostgresRdfTermDictionary(tx);
+                await scopedDictionary.initialize();
+                const sourceId = options?.source ? await this.upsertSource(options.source, tx) : null;
+                await this.insertQuads(tx, scopedDictionary, quadList, sourceId, options?.sourceLineNo ?? null);
+                await this.bumpFactsDataVersion(tx);
+            });
+            this.factsDataVersion = await this.readFactsDataVersion();
+            this.markDerivedDirty();
+        }
+        catch (error) {
+            this.cacheDirty = true;
+            throw error;
+        }
+    }
+    async replaceSource(quads, source) {
+        await this.ensureReady();
+        const executor = this.requireExecutor();
+        try {
+            await executor.transaction(async (tx) => {
+                const scopedDictionary = new PostgresRdfTermDictionary(tx);
+                await scopedDictionary.initialize();
+                const sourceId = await this.upsertSource(source, tx);
+                await tx.exec('DELETE FROM rdf_quads WHERE source_file_id = $1', [sourceId]);
+                await this.insertQuads(tx, scopedDictionary, quads, sourceId, null);
+                await this.bumpFactsDataVersion(tx);
+            });
+            this.factsDataVersion = await this.readFactsDataVersion();
+            this.markDerivedDirty();
+        }
+        catch (error) {
+            this.cacheDirty = true;
+            throw error;
+        }
+    }
+    async deleteSource(source) {
+        await this.ensureReady();
+        const executor = this.requireExecutor();
+        try {
+            const sourceRow = await this.findSourceRow(source, executor);
+            if (!sourceRow) {
+                return 0;
+            }
+            const result = await executor.transaction(async (tx) => {
+                const deleteResult = await tx.query('DELETE FROM rdf_quads WHERE source_file_id = $1 RETURNING 1', [sourceRow.id]);
+                await tx.exec('DELETE FROM rdf_sources WHERE id = $1', [sourceRow.id]);
+                await this.bumpFactsDataVersion(tx);
+                return deleteResult.length;
+            });
+            this.factsDataVersion = await this.readFactsDataVersion();
+            this.markDerivedDirty();
+            return result;
+        }
+        catch (error) {
+            this.cacheDirty = true;
+            throw error;
+        }
+    }
+    async delete(pattern) {
+        await this.ensureReady();
+        const scan = await this.scan({ pattern });
+        if (scan.quads.length === 0) {
+            return 0;
+        }
+        const executor = this.requireExecutor();
+        try {
+            await executor.transaction(async (tx) => {
+                const scopedDictionary = new PostgresRdfTermDictionary(tx);
+                await scopedDictionary.initialize();
+                for (const value of scan.quads) {
+                    await this.deleteExactQuad(tx, scopedDictionary, value);
+                }
+                await this.bumpFactsDataVersion(tx);
+            });
+            this.factsDataVersion = await this.readFactsDataVersion();
+            this.markDerivedDirty();
+            return scan.quads.length;
+        }
+        catch (error) {
+            this.cacheDirty = true;
+            throw error;
+        }
+    }
+    async applyDelta(deletes, inserts, options) {
+        await this.ensureReady();
+        if (deletes.length === 0 && inserts.length === 0) {
+            return { deletedRows: 0, insertedRows: 0 };
+        }
+        const deleteQuads = [];
+        for (const pattern of deletes) {
+            deleteQuads.push(...(await this.scan({ pattern })).quads);
+        }
+        const uniqueDeleteQuads = uniqueQuads(deleteQuads);
+        const executor = this.requireExecutor();
+        let deletedRows = 0;
+        try {
+            deletedRows = await executor.transaction(async (tx) => {
+                const scopedDictionary = new PostgresRdfTermDictionary(tx);
+                await scopedDictionary.initialize();
+                let deletedRows = 0;
+                for (const value of uniqueDeleteQuads) {
+                    const deleted = await this.deleteExactQuad(tx, scopedDictionary, value);
+                    deletedRows += deleted;
+                }
+                const sourceId = options?.source ? await this.upsertSource(options.source, tx) : null;
+                await this.insertQuads(tx, scopedDictionary, inserts, sourceId, options?.sourceLineNo ?? null);
+                if (deletedRows > 0 || inserts.length > 0) {
+                    await this.bumpFactsDataVersion(tx);
+                }
+                return deletedRows;
+            });
+            this.factsDataVersion = await this.readFactsDataVersion();
+            this.markDerivedDirty();
+            return {
+                deletedRows,
+                insertedRows: inserts.length,
+            };
+        }
+        catch (error) {
+            this.cacheDirty = true;
+            throw error;
+        }
+    }
+    async scan(query) {
+        await this.ensureReady();
+        if (!isPgRdf3xCompatiblePattern(query.pattern)) {
+            await this.ensureCacheReady();
+            const fallback = await this.requireCache().scan(query);
+            fallback.metrics.queryPlan = ['PostgresRdf3xScanFallback', ...(fallback.metrics.queryPlan ?? [])];
+            return fallback;
+        }
+        return this.scanNative(query.pattern, query.options);
+    }
+    async query(query) {
+        await this.ensureReady();
+        const native = await this.queryNative(query);
+        if (native.result) {
+            return native.result;
+        }
+        await this.ensureCacheReady();
+        const fallback = await this.requireCache().query(query);
+        fallback.metrics.plan.unshift('PostgresRdf3xFallback');
+        return fallback;
+    }
+    async refreshDerivedIndexes() {
+        await this.ensureReady();
+        const factsDataVersion = await this.readFactsDataVersion();
+        const previousFactsDataVersion = await this.readRdf3xFactsDataVersion();
+        if (previousFactsDataVersion === factsDataVersion && !this.rdf3xDirty) {
+            return {
+                derivedIndexProfile: 'rdf3x',
+                factsDataVersion,
+                rdf3x: {
+                    refreshed: false,
+                    previousFactsDataVersion,
+                    factsDataVersion,
+                    syncedWithFacts: true,
+                },
+            };
+        }
+        const rebuild = await this.rebuildRdf3xDerivedIndexes(factsDataVersion);
+        this.rdf3xDataVersion = factsDataVersion;
+        this.rdf3xDirty = false;
+        return {
+            derivedIndexProfile: 'rdf3x',
+            factsDataVersion,
+            rdf3x: {
+                refreshed: previousFactsDataVersion !== factsDataVersion,
+                previousFactsDataVersion,
+                factsDataVersion,
+                syncedWithFacts: true,
+                rebuild,
+            },
+        };
+    }
+    async storageStats() {
+        await this.ensureReady();
+        const facts = await this.factsStats();
+        const rdf3x = await this.rdf3xStats();
+        const factsBytes = facts.databaseBytes;
+        const derivedBytes = rdf3x.databaseBytes;
+        const totalBytes = factsBytes + derivedBytes;
+        return {
+            derivedIndexProfile: 'rdf3x',
+            facts,
+            rdf3x: {
+                stats: rdf3x,
+                syncedWithFacts: rdf3x.factsDataVersion === await this.readFactsDataVersion(),
+            },
+            factsBytes,
+            derivedBytes,
+            totalBytes,
+            derivedToFactsRatio: factsBytes === 0 ? 0 : derivedBytes / factsBytes,
+            totalToFactsRatio: factsBytes === 0 ? 0 : totalBytes / factsBytes,
+        };
+    }
+    async initializeSchema() {
+        const executor = this.requireExecutor();
+        await this.ensureCompatibleSchemaVersion(executor);
+        await executor.exec(`
+      CREATE TABLE IF NOT EXISTS rdf_sources (
+        id BIGSERIAL PRIMARY KEY,
+        source TEXT NOT NULL UNIQUE,
+        workspace TEXT NOT NULL,
+        local_path TEXT,
+        content_type TEXT,
+        last_indexed_at TIMESTAMPTZ,
+        source_version TEXT
+      )
+    `);
+        await executor.exec(`
+      CREATE TABLE IF NOT EXISTS rdf_quads (
+        graph_id BIGINT NOT NULL,
+        subject_id BIGINT NOT NULL,
+        predicate_id BIGINT NOT NULL,
+        object_id BIGINT NOT NULL,
+        source_file_id BIGINT,
+        source_line_no BIGINT,
+        PRIMARY KEY (graph_id, subject_id, predicate_id, object_id)
+      )
+    `);
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_spog ON rdf_quads (subject_id, predicate_id, object_id, graph_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_sopg ON rdf_quads (subject_id, object_id, predicate_id, graph_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_psog ON rdf_quads (predicate_id, subject_id, object_id, graph_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_posg ON rdf_quads (predicate_id, object_id, subject_id, graph_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_ospg ON rdf_quads (object_id, subject_id, predicate_id, graph_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_opsg ON rdf_quads (object_id, predicate_id, subject_id, graph_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_gspo ON rdf_quads (graph_id, subject_id, predicate_id, object_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_gpos ON rdf_quads (graph_id, predicate_id, object_id, subject_id)');
+        await executor.exec('CREATE INDEX IF NOT EXISTS rdf_quads_source ON rdf_quads (source_file_id, source_line_no)');
+        await executor.exec(`
+      CREATE TABLE IF NOT EXISTS rdf_index_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        await executor.exec(`
+      INSERT INTO rdf_index_metadata (key, value)
+      VALUES ('schema_version', '${POSTGRES_RDF_SCHEMA_VERSION}')
+      ON CONFLICT (key) DO NOTHING
+    `);
+        await executor.exec(`
+      INSERT INTO rdf_index_metadata (key, value)
+      VALUES ('data_version', '0')
+      ON CONFLICT (key) DO NOTHING
+    `);
+        await this.initializeRdf3xSchema(executor);
+    }
+    async ensureCompatibleSchemaVersion(executor) {
+        await executor.exec(`
+      CREATE TABLE IF NOT EXISTS rdf_index_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        const row = await executor.query("SELECT value FROM rdf_index_metadata WHERE key = 'schema_version'");
+        const version = row[0]?.value;
+        if (version === undefined || version === String(POSTGRES_RDF_SCHEMA_VERSION)) {
+            return;
+        }
+        await executor.transaction(async (tx) => {
+            await tx.exec('DROP TABLE IF EXISTS rdf_quads');
+            await tx.exec('DROP TABLE IF EXISTS rdf_sources');
+            await tx.exec('DROP TABLE IF EXISTS rdf_terms');
+            await tx.exec('DELETE FROM rdf_index_metadata');
+            await tx.exec("INSERT INTO rdf_index_metadata (key, value) VALUES ('schema_version', $1)", [String(POSTGRES_RDF_SCHEMA_VERSION)]);
+            await tx.exec("INSERT INTO rdf_index_metadata (key, value) VALUES ('data_version', '0')");
+        });
+    }
+    async initializeRdf3xSchema(executor) {
+        await executor.exec(`
+      CREATE TABLE IF NOT EXISTS rdf3x_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      )
+    `);
+        const row = await executor.query("SELECT value FROM rdf3x_metadata WHERE key = 'schema_version'");
+        const version = row[0]?.value;
+        if (version !== undefined && version !== String(POSTGRES_RDF3X_SCHEMA_VERSION)) {
+            await this.dropRdf3xDerivedSchema(executor);
+        }
+        await executor.exec(`
+      CREATE TABLE IF NOT EXISTS ${Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE} (
+        graph_id BIGINT PRIMARY KEY,
+        membership_count BIGINT NOT NULL
+      )
+    `);
+        for (const projection of PAIR_PROJECTIONS) {
+            await executor.exec(`
+        CREATE TABLE IF NOT EXISTS ${projection.table} (
+          ${projection.columns[0]} BIGINT NOT NULL,
+          ${projection.columns[1]} BIGINT NOT NULL,
+          triple_count BIGINT NOT NULL,
+          membership_count BIGINT NOT NULL,
+          min_${projection.remainder} BIGINT,
+          max_${projection.remainder} BIGINT,
+          PRIMARY KEY (${projection.columns.join(', ')})
+        )
+      `);
+        }
+        for (const projection of TERM_PROJECTIONS) {
+            await executor.exec(`
+        CREATE TABLE IF NOT EXISTS ${projection.table} (
+          ${projection.column} BIGINT PRIMARY KEY,
+          triple_count BIGINT NOT NULL,
+          membership_count BIGINT NOT NULL
+        )
+      `);
+        }
+        await executor.exec(`
+      INSERT INTO rdf3x_metadata (key, value)
+      VALUES ('schema_version', $1)
+      ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value
+    `, [String(POSTGRES_RDF3X_SCHEMA_VERSION)]);
+        await executor.exec(`
+      INSERT INTO rdf3x_metadata (key, value)
+      VALUES ('facts_data_version', '0')
+      ON CONFLICT (key) DO NOTHING
+    `);
+    }
+    async dropRdf3xDerivedSchema(executor) {
+        for (const table of [
+            ...PAIR_PROJECTIONS.map((projection) => projection.table),
+            ...TERM_PROJECTIONS.map((projection) => projection.table),
+            Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE,
+        ]) {
+            await executor.exec(`DROP TABLE IF EXISTS ${table}`);
+        }
+        await executor.exec('DELETE FROM rdf3x_metadata');
+    }
+    async clearRdf3xDerivedTables(executor) {
+        for (const projection of PAIR_PROJECTIONS) {
+            await executor.exec(`DELETE FROM ${projection.table}`);
+        }
+        for (const projection of TERM_PROJECTIONS) {
+            await executor.exec(`DELETE FROM ${projection.table}`);
+        }
+        await executor.exec(`DELETE FROM ${Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE}`);
+    }
+    async rebuildRdf3xDerivedIndexes(factsDataVersion) {
+        const start = Date.now();
+        const executor = this.requireExecutor();
+        const scannedQuads = await this.scalarCount(`SELECT COUNT(*) AS count FROM ${RDF_FACTS_TABLE}`);
+        await executor.transaction(async (tx) => {
+            await this.clearRdf3xDerivedTables(tx);
+            for (const projection of PAIR_PROJECTIONS) {
+                await tx.exec(`
+          INSERT INTO ${projection.table} (
+            ${projection.columns[0]},
+            ${projection.columns[1]},
+            triple_count,
+            membership_count,
+            min_${projection.remainder},
+            max_${projection.remainder}
+          )
+          SELECT
+            triple.${projection.columns[0]},
+            triple.${projection.columns[1]},
+            triple.triple_count,
+            COALESCE(member.membership_count, 0) AS membership_count,
+            triple.min_remainder,
+            triple.max_remainder
+          FROM (
+            SELECT
+              ${projection.columns[0]},
+              ${projection.columns[1]},
+              COUNT(DISTINCT ${projection.remainder}) AS triple_count,
+              MIN(${projection.remainder}) AS min_remainder,
+              MAX(${projection.remainder}) AS max_remainder
+            FROM ${RDF_FACTS_TABLE}
+            GROUP BY ${projection.columns[0]}, ${projection.columns[1]}
+          ) triple
+          LEFT JOIN (
+            SELECT
+              ${projection.columns[0]},
+              ${projection.columns[1]},
+              COUNT(*) AS membership_count
+            FROM ${RDF_FACTS_TABLE}
+            GROUP BY ${projection.columns[0]}, ${projection.columns[1]}
+          ) member
+            ON member.${projection.columns[0]} = triple.${projection.columns[0]}
+           AND member.${projection.columns[1]} = triple.${projection.columns[1]}
+        `);
+            }
+            for (const projection of TERM_PROJECTIONS) {
+                await tx.exec(`
+          INSERT INTO ${projection.table} (
+            ${projection.column},
+            triple_count,
+            membership_count
+          )
+          SELECT
+            triple.${projection.column},
+            triple.triple_count,
+            COALESCE(member.membership_count, 0) AS membership_count
+          FROM (
+            SELECT
+              ${projection.column},
+              COUNT(*) AS triple_count
+            FROM (
+              SELECT DISTINCT subject_id, predicate_id, object_id
+              FROM ${RDF_FACTS_TABLE}
+            ) distinct_triples
+            GROUP BY ${projection.column}
+          ) triple
+          LEFT JOIN (
+            SELECT
+              ${projection.column},
+              COUNT(*) AS membership_count
+            FROM ${RDF_FACTS_TABLE}
+            GROUP BY ${projection.column}
+          ) member
+            ON member.${projection.column} = triple.${projection.column}
+        `);
+            }
+            await tx.exec(`
+        INSERT INTO ${Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE} (
+          graph_id,
+          membership_count
+        )
+        SELECT graph_id, COUNT(*) AS membership_count
+        FROM ${RDF_FACTS_TABLE}
+        GROUP BY graph_id
+      `);
+            await tx.exec(`
+        INSERT INTO rdf3x_metadata (key, value)
+        VALUES ('facts_data_version', $1)
+        ON CONFLICT (key) DO UPDATE SET value = EXCLUDED.value
+      `, [String(factsDataVersion)]);
+        });
+        const stats = await this.rdf3xStats();
+        return {
+            scannedQuads,
+            uniqueTriples: stats.uniqueTriples,
+            memberships: stats.membershipCount,
+            projectionRows: pairProjectionRowTotal(stats.pairProjectionRows) + termProjectionRowTotal(stats.termProjectionRows),
+            factsDataVersion,
+            durationMs: Date.now() - start,
+        };
+    }
+    async scanNative(pattern, options) {
+        const start = Date.now();
+        const resolved = await this.resolvePattern(pattern);
+        if (resolved.unresolved) {
+            return {
+                quads: [],
+                metrics: this.indexMetrics('none', 0, 0, start, [`unresolved ${resolved.unresolved}`]),
+            };
+        }
+        const compiled = this.compileScanSql(resolved, options);
+        const matchedRows = await this.scalarCount(compiled.countSql, compiled.countParams);
+        const rows = await this.requireExecutor().query(compiled.sql, compiled.params);
+        return {
+            quads: await this.rowsToQuads(rows),
+            metrics: this.indexMetrics(compiled.indexChoice, matchedRows, rows.length, start, [
+                ...compiled.queryPlan,
+                compiled.sql,
+            ]),
+        };
+    }
+    async queryNative(query) {
+        if (!this.canTryNativeQuery(query)) {
+            return { unsupported: true };
+        }
+        const start = Date.now();
+        const aggregates = queryAggregates(query);
+        const requiredPatterns = query.patterns.length > 0 ? query.patterns : [{}];
+        const compiledPatterns = await this.compileNativeJoinPatterns(requiredPatterns, query.filters ?? []);
+        if (!compiledPatterns) {
+            return { unsupported: true };
+        }
+        if (!this.allFiltersPushed(query.filters ?? [], compiledPatterns)) {
+            return { unsupported: true };
+        }
+        if (aggregates.length > 0) {
+            if (!query.patterns.length) {
+                return { unsupported: true };
+            }
+            const aggregateResult = await this.queryNativeAggregate(query, compiledPatterns, aggregates, start);
+            return aggregateResult ? { result: aggregateResult } : { unsupported: true };
+        }
+        const visibleVariables = uniqueStrings(requiredPatterns.flatMap((pattern) => variablesInPattern(pattern)));
+        const project = query.select && query.select.length > 0 ? query.select : visibleVariables;
+        if (project.some((variableName) => !visibleVariables.includes(variableName))) {
+            return { unsupported: true };
+        }
+        if ((query.orderBy ?? []).some((entry) => !visibleVariables.includes(entry.variable))) {
+            return { unsupported: true };
+        }
+        const compiled = await this.compileJoinSql(compiledPatterns, {
+            project,
+            distinct: query.distinct,
+            orderBy: query.orderBy,
+            limit: query.limit,
+            offset: query.offset,
+            countMatchedRows: query.limit !== undefined || query.offset !== undefined,
+        });
+        if (compiled.unresolved) {
+            return {
+                result: {
+                    bindings: [],
+                    metrics: this.localMetrics(start, 0, 0, 0, [compiled.indexChoice], [
+                        ...compiled.queryPlan,
+                        `unresolved ${compiled.unresolved}`,
+                    ], query.filters?.length ?? 0),
+                },
+            };
+        }
+        const rows = await this.requireExecutor().query(compiled.sql, compiled.params);
+        const matchedRows = compiled.countSql
+            ? await this.scalarCount(compiled.countSql, compiled.countParams)
+            : rows.length;
+        const bindings = await this.joinRowsToBindings(rows, compiled.variableAliases);
+        const plan = [
+            ...storagePlanMarkers(compiled.queryPlan),
+            `PostgresRdf3xJoin(${compiledPatterns.map((entry) => describePatternSource(entry)).join('|')})`,
+            ...(query.distinct ? [`PostgresRdf3xJoinDistinct(${project.map((variableName) => `?${variableName}`).join(',')})`] : []),
+            ...(query.limit !== undefined || query.offset !== undefined ? ['PostgresRdf3xJoinLimit'] : []),
+        ];
+        return {
+            result: {
+                bindings,
+                metrics: this.localMetrics(start, matchedRows, matchedRows, bindings.length, [compiled.indexChoice], plan, query.filters?.length ?? 0),
+            },
+        };
+    }
+    async queryNativeAggregate(query, patterns, aggregates, start) {
+        if (!this.canNativeAggregate(query, aggregates)) {
+            return undefined;
+        }
+        const visibleVariables = uniqueStrings(query.patterns.flatMap((pattern) => variablesInPattern(pattern)));
+        const compiled = await this.compileJoinSql(patterns, {
+            project: visibleVariables,
+            countMatchedRows: false,
+        });
+        if (compiled.unresolved) {
+            return {
+                bindings: [],
+                count: 0,
+                metrics: this.localMetrics(start, 0, 0, 0, [compiled.indexChoice], [
+                    ...compiled.queryPlan,
+                    `unresolved ${compiled.unresolved}`,
+                ], query.filters?.length ?? 0),
+            };
+        }
+        const aggregateAliases = new Map();
+        const aggregateTypes = new Map();
+        const aggregateColumns = aggregates.map((aggregate, index) => this.compileAggregateColumn(aggregate, index, compiled.variableAliases, aggregateAliases, aggregateTypes));
+        const groupColumns = (query.groupBy ?? []).map((variableName) => {
+            const alias = compiled.variableAliases.get(variableName);
+            if (!alias) {
+                throw new Error(`Postgres RDF-3X group aggregate cannot read unbound variable: ${variableName}`);
+            }
+            return { variableName, alias, column: `source.${alias}` };
+        });
+        const projection = [
+            ...groupColumns.map((group) => `${group.column} AS ${group.alias}`),
+            ...aggregateColumns.map((aggregate) => aggregate.sql),
+        ].filter(Boolean).join(', ');
+        let sql = `SELECT ${projection} FROM (${compiled.sql}) source`;
+        if (groupColumns.length > 0) {
+            sql += ` GROUP BY ${groupColumns.map((group) => group.column).join(', ')}`;
+        }
+        const builder = new PgSqlBuilder(compiled.params);
+        const havingClause = this.buildAggregateHavingClause(query.having ?? [], aggregateColumns, builder);
+        sql += havingClause.sql;
+        sql += this.buildAggregateOrderClause(query.orderBy ?? [], compiled.variableAliases, aggregateColumns);
+        const pagination = this.buildPagination(query, builder);
+        sql += pagination.sql;
+        const params = builder.snapshot();
+        const rows = await this.requireExecutor().query(sql, params);
+        const matchedRows = groupColumns.length > 0
+            ? await this.scalarCount(`SELECT COUNT(*) AS count FROM (
+            SELECT ${groupColumns.map((group) => group.column).join(', ')}
+            FROM (${compiled.sql}) source
+            GROUP BY ${groupColumns.map((group) => group.column).join(', ')}
+            ${havingClause.sql}
+          ) grouped_count`, builder.snapshot().slice(0, builder.snapshot().length - pagination.paramCount))
+            : rows.length;
+        const bindings = await this.joinRowsToBindings(rows, new Map(groupColumns.map((group) => [group.variableName, group.alias])), aggregateAliases, aggregateTypes);
+        const firstCount = !groupColumns.length && aggregates[0] ? Number(bindings[0]?.[aggregates[0].as]?.value ?? 0) : undefined;
+        const plan = [
+            ...storagePlanMarkers(compiled.queryPlan),
+            groupColumns.length > 0 ? 'PostgresRdf3xGroupCount' : 'PostgresRdf3xJoinCount',
+            aggregatePlan(aggregates, groupColumns.length > 0),
+            ...(havingClause.sql ? [`PostgresRdf3xAggregateHaving(${(query.having ?? []).map(describeFilter).join(',')})`] : []),
+            ...((query.orderBy ?? []).length > 0 ? [`PostgresRdf3xAggregateOrder(${describeQueryOrder(query.orderBy ?? [])})`] : []),
+            ...(pagination.sql ? ['PostgresRdf3xAggregateLimit'] : []),
+        ];
+        return {
+            bindings,
+            ...(firstCount !== undefined ? { count: firstCount } : {}),
+            metrics: this.localMetrics(start, matchedRows, matchedRows, bindings.length, [compiled.indexChoice], plan, query.filters?.length ?? 0),
+        };
+    }
+    canNativeAggregate(query, aggregates) {
+        if (aggregates.length === 0 || aggregates.some((aggregate) => aggregate.type !== 'count')) {
+            return false;
+        }
+        const visibleVariables = uniqueStrings(query.patterns.flatMap((pattern) => variablesInPattern(pattern)));
+        const aggregateVariables = new Set(aggregates.map((aggregate) => aggregate.as));
+        if ((query.groupBy ?? []).some((variableName) => !visibleVariables.includes(variableName))) {
+            return false;
+        }
+        if (aggregates.some((aggregate) => (aggregate.variable !== undefined && !visibleVariables.includes(aggregate.variable)))) {
+            return false;
+        }
+        if (aggregates.some((aggregate) => (aggregate.distinctVariables !== undefined
+            && aggregate.distinctVariables.some((variableName) => !visibleVariables.includes(variableName))))) {
+            return false;
+        }
+        if ((query.having ?? []).some((filter) => !this.canNativeAggregateHaving(filter, aggregateVariables))) {
+            return false;
+        }
+        if ((query.orderBy ?? []).some((entry) => (!visibleVariables.includes(entry.variable) && !aggregateVariables.has(entry.variable)))) {
+            return false;
+        }
+        if ((query.groupBy ?? []).length === 0) {
+            return !query.distinct
+                && (query.having ?? []).length === 0
+                && (query.orderBy ?? []).length === 0
+                && query.limit === undefined
+                && query.offset === undefined
+                && (query.select ?? []).every((variableName) => aggregateVariables.has(variableName));
+        }
+        return !query.distinct && (query.orderBy ?? []).every((entry) => ((query.groupBy ?? []).includes(entry.variable) || aggregateVariables.has(entry.variable))) && (query.select ?? []).every((variableName) => ((query.groupBy ?? []).includes(variableName) || aggregateVariables.has(variableName)));
+    }
+    canNativeAggregateHaving(filter, aggregateVariables) {
+        return aggregateVariables.has(filter.variable)
+            && !filter.operand
+            && !filter.variable2
+            && filter.value !== undefined
+            && isNativeAggregateHavingOperator(filter.operator)
+            && typeof filter.value !== 'boolean'
+            && this.aggregateFilterValue(filter.value) !== undefined;
+    }
+    compileAggregateColumn(aggregate, index, variableAliases, aggregateAliases, aggregateTypes) {
+        const alias = `a${index}`;
+        aggregateAliases.set(aggregate.as, alias);
+        aggregateTypes.set(aggregate.as, 'integer');
+        if (!aggregate.variable) {
+            const expression = aggregate.distinct
+                ? `COUNT(DISTINCT ${joinSolutionMappingKeyExpression(variableAliases, aggregate.distinctVariables)})`
+                : 'COUNT(*)';
+            return {
+                variableName: aggregate.as,
+                alias,
+                type: 'integer',
+                expression,
+                sql: `${expression} AS ${alias}`,
+            };
+        }
+        const variableAlias = variableAliases.get(aggregate.variable);
+        if (!variableAlias) {
+            throw new Error(`Postgres RDF-3X aggregate cannot read unbound variable: ${aggregate.variable}`);
+        }
+        const expression = `COUNT(${aggregate.distinct ? 'DISTINCT ' : ''}source.${variableAlias})`;
+        return {
+            variableName: aggregate.as,
+            alias,
+            type: 'integer',
+            expression,
+            sql: `${expression} AS ${alias}`,
+        };
+    }
+    buildAggregateHavingClause(filters, aggregates, builder) {
+        if (filters.length === 0) {
+            return { sql: '' };
+        }
+        return {
+            sql: ` HAVING ${filters.map((filter) => {
+                const aggregate = aggregates.find((entry) => entry.variableName === filter.variable);
+                if (!aggregate) {
+                    throw new Error(`Postgres RDF-3X aggregate cannot HAVING on unknown aggregate: ${filter.variable}`);
+                }
+                return `${aggregate.expression} ${aggregateSqlOperator(filter.operator)} ${builder.add(this.aggregateFilterValue(filter.value))}`;
+            }).join(' AND ')}`,
+        };
+    }
+    buildAggregateOrderClause(orderBy, variableAliases, aggregates) {
+        if (orderBy.length === 0) {
+            return '';
+        }
+        const order = orderBy.map((entry) => {
+            const aggregate = aggregates.find((candidate) => candidate.variableName === entry.variable);
+            if (aggregate) {
+                return `${aggregate.alias} ${entry.direction === 'desc' ? 'DESC' : 'ASC'}`;
+            }
+            const alias = variableAliases.get(entry.variable);
+            if (!alias) {
+                throw new Error(`Postgres RDF-3X aggregate cannot order by unbound variable: ${entry.variable}`);
+            }
+            return `source.${alias} ${entry.direction === 'desc' ? 'DESC' : 'ASC'}`;
+        });
+        return ` ORDER BY ${order.join(', ')}`;
+    }
+    aggregateFilterValue(value) {
+        if (typeof value === 'number')
+            return Number.isFinite(value) ? value : undefined;
+        if (typeof value === 'string') {
+            const numeric = Number(value);
+            return Number.isFinite(numeric) ? numeric : undefined;
+        }
+        if (value && typeof value === 'object' && 'termType' in value) {
+            const numeric = (0, RdfTermSemantics_1.rdfNumericValue)(value.value);
+            return Number.isFinite(numeric) ? numeric : undefined;
+        }
+        return undefined;
+    }
+    canTryNativeQuery(query) {
+        return (query.values?.length ?? 0) === 0
+            && (query.textSearch?.length ?? 0) === 0
+            && (query.vectorSearch?.length ?? 0) === 0
+            && (query.unions?.length ?? 0) === 0
+            && (query.minus?.length ?? 0) === 0
+            && (query.exists?.length ?? 0) === 0
+            && (query.optional?.length ?? 0) === 0
+            && (query.binds?.length ?? 0) === 0;
+    }
+    async compileNativeJoinPatterns(patterns, filters) {
+        const result = [];
+        for (const pattern of patterns) {
+            const compiled = {};
+            const variables = {};
+            const slotsByVariable = new Map();
+            const pushed = new Set();
+            for (const key of PATTERN_KEYS) {
+                const value = pattern[key];
+                if (!value)
+                    continue;
+                if (isVariable(value)) {
+                    variables[key] = value.variable;
+                    slotsByVariable.set(value.variable, [...(slotsByVariable.get(value.variable) ?? []), key]);
+                    const pushdown = this.compilePushdownFilterWithIndexes(value.variable, filters);
+                    if (pushdown) {
+                        compiled[key] = pushdown.pattern;
+                        pushdown.filterIndexes.forEach((index) => pushed.add(index));
+                    }
+                }
+                else {
+                    compiled[key] = value;
+                }
+            }
+            result.push({
+                pattern: compiled,
+                variables,
+                equalities: patternEqualities(slotsByVariable),
+                pushedDownFilterIndexes: [...pushed],
+            });
+        }
+        return result;
+    }
+    allFiltersPushed(filters, patterns) {
+        const pushed = new Set(patterns.flatMap((pattern) => pattern.pushedDownFilterIndexes));
+        return filters.every((_filter, index) => pushed.has(index));
+    }
+    compilePushdownFilterWithIndexes(variableName, filters) {
+        const operators = {};
+        const filterIndexes = [];
+        for (const [index, filter] of filters.entries()) {
+            if (filter.variable !== variableName || filter.variable2 || !this.isPushdownFilter(filter)) {
+                continue;
+            }
+            switch (filter.operator) {
+                case '$eq':
+                case '$ne':
+                    if (filter.value === undefined || !(0, types_1.isTerm)(filter.value))
+                        return null;
+                    operators[filter.operator] = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$gt':
+                case '$gte':
+                case '$lt':
+                case '$lte':
+                    if (filter.value === undefined)
+                        return null;
+                    operators[filter.operator] = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$in':
+                case '$notIn':
+                    if (!filter.values?.length || filter.values.some((value) => !(0, types_1.isTerm)(value)))
+                        return null;
+                    operators[filter.operator] = filter.values;
+                    filterIndexes.push(index);
+                    break;
+                case '$sameTerm':
+                    if (filter.value === undefined || !(0, types_1.isTerm)(filter.value))
+                        return null;
+                    operators.$eq = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$termType':
+                    if (typeof filter.value !== 'string' || !['iri', 'blank', 'literal', 'numeric'].includes(filter.value))
+                        return null;
+                    operators.$termType = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$lang':
+                    if (typeof filter.value !== 'string')
+                        return null;
+                    operators.$language = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$notLang':
+                    if (typeof filter.value !== 'string')
+                        return null;
+                    operators.$notLanguage = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$langMatches':
+                    if (typeof filter.value !== 'string')
+                        return null;
+                    operators.$langMatches = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$datatype':
+                case '$notDatatype':
+                    if (filter.value === undefined || !(0, types_1.isTerm)(filter.value) || filter.value.termType !== 'NamedNode')
+                        return null;
+                    operators[filter.operator] = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$startsWith':
+                    if (typeof filter.value !== 'string')
+                        return null;
+                    operators.$startsWith = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                case '$contains':
+                case '$endsWith':
+                    if (typeof filter.value !== 'string')
+                        return null;
+                    operators[filter.operator] = filter.value;
+                    filterIndexes.push(index);
+                    break;
+                default:
+                    return null;
+            }
+        }
+        return Object.keys(operators).length > 0 ? { pattern: operators, filterIndexes } : null;
+    }
+    isPushdownFilter(filter) {
+        if (filter.operand === 'stringLength' || filter.operand === 'lowerStringValue' || filter.operand === 'upperStringValue') {
+            return false;
+        }
+        if (filter.operand === 'stringValue') {
+            return filter.operator === '$startsWith'
+                || filter.operator === '$contains'
+                || filter.operator === '$endsWith';
+        }
+        return filter.operator === '$eq'
+            || filter.operator === '$ne'
+            || filter.operator === '$gt'
+            || filter.operator === '$gte'
+            || filter.operator === '$lt'
+            || filter.operator === '$lte'
+            || filter.operator === '$in'
+            || filter.operator === '$notIn'
+            || filter.operator === '$startsWith'
+            || filter.operator === '$contains'
+            || filter.operator === '$endsWith'
+            || filter.operator === '$sameTerm'
+            || filter.operator === '$termType'
+            || filter.operator === '$lang'
+            || filter.operator === '$notLang'
+            || filter.operator === '$langMatches'
+            || filter.operator === '$datatype'
+            || filter.operator === '$notDatatype';
+    }
+    async resolvePattern(pattern) {
+        const ids = {};
+        const idSets = {};
+        const excludedIdSets = {};
+        const termFilters = {};
+        let graphPrefix;
+        let objectRange;
+        for (const key of PATTERN_KEYS) {
+            const value = pattern[key];
+            if (!value) {
+                continue;
+            }
+            if ((0, types_1.isTerm)(value)) {
+                const id = await this.requireDictionary().find(value);
+                if (id === undefined) {
+                    return { ids, idSets, excludedIdSets, termFilters, unresolved: key };
+                }
+                ids[key] = id;
+                continue;
+            }
+            const operators = value;
+            if (operators.$eq !== undefined) {
+                const id = await this.termOperatorValueId(operators.$eq);
+                if (id === undefined)
+                    return { ids, idSets, excludedIdSets, termFilters, unresolved: key };
+                ids[key] = id;
+            }
+            if (operators.$in !== undefined) {
+                const set = uniqueNumbers((await Promise.all(operators.$in.map((entry) => this.termOperatorValueId(entry))))
+                    .filter((id) => id !== undefined));
+                if (set.length === 0)
+                    return { ids, idSets, excludedIdSets, termFilters, unresolved: key };
+                idSets[key] = set;
+            }
+            if (operators.$notIn !== undefined) {
+                const set = uniqueNumbers((await Promise.all(operators.$notIn.map((entry) => this.termOperatorValueId(entry))))
+                    .filter((id) => id !== undefined));
+                if (set.length > 0)
+                    excludedIdSets[key] = set;
+            }
+            if (operators.$ne !== undefined) {
+                const id = await this.termOperatorValueId(operators.$ne);
+                if (id !== undefined)
+                    excludedIdSets[key] = uniqueNumbers([...(excludedIdSets[key] ?? []), id]);
+            }
+            if (key === 'graph' && operators.$startsWith !== undefined) {
+                graphPrefix = operators.$startsWith;
+            }
+            const filter = await this.resolveTermFilter(key, operators);
+            if (filter)
+                termFilters[key] = filter;
+            if (key === 'object') {
+                objectRange = this.resolveObjectRange(operators);
+            }
+        }
+        return { ids, idSets, excludedIdSets, termFilters, ...(graphPrefix !== undefined ? { graphPrefix } : {}), ...(objectRange ? { objectRange } : {}) };
+    }
+    async resolveTermFilter(key, operators) {
+        const filter = {};
+        if (operators.$termType !== undefined)
+            filter.termType = operators.$termType;
+        if (operators.$language !== undefined)
+            filter.language = operators.$language;
+        if (operators.$notLanguage !== undefined)
+            filter.notLanguage = operators.$notLanguage;
+        if (operators.$langMatches !== undefined)
+            filter.langMatches = operators.$langMatches;
+        if (operators.$datatype !== undefined)
+            filter.datatype = await this.resolveDatatypeFilter(operators.$datatype);
+        if (operators.$notDatatype !== undefined)
+            filter.notDatatype = await this.resolveDatatypeFilter(operators.$notDatatype);
+        if (key === 'object') {
+            const textSearches = [];
+            if (operators.$contains !== undefined)
+                textSearches.push({ operator: '$contains', value: operators.$contains });
+            if (operators.$endsWith !== undefined)
+                textSearches.push({ operator: '$endsWith', value: operators.$endsWith });
+            if (textSearches.length > 0)
+                filter.textSearches = textSearches;
+        }
+        return Object.keys(filter).length > 0 ? filter : undefined;
+    }
+    async resolveDatatypeFilter(datatype) {
+        if (datatype.termType !== 'NamedNode') {
+            return { kind: 'unknown' };
+        }
+        if (datatype.value === XSD_STRING) {
+            return { kind: 'xsd-string' };
+        }
+        const id = await this.requireDictionary().find(datatype);
+        return id === undefined ? { kind: 'unknown' } : { kind: 'id', id };
+    }
+    resolveObjectRange(match) {
+        const numericRange = { mode: 'numeric' };
+        const lexicalRange = { mode: 'lexical' };
+        let hasRange = false;
+        let allNumeric = true;
+        for (const [operator, inclusive] of [
+            ['$gt', false],
+            ['$gte', true],
+            ['$lt', false],
+            ['$lte', true],
+        ]) {
+            const value = match[operator];
+            if (value === undefined)
+                continue;
+            hasRange = true;
+            const numericValue = this.numericValueForPattern(value);
+            const lexicalValue = this.lexicalValueForPattern(value);
+            allNumeric = allNumeric && numericValue !== undefined;
+            if (lexicalValue === undefined)
+                return undefined;
+            if (operator === '$gt' || operator === '$gte') {
+                if (numericValue !== undefined)
+                    numericRange.min = numericValue;
+                numericRange.minInclusive = inclusive;
+                lexicalRange.min = lexicalValue;
+                lexicalRange.minInclusive = inclusive;
+            }
+            else {
+                if (numericValue !== undefined)
+                    numericRange.max = numericValue;
+                numericRange.maxInclusive = inclusive;
+                lexicalRange.max = lexicalValue;
+                lexicalRange.maxInclusive = inclusive;
+            }
+        }
+        if (!hasRange)
+            return undefined;
+        return allNumeric ? numericRange : lexicalRange;
+    }
+    numericValueForPattern(value) {
+        if (typeof value === 'number')
+            return Number.isFinite(value) ? value : undefined;
+        if (typeof value === 'string') {
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : undefined;
+        }
+        if (value.termType !== 'Literal' || !(0, RdfTermSemantics_1.isRdfNumericDatatype)(value.datatype.value))
+            return undefined;
+        const parsed = (0, RdfTermSemantics_1.rdfNumericValue)(value.value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    lexicalValueForPattern(value) {
+        if (typeof value === 'number')
+            return Number.isFinite(value) ? String(value) : undefined;
+        if (typeof value === 'string')
+            return value;
+        return value.value;
+    }
+    async termOperatorValueId(value) {
+        if (!value || typeof value !== 'object' || !('termType' in value)) {
+            throw new Error('PostgresRdfEngine exact operators only support RDF terms');
+        }
+        return this.requireDictionary().find(value);
+    }
+    compileScanSql(resolved, options) {
+        const builder = new PgSqlBuilder();
+        const conditions = [];
+        const joins = [];
+        const queryPlan = [];
+        const useMembershipSource = shouldUseMembershipSource(resolved);
+        const permutation = this.choosePermutation(resolved);
+        const alias = 'q';
+        this.appendResolvedPatternConditions(resolved, alias, conditions, joins, builder, queryPlan);
+        const order = this.buildOrderClause(options, alias);
+        const pagination = this.buildPagination(options, builder);
+        const from = `${RDF_FACTS_TABLE} ${alias}`;
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        return {
+            sql: `
+        SELECT ${alias}.graph_id, ${alias}.subject_id, ${alias}.predicate_id, ${alias}.object_id
+        FROM ${from}${joins.join('')}
+        ${whereClause}
+        ${order || ` ORDER BY ${permutation.columns.map((column) => `${alias}.${column}`).join(', ')}`}
+        ${pagination.sql}
+      `,
+            params: builder.snapshot(),
+            countSql: `SELECT COUNT(*) AS count FROM ${from}${joins.join('')}${whereClause}`,
+            countParams: builder.snapshot().slice(0, builder.snapshot().length - pagination.paramCount),
+            indexChoice: useMembershipSource ? 'source-membership' : permutation.name,
+            queryPlan: [
+                ...(useMembershipSource ? ['Rdf3xMembershipScan'] : [`Rdf3xPermutationScan(${permutation.name})`]),
+                ...queryPlan,
+                ...(order ? [`Rdf3xJoinOrder(${describeScanOrder(options)})`] : []),
+                ...(pagination.sql ? ['Pagination'] : []),
+            ],
+        };
+    }
+    async compileJoinSql(patterns, options) {
+        const resolvedSources = [];
+        for (const [inputIndex, entry] of patterns.entries()) {
+            const resolved = await this.resolvePattern(entry.pattern);
+            const permutation = this.choosePermutation(resolved);
+            const estimateRows = resolved.unresolved ? 0 : await this.estimateResolvedRows(resolved);
+            resolvedSources.push({
+                inputIndex,
+                alias: `q${inputIndex}`,
+                entry,
+                resolved,
+                permutation,
+                estimateRows,
+            });
+        }
+        const orderedSources = this.orderJoinSources(resolvedSources);
+        const builder = new PgSqlBuilder();
+        const conditions = [];
+        const joins = [];
+        const queryPlan = [
+            `Rdf3xJoinBGP(${patterns.length})`,
+            `Rdf3xJoinOrder(${orderedSources.map((source) => `?${source.inputIndex}:${source.estimateRows}`).join('>')})`,
+        ];
+        const variableColumns = new Map();
+        const variableAliases = new Map();
+        const indexChoices = [];
+        for (const [position, source] of orderedSources.entries()) {
+            if (source.resolved.unresolved) {
+                return {
+                    sql: '',
+                    params: [],
+                    countParams: [],
+                    indexChoice: 'none',
+                    queryPlan,
+                    variableAliases,
+                    unresolved: source.resolved.unresolved,
+                };
+            }
+            const alias = source.alias;
+            if (position === 0) {
+                joins.push(`${RDF_FACTS_TABLE} ${alias}`);
+            }
+            else {
+                const mergeConditions = this.mergeJoinConditions(source, variableColumns);
+                joins.push(` JOIN ${RDF_FACTS_TABLE} ${alias} ON ${mergeConditions.length > 0 ? mergeConditions.join(' AND ') : '1 = 1'}`);
+                if (mergeConditions.length > 0) {
+                    queryPlan.push(`Rdf3xMergeJoin(${mergeConditions.length})`);
+                }
+            }
+            this.appendResolvedPatternConditions(source.resolved, alias, conditions, joins, builder, queryPlan);
+            this.appendPatternEqualityConditions(source.entry.equalities, alias, conditions, queryPlan);
+            indexChoices.push(shouldUseMembershipSource(source.resolved) ? 'source-membership' : source.permutation.name);
+            for (const key of PATTERN_KEYS) {
+                const variableName = source.entry.variables[key];
+                if (!variableName)
+                    continue;
+                const column = `${alias}.${TERM_COLUMN[key]}`;
+                if (!variableColumns.has(variableName)) {
+                    variableColumns.set(variableName, column);
+                }
+            }
+        }
+        const projectVariables = options?.project ?? [...variableColumns.keys()];
+        const projectionColumns = projectVariables.map((variableName) => {
+            const column = variableColumns.get(variableName);
+            if (!column)
+                throw new Error(`Postgres RDF-3X join cannot project unbound variable: ${variableName}`);
+            const alias = `v${variableAliases.size}`;
+            variableAliases.set(variableName, alias);
+            return `${column} AS ${alias}`;
+        });
+        const projection = projectionColumns.length > 0
+            ? `${options?.distinct ? 'DISTINCT ' : ''}${projectionColumns.join(', ')}`
+            : `${options?.distinct ? 'DISTINCT ' : ''}1 AS __empty`;
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const orderClause = this.buildJoinOrderClause(options?.orderBy, variableColumns);
+        const pagination = this.buildPagination(options, builder);
+        const from = joins.join('');
+        const sql = `
+      SELECT ${projection}
+      FROM ${from}${orderClause.joins}
+      ${whereClause}
+      ${orderClause.orderBy}
+      ${pagination.sql}
+    `;
+        return {
+            sql,
+            params: builder.snapshot(),
+            countSql: pagination.sql && options?.countMatchedRows !== false
+                ? `SELECT COUNT(*) AS count FROM ${from}${orderClause.joins}${whereClause}`
+                : undefined,
+            countParams: builder.snapshot().slice(0, builder.snapshot().length - pagination.paramCount),
+            indexChoice: `Rdf3xJoinBGP(${indexChoices.join('>')})`,
+            queryPlan: [
+                ...queryPlan,
+                ...(orderClause.orderBy ? [`Rdf3xJoinOrderBy(${(options?.orderBy ?? []).map((entry) => `${entry.direction ?? 'asc'}:${entry.variable}`).join(',')})`] : []),
+                ...(options?.distinct ? [`Rdf3xJoinDistinct(${projectVariables.map((variableName) => `?${variableName}`).join(',')})`] : []),
+                ...(pagination.sql ? ['Rdf3xJoinLimit'] : []),
+                sql,
+            ],
+            variableAliases,
+        };
+    }
+    appendResolvedPatternConditions(resolved, alias, conditions, joins, builder, queryPlan) {
+        for (const key of PATTERN_KEYS) {
+            const column = `${alias}.${TERM_COLUMN[key]}`;
+            const id = resolved.ids[key];
+            if (id !== undefined) {
+                conditions.push(`${column} = ${builder.add(id)}`);
+                if (key === 'graph')
+                    queryPlan.push('GraphMembershipFilter');
+            }
+            const ids = resolved.idSets[key];
+            if (ids?.length) {
+                conditions.push(`${column} = ANY(${builder.add(ids)}::bigint[])`);
+                queryPlan.push(`TermIn(${key})`);
+            }
+            const excluded = resolved.excludedIdSets[key];
+            if (excluded?.length) {
+                conditions.push(`NOT (${column} = ANY(${builder.add(excluded)}::bigint[]))`);
+                queryPlan.push(`TermNotIn(${key})`);
+            }
+            const filter = resolved.termFilters[key];
+            if (filter) {
+                const filterAlias = `${alias}_${key}_term_filter`;
+                joins.push(` JOIN rdf_terms ${filterAlias} ON ${filterAlias}.id = ${column}`);
+                this.appendTermFilterCondition(key, filterAlias, filter, conditions, builder, queryPlan);
+            }
+        }
+        if (resolved.graphPrefix !== undefined) {
+            const graphAlias = `${alias}_graph_prefix`;
+            joins.push(` JOIN rdf_terms ${graphAlias} ON ${graphAlias}.id = ${alias}.graph_id`);
+            conditions.push(`${graphAlias}.kind = ${builder.add('iri')}`);
+            conditions.push(`${graphAlias}.value_head >= ${builder.add((0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix))}`);
+            conditions.push(`${graphAlias}.value_head < ${builder.add(`${(0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix)}\uffff`)}`);
+            conditions.push(`${graphAlias}.value >= ${builder.add(resolved.graphPrefix)}`);
+            conditions.push(`${graphAlias}.value < ${builder.add(`${resolved.graphPrefix}\uffff`)}`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (resolved.objectRange) {
+            const rangeAlias = `${alias}_object_range`;
+            joins.push(` JOIN rdf_terms ${rangeAlias} ON ${rangeAlias}.id = ${alias}.object_id`);
+            this.appendObjectRangeCondition(rangeAlias, resolved.objectRange, conditions, builder, queryPlan);
+        }
+    }
+    appendPatternEqualityConditions(equalities, alias, conditions, queryPlan) {
+        for (const equality of equalities) {
+            conditions.push(`${alias}.${TERM_COLUMN[equality.left]} = ${alias}.${TERM_COLUMN[equality.right]}`);
+            queryPlan.push(`Rdf3xPatternEquality(?${equality.variable}:${equality.left}=${equality.right})`);
+        }
+    }
+    appendTermFilterCondition(key, alias, filter, conditions, builder, queryPlan) {
+        if (filter.termType !== undefined) {
+            this.appendTermTypeCondition(key, alias, filter.termType, conditions, builder);
+            queryPlan.push(`TermType(${key}:${filter.termType})`);
+        }
+        if (filter.language !== undefined) {
+            this.appendLanguageCondition(key, alias, '$language', filter.language, conditions, builder);
+            queryPlan.push(`Language(${key}$language)`);
+        }
+        if (filter.notLanguage !== undefined) {
+            this.appendLanguageCondition(key, alias, '$notLanguage', filter.notLanguage, conditions, builder);
+            queryPlan.push(`Language(${key}$notLanguage)`);
+        }
+        if (filter.langMatches !== undefined) {
+            this.appendLanguageCondition(key, alias, '$langMatches', filter.langMatches, conditions, builder);
+            queryPlan.push(`Language(${key}$langMatches)`);
+        }
+        if (filter.datatype !== undefined) {
+            this.appendDatatypeCondition(key, alias, '$datatype', filter.datatype, conditions, builder);
+            queryPlan.push(`Datatype(${key}$datatype)`);
+        }
+        if (filter.notDatatype !== undefined) {
+            this.appendDatatypeCondition(key, alias, '$notDatatype', filter.notDatatype, conditions, builder);
+            queryPlan.push(`Datatype(${key}$notDatatype)`);
+        }
+        for (const search of filter.textSearches ?? []) {
+            this.appendTextSearchCondition(key, alias, search, conditions, builder, queryPlan);
+        }
+    }
+    appendTermTypeCondition(key, alias, termType, conditions, builder) {
+        const possibleKinds = termKindsForPatternKey(key);
+        if (termType === 'numeric') {
+            conditions.push(possibleKinds.includes('literal')
+                ? `${alias}.kind = 'literal' AND ${alias}.numeric_value IS NOT NULL`
+                : '1 = 0');
+            return;
+        }
+        if (!possibleKinds.includes(termType)) {
+            conditions.push('1 = 0');
+            return;
+        }
+        conditions.push(`${alias}.kind = ${builder.add(termType)}`);
+    }
+    appendLanguageCondition(key, alias, operator, language, conditions, builder) {
+        if (!termKindsForPatternKey(key).includes('literal')) {
+            conditions.push('1 = 0');
+            return;
+        }
+        if (operator === '$language') {
+            conditions.push(`${alias}.kind = 'literal' AND COALESCE(${alias}.lang, '') = ${builder.add(language)}`);
+            return;
+        }
+        if (operator === '$notLanguage') {
+            conditions.push(`${alias}.kind = 'literal' AND COALESCE(${alias}.lang, '') != ${builder.add(language)}`);
+            return;
+        }
+        if (language === '*') {
+            conditions.push(`${alias}.kind = 'literal' AND ${alias}.lang IS NOT NULL AND ${alias}.lang != ''`);
+            return;
+        }
+        conditions.push(`${alias}.kind = 'literal'
+      AND (lower(${alias}.lang) = lower(${builder.add(language)}) OR lower(${alias}.lang) LIKE lower(${builder.add(`${escapeLikePattern(language)}-%`)}) ESCAPE '\\')`);
+    }
+    appendDatatypeCondition(key, alias, operator, datatype, conditions, builder) {
+        if (!termKindsForPatternKey(key).includes('literal')) {
+            conditions.push('1 = 0');
+            return;
+        }
+        if (datatype.kind === 'xsd-string') {
+            conditions.push(operator === '$datatype'
+                ? `${alias}.kind = 'literal' AND ${alias}.lang IS NULL AND ${alias}.datatype_id IS NULL`
+                : `${alias}.kind = 'literal' AND NOT (${alias}.lang IS NULL AND ${alias}.datatype_id IS NULL)`);
+            return;
+        }
+        if (datatype.kind === 'unknown') {
+            conditions.push(operator === '$datatype' ? '1 = 0' : `${alias}.kind = 'literal'`);
+            return;
+        }
+        conditions.push(operator === '$datatype'
+            ? `${alias}.kind = 'literal' AND ${alias}.datatype_id = ${builder.add(datatype.id)}`
+            : `${alias}.kind = 'literal' AND (${alias}.datatype_id IS NULL OR ${alias}.datatype_id != ${builder.add(datatype.id)})`);
+    }
+    appendTextSearchCondition(key, alias, search, conditions, builder, queryPlan) {
+        const kinds = termKindsForPatternKey(key);
+        const kindArray = builder.add(kinds);
+        const normalized = search.value.toLowerCase();
+        switch (search.operator) {
+            case '$contains':
+                conditions.push(`${alias}.kind = ANY(${kindArray}::text[])
+          AND ${alias}.normalized_text LIKE ${builder.add(`%${escapeLikePattern(normalized)}%`)} ESCAPE '\\'
+          AND strpos(${alias}.value, ${builder.add(search.value)}) > 0`);
+                queryPlan.push(`TextSearch(${key}$contains)`);
+                return;
+            case '$endsWith':
+                conditions.push(`${alias}.kind = ANY(${kindArray}::text[])
+          AND ${alias}.normalized_text LIKE ${builder.add(`%${escapeLikePattern(normalized)}`)} ESCAPE '\\'
+          AND right(${alias}.value, length(${builder.add(search.value)})) = ${builder.add(search.value)}`);
+                queryPlan.push(`TextSearch(${key}$endsWith)`);
+                return;
+            default: {
+                const exhaustive = search.operator;
+                throw new Error(`Unsupported PostgreSQL RDF-3X text search operator: ${exhaustive}`);
+            }
+        }
+    }
+    appendObjectRangeCondition(alias, range, conditions, builder, queryPlan) {
+        if (range.mode === 'numeric') {
+            conditions.push(`${alias}.kind = 'literal'`);
+            conditions.push(`${alias}.numeric_value IS NOT NULL`);
+            if (range.min !== undefined)
+                conditions.push(`${alias}.numeric_value ${range.minInclusive ? '>=' : '>'} ${builder.add(range.min)}`);
+            if (range.max !== undefined)
+                conditions.push(`${alias}.numeric_value ${range.maxInclusive ? '<=' : '<'} ${builder.add(range.max)}`);
+            queryPlan.push(`NumericRange(object${rangeSuffix(range)})`);
+            return;
+        }
+        conditions.push(`${alias}.kind = ANY(${builder.add(OBJECT_RANGE_KINDS)}::text[])`);
+        if (range.min !== undefined)
+            conditions.push(`${alias}.value ${range.minInclusive ? '>=' : '>'} ${builder.add(range.min)}`);
+        if (range.max !== undefined)
+            conditions.push(`${alias}.value ${range.maxInclusive ? '<=' : '<'} ${builder.add(range.max)}`);
+        queryPlan.push(`LexicalRange(object${rangeSuffix(range)})`);
+    }
+    mergeJoinConditions(source, variableColumns) {
+        const conditions = [];
+        for (const key of PATTERN_KEYS) {
+            const variableName = source.entry.variables[key];
+            if (!variableName)
+                continue;
+            const existing = variableColumns.get(variableName);
+            if (existing) {
+                conditions.push(`${existing} = ${source.alias}.${TERM_COLUMN[key]}`);
+            }
+        }
+        return conditions;
+    }
+    choosePermutation(resolved) {
+        const has = (key) => resolved.ids[key] !== undefined || Boolean(resolved.idSets[key]?.length);
+        const hasObjectConstraint = has('object') || Boolean(resolved.objectRange) || Boolean(resolved.termFilters.object);
+        if (has('subject') && has('predicate'))
+            return this.permutation('SPO');
+        if (has('subject') && hasObjectConstraint)
+            return this.permutation('SOP');
+        if (has('predicate') && has('subject'))
+            return this.permutation('PSO');
+        if (has('predicate') && hasObjectConstraint)
+            return this.permutation('POS');
+        if (hasObjectConstraint && has('subject'))
+            return this.permutation('OSP');
+        if (hasObjectConstraint && has('predicate'))
+            return this.permutation('OPS');
+        if (has('subject'))
+            return this.permutation('SPO');
+        if (has('predicate'))
+            return this.permutation('PSO');
+        if (hasObjectConstraint)
+            return this.permutation('OSP');
+        return this.permutation('SPO');
+    }
+    permutation(name) {
+        const permutation = PERMUTATIONS.find((candidate) => candidate.name === name);
+        if (!permutation)
+            throw new Error(`Unknown PostgreSQL RDF-3X permutation: ${name}`);
+        return permutation;
+    }
+    async estimateResolvedRows(resolved) {
+        const compiled = this.compileScanSql(resolved, { limit: 0 });
+        return this.scalarCount(compiled.countSql, compiled.countParams);
+    }
+    orderJoinSources(sources) {
+        const remaining = [...sources];
+        const selected = [];
+        const selectedVariables = new Set();
+        while (remaining.length > 0) {
+            const hasSelectedVariables = selectedVariables.size > 0;
+            remaining.sort((left, right) => {
+                const leftConnected = !hasSelectedVariables || joinSourceVariables(left).some((variableName) => selectedVariables.has(variableName));
+                const rightConnected = !hasSelectedVariables || joinSourceVariables(right).some((variableName) => selectedVariables.has(variableName));
+                return Number(rightConnected) - Number(leftConnected)
+                    || left.estimateRows - right.estimateRows
+                    || left.inputIndex - right.inputIndex;
+            });
+            const [next] = remaining.splice(0, 1);
+            selected.push(next);
+            for (const variableName of joinSourceVariables(next)) {
+                selectedVariables.add(variableName);
+            }
+        }
+        return selected;
+    }
+    buildOrderClause(options, alias) {
+        if (!options?.order || options.order.length === 0)
+            return '';
+        const directions = 'orderDirections' in options && Array.isArray(options.orderDirections)
+            ? options.orderDirections
+            : options.order.map(() => (options.reverse ? 'desc' : 'asc'));
+        return ` ORDER BY ${options.order.map((key, index) => `${alias}.${TERM_COLUMN[key]} ${(directions[index] ?? 'asc').toUpperCase()}`).join(', ')}`;
+    }
+    buildJoinOrderClause(orderBy, variableColumns) {
+        if (!orderBy || orderBy.length === 0)
+            return { joins: '', orderBy: '' };
+        const joins = [];
+        const orders = [];
+        for (const [index, entry] of orderBy.entries()) {
+            const column = variableColumns.get(entry.variable);
+            if (!column)
+                throw new Error(`Postgres RDF-3X join cannot order by unbound variable: ${entry.variable}`);
+            const alias = `join_order_t${index}`;
+            joins.push(` JOIN rdf_terms ${alias} ON ${alias}.id = ${column}`);
+            orders.push(`${alias}.value ${entry.direction === 'desc' ? 'DESC' : 'ASC'}`);
+        }
+        return { joins: joins.join(''), orderBy: ` ORDER BY ${orders.join(', ')}` };
+    }
+    buildPagination(options, builder) {
+        let sql = '';
+        let paramCount = 0;
+        if (options?.limit !== undefined) {
+            sql += ` LIMIT ${builder.add(Math.max(0, options.limit))}`;
+            paramCount++;
+        }
+        if (options?.offset !== undefined) {
+            if (options.limit === undefined) {
+                sql += ' LIMIT ALL';
+            }
+            sql += ` OFFSET ${builder.add(Math.max(0, options.offset))}`;
+            paramCount++;
+        }
+        return { sql, paramCount };
+    }
+    async rowsToQuads(rows) {
+        const ids = rows.flatMap((row) => [row.graph_id, row.subject_id, row.predicate_id, row.object_id]);
+        const terms = await this.requireDictionary().rowsForIds(ids);
+        return rows.map((row) => quad(this.requiredTerm(terms, row.subject_id), this.requiredTerm(terms, row.predicate_id), this.requiredTerm(terms, row.object_id), this.requiredTerm(terms, row.graph_id)));
+    }
+    async joinRowsToBindings(rows, variableAliases, aggregateAliases, aggregateTypes) {
+        const termIds = rows.flatMap((row) => [...variableAliases.values()]
+            .map((alias) => row[alias])
+            .map(pgInteger)
+            .filter((value) => value !== undefined));
+        const terms = await this.requireDictionary().rowsForIds(termIds);
+        return rows.map((row) => {
+            const binding = {};
+            for (const [variableName, alias] of variableAliases) {
+                const id = pgInteger(row[alias]);
+                if (id !== undefined)
+                    binding[variableName] = this.requiredTerm(terms, id);
+            }
+            for (const [variableName, alias] of aggregateAliases ?? []) {
+                const value = pgInteger(row[alias]);
+                if (value !== undefined) {
+                    binding[variableName] = n3_1.DataFactory.literal(String(value), n3_1.DataFactory.namedNode(aggregateTypes?.get(variableName) === 'decimal' ? XSD_DECIMAL : XSD_INTEGER));
+                }
+            }
+            return binding;
+        });
+    }
+    indexMetrics(indexChoice, matchedRows, returnedRows, start, queryPlan) {
+        return {
+            engine: 'solid-rdf',
+            indexChoice,
+            matchedRows,
+            returnedRows,
+            durationMs: Date.now() - start,
+            queryPlan,
+        };
+    }
+    localMetrics(start, scannedRows, joinedRows, returnedRows, indexChoices, plan, filtersPushedDown = 0) {
+        return {
+            engine: 'solid-rdf',
+            plan,
+            scannedRows,
+            joinedRows,
+            returnedRows,
+            durationMs: Date.now() - start,
+            indexChoices,
+            cardinalityEstimates: 0,
+            distinctCardinalityEstimates: 0,
+            searchCardinalityEstimates: 0,
+            filtersApplied: 0,
+            filtersPushedDown,
+        };
+    }
+    async rebuildCacheFromStore() {
+        if (this.cacheEngine) {
+            await this.cacheEngine.close();
+            this.cacheEngine = null;
+        }
+        if (this.cacheDir) {
+            await (0, promises_1.rm)(this.cacheDir, { recursive: true, force: true });
+        }
+        this.cacheDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'xpod-pg-rdf-cache-'));
+        this.cachePath = (0, node_path_1.join)(this.cacheDir, 'rdf-cache.sqlite');
+        this.cacheEngine = new SolidRdfEngine_1.SolidRdfEngine({
+            index: { path: this.cachePath },
+            autoOpen: true,
+        });
+        const sources = await this.requireExecutor().query('SELECT * FROM rdf_sources ORDER BY id');
+        const nullSourceRows = await this.requireExecutor().query('SELECT * FROM rdf_quads WHERE source_file_id IS NULL ORDER BY graph_id, subject_id, predicate_id, object_id');
+        await this.loadCacheQuads(nullSourceRows, undefined);
+        for (const source of sources) {
+            const quadRows = await this.requireExecutor().query('SELECT * FROM rdf_quads WHERE source_file_id = $1 ORDER BY graph_id, subject_id, predicate_id, object_id', [source.id]);
+            await this.loadCacheQuads(quadRows, source);
+        }
+        await this.requireCache().refreshDerivedIndexes();
+        this.factsDataVersion = await this.readFactsDataVersion();
+        this.cacheDirty = false;
+    }
+    async loadCacheQuads(rows, source) {
+        if (rows.length === 0) {
+            return;
+        }
+        const dictionary = this.requireDictionary();
+        const termIds = Array.from(new Set(rows.flatMap((row) => [row.graph_id, row.subject_id, row.predicate_id, row.object_id])));
+        const terms = await dictionary.rowsForIds(termIds);
+        const quads = rows.map((row) => quad(this.requiredTerm(terms, row.subject_id), this.requiredTerm(terms, row.predicate_id), this.requiredTerm(terms, row.object_id), this.requiredTerm(terms, row.graph_id)));
+        const sourceInput = source ? this.sourceRowToInput(source) : undefined;
+        if (sourceInput) {
+            this.requireCache().replaceSource(quads, sourceInput);
+        }
+        else {
+            this.requireCache().put(quads);
+        }
+    }
+    async insertQuads(executor, dictionary, quads, sourceId, sourceLineNo) {
+        for (const quadValue of quads) {
+            const graphId = await dictionary.getOrCreate(quadValue.graph);
+            const subjectId = await dictionary.getOrCreate(quadValue.subject);
+            const predicateId = await dictionary.getOrCreate(quadValue.predicate);
+            const objectId = await dictionary.getOrCreate(quadValue.object);
+            await executor.exec(`
+        INSERT INTO rdf_quads (
+          graph_id,
+          subject_id,
+          predicate_id,
+          object_id,
+          source_file_id,
+          source_line_no
+        )
+        VALUES ($1, $2, $3, $4, $5, $6)
+        ON CONFLICT (graph_id, subject_id, predicate_id, object_id)
+        DO UPDATE SET
+          source_file_id = EXCLUDED.source_file_id,
+          source_line_no = EXCLUDED.source_line_no
+      `, [graphId, subjectId, predicateId, objectId, sourceId, sourceLineNo]);
+        }
+    }
+    async deleteExactQuad(executor, dictionary, value) {
+        const graphId = await dictionary.find(value.graph);
+        const subjectId = await dictionary.find(value.subject);
+        const predicateId = await dictionary.find(value.predicate);
+        const objectId = await dictionary.find(value.object);
+        if (graphId === undefined || subjectId === undefined || predicateId === undefined || objectId === undefined) {
+            return 0;
+        }
+        const result = await executor.query(`
+        DELETE FROM rdf_quads
+        WHERE graph_id = $1
+          AND subject_id = $2
+          AND predicate_id = $3
+          AND object_id = $4
+        RETURNING 1 AS one
+      `, [graphId, subjectId, predicateId, objectId]);
+        return result.length;
+    }
+    sourceRowToInput(row) {
+        return {
+            source: row.source,
+            workspace: row.workspace,
+            localPath: row.local_path !== null ? row.local_path : undefined,
+            contentType: row.content_type !== null ? row.content_type : undefined,
+            sourceVersion: row.source_version !== null ? row.source_version : undefined,
+        };
+    }
+    async upsertSource(source, executor = this.requireExecutor()) {
+        const row = await executor.query(`
+      INSERT INTO rdf_sources (
+        source,
+        workspace,
+        local_path,
+        content_type,
+        source_version,
+        last_indexed_at
+      )
+      VALUES ($1, $2, $3, $4, $5, NOW())
+      ON CONFLICT (source) DO UPDATE
+      SET
+        workspace = EXCLUDED.workspace,
+        local_path = EXCLUDED.local_path,
+        content_type = EXCLUDED.content_type,
+        source_version = EXCLUDED.source_version,
+        last_indexed_at = NOW()
+      RETURNING id
+    `, [
+            source.source,
+            source.workspace,
+            source.localPath ?? null,
+            source.contentType ?? null,
+            source.sourceVersion ?? null,
+        ]);
+        const id = row[0]?.id;
+        if (id === undefined) {
+            throw new Error(`Failed to upsert RDF source ${source.source}`);
+        }
+        return id;
+    }
+    async findSourceRow(source, executor = this.requireExecutor()) {
+        const rows = await executor.query('SELECT * FROM rdf_sources WHERE source = $1', [source]);
+        return rows[0];
+    }
+    async bumpFactsDataVersion(executor = this.requireExecutor()) {
+        await executor.exec(`
+      UPDATE rdf_index_metadata
+      SET value = (COALESCE(NULLIF(value, ''), '0')::bigint + 1)::text
+      WHERE key = 'data_version'
+    `);
+    }
+    async readFactsDataVersion() {
+        const row = await this.requireExecutor().query("SELECT value FROM rdf_index_metadata WHERE key = 'data_version'");
+        return Number(row[0]?.value ?? 0) || 0;
+    }
+    async readRdf3xFactsDataVersion() {
+        try {
+            const row = await this.requireExecutor().query("SELECT value FROM rdf3x_metadata WHERE key = 'facts_data_version'");
+            return Number(row[0]?.value ?? 0) || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async ensureReady() {
+        await this.open();
+        const currentVersion = await this.readFactsDataVersion();
+        if (currentVersion !== this.factsDataVersion) {
+            this.factsDataVersion = currentVersion;
+            this.markDerivedDirty();
+        }
+    }
+    async ensureCacheReady() {
+        await this.ensureReady();
+        if (this.cacheDirty || !this.cacheEngine) {
+            await this.rebuildCacheFromStore();
+        }
+    }
+    markDerivedDirty() {
+        this.rdf3xDirty = true;
+        this.cacheDirty = true;
+    }
+    async scalarCount(sql, params = []) {
+        const row = await this.requireExecutor().query(sql, params);
+        return Number(row[0]?.count ?? 0) || 0;
+    }
+    async factsStats() {
+        const [termCount, quadCount, sourceCount, graphCount] = await Promise.all([
+            this.scalarCount('SELECT COUNT(*) AS count FROM rdf_terms'),
+            this.scalarCount(`SELECT COUNT(*) AS count FROM ${RDF_FACTS_TABLE}`),
+            this.scalarCount('SELECT COUNT(*) AS count FROM rdf_sources'),
+            this.scalarCount(`SELECT COUNT(DISTINCT graph_id) AS count FROM ${RDF_FACTS_TABLE}`),
+        ]);
+        const spaceObjects = await this.collectSpaceObjects(false);
+        const databaseBytes = spaceObjects.reduce((sum, object) => sum + object.bytes, 0);
+        return {
+            termCount,
+            quadCount,
+            sourceCount,
+            graphCount,
+            databaseBytes,
+            tableBytes: sumSpaceObjects(spaceObjects, 'table'),
+            indexBytes: sumSpaceObjects(spaceObjects, 'index'),
+            spaceObjects,
+            serializedTermTextBytes: await this.scalarCount('SELECT COALESCE(SUM(length(value)), 0) AS count FROM rdf_terms'),
+            literalDatatypeDistribution: [],
+            cardinalityDistributions: {
+                graphs: [],
+                predicates: [],
+                predicateObjects: [],
+                subjectPredicates: [],
+            },
+        };
+    }
+    async rdf3xStats() {
+        const spaceObjects = await this.collectSpaceObjects(true);
+        const databaseBytes = spaceObjects.reduce((sum, object) => sum + object.bytes, 0);
+        const uniqueTriples = await this.scalarCount(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT DISTINCT subject_id, predicate_id, object_id
+        FROM ${RDF_FACTS_TABLE}
+      ) distinct_triples
+    `);
+        return {
+            uniqueTriples,
+            membershipCount: await this.scalarCount(`SELECT COUNT(*) AS count FROM ${RDF_FACTS_TABLE}`),
+            graphCount: await this.scalarCount(`SELECT COUNT(*) AS count FROM ${Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE}`),
+            factsDataVersion: await this.readRdf3xFactsDataVersion(),
+            permutationRows: Object.fromEntries(PERMUTATIONS.map((permutation) => [permutation.name, uniqueTriples])),
+            pairProjectionRows: Object.fromEntries(await Promise.all(PAIR_PROJECTIONS.map(async (projection) => [
+                projection.name,
+                await this.scalarCount(`SELECT COUNT(*) AS count FROM ${projection.table}`),
+            ]))),
+            termProjectionRows: Object.fromEntries(await Promise.all(TERM_PROJECTIONS.map(async (projection) => [
+                projection.name,
+                await this.scalarCount(`SELECT COUNT(*) AS count FROM ${projection.table}`),
+            ]))),
+            databaseBytes,
+            tableBytes: sumSpaceObjects(spaceObjects, 'table'),
+            indexBytes: sumSpaceObjects(spaceObjects, 'index'),
+            spaceObjects,
+        };
+    }
+    async collectSpaceObjects(derived) {
+        try {
+            const rows = await this.requireExecutor().query(`
+        SELECT
+          rel.relname AS name,
+          CASE WHEN rel.relkind = 'i' THEN 'index' ELSE 'table' END AS kind,
+          tbl.relname AS table_name,
+          pg_total_relation_size(rel.oid) AS bytes
+        FROM pg_class rel
+        LEFT JOIN pg_index idx ON idx.indexrelid = rel.oid
+        LEFT JOIN pg_class tbl ON tbl.oid = idx.indrelid
+        WHERE rel.relkind IN ('r', 'i')
+          AND ${derived
+                ? "(rel.relname LIKE 'rdf3x_%' OR tbl.relname LIKE 'rdf3x_%')"
+                : "(rel.relname LIKE 'rdf_%' OR tbl.relname LIKE 'rdf_%') AND rel.relname NOT LIKE 'rdf3x_%' AND COALESCE(tbl.relname, '') NOT LIKE 'rdf3x_%'"}
+        ORDER BY rel.relname
+      `);
+            return rows.map((row) => ({
+                name: row.name,
+                kind: row.kind,
+                ...(row.table_name && row.table_name !== row.name ? { tableName: row.table_name } : {}),
+                bytes: Number(row.bytes ?? 0),
+                pages: 0,
+                estimated: false,
+            }));
+        }
+        catch {
+            const tables = derived
+                ? ['rdf3x_metadata', Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE, ...PAIR_PROJECTIONS.map((projection) => projection.table), ...TERM_PROJECTIONS.map((projection) => projection.table)]
+                : ['rdf_terms', 'rdf_sources', RDF_FACTS_TABLE, 'rdf_index_metadata'];
+            const rows = await Promise.all(tables.map(async (table) => ({
+                name: table,
+                kind: 'table',
+                rows: await this.scalarCount(`SELECT COUNT(*) AS count FROM ${table}`).catch(() => 0),
+            })));
+            return rows.map((row) => ({
+                name: row.name,
+                kind: row.kind,
+                bytes: Math.max(4096, row.rows * 128),
+                pages: Math.max(1, Math.ceil(Math.max(4096, row.rows * 128) / 4096)),
+                estimated: true,
+            }));
+        }
+    }
+    requireExecutor() {
+        if (!this.executor) {
+            throw new Error('PostgresRdfEngine is not open');
+        }
+        return this.executor;
+    }
+    requireDictionary() {
+        if (!this.termDictionary) {
+            throw new Error('PostgresRdfEngine term dictionary is not initialized');
+        }
+        return this.termDictionary;
+    }
+    requireCache() {
+        if (!this.cacheEngine) {
+            throw new Error('PostgresRdfEngine cache is not initialized');
+        }
+        return this.cacheEngine;
+    }
+    requiredTerm(termMap, id) {
+        const term = termMap.get(id);
+        if (!term) {
+            throw new Error(`RDF term not found while reading quad row: ${id}`);
+        }
+        return term;
+    }
+    async openExecutor() {
+        if (this.executor) {
+            return;
+        }
+        if (this.pgOptions.pool) {
+            this.pgPool = this.pgOptions.pool;
+            this.sharedPoolConfig = null;
+            this.executor = new PgPoolExecutor(this.pgPool);
+            return;
+        }
+        if (this.pgOptions.driver === 'pglite') {
+            this.pglite = new pglite_1.PGlite(this.pgOptions.dataDir);
+            await this.pglite.waitReady;
+            this.executor = new PgliteExecutor(this.pglite);
+            return;
+        }
+        this.sharedPoolConfig = {
+            connectionString: this.pgOptions.connectionString,
+            host: this.pgOptions.host,
+            port: this.pgOptions.port,
+            database: this.pgOptions.database,
+            user: this.pgOptions.user,
+            password: this.pgOptions.password,
+        };
+        this.pgPool = (0, PostgresPoolManager_1.getSharedPool)(this.sharedPoolConfig);
+        this.executor = new PgPoolExecutor(this.pgPool);
+    }
+}
+exports.PostgresRdfEngine = PostgresRdfEngine;
+function restoreRow(row) {
+    if (!row || typeof row !== 'object') {
+        return row;
+    }
+    const restored = {};
+    for (const [key, value] of Object.entries(row)) {
+        restored[key] = restoreValue(key, value);
+    }
+    return restored;
+}
+function restoreValue(key, value) {
+    if (typeof value !== 'string') {
+        return value;
+    }
+    if (isIntegerResultKey(key) && /^-?\d+$/.test(value)) {
+        return Number(value);
+    }
+    return fromPgSafe(value);
+}
+function isIntegerResultKey(key) {
+    return INTEGER_RESULT_KEYS.has(key) || INTEGER_ALIAS_RESULT_KEY.test(key);
+}
+function pgInteger(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? value : undefined;
+    }
+    if (typeof value === 'string' && /^-?\d+$/.test(value)) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : undefined;
+    }
+    return undefined;
+}
+function isVariable(value) {
+    return Boolean(value && typeof value === 'object' && 'variable' in value);
+}
+function variablesInPattern(pattern) {
+    return uniqueStrings(PATTERN_KEYS
+        .map((key) => pattern[key])
+        .filter(isVariable)
+        .map((value) => value.variable));
+}
+function isPgRdf3xCompatiblePattern(pattern) {
+    return PATTERN_KEYS.every((key) => {
+        const value = pattern[key];
+        if (!value || (0, types_1.isTerm)(value))
+            return true;
+        if (value === null || typeof value !== 'object' || 'termType' in value)
+            return false;
+        const operators = value;
+        const allowed = new Set([
+            '$eq',
+            '$ne',
+            '$in',
+            '$notIn',
+            '$termType',
+            '$language',
+            '$notLanguage',
+            '$langMatches',
+            '$datatype',
+            '$notDatatype',
+            ...(key === 'graph' ? ['$startsWith'] : []),
+            ...(key === 'object' ? ['$gt', '$gte', '$lt', '$lte', '$contains', '$endsWith'] : []),
+        ]);
+        if (Object.keys(operators).length === 0 || Object.keys(operators).some((operator) => !allowed.has(operator)))
+            return false;
+        if (operators.$eq !== undefined && !(0, types_1.isTerm)(operators.$eq))
+            return false;
+        if (operators.$ne !== undefined && !(0, types_1.isTerm)(operators.$ne))
+            return false;
+        if (operators.$in !== undefined && (!Array.isArray(operators.$in) || operators.$in.length === 0 || !operators.$in.every((entry) => (0, types_1.isTerm)(entry))))
+            return false;
+        if (operators.$notIn !== undefined && (!Array.isArray(operators.$notIn) || operators.$notIn.length === 0 || !operators.$notIn.every((entry) => (0, types_1.isTerm)(entry))))
+            return false;
+        if (operators.$startsWith !== undefined && typeof operators.$startsWith !== 'string')
+            return false;
+        if (operators.$termType !== undefined && !['iri', 'blank', 'literal', 'numeric'].includes(operators.$termType))
+            return false;
+        for (const languageOperator of ['$language', '$notLanguage', '$langMatches']) {
+            if (operators[languageOperator] !== undefined && typeof operators[languageOperator] !== 'string')
+                return false;
+        }
+        for (const datatypeOperator of ['$datatype', '$notDatatype']) {
+            const datatype = operators[datatypeOperator];
+            if (datatype !== undefined && (!(0, types_1.isTerm)(datatype) || datatype.termType !== 'NamedNode'))
+                return false;
+        }
+        if (key === 'object') {
+            for (const rangeOperator of ['$gt', '$gte', '$lt', '$lte']) {
+                const value = operators[rangeOperator];
+                if (value !== undefined && !isObjectRangeValue(value))
+                    return false;
+            }
+            for (const textOperator of ['$contains', '$endsWith']) {
+                if (operators[textOperator] !== undefined && typeof operators[textOperator] !== 'string')
+                    return false;
+            }
+        }
+        return true;
+    });
+}
+function isObjectRangeValue(value) {
+    return typeof value === 'number'
+        ? Number.isFinite(value)
+        : typeof value === 'string'
+            ? true
+            : (0, types_1.isTerm)(value);
+}
+function shouldUseMembershipSource(resolved) {
+    return resolved.ids.graph !== undefined
+        || Boolean(resolved.idSets.graph?.length)
+        || Boolean(resolved.excludedIdSets.graph?.length)
+        || resolved.graphPrefix !== undefined;
+}
+function termKindsForPatternKey(key) {
+    switch (key) {
+        case 'object':
+            return ['iri', 'literal', 'blank'];
+        case 'subject':
+            return ['iri', 'blank'];
+        case 'graph':
+            return ['iri', 'default_graph'];
+        case 'predicate':
+            return ['iri'];
+        default: {
+            const exhaustive = key;
+            throw new Error(`Unsupported RDF pattern key: ${exhaustive}`);
+        }
+    }
+}
+function escapeLikePattern(value) {
+    return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function rangeSuffix(range) {
+    return `${range.min !== undefined ? (range.minInclusive ? '$gte' : '$gt') : ''}${range.max !== undefined ? (range.maxInclusive ? '$lte' : '$lt') : ''}`;
+}
+function describeScanOrder(options) {
+    const order = options?.order ?? [];
+    const directions = 'orderDirections' in (options ?? {})
+        ? (options?.orderDirections ?? [])
+        : order.map(() => (options?.reverse ? 'desc' : 'asc'));
+    return order.map((entry, index) => `${directions[index] ?? 'asc'}:${entry}`).join(',');
+}
+function describePatternSource(source) {
+    return PATTERN_KEYS
+        .map((key) => {
+        const variableName = source.variables[key];
+        if (variableName)
+            return `${key}:?${variableName}`;
+        const value = source.pattern[key];
+        return value ? `${key}:${termMatchKey(value)}` : undefined;
+    })
+        .filter(Boolean)
+        .join(',');
+}
+function termMatchKey(match) {
+    if (!match)
+        return '*';
+    if ((0, types_1.isTerm)(match))
+        return `${match.termType}:${match.value}`;
+    return JSON.stringify(match);
+}
+function queryAggregates(query) {
+    if (query.aggregates && query.aggregates.length > 0)
+        return query.aggregates;
+    return query.aggregate ? [query.aggregate] : [];
+}
+function aggregatePlan(aggregates, grouped) {
+    return `Aggregate(${grouped ? 'group-' : ''}${aggregates.map((aggregate) => (`${aggregate.type}${aggregate.distinct ? ':DISTINCT' : ''}(${aggregate.variable ? `?${aggregate.variable}` : '*'})`)).join(',')})`;
+}
+function describeFilter(filter) {
+    return `?${filter.variable}${filter.operator}`;
+}
+function describeQueryOrder(orderBy) {
+    return orderBy.map((entry) => `${entry.direction ?? 'asc'}:${entry.variable}`).join(',');
+}
+function isNativeAggregateHavingOperator(operator) {
+    return operator === '$eq'
+        || operator === '$ne'
+        || operator === '$gt'
+        || operator === '$gte'
+        || operator === '$lt'
+        || operator === '$lte';
+}
+function aggregateSqlOperator(operator) {
+    switch (operator) {
+        case '$eq':
+            return '=';
+        case '$ne':
+            return '!=';
+        case '$gt':
+            return '>';
+        case '$gte':
+            return '>=';
+        case '$lt':
+            return '<';
+        case '$lte':
+            return '<=';
+        default:
+            throw new Error(`Unsupported PostgreSQL RDF-3X aggregate HAVING operator: ${operator}`);
+    }
+}
+function patternEqualities(slotsByVariable) {
+    const equalities = [];
+    for (const [variable, slots] of slotsByVariable) {
+        const [first, ...rest] = slots;
+        if (!first)
+            continue;
+        for (const slot of rest) {
+            equalities.push({ variable, left: first, right: slot });
+        }
+    }
+    return equalities;
+}
+function storagePlanMarkers(queryPlan) {
+    return (queryPlan ?? []).filter((entry) => (entry.startsWith('TextSearch(')
+        || entry.startsWith('Rdf3x')
+        || entry === 'GraphMembershipFilter'
+        || entry === 'GraphPrefixMembershipFilter'
+        || entry.startsWith('LexicalRange(')
+        || entry.startsWith('NumericRange(')
+        || entry.startsWith('TermIn(')
+        || entry.startsWith('TermNotIn(')
+        || entry.startsWith('TermType(')
+        || entry.startsWith('Language(')
+        || entry.startsWith('Datatype(')));
+}
+function uniqueStrings(values) {
+    return [...new Set(values)];
+}
+function uniqueNumbers(values) {
+    return [...new Set(values)];
+}
+function joinSourceVariables(source) {
+    return uniqueStrings(Object.values(source.entry.variables).filter((value) => Boolean(value)));
+}
+function joinSolutionMappingKeyExpression(variableAliases, variables) {
+    const variableNames = uniqueStrings(variables ?? [...variableAliases.keys()]);
+    if (variableNames.length === 0)
+        return '1';
+    return variableNames.map((variableName) => {
+        const alias = variableAliases.get(variableName);
+        if (!alias)
+            throw new Error(`Postgres RDF-3X COUNT(DISTINCT *) cannot read unbound variable: ${variableName}`);
+        return `source.${alias}`;
+    }).join(` || ':' || `);
+}
+function pairProjectionRowTotal(rows) {
+    return Object.values(rows).reduce((sum, count) => sum + count, 0);
+}
+function termProjectionRowTotal(rows) {
+    return Object.values(rows).reduce((sum, count) => sum + count, 0);
+}
+function sumSpaceObjects(objects, kind) {
+    return objects
+        .filter((object) => object.kind === kind)
+        .reduce((sum, object) => sum + object.bytes, 0);
+}
+const INTEGER_RESULT_KEYS = new Set([
+    'id',
+    'graph_id',
+    'subject_id',
+    'predicate_id',
+    'object_id',
+    'source_file_id',
+    'source_line_no',
+    'datatype_id',
+    'count',
+    'term_count',
+    'quad_count',
+    'source_count',
+    'graph_count',
+]);
+const INTEGER_ALIAS_RESULT_KEY = /^(?:v|a)\d+$/;
+function uniqueQuads(quads) {
+    const seen = new Set();
+    const result = [];
+    for (const value of quads) {
+        const key = [
+            value.graph.termType,
+            value.graph.value,
+            value.subject.termType,
+            value.subject.value,
+            value.predicate.termType,
+            value.predicate.value,
+            value.object.termType,
+            value.object.value,
+            value.object.termType === 'Literal' ? value.object.language : '',
+            value.object.termType === 'Literal' ? value.object.datatype.value : '',
+        ].join('\u001f');
+        if (!seen.has(key)) {
+            seen.add(key);
+            result.push(value);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=PostgresRdfEngine.js.map