@undefineds.co/xpod 0.3.18 → 0.3.22

package/dist/storage/rdf/Rdf3xIndex.js

@@ -0,0 +1,2695 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rdf3xIndex = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const n3_1 = require("n3");
+const SqliteRuntime_1 = require("../SqliteRuntime");
+const RdfTermDictionary_1 = require("./RdfTermDictionary");
+const RdfTermSemantics_1 = require("./RdfTermSemantics");
+const Rdf3xSchema_1 = require("./Rdf3xSchema");
+const XSD_INTEGER = 'http://www.w3.org/2001/XMLSchema#integer';
+const XSD_DECIMAL = 'http://www.w3.org/2001/XMLSchema#decimal';
+const XSD_STRING = 'http://www.w3.org/2001/XMLSchema#string';
+const OBJECT_RANGE_KINDS = ['iri', 'literal', 'blank'];
+const RDF3X_INDEX_SCHEMA_VERSION = 1;
+const TERM_COLUMN = {
+    subject: 'subject_id',
+    predicate: 'predicate_id',
+    object: 'object_id',
+};
+const ORDER_COLUMN = {
+    graph: 'graph_id',
+    ...TERM_COLUMN,
+};
+const PATTERN_COLUMNS = {
+    graph: 'graph_id',
+    ...TERM_COLUMN,
+};
+const TERM_KEYS = ['subject', 'predicate', 'object'];
+const RDF_FACTS_TABLE = 'rdf_quads';
+const PERMUTATIONS = [
+    { name: 'SPO', indexName: 'rdf_quads_spog', columns: ['subject_id', 'predicate_id', 'object_id'] },
+    { name: 'SOP', indexName: 'rdf_quads_sopg', columns: ['subject_id', 'object_id', 'predicate_id'] },
+    { name: 'PSO', indexName: 'rdf_quads_psog', columns: ['predicate_id', 'subject_id', 'object_id'] },
+    { name: 'POS', indexName: 'rdf_quads_posg', columns: ['predicate_id', 'object_id', 'subject_id'] },
+    { name: 'OSP', indexName: 'rdf_quads_ospg', columns: ['object_id', 'subject_id', 'predicate_id'] },
+    { name: 'OPS', indexName: 'rdf_quads_opsg', columns: ['object_id', 'predicate_id', 'subject_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 GRAPH_PROJECTION_TABLE = Rdf3xSchema_1.RDF3X_GRAPH_PROJECTION_TABLE;
+class Rdf3xIndex {
+    constructor(options) {
+        this.options = options;
+        this.sqliteRuntime = (0, SqliteRuntime_1.createSqliteRuntime)();
+        this.db = null;
+        this.dictionary = null;
+    }
+    open() {
+        if (this.db) {
+            return;
+        }
+        if (this.options.path !== ':memory:') {
+            const dir = (0, node_path_1.dirname)(this.options.path);
+            if (!(0, node_fs_1.existsSync)(dir)) {
+                (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+            }
+        }
+        this.db = this.sqliteRuntime.openDatabase(this.options.path);
+        this.dictionary = new RdfTermDictionary_1.RdfTermDictionary(this.db);
+        this.dictionary.initialize();
+        this.initializeSchema();
+    }
+    close() {
+        this.db?.close();
+        this.db = null;
+        this.dictionary = null;
+    }
+    clear() {
+        this.clearRdf3xTables();
+        this.setFactsDataVersion(0);
+    }
+    rebuildFromCurrentQuads() {
+        const start = Date.now();
+        const db = this.requireDb();
+        const factsDataVersion = this.currentFactsDataVersion();
+        const scannedQuads = db.prepare('SELECT COUNT(*) AS count FROM rdf_quads').get()?.count ?? 0;
+        db.transaction(() => {
+            this.clearRdf3xTables();
+            for (const projection of PAIR_PROJECTIONS) {
+                this.rebuildPairProjection(projection);
+            }
+            for (const projection of TERM_PROJECTIONS) {
+                this.rebuildTermProjection(projection);
+            }
+            this.rebuildGraphProjection();
+            this.setFactsDataVersion(factsDataVersion);
+        })();
+        const stats = this.stats();
+        return {
+            scannedQuads,
+            uniqueTriples: stats.uniqueTriples,
+            memberships: stats.membershipCount,
+            projectionRows: pairProjectionRowTotal(stats.pairProjectionRows) + termProjectionRowTotal(stats.termProjectionRows),
+            factsDataVersion,
+            durationMs: Date.now() - start,
+        };
+    }
+    factsDataVersion() {
+        const row = this.requireDb()
+            .prepare("SELECT value FROM rdf3x_metadata WHERE key = 'facts_data_version'")
+            .get();
+        return Number(row?.value ?? 0) || 0;
+    }
+    isSyncedWithCurrentQuads() {
+        return this.factsDataVersion() === this.currentFactsDataVersion();
+    }
+    scan(pattern, options) {
+        return this.scanInternal(pattern, options);
+    }
+    scanWithTupleConstraints(pattern, tupleValues, options) {
+        return this.scanInternal(pattern, options, tupleValues);
+    }
+    countDistinct(pattern, distinctKey) {
+        const start = Date.now();
+        const resolved = this.resolvePattern(pattern);
+        if (resolved.unresolved) {
+            return {
+                count: 0,
+                metrics: this.metrics('none', 0, 0, start, [`unresolved ${resolved.unresolved}`]),
+            };
+        }
+        const useMembershipSource = shouldUseMembershipSource(resolved);
+        const permutation = this.choosePermutation(resolved.ids, {
+            idSets: resolved.idSets,
+            objectRange: Boolean(resolved.objectRange),
+            termFilters: resolved.termFilters,
+        });
+        const compiled = useMembershipSource
+            ? this.compileMembershipDistinctCountSql(resolved, distinctKey)
+            : this.compileDistinctCountSql(permutation, resolved, distinctKey);
+        const count = this.requireDb()
+            .prepare(compiled.sql)
+            .get(...compiled.params)?.count ?? 0;
+        return {
+            count,
+            metrics: this.metrics(useMembershipSource ? 'source-membership' : permutation.name, count, 1, start, [
+                ...(useMembershipSource ? [] : [`Rdf3xPermutationScan(${permutation.name})`]),
+                ...compiled.queryPlan,
+                compiled.sql,
+            ]),
+        };
+    }
+    scanInternal(pattern, options, tupleValues) {
+        const start = Date.now();
+        const resolved = this.resolvePattern(pattern);
+        if (resolved.unresolved) {
+            return {
+                quads: [],
+                metrics: this.metrics('none', 0, 0, start, [`unresolved ${resolved.unresolved}`]),
+            };
+        }
+        const useMembershipSource = shouldUseMembershipSource(resolved);
+        const permutation = this.choosePermutation(resolved.ids, {
+            idSets: resolved.idSets,
+            objectRange: Boolean(resolved.objectRange),
+            termFilters: resolved.termFilters,
+        });
+        const compiled = useMembershipSource
+            ? this.compileMembershipScanSql(resolved, options, tupleValues)
+            : this.compileScanSql(permutation, resolved, options, tupleValues);
+        const matchedRows = this.requireDb()
+            .prepare(compiled.countSql)
+            .get(...compiled.countParams)?.count ?? 0;
+        const rows = this.requireDb().prepare(compiled.sql).all(...compiled.params);
+        return {
+            quads: this.rowsToQuads(rows),
+            metrics: this.metrics(useMembershipSource ? 'source-membership' : permutation.name, matchedRows, rows.length, start, [
+                ...(useMembershipSource ? [] : [`Rdf3xPermutationScan(${permutation.name})`]),
+                ...compiled.queryPlan,
+                compiled.sql,
+            ]),
+        };
+    }
+    compileDistinctCountSql(permutation, resolved, distinctKey) {
+        const conditions = [];
+        const params = [];
+        const queryPlan = [`Permutation(${permutation.name})`];
+        const ids = resolved.ids;
+        for (const key of TERM_KEYS) {
+            const id = ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`idx.${TERM_COLUMN[key]} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(resolved, TERM_KEYS, (key) => `idx.${TERM_COLUMN[key]}`, conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(resolved, TERM_KEYS, (key) => `idx.${TERM_COLUMN[key]}`, conditions, params, queryPlan);
+        if (ids.graph !== undefined) {
+            conditions.push('idx.graph_id = ?');
+            params.push(ids.graph);
+            queryPlan.push('GraphMembershipFilter');
+        }
+        this.appendResolvedExcludedIdSetConditions(resolved, ['graph'], () => 'idx.graph_id', conditions, params, queryPlan);
+        const graphPrefixJoin = resolved.graphPrefix
+            ? ` JOIN rdf_terms graph_prefix
+          ON graph_prefix.id = idx.graph_id`
+            : '';
+        if (resolved.graphPrefix) {
+            conditions.push(`graph_prefix.kind = ?
+        AND graph_prefix.value_head >= ?
+        AND graph_prefix.value_head < ?
+        AND graph_prefix.value >= ?
+        AND graph_prefix.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix)}\uffff`, resolved.graphPrefix, `${resolved.graphPrefix}\uffff`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (resolved.objectRange) {
+            this.appendObjectRangeCondition('object_range', resolved.objectRange, conditions, params, queryPlan);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(resolved, ['graph', ...TERM_KEYS], (key) => `idx.${PATTERN_COLUMNS[key]}`, termFilterJoins, conditions, params, queryPlan, 'distinct_term_filter');
+        const distinctColumn = distinctKey === 'graph'
+            ? 'idx.graph_id'
+            : `idx.${TERM_COLUMN[distinctKey]}`;
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const from = `
+      FROM ${this.permutationSource(permutation, 'idx')}
+      ${termFilterJoins.join('')}
+      ${graphPrefixJoin}
+      ${resolved.objectRange ? 'JOIN rdf_terms object_range ON object_range.id = idx.object_id' : ''}
+    `;
+        return {
+            sql: `SELECT COUNT(DISTINCT ${distinctColumn}) AS count ${from} ${whereClause}`,
+            params,
+            queryPlan: [
+                ...queryPlan,
+                `Rdf3xDistinctCount(?${distinctKey})`,
+            ],
+        };
+    }
+    compileMembershipDistinctCountSql(resolved, distinctKey) {
+        const conditions = [];
+        const params = [];
+        const queryPlan = ['Rdf3xMembershipScan'];
+        const ids = resolved.ids;
+        const alias = 'membership';
+        const graphAlias = `${alias}_graph`;
+        const graphPrefixAlias = 'graph_prefix';
+        for (const key of ['graph', ...TERM_KEYS]) {
+            const id = ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`${alias}.${PATTERN_COLUMNS[key]} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, conditions, params, queryPlan);
+        if (ids.graph !== undefined) {
+            queryPlan.push('GraphMembershipFilter');
+        }
+        const useGraphPrefixSource = resolved.graphPrefix !== undefined
+            && ids.graph === undefined
+            && !resolved.idSets?.graph?.length
+            && !resolved.excludedIdSets?.graph?.length;
+        let from = useGraphPrefixSource
+            ? `${GRAPH_PROJECTION_TABLE} ${graphAlias}
+        JOIN rdf_terms ${graphPrefixAlias}
+          ON ${graphPrefixAlias}.id = ${graphAlias}.graph_id
+        JOIN ${this.factSource(alias)}
+          ON ${alias}.graph_id = ${graphAlias}.graph_id`
+            : this.factSource(alias);
+        if (resolved.graphPrefix !== undefined) {
+            if (!useGraphPrefixSource) {
+                from += ` JOIN rdf_terms ${graphPrefixAlias}
+          ON ${graphPrefixAlias}.id = ${alias}.graph_id`;
+            }
+            conditions.push(`${graphPrefixAlias}.kind = ?
+        AND ${graphPrefixAlias}.value_head >= ?
+        AND ${graphPrefixAlias}.value_head < ?
+        AND ${graphPrefixAlias}.value >= ?
+        AND ${graphPrefixAlias}.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix)}\uffff`, resolved.graphPrefix, `${resolved.graphPrefix}\uffff`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (resolved.objectRange) {
+            from += ` JOIN rdf_terms object_range
+        ON object_range.id = ${alias}.object_id`;
+            this.appendObjectRangeCondition('object_range', resolved.objectRange, conditions, params, queryPlan);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, termFilterJoins, conditions, params, queryPlan, 'membership_distinct_term_filter');
+        from += termFilterJoins.join('');
+        const distinctColumn = `${alias}.${PATTERN_COLUMNS[distinctKey]}`;
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        return {
+            sql: `SELECT COUNT(DISTINCT ${distinctColumn}) AS count FROM ${from} ${whereClause}`,
+            params,
+            queryPlan: [
+                ...queryPlan,
+                `Rdf3xDistinctCount(?${distinctKey})`,
+            ],
+        };
+    }
+    joinPatterns(patterns, options) {
+        const start = Date.now();
+        if (patterns.length === 0) {
+            return {
+                bindings: [],
+                metrics: this.joinMetrics('none', 0, 0, start, ['Rdf3xJoinBGP(empty)']),
+            };
+        }
+        const compiled = this.compileJoinPatterns(patterns, options);
+        if (compiled.unresolved) {
+            return {
+                bindings: [],
+                metrics: this.joinMetrics('none', 0, 0, start, [
+                    ...compiled.queryPlan,
+                    `unresolved ${compiled.unresolved}`,
+                ]),
+            };
+        }
+        const rows = this.requireDb().prepare(compiled.sql).all(...compiled.params);
+        const matchedRows = compiled.countSql
+            ? this.requireDb().prepare(compiled.countSql).get(...compiled.countParams)?.count ?? 0
+            : rows.length;
+        return {
+            bindings: this.joinRowsToBindings(rows, compiled.variableAliases),
+            metrics: this.joinMetrics(compiled.indexChoice, matchedRows, rows.length, start, [...compiled.queryPlan, compiled.sql]),
+        };
+    }
+    countJoinPatterns(patterns, options) {
+        return this.aggregateJoinPatternsInternal(patterns, options, 'Rdf3xJoinCount');
+    }
+    aggregateJoinPatterns(patterns, options) {
+        return this.aggregateJoinPatternsInternal(patterns, options, 'Rdf3xJoinAggregate');
+    }
+    groupCountJoinPatterns(patterns, options) {
+        return this.groupAggregateJoinPatternsInternal(patterns, options, 'Rdf3xJoinGroupCount');
+    }
+    groupAggregateJoinPatterns(patterns, options) {
+        return this.groupAggregateJoinPatternsInternal(patterns, options, 'Rdf3xJoinGroupAggregate');
+    }
+    aggregateJoinPatternsInternal(patterns, options, label) {
+        const start = Date.now();
+        if (patterns.length === 0) {
+            return {
+                bindings: [],
+                metrics: this.joinMetrics('none', 0, 0, start, [`${label}(empty)`]),
+            };
+        }
+        const compiled = this.compileJoinPatterns(patterns);
+        if (compiled.unresolved) {
+            return {
+                bindings: [],
+                metrics: this.joinMetrics('none', 0, 0, start, [...compiled.queryPlan, `unresolved ${compiled.unresolved}`]),
+            };
+        }
+        const aggregateAliases = new Map();
+        const aggregateTypes = new Map();
+        const numericJoins = new Map();
+        const numericJoinSql = [];
+        const projection = options.aggregates.map((aggregate, index) => {
+            const alias = `a${index}`;
+            aggregateAliases.set(aggregate.as, alias);
+            return this.buildJoinAggregateColumn(aggregate, alias, compiled.variableColumns, aggregateTypes, numericJoins, numericJoinSql, 'RDF-3X BGP');
+        }).join(', ');
+        const aggregateJoins = numericJoinSql.join('');
+        const sql = `SELECT ${projection} FROM ${compiled.from}${compiled.joins}${aggregateJoins}${compiled.whereClause}`;
+        const rows = this.requireDb().prepare(sql).all(...compiled.params);
+        const matchedRows = this.requireDb()
+            .prepare(`SELECT COUNT(*) AS count FROM ${compiled.from}${compiled.joins}${aggregateJoins}${compiled.whereClause}`)
+            .get(...compiled.params)?.count ?? 0;
+        return {
+            bindings: this.joinRowsToBindings(rows, compiled.variableAliases, aggregateAliases, aggregateTypes),
+            metrics: this.joinMetrics(compiled.indexChoice, matchedRows, rows.length, start, [
+                ...compiled.queryPlan,
+                ...(numericJoinSql.length > 0 ? [`Rdf3xJoinAggregateNumeric(${[...numericJoins.keys()].map((variableName) => `?${variableName}`).join(',')})`] : []),
+                `${label}(${options.aggregates.map((aggregate) => (`${aggregate.type}${aggregate.distinct ? ':DISTINCT' : ''}(${aggregate.variable ? `?${aggregate.variable}` : '*'})`)).join(',')})`,
+                sql,
+            ]),
+        };
+    }
+    groupAggregateJoinPatternsInternal(patterns, options, label) {
+        const start = Date.now();
+        if (patterns.length === 0) {
+            return {
+                bindings: [],
+                metrics: this.joinMetrics('none', 0, 0, start, [`${label}(empty)`]),
+            };
+        }
+        const compiled = this.compileJoinPatterns(patterns);
+        if (compiled.unresolved) {
+            return {
+                bindings: [],
+                metrics: this.joinMetrics('none', 0, 0, start, [...compiled.queryPlan, `unresolved ${compiled.unresolved}`]),
+            };
+        }
+        const aggregateAliases = new Map();
+        const aggregateSqlAliases = new Map();
+        const aggregateTypes = new Map();
+        const numericJoins = new Map();
+        const numericJoinSql = [];
+        const groupColumns = options.groupBy.map((variableName) => {
+            const column = compiled.variableColumns.get(variableName);
+            if (!column) {
+                throw new Error(`RDF-3X BGP group aggregate cannot group by unbound variable: ${variableName}`);
+            }
+            return column;
+        });
+        const aggregateColumns = options.aggregates.map((aggregate, index) => {
+            const alias = `a${index}`;
+            aggregateAliases.set(aggregate.as, alias);
+            aggregateSqlAliases.set(aggregate.as, alias);
+            return this.buildJoinAggregateColumn(aggregate, alias, compiled.variableColumns, aggregateTypes, numericJoins, numericJoinSql, 'RDF-3X BGP group aggregate');
+        });
+        const projection = [
+            ...options.groupBy.map((variableName) => {
+                const alias = compiled.variableAliases.get(variableName);
+                const column = compiled.variableColumns.get(variableName);
+                if (!alias || !column) {
+                    throw new Error(`RDF-3X BGP group aggregate cannot project unbound group variable: ${variableName}`);
+                }
+                return `${column} AS ${alias}`;
+            }),
+            ...aggregateColumns,
+        ].join(', ');
+        const groupBy = groupColumns.join(', ');
+        const aggregateJoins = numericJoinSql.join('');
+        const havingClause = this.buildGroupAggregateHavingClause(options.having, aggregateSqlAliases);
+        const orderScope = this.buildGroupAggregateOrderScope(options, compiled.variableColumns, aggregateSqlAliases);
+        const fromSql = `${compiled.from}${compiled.joins}${aggregateJoins}${compiled.whereClause}`;
+        const sourceFromSql = `${compiled.from}${compiled.joins}${aggregateJoins}${orderScope.joins}${compiled.whereClause}`;
+        const orderClause = orderScope.orderBy;
+        let sql = `SELECT ${projection} FROM ${sourceFromSql} GROUP BY ${groupBy}${havingClause.sql}${orderClause}`;
+        const params = [...compiled.params, ...havingClause.params];
+        const paginated = options.limit !== undefined || options.offset !== undefined;
+        if (options.limit !== undefined) {
+            sql += ' LIMIT ?';
+            params.push(options.limit);
+        }
+        if (options.offset !== undefined) {
+            if (options.limit === undefined) {
+                sql += ' LIMIT -1';
+            }
+            sql += ' OFFSET ?';
+            params.push(options.offset);
+        }
+        const rows = this.requireDb().prepare(sql).all(...params);
+        const matchedRows = this.requireDb()
+            .prepare(`SELECT COUNT(*) AS count FROM ${fromSql}`)
+            .get(...compiled.params)?.count ?? 0;
+        return {
+            bindings: this.joinRowsToBindings(rows, compiled.variableAliases, aggregateAliases, aggregateTypes),
+            metrics: this.joinMetrics(compiled.indexChoice, matchedRows, rows.length, start, [
+                ...compiled.queryPlan,
+                ...(numericJoinSql.length > 0 ? [`Rdf3xJoinGroupAggregateNumeric(${[...numericJoins.keys()].map((variableName) => `?${variableName}`).join(',')})`] : []),
+                `${label}(${options.groupBy.map((variableName) => `?${variableName}`).join(',')})`,
+                ...(havingClause.sql ? [`${label}Having(${(options.having ?? []).map((entry) => `${entry.aggregate}${entry.operator}`).join(',')})`] : []),
+                ...(orderClause ? [`${label}Order(${(options.orderBy ?? []).map((entry) => `${entry.direction ?? 'asc'}:${entry.variable}`).join(',')})`] : []),
+                ...(paginated ? [`${label}Limit`] : []),
+                sql,
+            ]),
+        };
+    }
+    estimateCardinality(pattern) {
+        const resolved = this.resolvePattern(pattern);
+        if (resolved.unresolved) {
+            return {
+                uniqueTriples: 0,
+                matchingQuads: 0,
+                source: 'exact-membership',
+                indexChoice: 'none',
+            };
+        }
+        if (resolved.objectRange || hasResolvedTermFilters(resolved)) {
+            return this.estimateObjectRangeCardinality(resolved);
+        }
+        if (hasResolvedIdSets(resolved) || hasResolvedExcludedIdSets(resolved)) {
+            return this.estimateResolvedMembershipCardinality(resolved);
+        }
+        if (resolved.ids.graph !== undefined || resolved.graphPrefix !== undefined) {
+            return this.estimateResolvedMembershipCardinality(resolved);
+        }
+        const termIds = TERM_KEYS.filter((key) => resolved.ids[key] !== undefined);
+        const permutation = this.choosePermutation(resolved.ids, {
+            idSets: resolved.idSets,
+            termFilters: resolved.termFilters,
+        });
+        if (termIds.length === 3) {
+            return this.estimateExactTriple(resolved.ids, permutation.name);
+        }
+        if (termIds.length === 2) {
+            return this.estimatePairProjection(resolved.ids, permutation.name);
+        }
+        if (termIds.length === 1) {
+            return this.estimateTermProjection(resolved.ids, permutation.name);
+        }
+        return {
+            uniqueTriples: this.uniqueTripleCount(),
+            matchingQuads: this.rowCount(RDF_FACTS_TABLE),
+            source: 'full-count',
+            indexChoice: permutation.name,
+        };
+    }
+    stats() {
+        const spaceObjects = this.collectSpaceObjects();
+        const accountedBytes = spaceObjects.reduce((sum, object) => sum + object.bytes, 0);
+        const databaseBytes = accountedBytes || this.estimateDatabaseBytes();
+        const uniqueTriples = this.uniqueTripleCount();
+        return {
+            uniqueTriples,
+            membershipCount: this.rowCount(RDF_FACTS_TABLE),
+            graphCount: this.rowCount(GRAPH_PROJECTION_TABLE),
+            factsDataVersion: this.factsDataVersion(),
+            permutationRows: Object.fromEntries(PERMUTATIONS.map((permutation) => [
+                permutation.name,
+                uniqueTriples,
+            ])),
+            pairProjectionRows: Object.fromEntries(PAIR_PROJECTIONS.map((projection) => [
+                projection.name,
+                this.rowCount(projection.table),
+            ])),
+            termProjectionRows: Object.fromEntries(TERM_PROJECTIONS.map((projection) => [
+                projection.name,
+                this.rowCount(projection.table),
+            ])),
+            databaseBytes,
+            tableBytes: sumSpaceObjects(spaceObjects, 'table'),
+            indexBytes: sumSpaceObjects(spaceObjects, 'index'),
+            spaceObjects,
+        };
+    }
+    collectSpaceObjects() {
+        const db = this.requireDb();
+        try {
+            const schemaRows = db.prepare(`
+        SELECT name, type, tbl_name
+        FROM sqlite_schema
+        WHERE type IN ('table', 'index')
+          AND (name LIKE 'rdf3x_%' OR tbl_name LIKE 'rdf3x_%')
+      `).all();
+            const schema = new Map(schemaRows.map((row) => [row.name, row]));
+            try {
+                const rows = db.prepare(`
+          SELECT name, COUNT(*) AS pages, SUM(pgsize) AS bytes
+          FROM dbstat
+          WHERE name LIKE 'rdf3x_%'
+             OR name LIKE 'sqlite_autoindex_rdf3x_%'
+          GROUP BY name
+          ORDER BY name
+        `).all();
+                if (rows.length > 0) {
+                    return rows.map((row) => {
+                        const object = schema.get(row.name);
+                        const kind = rdf3xSpaceObjectKind(row.name, object?.type, object?.tbl_name);
+                        return {
+                            name: row.name,
+                            kind,
+                            ...(object?.tbl_name && object.tbl_name !== row.name ? { tableName: object.tbl_name } : {}),
+                            pages: row.pages,
+                            bytes: row.bytes ?? 0,
+                        };
+                    });
+                }
+            }
+            catch {
+                // dbstat is optional in SQLite builds and often unavailable for in-memory databases.
+            }
+            return this.estimateSpaceObjectsFromSchema(schemaRows);
+        }
+        catch {
+            return [];
+        }
+    }
+    initializeSchema() {
+        this.dropMaterializedFactCopies();
+        this.dropLegacyRowidTables();
+        this.prepareSchemaVersion();
+        const pairProjectionTables = PAIR_PROJECTIONS.map((projection) => `
+      CREATE TABLE IF NOT EXISTS ${projection.table} (
+        ${projection.columns[0]} INTEGER NOT NULL,
+        ${projection.columns[1]} INTEGER NOT NULL,
+        triple_count INTEGER NOT NULL,
+        membership_count INTEGER NOT NULL,
+        min_${projection.remainder} INTEGER,
+        max_${projection.remainder} INTEGER,
+        PRIMARY KEY (${projection.columns.join(', ')})
+      ) WITHOUT ROWID;
+    `).join('\n');
+        const termProjectionTables = TERM_PROJECTIONS.map((projection) => `
+      CREATE TABLE IF NOT EXISTS ${projection.table} (
+        ${projection.column} INTEGER NOT NULL PRIMARY KEY,
+        triple_count INTEGER NOT NULL,
+        membership_count INTEGER NOT NULL
+      ) WITHOUT ROWID;
+    `).join('\n');
+        this.requireDb().exec(`
+      CREATE TABLE IF NOT EXISTS ${GRAPH_PROJECTION_TABLE} (
+        graph_id INTEGER NOT NULL PRIMARY KEY,
+        membership_count INTEGER NOT NULL
+      ) WITHOUT ROWID;
+
+      CREATE TABLE IF NOT EXISTS rdf3x_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      ) WITHOUT ROWID;
+
+      ${pairProjectionTables}
+      ${termProjectionTables}
+    `);
+        this.setMetadataValue('schema_version', String(RDF3X_INDEX_SCHEMA_VERSION));
+    }
+    dropMaterializedFactCopies() {
+        (0, Rdf3xSchema_1.dropRdf3xMaterializedFactCopies)(this.requireDb());
+    }
+    dropLegacyRowidTables() {
+        const db = this.requireDb();
+        try {
+            const rows = db.prepare(`
+        SELECT name, wr
+        FROM pragma_table_list
+        WHERE name IN (${Rdf3xSchema_1.RDF3X_DERIVED_TABLES.map(() => '?').join(', ')})
+      `).all(...Rdf3xSchema_1.RDF3X_DERIVED_TABLES);
+            if (!rows.some((row) => row.wr === 0)) {
+                return;
+            }
+        }
+        catch {
+            return;
+        }
+        db.exec([
+            ...Rdf3xSchema_1.RDF3X_DERIVED_INDEXES.map((index) => `DROP INDEX IF EXISTS ${index};`),
+            ...Rdf3xSchema_1.RDF3X_DERIVED_TABLES.map((table) => `DROP TABLE IF EXISTS ${table};`),
+        ].join('\n'));
+    }
+    clearRdf3xTables() {
+        const db = this.requireDb();
+        db.exec([
+            ...PAIR_PROJECTIONS.map((projection) => `DELETE FROM ${projection.table};`),
+            ...TERM_PROJECTIONS.map((projection) => `DELETE FROM ${projection.table};`),
+            `DELETE FROM ${GRAPH_PROJECTION_TABLE};`,
+        ].join('\n'));
+    }
+    prepareSchemaVersion() {
+        this.ensureMetadataTable();
+        const row = this.requireDb()
+            .prepare("SELECT value FROM rdf3x_metadata WHERE key = 'schema_version'")
+            .get();
+        if (!row || row.value === String(RDF3X_INDEX_SCHEMA_VERSION)) {
+            return;
+        }
+        this.dropRdf3xSchema();
+        this.ensureMetadataTable();
+    }
+    ensureMetadataTable() {
+        this.requireDb().exec(`
+      CREATE TABLE IF NOT EXISTS rdf3x_metadata (
+        key TEXT PRIMARY KEY,
+        value TEXT NOT NULL
+      ) WITHOUT ROWID;
+    `);
+    }
+    dropRdf3xSchema() {
+        (0, Rdf3xSchema_1.dropRdf3xDerivedSchemaObjects)(this.requireDb());
+    }
+    currentFactsDataVersion() {
+        try {
+            const row = this.requireDb()
+                .prepare("SELECT value FROM rdf_index_metadata WHERE key = 'data_version'")
+                .get();
+            return Number(row?.value ?? 0) || 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    setFactsDataVersion(version) {
+        this.requireDb().prepare(`
+      INSERT INTO rdf3x_metadata (key, value)
+      VALUES ('facts_data_version', ?)
+      ON CONFLICT (key)
+      DO UPDATE SET value = excluded.value
+    `).run(String(version));
+    }
+    setMetadataValue(key, value) {
+        this.requireDb().prepare(`
+      INSERT INTO rdf3x_metadata (key, value)
+      VALUES (?, ?)
+      ON CONFLICT (key)
+      DO UPDATE SET value = excluded.value
+    `).run(key, value);
+    }
+    rebuildPairProjection(projection) {
+        const [left, right] = projection.columns;
+        this.requireDb().prepare(`
+      INSERT INTO ${projection.table} (
+        ${left},
+        ${right},
+        triple_count,
+        membership_count,
+        min_${projection.remainder},
+        max_${projection.remainder}
+      )
+      SELECT
+        triple.${left},
+        triple.${right},
+        triple.triple_count,
+        COALESCE(member.membership_count, 0) AS membership_count,
+        triple.min_remainder,
+        triple.max_remainder
+      FROM (
+        SELECT
+          ${left},
+          ${right},
+          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 ${left}, ${right}
+      ) triple
+      LEFT JOIN (
+        SELECT
+          ${left},
+          ${right},
+          COUNT(*) AS membership_count
+        FROM ${RDF_FACTS_TABLE}
+        GROUP BY ${left}, ${right}
+      ) member
+        ON member.${left} = triple.${left}
+       AND member.${right} = triple.${right}
+    `).run();
+    }
+    rebuildTermProjection(projection) {
+        this.requireDb().prepare(`
+      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}
+    `).run();
+    }
+    rebuildGraphProjection() {
+        this.requireDb().prepare(`
+      INSERT INTO ${GRAPH_PROJECTION_TABLE} (
+        graph_id,
+        membership_count
+      )
+      SELECT
+        graph_id,
+        COUNT(*) AS membership_count
+      FROM ${RDF_FACTS_TABLE}
+      GROUP BY graph_id
+    `).run();
+    }
+    compileScanSql(permutation, resolved, options, tupleValues) {
+        const conditions = [];
+        const params = [];
+        const queryPlan = [`Permutation(${permutation.name})`];
+        const ids = resolved.ids;
+        for (const key of TERM_KEYS) {
+            const id = ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`idx.${TERM_COLUMN[key]} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(resolved, TERM_KEYS, (key) => `idx.${TERM_COLUMN[key]}`, conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(resolved, TERM_KEYS, (key) => `idx.${TERM_COLUMN[key]}`, conditions, params, queryPlan);
+        if (ids.graph !== undefined) {
+            conditions.push('idx.graph_id = ?');
+            params.push(ids.graph);
+            queryPlan.push('GraphMembershipFilter');
+        }
+        this.appendResolvedExcludedIdSetConditions(resolved, ['graph'], () => 'idx.graph_id', conditions, params, queryPlan);
+        const graphPrefixJoin = resolved.graphPrefix
+            ? ` JOIN rdf_terms graph_prefix
+          ON graph_prefix.id = idx.graph_id`
+            : '';
+        const tupleJoin = tupleValues
+            ? this.buildTupleConstraintJoin(tupleValues, 'rdf3x_tuple_values_scan', 'idx', 'idx')
+            : { join: '', queryPlan: [] };
+        if (resolved.graphPrefix) {
+            conditions.push(`graph_prefix.kind = ?
+        AND graph_prefix.value_head >= ?
+        AND graph_prefix.value_head < ?
+        AND graph_prefix.value >= ?
+        AND graph_prefix.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix)}\uffff`, resolved.graphPrefix, `${resolved.graphPrefix}\uffff`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (resolved.objectRange) {
+            this.appendObjectRangeCondition('object_range', resolved.objectRange, conditions, params, queryPlan);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(resolved, ['graph', ...TERM_KEYS], (key) => `idx.${PATTERN_COLUMNS[key]}`, termFilterJoins, conditions, params, queryPlan, 'scan_term_filter');
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const orderClause = this.buildOrderClause(options, {
+            graph: 'idx.graph_id',
+            subject: 'idx.subject_id',
+            predicate: 'idx.predicate_id',
+            object: 'idx.object_id',
+        });
+        const from = `
+      FROM ${this.permutationSource(permutation, 'idx')}
+      ${tupleJoin.join}
+      ${termFilterJoins.join('')}
+      ${graphPrefixJoin}
+      ${resolved.objectRange ? 'JOIN rdf_terms object_range ON object_range.id = idx.object_id' : ''}
+    `;
+        const pagination = this.buildPagination(options);
+        return {
+            sql: `
+        SELECT
+          idx.graph_id,
+          idx.subject_id,
+          idx.predicate_id,
+          idx.object_id
+        ${from}
+        ${orderClause.joins}
+        ${whereClause}
+        ${orderClause.orderBy || ` ORDER BY ${permutation.columns.map((column) => `idx.${column}`).join(', ')}, idx.graph_id`}
+        ${pagination.sql}
+      `,
+            params: [...params, ...pagination.params],
+            countSql: `SELECT COUNT(*) AS count ${from} ${whereClause}`,
+            countParams: params,
+            queryPlan: [
+                ...queryPlan,
+                ...(orderClause.orderBy ? [`Rdf3xJoinOrder(${describeScanOrder(options)})`] : []),
+                ...tupleJoin.queryPlan,
+                ...(pagination.sql ? ['Pagination'] : []),
+            ],
+        };
+    }
+    compileMembershipScanSql(resolved, options, tupleValues) {
+        const conditions = [];
+        const params = [];
+        const queryPlan = ['Rdf3xMembershipScan'];
+        const ids = resolved.ids;
+        const alias = 'membership';
+        const graphAlias = `${alias}_graph`;
+        const graphPrefixAlias = 'graph_prefix';
+        for (const key of ['graph', ...TERM_KEYS]) {
+            const id = ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`${alias}.${PATTERN_COLUMNS[key]} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, conditions, params, queryPlan);
+        if (ids.graph !== undefined) {
+            queryPlan.push('GraphMembershipFilter');
+        }
+        const useGraphPrefixSource = resolved.graphPrefix !== undefined
+            && ids.graph === undefined
+            && !resolved.idSets?.graph?.length
+            && !resolved.excludedIdSets?.graph?.length;
+        let from = useGraphPrefixSource
+            ? `${GRAPH_PROJECTION_TABLE} ${graphAlias}
+        JOIN rdf_terms ${graphPrefixAlias}
+          ON ${graphPrefixAlias}.id = ${graphAlias}.graph_id
+        JOIN ${this.factSource(alias)}
+          ON ${alias}.graph_id = ${graphAlias}.graph_id`
+            : this.factSource(alias);
+        const tupleJoin = tupleValues
+            ? this.buildTupleConstraintJoin(tupleValues, 'rdf3x_tuple_values_scan', alias, alias)
+            : { join: '', queryPlan: [] };
+        from += tupleJoin.join;
+        if (resolved.graphPrefix !== undefined) {
+            if (!useGraphPrefixSource) {
+                from += ` JOIN rdf_terms ${graphPrefixAlias}
+          ON ${graphPrefixAlias}.id = ${alias}.graph_id`;
+            }
+            conditions.push(`${graphPrefixAlias}.kind = ?
+        AND ${graphPrefixAlias}.value_head >= ?
+        AND ${graphPrefixAlias}.value_head < ?
+        AND ${graphPrefixAlias}.value >= ?
+        AND ${graphPrefixAlias}.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix)}\uffff`, resolved.graphPrefix, `${resolved.graphPrefix}\uffff`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (resolved.objectRange) {
+            from += ` JOIN rdf_terms object_range
+        ON object_range.id = ${alias}.object_id`;
+            this.appendObjectRangeCondition('object_range', resolved.objectRange, conditions, params, queryPlan);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, termFilterJoins, conditions, params, queryPlan, 'membership_scan_term_filter');
+        from += termFilterJoins.join('');
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const orderClause = this.buildOrderClause(options, {
+            graph: `${alias}.graph_id`,
+            subject: `${alias}.subject_id`,
+            predicate: `${alias}.predicate_id`,
+            object: `${alias}.object_id`,
+        });
+        const pagination = this.buildPagination(options);
+        return {
+            sql: `
+        SELECT
+          ${alias}.graph_id,
+          ${alias}.subject_id,
+          ${alias}.predicate_id,
+          ${alias}.object_id
+        FROM ${from}
+        ${orderClause.joins}
+        ${whereClause}
+        ${orderClause.orderBy || ` ORDER BY ${alias}.graph_id, ${alias}.subject_id, ${alias}.predicate_id, ${alias}.object_id`}
+        ${pagination.sql}
+      `,
+            params: [...params, ...pagination.params],
+            countSql: `SELECT COUNT(*) AS count FROM ${from} ${whereClause}`,
+            countParams: params,
+            queryPlan: [
+                ...queryPlan,
+                ...(orderClause.orderBy ? [`Rdf3xJoinOrder(${describeScanOrder(options)})`] : []),
+                ...tupleJoin.queryPlan,
+                ...(pagination.sql ? ['Pagination'] : []),
+            ],
+        };
+    }
+    compileJoinPatterns(patterns, options) {
+        const sources = patterns.map((entry, inputIndex) => {
+            const resolved = this.resolveJoinPattern(entry.pattern);
+            const permutation = this.choosePermutation(resolved.ids, {
+                idSets: resolved.idSets,
+                objectRange: Boolean(resolved.objectRange),
+                termFilters: resolved.termFilters,
+            });
+            const estimate = resolved.unresolved
+                ? {
+                    uniqueTriples: 0,
+                    matchingQuads: 0,
+                    source: 'full-count',
+                    indexChoice: 'none',
+                }
+                : this.estimateResolvedCardinality(resolved);
+            return {
+                inputIndex,
+                alias: `q${inputIndex}`,
+                membershipAlias: `m${inputIndex}`,
+                sourceKind: shouldUseMembershipSource(resolved) ? 'membership' : 'permutation',
+                entry,
+                resolved,
+                permutation,
+                estimate,
+            };
+        });
+        const orderedSources = this.orderJoinSources(sources);
+        const indexOnly = this.canUseIndexOnlyJoin(sources, options);
+        const queryPlan = [
+            `Rdf3xJoinBGP(${patterns.length})`,
+            `Rdf3xJoinOrder(${orderedSources.map((source) => `?${source.inputIndex}:${source.estimate.indexChoice}`).join('>')})`,
+            ...(indexOnly ? ['Rdf3xIndexOnlyJoin'] : []),
+        ];
+        const variableColumns = new Map();
+        const variableAliases = new Map();
+        const conditions = [];
+        const params = [];
+        const countParams = [];
+        const indexChoices = [];
+        const fromFragments = [];
+        for (const [position, source] of orderedSources.entries()) {
+            if (source.resolved.unresolved) {
+                return {
+                    from: '',
+                    joins: '',
+                    whereClause: '',
+                    sql: '',
+                    params: [],
+                    countParams: [],
+                    indexChoice: 'none',
+                    queryPlan,
+                    variableColumns,
+                    variableAliases,
+                    unresolved: source.resolved.unresolved,
+                };
+            }
+            const mergeJoin = this.buildMergeJoinPlan(source, variableColumns);
+            const scanSql = this.joinSourceSql(source, position === 0, mergeJoin, indexOnly);
+            fromFragments.push(scanSql.from);
+            conditions.push(...scanSql.conditions);
+            params.push(...scanSql.params);
+            countParams.push(...scanSql.params);
+            queryPlan.push(...scanSql.queryPlan);
+            indexChoices.push(source.estimate.indexChoice);
+            for (const key of ['graph', ...TERM_KEYS]) {
+                const variableName = source.entry.variables[key];
+                if (!variableName) {
+                    continue;
+                }
+                const column = this.joinSourceColumnRef(source, key);
+                const existing = variableColumns.get(variableName);
+                if (existing) {
+                    if (!mergeJoin.keys.has(key)) {
+                        conditions.push(`${existing} = ${column}`);
+                    }
+                }
+                else {
+                    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(`Rdf3x BGP 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 valueJoins = this.buildJoinValuesJoins(options?.values ?? [], variableColumns);
+        const orderClause = this.buildJoinOrderClause(options, variableColumns);
+        const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '';
+        const from = `${fromFragments.join('')}${valueJoins.joins}`;
+        let sql = `SELECT ${projection} FROM ${from}${orderClause.joins}${whereClause}${orderClause.orderBy}`;
+        const sqlParams = [...params];
+        const paginated = options?.limit !== undefined || options?.offset !== undefined;
+        const countMatchedRows = options?.countMatchedRows ?? true;
+        if (options?.limit !== undefined) {
+            sql += ' LIMIT ?';
+            sqlParams.push(options.limit);
+        }
+        if (options?.offset !== undefined) {
+            if (options.limit === undefined) {
+                sql += ' LIMIT -1';
+            }
+            sql += ' OFFSET ?';
+            sqlParams.push(options.offset);
+        }
+        if (orderClause.orderBy) {
+            queryPlan.push(`Rdf3xJoinOrderBy(${(options?.orderBy ?? []).map((entry) => `${entry.direction ?? 'asc'}:${entry.variable}`).join(',')})`);
+        }
+        queryPlan.push(...valueJoins.queryPlan);
+        if (options?.distinct) {
+            queryPlan.push(`Rdf3xJoinDistinct(${projectVariables.map((variableName) => `?${variableName}`).join(',')})`);
+        }
+        if (paginated) {
+            queryPlan.push('Rdf3xJoinLimit');
+        }
+        return {
+            from,
+            joins: orderClause.joins,
+            whereClause,
+            sql,
+            params: sqlParams,
+            countSql: paginated && countMatchedRows ? `SELECT COUNT(*) AS count FROM ${from}${orderClause.joins}${whereClause}` : undefined,
+            countParams,
+            indexChoice: `Rdf3xJoinBGP(${indexChoices.join('>')})`,
+            queryPlan,
+            variableColumns,
+            variableAliases,
+        };
+    }
+    joinSourceSql(source, first, mergeJoin, indexOnly) {
+        if (source.sourceKind === 'membership') {
+            return this.membershipJoinSourceSql(source, first, mergeJoin);
+        }
+        const conditions = [];
+        const params = [];
+        const queryPlan = [`Rdf3xPermutationScan(${source.permutation.name})`];
+        const alias = source.alias;
+        const graphPrefixAlias = `${source.membershipAlias}_graph_prefix`;
+        for (const key of TERM_KEYS) {
+            const id = source.resolved.ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`${alias}.${TERM_COLUMN[key]} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(source.resolved, TERM_KEYS, (key) => `${alias}.${TERM_COLUMN[key]}`, conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(source.resolved, TERM_KEYS, (key) => `${alias}.${TERM_COLUMN[key]}`, conditions, params, queryPlan);
+        let from = first
+            ? this.permutationSource(source.permutation, alias)
+            : ` JOIN ${this.permutationSource(source.permutation, alias)}
+          ON ${mergeJoin.conditions.length > 0 ? mergeJoin.conditions.join(' AND ') : '1 = 1'}`;
+        if (!first && mergeJoin.variables.length > 0) {
+            queryPlan.push(`Rdf3xMergeJoin(${mergeJoin.variables.map((variableName) => `?${variableName}`).join(',')})`);
+        }
+        if (source.resolved.ids.graph !== undefined) {
+            conditions.push(`${alias}.graph_id = ?`);
+            params.push(source.resolved.ids.graph);
+            queryPlan.push('GraphMembershipFilter');
+        }
+        this.appendResolvedIdSetConditions(source.resolved, ['graph'], () => `${alias}.graph_id`, conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(source.resolved, ['graph'], () => `${alias}.graph_id`, conditions, params, queryPlan);
+        if (source.resolved.graphPrefix !== undefined) {
+            from += ` JOIN rdf_terms ${graphPrefixAlias}
+          ON ${graphPrefixAlias}.id = ${alias}.graph_id`;
+            conditions.push(`${graphPrefixAlias}.kind = ?
+        AND ${graphPrefixAlias}.value_head >= ?
+        AND ${graphPrefixAlias}.value_head < ?
+        AND ${graphPrefixAlias}.value >= ?
+        AND ${graphPrefixAlias}.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(source.resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(source.resolved.graphPrefix)}\uffff`, source.resolved.graphPrefix, `${source.resolved.graphPrefix}\uffff`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (source.resolved.objectRange) {
+            const alias = `${source.alias}_object_range`;
+            from += ` JOIN rdf_terms ${alias}
+          ON ${alias}.id = ${source.alias}.object_id`;
+            this.appendObjectRangeCondition(alias, source.resolved.objectRange, conditions, params, queryPlan);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(source.resolved, ['graph', ...TERM_KEYS], (key) => this.joinSourceColumnRef(source, key), termFilterJoins, conditions, params, queryPlan, `${source.alias}_term_filter`);
+        from += termFilterJoins.join('');
+        return {
+            from,
+            conditions,
+            params,
+            queryPlan,
+        };
+    }
+    membershipJoinSourceSql(source, first, mergeJoin) {
+        const conditions = [];
+        const params = [];
+        const queryPlan = ['Rdf3xMembershipScan'];
+        const alias = source.membershipAlias;
+        const graphAlias = `${alias}_graph`;
+        const graphPrefixAlias = `${alias}_graph_prefix`;
+        const useGraphPrefixSource = first
+            && source.resolved.graphPrefix !== undefined
+            && source.resolved.ids.graph === undefined
+            && !source.resolved.idSets?.graph?.length
+            && !source.resolved.excludedIdSets?.graph?.length;
+        for (const key of ['graph', ...TERM_KEYS]) {
+            const id = source.resolved.ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`${this.joinSourceColumnRef(source, key)} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(source.resolved, ['graph', ...TERM_KEYS], (key) => this.joinSourceColumnRef(source, key), conditions, params, queryPlan);
+        this.appendResolvedExcludedIdSetConditions(source.resolved, ['graph', ...TERM_KEYS], (key) => this.joinSourceColumnRef(source, key), conditions, params, queryPlan);
+        let from = '';
+        if (useGraphPrefixSource) {
+            from = `${GRAPH_PROJECTION_TABLE} ${graphAlias}
+          JOIN rdf_terms ${graphPrefixAlias}
+            ON ${graphPrefixAlias}.id = ${graphAlias}.graph_id
+          JOIN ${this.factSource(alias)}
+            ON ${alias}.graph_id = ${graphAlias}.graph_id`;
+        }
+        else {
+            from = first
+                ? this.factSource(alias)
+                : ` JOIN ${this.factSource(alias)}
+            ON ${mergeJoin.conditions.length > 0 ? mergeJoin.conditions.join(' AND ') : '1 = 1'}`;
+        }
+        if (!first && mergeJoin.variables.length > 0) {
+            queryPlan.push(`Rdf3xMergeJoin(${mergeJoin.variables.map((variableName) => `?${variableName}`).join(',')})`);
+        }
+        if (source.resolved.ids.graph !== undefined) {
+            queryPlan.push('GraphMembershipFilter');
+        }
+        if (source.resolved.graphPrefix !== undefined) {
+            if (!useGraphPrefixSource) {
+                from += ` JOIN rdf_terms ${graphPrefixAlias}
+            ON ${graphPrefixAlias}.id = ${alias}.graph_id`;
+            }
+            conditions.push(`${graphPrefixAlias}.kind = ?
+        AND ${graphPrefixAlias}.value_head >= ?
+        AND ${graphPrefixAlias}.value_head < ?
+        AND ${graphPrefixAlias}.value >= ?
+        AND ${graphPrefixAlias}.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(source.resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(source.resolved.graphPrefix)}\uffff`, source.resolved.graphPrefix, `${source.resolved.graphPrefix}\uffff`);
+            queryPlan.push('GraphPrefixMembershipFilter');
+        }
+        if (source.resolved.objectRange) {
+            const rangeAlias = `${alias}_object_range`;
+            from += ` JOIN rdf_terms ${rangeAlias}
+          ON ${rangeAlias}.id = ${alias}.object_id`;
+            this.appendObjectRangeCondition(rangeAlias, source.resolved.objectRange, conditions, params, queryPlan);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(source.resolved, ['graph', ...TERM_KEYS], (key) => this.joinSourceColumnRef(source, key), termFilterJoins, conditions, params, queryPlan, `${alias}_term_filter`);
+        from += termFilterJoins.join('');
+        return {
+            from,
+            conditions,
+            params,
+            queryPlan,
+        };
+    }
+    canUseIndexOnlyJoin(sources, options) {
+        if (!options?.distinct) {
+            return false;
+        }
+        if (options.limit !== undefined || options.offset !== undefined) {
+            return false;
+        }
+        return sources.every((source) => (!source.resolved.unresolved
+            && source.resolved.ids.graph === undefined
+            && !source.resolved.idSets?.graph?.length
+            && !source.resolved.excludedIdSets?.graph?.length
+            && !source.resolved.termFilters?.graph
+            && source.resolved.graphPrefix === undefined
+            && !source.entry.variables.graph));
+    }
+    buildMergeJoinPlan(source, variableColumns) {
+        const conditions = [];
+        const keys = new Set();
+        const variables = new Set();
+        for (const key of TERM_KEYS) {
+            const variableName = source.entry.variables[key];
+            if (!variableName) {
+                continue;
+            }
+            const existing = variableColumns.get(variableName);
+            if (!existing) {
+                continue;
+            }
+            conditions.push(`${existing} = ${this.joinSourceColumnRef(source, key)}`);
+            keys.add(key);
+            variables.add(variableName);
+        }
+        return {
+            conditions,
+            keys,
+            variables: [...variables],
+        };
+    }
+    joinSourceColumnRef(source, key) {
+        const alias = source.sourceKind === 'membership' ? source.membershipAlias : source.alias;
+        return `${alias}.${PATTERN_COLUMNS[key]}`;
+    }
+    buildTupleConstraintJoin(source, tableName, indexAlias, membershipAlias) {
+        const columns = uniquePatternKeys(source.columns);
+        if (columns.length === 0) {
+            return { join: '', queryPlan: [] };
+        }
+        this.populateTupleConstraintTable(tableName, columns, source.rows);
+        const alias = 'tuple_values';
+        const onClause = columns
+            .map((key) => `${alias}.${this.tupleColumnName(key)} = ${this.tupleColumnRef(key, indexAlias, membershipAlias)}`)
+            .join(' AND ');
+        return {
+            join: ` JOIN ${tableName} ${alias} ON ${onClause}`,
+            queryPlan: [`TupleValuesJoin(${columns.join(',')})`],
+        };
+    }
+    buildJoinValuesJoins(sources, variableColumns) {
+        if (sources.length === 0) {
+            return { joins: '', queryPlan: [] };
+        }
+        const joins = [];
+        const queryPlan = [];
+        sources.forEach((source, sourceIndex) => {
+            const tableName = `rdf3x_join_values_${sourceIndex}`;
+            const alias = `join_values_${sourceIndex}`;
+            this.populateJoinValuesTable(tableName, source);
+            const onClause = source.variables.map((variableName, variableIndex) => {
+                const column = variableColumns.get(variableName);
+                if (!column) {
+                    throw new Error(`Rdf3x BGP join VALUES cannot constrain unbound variable: ${variableName}`);
+                }
+                return `${alias}.${this.joinValueColumnName(variableIndex)} = ${column}`;
+            }).join(' AND ');
+            joins.push(` JOIN ${tableName} ${alias} ON ${onClause}`);
+            queryPlan.push(`Rdf3xJoinTupleValues(${source.variables.map((variableName) => `?${variableName}`).join(',')})`);
+        });
+        return {
+            joins: joins.join(''),
+            queryPlan,
+        };
+    }
+    populateJoinValuesTable(tableName, source) {
+        const db = this.requireDb();
+        const columnDefs = source.variables
+            .map((_variableName, index) => `${this.joinValueColumnName(index)} INTEGER NOT NULL`)
+            .join(', ');
+        db.exec(`DROP TABLE IF EXISTS ${tableName}`);
+        db.exec(`CREATE TEMP TABLE ${tableName} (${columnDefs})`);
+        const valueRows = source.rows
+            .map((row) => source.variables.map((variableName) => this.termIdForTupleConstraint(row[variableName])))
+            .filter((ids) => ids.every((id) => id !== undefined));
+        if (valueRows.length === 0) {
+            return;
+        }
+        const insertColumns = source.variables
+            .map((_variableName, index) => this.joinValueColumnName(index))
+            .join(', ');
+        const placeholders = `(${source.variables.map(() => '?').join(', ')})`;
+        const insert = db.prepare(`INSERT INTO ${tableName} (${insertColumns}) VALUES ${placeholders}`);
+        for (const valueRow of valueRows) {
+            insert.run(...valueRow);
+        }
+    }
+    joinValueColumnName(index) {
+        return `value_${index}_id`;
+    }
+    populateTupleConstraintTable(tableName, columns, rows) {
+        const db = this.requireDb();
+        const columnDefs = columns.map((key) => `${this.tupleColumnName(key)} INTEGER NOT NULL`).join(', ');
+        const primaryKey = columns.map((key) => this.tupleColumnName(key)).join(', ');
+        db.exec(`DROP TABLE IF EXISTS ${tableName}`);
+        db.exec(`CREATE TEMP TABLE ${tableName} (${columnDefs}, PRIMARY KEY (${primaryKey}))`);
+        const valueRows = rows
+            .map((row) => columns.map((key) => this.termIdForTupleConstraint(row[key])))
+            .filter((ids) => ids.every((id) => id !== undefined));
+        if (valueRows.length === 0) {
+            return;
+        }
+        const insertColumns = columns.map((key) => this.tupleColumnName(key)).join(', ');
+        const placeholders = `(${columns.map(() => '?').join(', ')})`;
+        const insert = db.prepare(`INSERT OR IGNORE INTO ${tableName} (${insertColumns}) VALUES ${placeholders}`);
+        for (const valueRow of valueRows) {
+            insert.run(...valueRow);
+        }
+    }
+    termIdForTupleConstraint(term) {
+        if (!term) {
+            return undefined;
+        }
+        return this.requireDictionary().find(term);
+    }
+    tupleColumnName(key) {
+        return key === 'graph' ? 'graph_id' : TERM_COLUMN[key];
+    }
+    tupleColumnRef(key, indexAlias, membershipAlias) {
+        return key === 'graph' ? `${membershipAlias}.graph_id` : `${indexAlias}.${TERM_COLUMN[key]}`;
+    }
+    buildJoinOrderClause(options, variableColumns) {
+        if (!options?.orderBy || options.orderBy.length === 0) {
+            return { joins: '', orderBy: '' };
+        }
+        const joins = options.orderBy.map((entry, index) => {
+            const column = variableColumns.get(entry.variable);
+            if (!column) {
+                throw new Error(`Rdf3x join cannot order by unbound variable: ${entry.variable}`);
+            }
+            const alias = `join_order_t${index}`;
+            return {
+                join: ` JOIN rdf_terms ${alias} ON ${alias}.id = ${column}`,
+                order: `${alias}.value${entry.direction === 'desc' ? ' DESC' : ''}`,
+            };
+        });
+        return {
+            joins: joins.map((entry) => entry.join).join(''),
+            orderBy: ` ORDER BY ${joins.map((entry) => entry.order).join(', ')}`,
+        };
+    }
+    buildJoinAggregateColumn(aggregate, alias, variableColumns, aggregateTypes, numericJoins, numericJoinSql, errorPrefix) {
+        if (aggregate.type === 'count' && !aggregate.variable) {
+            aggregateTypes.set(aggregate.as, 'integer');
+            return `${aggregate.distinct ? `COUNT(DISTINCT ${joinSolutionMappingKeyExpression(variableColumns, aggregate.distinctVariables, errorPrefix)})` : 'COUNT(*)'} AS ${alias}`;
+        }
+        if (!aggregate.variable) {
+            throw new Error(`${errorPrefix} ${aggregate.type} aggregate requires a bound variable`);
+        }
+        const column = variableColumns.get(aggregate.variable);
+        if (!column) {
+            throw new Error(`${errorPrefix} aggregate cannot read unbound variable: ${aggregate.variable}`);
+        }
+        if (aggregate.type === 'count') {
+            aggregateTypes.set(aggregate.as, 'integer');
+            return `COUNT(${aggregate.distinct ? 'DISTINCT ' : ''}${column}) AS ${alias}`;
+        }
+        if (aggregate.distinct) {
+            throw new Error(`${errorPrefix} ${aggregate.type} DISTINCT aggregate is not supported in SQL aggregate path`);
+        }
+        aggregateTypes.set(aggregate.as, 'decimal');
+        const termAlias = numericJoins.get(aggregate.variable) ?? `rdf3x_agg_numeric_t${numericJoins.size}`;
+        if (!numericJoins.has(aggregate.variable)) {
+            numericJoins.set(aggregate.variable, termAlias);
+            numericJoinSql.push(` JOIN rdf_terms ${termAlias} ON ${termAlias}.id = ${column} AND ${termAlias}.kind = 'literal' AND ${termAlias}.numeric_value IS NOT NULL`);
+        }
+        switch (aggregate.type) {
+            case 'sum':
+                return `COALESCE(SUM(${termAlias}.numeric_value), 0) AS ${alias}`;
+            case 'avg':
+                return `AVG(${termAlias}.numeric_value) AS ${alias}`;
+            case 'min':
+                return `MIN(${termAlias}.numeric_value) AS ${alias}`;
+            case 'max':
+                return `MAX(${termAlias}.numeric_value) AS ${alias}`;
+            default: {
+                const exhaustive = aggregate.type;
+                throw new Error(`Unsupported RDF-3X BGP aggregate type: ${exhaustive}`);
+            }
+        }
+    }
+    buildGroupAggregateHavingClause(having, aggregateAliases) {
+        if (!having || having.length === 0) {
+            return { sql: '', params: [] };
+        }
+        const conditions = [];
+        const params = [];
+        for (const entry of having) {
+            const alias = aggregateAliases.get(entry.aggregate);
+            if (!alias) {
+                throw new Error(`RDF-3X BGP group aggregate cannot HAVING on unknown aggregate: ${entry.aggregate}`);
+            }
+            conditions.push(`${alias} ${this.havingSqlOperator(entry.operator)} ?`);
+            params.push(entry.value);
+        }
+        return {
+            sql: ` HAVING ${conditions.join(' AND ')}`,
+            params,
+        };
+    }
+    havingSqlOperator(operator) {
+        switch (operator) {
+            case '$eq':
+                return '=';
+            case '$ne':
+                return '!=';
+            case '$gt':
+                return '>';
+            case '$gte':
+                return '>=';
+            case '$lt':
+                return '<';
+            case '$lte':
+                return '<=';
+            default: {
+                const exhaustive = operator;
+                throw new Error(`Unsupported RDF-3X BGP group aggregate HAVING operator: ${exhaustive}`);
+            }
+        }
+    }
+    buildGroupAggregateOrderScope(options, variableColumns, aggregateAliases) {
+        if (!options.orderBy || options.orderBy.length === 0) {
+            return { joins: '', orderBy: '' };
+        }
+        const joins = [];
+        const orders = options.orderBy.map((entry, index) => {
+            const aggregateAlias = aggregateAliases.get(entry.variable);
+            if (aggregateAlias) {
+                return `${aggregateAlias}${entry.direction === 'desc' ? ' DESC' : ''}`;
+            }
+            const column = variableColumns.get(entry.variable);
+            if (!column) {
+                throw new Error(`RDF-3X BGP group aggregate cannot order by unbound variable: ${entry.variable}`);
+            }
+            const alias = `rdf3x_group_order_t${index}`;
+            joins.push(` JOIN rdf_terms ${alias} ON ${alias}.id = ${column}`);
+            return `${alias}.value${entry.direction === 'desc' ? ' DESC' : ''}`;
+        });
+        return {
+            joins: joins.join(''),
+            orderBy: ` ORDER BY ${orders.join(', ')}`,
+        };
+    }
+    buildOrderClause(options, columnRefs) {
+        if (!options?.order || options.order.length === 0) {
+            return { joins: '', orderBy: '' };
+        }
+        const joins = options.order.map((termName, index) => {
+            const column = ORDER_COLUMN[termName];
+            const alias = `order_t${index}`;
+            const direction = options.orderDirections?.[index] ?? (options.reverse ? 'desc' : 'asc');
+            const columnRef = columnRefs?.[termName] ?? (termName === 'graph' ? 'membership.graph_id' : `idx.${column}`);
+            return {
+                join: ` JOIN rdf_terms ${alias} ON ${alias}.id = ${columnRef}`,
+                order: `${alias}.value${direction === 'desc' ? ' DESC' : ''}`,
+            };
+        });
+        return {
+            joins: joins.map((entry) => entry.join).join(''),
+            orderBy: ` ORDER BY ${joins.map((entry) => entry.order).join(', ')}`,
+        };
+    }
+    chooseJoinStart(sources) {
+        if (sources.length === 0) {
+            throw new Error('Rdf3x join requires at least one source');
+        }
+        return [...sources].sort((left, right) => this.compareJoinSources(left, right))[0];
+    }
+    orderJoinSources(sources) {
+        const remaining = [...sources];
+        const ordered = [];
+        const boundVariables = new Set();
+        while (remaining.length > 0) {
+            const next = ordered.length === 0
+                ? this.chooseJoinStart(remaining)
+                : this.chooseNextJoinSource(remaining, boundVariables);
+            ordered.push(next);
+            for (const variableName of this.sourceVariables(next)) {
+                boundVariables.add(variableName);
+            }
+            remaining.splice(remaining.findIndex((source) => source.inputIndex === next.inputIndex), 1);
+        }
+        return ordered;
+    }
+    chooseNextJoinSource(sources, boundVariables) {
+        return [...sources].sort((left, right) => (this.compareJoinConnectivity(left, right, boundVariables)
+            || this.compareJoinFanout(left, right, boundVariables)
+            || this.compareJoinSources(left, right)))[0];
+    }
+    compareJoinConnectivity(left, right, boundVariables) {
+        const leftConnected = this.boundVariableCount(left, boundVariables);
+        const rightConnected = this.boundVariableCount(right, boundVariables);
+        if (leftConnected !== rightConnected) {
+            return rightConnected - leftConnected;
+        }
+        return 0;
+    }
+    boundVariableCount(source, boundVariables) {
+        return this.sourceVariables(source).filter((variableName) => boundVariables.has(variableName)).length;
+    }
+    compareJoinFanout(left, right, boundVariables) {
+        const leftFanout = this.estimateJoinFanout(left, boundVariables);
+        const rightFanout = this.estimateJoinFanout(right, boundVariables);
+        if (leftFanout !== rightFanout) {
+            return leftFanout - rightFanout;
+        }
+        return 0;
+    }
+    estimateJoinFanout(source, boundVariables) {
+        if (source.resolved.unresolved) {
+            return Number.POSITIVE_INFINITY;
+        }
+        const boundKeys = this.boundPatternKeys(source, boundVariables);
+        if (boundKeys.length === 0) {
+            return source.estimate.matchingQuads;
+        }
+        const distinctBoundTuples = this.countDistinctResolvedMembershipTuple(source.resolved, boundKeys);
+        if (distinctBoundTuples === 0) {
+            return source.estimate.matchingQuads === 0 ? 0 : Number.POSITIVE_INFINITY;
+        }
+        return source.estimate.matchingQuads / distinctBoundTuples;
+    }
+    boundPatternKeys(source, boundVariables) {
+        return uniquePatternKeys(['graph', ...TERM_KEYS].filter((key) => {
+            const variableName = source.entry.variables[key];
+            return variableName ? boundVariables.has(variableName) : false;
+        }));
+    }
+    sourceVariables(source) {
+        return [...new Set(Object.values(source.entry.variables).filter((value) => Boolean(value)))];
+    }
+    compareJoinSources(left, right) {
+        const leftResolved = left.resolved.unresolved ? Number.POSITIVE_INFINITY : left.estimate.matchingQuads;
+        const rightResolved = right.resolved.unresolved ? Number.POSITIVE_INFINITY : right.estimate.matchingQuads;
+        if (leftResolved !== rightResolved) {
+            return leftResolved - rightResolved;
+        }
+        if (left.estimate.uniqueTriples !== right.estimate.uniqueTriples) {
+            return left.estimate.uniqueTriples - right.estimate.uniqueTriples;
+        }
+        return left.inputIndex - right.inputIndex;
+    }
+    estimateResolvedCardinality(resolved) {
+        const ids = resolved.ids;
+        if (resolved.objectRange || hasResolvedTermFilters(resolved)) {
+            return this.estimateObjectRangeCardinality(resolved);
+        }
+        if (hasResolvedIdSets(resolved) || hasResolvedExcludedIdSets(resolved)) {
+            return this.estimateResolvedMembershipCardinality(resolved);
+        }
+        const termIds = TERM_KEYS.filter((key) => ids[key] !== undefined);
+        if (ids.graph !== undefined || resolved.graphPrefix !== undefined) {
+            return this.estimateResolvedMembershipCardinality(resolved);
+        }
+        if (termIds.length === 3) {
+            return this.estimateExactTriple(ids, this.choosePermutation(ids).name);
+        }
+        if (termIds.length === 2) {
+            return this.estimatePairProjection(ids, this.choosePermutation(ids).name);
+        }
+        if (termIds.length === 1) {
+            return this.estimateTermProjection(ids, this.choosePermutation(ids).name);
+        }
+        return {
+            uniqueTriples: this.uniqueTripleCount(),
+            matchingQuads: this.rowCount(RDF_FACTS_TABLE),
+            source: 'full-count',
+            indexChoice: this.choosePermutation(ids, {
+                idSets: resolved.idSets,
+                objectRange: Boolean(resolved.objectRange),
+                termFilters: resolved.termFilters,
+            }).name,
+        };
+    }
+    resolveJoinPattern(pattern) {
+        const ids = {};
+        const idSets = {};
+        const excludedIdSets = {};
+        const termFilters = {};
+        let graphPrefix;
+        let objectRange;
+        for (const key of ['graph', ...TERM_KEYS]) {
+            const match = pattern[key];
+            if (!match) {
+                continue;
+            }
+            if (key === 'graph' && isGraphPrefixPattern(match)) {
+                graphPrefix = match.$startsWith;
+                continue;
+            }
+            if (isTermInPattern(match)) {
+                const resolvedIds = this.resolveTermInIds(match);
+                if (resolvedIds.length === 0) {
+                    return { ids, idSets, excludedIdSets, graphPrefix, objectRange, unresolved: key };
+                }
+                idSets[key] = resolvedIds;
+                continue;
+            }
+            if (isTermNotInPattern(match)) {
+                const resolvedIds = this.resolveTermNotInIds(match);
+                if (resolvedIds.length > 0) {
+                    excludedIdSets[key] = resolvedIds;
+                }
+                continue;
+            }
+            if (isOperatorPattern(match)) {
+                const resolved = this.resolveOperatorPattern(key, match);
+                if (resolved.unresolved) {
+                    return { ids, idSets, excludedIdSets, termFilters, graphPrefix, objectRange, unresolved: key };
+                }
+                if (resolved.graphPrefix !== undefined)
+                    graphPrefix = resolved.graphPrefix;
+                if (resolved.idSet)
+                    idSets[key] = resolved.idSet;
+                if (resolved.excludedIdSet)
+                    excludedIdSets[key] = resolved.excludedIdSet;
+                if (resolved.objectRange)
+                    objectRange = resolved.objectRange;
+                if (resolved.termFilter)
+                    termFilters[key] = resolved.termFilter;
+                continue;
+            }
+            if (key === 'object' && isObjectRangePattern(match)) {
+                const resolvedRange = this.resolveObjectRange(match);
+                if (!resolvedRange) {
+                    return { ids, idSets, excludedIdSets, termFilters, graphPrefix, objectRange: resolvedRange, unresolved: key };
+                }
+                objectRange = resolvedRange;
+                continue;
+            }
+            if (!isRdfTerm(match)) {
+                return { ids, idSets, excludedIdSets, termFilters, graphPrefix, unresolved: key };
+            }
+            const id = this.requireDictionary().find(match);
+            if (id === undefined) {
+                return { ids, idSets, excludedIdSets, termFilters, graphPrefix, unresolved: key };
+            }
+            ids[key] = id;
+        }
+        return {
+            ids,
+            ...(Object.keys(idSets).length > 0 ? { idSets } : {}),
+            ...(Object.keys(excludedIdSets).length > 0 ? { excludedIdSets } : {}),
+            ...(Object.keys(termFilters).length > 0 ? { termFilters } : {}),
+            ...(graphPrefix !== undefined ? { graphPrefix } : {}),
+            ...(objectRange !== undefined ? { objectRange } : {}),
+        };
+    }
+    joinMetrics(indexChoice, matchedRows, returnedRows, start, queryPlan) {
+        return {
+            engine: 'solid-rdf3x',
+            indexChoice,
+            matchedRows,
+            returnedRows,
+            durationMs: Date.now() - start,
+            queryPlan,
+        };
+    }
+    joinRowsToBindings(rows, variableAliases, aggregateAliases, aggregateTypes) {
+        const aliases = [...variableAliases.entries()];
+        const termMap = this.requireDictionary().rowsForIds(rows.flatMap((row) => (aliases
+            .map(([, alias]) => row[alias])
+            .filter((id) => typeof id === 'number'))));
+        return rows.map((row) => {
+            const binding = {};
+            for (const [variableName, alias] of aliases) {
+                const id = row[alias];
+                if (typeof id !== 'number') {
+                    continue;
+                }
+                binding[variableName] = requiredTerm(termMap, id);
+            }
+            for (const [variableName, alias] of aggregateAliases ?? []) {
+                const value = row[alias];
+                if (typeof value === 'number') {
+                    const datatype = aggregateTypes?.get(variableName) === 'decimal' ? XSD_DECIMAL : XSD_INTEGER;
+                    binding[variableName] = n3_1.DataFactory.literal(String(value), n3_1.DataFactory.namedNode(datatype));
+                }
+            }
+            return binding;
+        });
+    }
+    buildPagination(options) {
+        if (!options) {
+            return { sql: '', params: [] };
+        }
+        const clauses = [];
+        const params = [];
+        if (options.limit !== undefined) {
+            clauses.push('LIMIT ?');
+            params.push(Math.max(0, options.limit));
+        }
+        if (options.offset !== undefined) {
+            if (options.limit === undefined) {
+                clauses.push('LIMIT -1');
+            }
+            clauses.push('OFFSET ?');
+            params.push(Math.max(0, options.offset));
+        }
+        return {
+            sql: clauses.length > 0 ? ` ${clauses.join(' ')}` : '',
+            params,
+        };
+    }
+    estimateExactTriple(ids, indexChoice) {
+        const row = this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT 1
+        FROM ${RDF_FACTS_TABLE}
+        WHERE subject_id = ?
+          AND predicate_id = ?
+          AND object_id = ?
+        LIMIT 1
+      ) exact_triple
+    `).get(ids.subject, ids.predicate, ids.object);
+        const membership = this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM ${RDF_FACTS_TABLE}
+      WHERE subject_id = ?
+        AND predicate_id = ?
+        AND object_id = ?
+    `).get(ids.subject, ids.predicate, ids.object);
+        return {
+            uniqueTriples: row?.count ?? 0,
+            matchingQuads: membership?.count ?? 0,
+            source: 'exact-triple',
+            indexChoice,
+        };
+    }
+    estimatePairProjection(ids, indexChoice) {
+        const projection = this.pairProjectionFor(ids);
+        if (!projection) {
+            return this.estimateMembershipCardinality(ids);
+        }
+        const [left, right] = projection.columns;
+        const row = this.requireDb().prepare(`
+      SELECT triple_count, membership_count
+      FROM ${projection.table}
+      WHERE ${left} = ?
+        AND ${right} = ?
+    `).get(ids[keyForColumn(left)], ids[keyForColumn(right)]);
+        return {
+            uniqueTriples: row?.triple_count ?? 0,
+            matchingQuads: row?.membership_count ?? 0,
+            source: 'projection-stat',
+            indexChoice,
+        };
+    }
+    estimateTermProjection(ids, indexChoice) {
+        const key = TERM_KEYS.find((candidate) => ids[candidate] !== undefined);
+        if (!key) {
+            return this.estimateMembershipCardinality(ids);
+        }
+        const projection = TERM_PROJECTIONS.find((candidate) => candidate.column === TERM_COLUMN[key]);
+        if (!projection) {
+            return this.estimateMembershipCardinality(ids);
+        }
+        const row = this.requireDb().prepare(`
+      SELECT triple_count, membership_count
+      FROM ${projection.table}
+      WHERE ${projection.column} = ?
+    `).get(ids[key]);
+        return {
+            uniqueTriples: row?.triple_count ?? 0,
+            matchingQuads: row?.membership_count ?? 0,
+            source: 'term-stat',
+            indexChoice,
+        };
+    }
+    estimateMembershipCardinality(ids) {
+        return this.estimateResolvedMembershipCardinality({ ids });
+    }
+    estimateResolvedMembershipCardinality(resolved) {
+        const { from, whereClause, params } = this.buildMembershipWhere(resolved);
+        const matchingQuads = this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM ${from}
+      ${whereClause}
+    `).get(...params)?.count ?? 0;
+        const uniqueTriples = this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT DISTINCT subject_id, predicate_id, object_id
+        FROM ${from}
+        ${whereClause}
+      ) distinct_triples
+    `).get(...params)?.count ?? 0;
+        return {
+            uniqueTriples,
+            matchingQuads,
+            source: 'exact-membership',
+            indexChoice: 'source-membership',
+        };
+    }
+    buildMembershipWhere(resolved) {
+        const ids = resolved.ids;
+        const conditions = [];
+        const params = [];
+        const alias = 'membership';
+        const useGraphPrefixSource = resolved.graphPrefix !== undefined
+            && ids.graph === undefined
+            && !resolved.idSets?.graph?.length
+            && !resolved.excludedIdSets?.graph?.length;
+        for (const key of ['graph', ...TERM_KEYS]) {
+            const id = ids[key];
+            if (id === undefined) {
+                continue;
+            }
+            conditions.push(`${alias}.${PATTERN_COLUMNS[key]} = ?`);
+            params.push(id);
+        }
+        this.appendResolvedIdSetConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, conditions, params);
+        this.appendResolvedExcludedIdSetConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, conditions, params);
+        let from = this.factSource(alias);
+        if (useGraphPrefixSource) {
+            from = `${GRAPH_PROJECTION_TABLE} membership_graph
+        JOIN rdf_terms membership_graph_prefix
+          ON membership_graph_prefix.id = membership_graph.graph_id
+        JOIN ${this.factSource(alias)}
+          ON ${alias}.graph_id = membership_graph.graph_id`;
+        }
+        else if (resolved.graphPrefix !== undefined) {
+            from += ` JOIN rdf_terms membership_graph_prefix
+        ON membership_graph_prefix.id = ${alias}.graph_id`;
+        }
+        if (resolved.graphPrefix !== undefined) {
+            conditions.push(`membership_graph_prefix.kind = ?
+        AND membership_graph_prefix.value_head >= ?
+        AND membership_graph_prefix.value_head < ?
+        AND membership_graph_prefix.value >= ?
+        AND membership_graph_prefix.value < ?`);
+            params.push('iri', (0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix), `${(0, RdfTermDictionary_1.rdfTermValueHead)(resolved.graphPrefix)}\uffff`, resolved.graphPrefix, `${resolved.graphPrefix}\uffff`);
+        }
+        const termFilterJoins = [];
+        this.appendTermFilterJoinsAndConditions(resolved, ['graph', ...TERM_KEYS], (key) => `${alias}.${PATTERN_COLUMNS[key]}`, termFilterJoins, conditions, params, undefined, 'membership_estimate_term_filter');
+        from += termFilterJoins.join('');
+        return {
+            whereClause: conditions.length > 0 ? ` WHERE ${conditions.join(' AND ')}` : '',
+            from,
+            params,
+        };
+    }
+    pairProjectionFor(ids) {
+        const columns = TERM_KEYS
+            .filter((key) => ids[key] !== undefined)
+            .map((key) => TERM_COLUMN[key]);
+        return PAIR_PROJECTIONS.find((projection) => (projection.columns.every((column) => columns.includes(column))));
+    }
+    appendResolvedIdSetConditions(resolved, keys, columnForKey, conditions, params, queryPlan) {
+        for (const key of keys) {
+            const ids = resolved.idSets?.[key];
+            if (!ids || ids.length === 0) {
+                continue;
+            }
+            conditions.push(`${columnForKey(key)} IN (${ids.map(() => '?').join(', ')})`);
+            params.push(...ids);
+            queryPlan?.push(`TermIn(${key})`);
+            if (key === 'graph') {
+                queryPlan?.push('GraphMembershipFilter');
+            }
+        }
+    }
+    appendResolvedExcludedIdSetConditions(resolved, keys, columnForKey, conditions, params, queryPlan) {
+        for (const key of keys) {
+            const ids = resolved.excludedIdSets?.[key];
+            if (!ids || ids.length === 0) {
+                continue;
+            }
+            conditions.push(`${columnForKey(key)} NOT IN (${ids.map(() => '?').join(', ')})`);
+            params.push(...ids);
+            queryPlan?.push(`TermNotIn(${key})`);
+            if (key === 'graph') {
+                queryPlan?.push('GraphMembershipFilter');
+            }
+        }
+    }
+    resolvePattern(pattern) {
+        const ids = {};
+        const idSets = {};
+        const excludedIdSets = {};
+        const termFilters = {};
+        let graphPrefix;
+        let objectRange;
+        for (const key of ['graph', ...TERM_KEYS]) {
+            const term = pattern[key];
+            if (!term) {
+                continue;
+            }
+            if (key === 'graph' && isGraphPrefixPattern(term)) {
+                graphPrefix = term.$startsWith;
+                continue;
+            }
+            if (isTermInPattern(term)) {
+                const resolvedIds = this.resolveTermInIds(term);
+                if (resolvedIds.length === 0) {
+                    return { ids, idSets, graphPrefix, objectRange, unresolved: key };
+                }
+                idSets[key] = resolvedIds;
+                continue;
+            }
+            if (isTermNotInPattern(term)) {
+                const resolvedIds = this.resolveTermNotInIds(term);
+                if (resolvedIds.length > 0) {
+                    excludedIdSets[key] = resolvedIds;
+                }
+                continue;
+            }
+            if (isOperatorPattern(term)) {
+                const resolved = this.resolveOperatorPattern(key, term);
+                if (resolved.unresolved) {
+                    return { ids, idSets, termFilters, graphPrefix, objectRange, unresolved: key };
+                }
+                if (resolved.graphPrefix !== undefined)
+                    graphPrefix = resolved.graphPrefix;
+                if (resolved.idSet)
+                    idSets[key] = resolved.idSet;
+                if (resolved.excludedIdSet)
+                    excludedIdSets[key] = resolved.excludedIdSet;
+                if (resolved.objectRange)
+                    objectRange = resolved.objectRange;
+                if (resolved.termFilter)
+                    termFilters[key] = resolved.termFilter;
+                continue;
+            }
+            if (key === 'object' && isObjectRangePattern(term)) {
+                const resolvedRange = this.resolveObjectRange(term);
+                if (!resolvedRange) {
+                    return { ids, idSets, termFilters, graphPrefix, objectRange: resolvedRange, unresolved: key };
+                }
+                objectRange = resolvedRange;
+                continue;
+            }
+            if (key === 'graph' && !isRdfTerm(term)) {
+                return { ids, idSets, termFilters, graphPrefix, unresolved: key };
+            }
+            if (key !== 'graph' && !isRdfTerm(term)) {
+                return { ids, idSets, termFilters, graphPrefix, unresolved: key };
+            }
+            const rdfTerm = term;
+            const id = this.requireDictionary().find(rdfTerm);
+            if (id === undefined) {
+                return { ids, idSets, termFilters, graphPrefix, unresolved: key };
+            }
+            ids[key] = id;
+        }
+        return {
+            ids,
+            ...(Object.keys(idSets).length > 0 ? { idSets } : {}),
+            ...(Object.keys(excludedIdSets).length > 0 ? { excludedIdSets } : {}),
+            ...(Object.keys(termFilters).length > 0 ? { termFilters } : {}),
+            ...(graphPrefix !== undefined ? { graphPrefix } : {}),
+            ...(objectRange !== undefined ? { objectRange } : {}),
+        };
+    }
+    resolveTermInIds(pattern) {
+        return uniqueNumbers(pattern.$in
+            .map((term) => this.requireDictionary().find(term))
+            .filter((id) => id !== undefined));
+    }
+    resolveTermNotInIds(pattern) {
+        return uniqueNumbers(pattern.$notIn
+            .map((term) => this.requireDictionary().find(term))
+            .filter((id) => id !== undefined));
+    }
+    resolveOperatorPattern(key, pattern) {
+        if (!isSupportedOperatorPattern(key, pattern)) {
+            return { unresolved: true };
+        }
+        const result = {};
+        if (key === 'graph' && pattern.$startsWith !== undefined) {
+            result.graphPrefix = pattern.$startsWith;
+        }
+        if (pattern.$in !== undefined) {
+            const resolvedIds = this.resolveTermInIds({ $in: pattern.$in });
+            if (resolvedIds.length === 0) {
+                return { unresolved: true };
+            }
+            result.idSet = resolvedIds;
+        }
+        if (pattern.$notIn !== undefined) {
+            const resolvedIds = this.resolveTermNotInIds({ $notIn: pattern.$notIn });
+            if (resolvedIds.length > 0) {
+                result.excludedIdSet = resolvedIds;
+            }
+        }
+        if (key === 'object' && hasObjectRangeOperator(pattern)) {
+            const objectRange = this.resolveObjectRange(pattern);
+            if (!objectRange) {
+                return { unresolved: true };
+            }
+            result.objectRange = objectRange;
+        }
+        const termFilter = this.resolveTermMetadataFilter(pattern);
+        if (termFilter) {
+            result.termFilter = termFilter;
+        }
+        return result;
+    }
+    resolveTermMetadataFilter(pattern) {
+        const filter = {};
+        if (pattern.$termType !== undefined) {
+            filter.termType = pattern.$termType;
+        }
+        if (pattern.$language !== undefined) {
+            filter.language = pattern.$language;
+        }
+        if (pattern.$notLanguage !== undefined) {
+            filter.notLanguage = pattern.$notLanguage;
+        }
+        if (pattern.$langMatches !== undefined) {
+            filter.langMatches = pattern.$langMatches;
+        }
+        if (pattern.$datatype !== undefined) {
+            filter.datatype = this.resolveDatatypeFilter(pattern.$datatype);
+        }
+        if (pattern.$notDatatype !== undefined) {
+            filter.notDatatype = this.resolveDatatypeFilter(pattern.$notDatatype);
+        }
+        const textSearches = this.resolveTextSearchFilter(pattern);
+        if (textSearches) {
+            filter.textSearches = textSearches;
+        }
+        return Object.keys(filter).length > 0 ? filter : undefined;
+    }
+    resolveTextSearchFilter(pattern) {
+        const searches = [];
+        if (pattern.$contains !== undefined) {
+            searches.push({ operator: '$contains', value: pattern.$contains });
+        }
+        if (pattern.$endsWith !== undefined) {
+            searches.push({ operator: '$endsWith', value: pattern.$endsWith });
+        }
+        return searches.length > 0 ? searches : undefined;
+    }
+    resolveDatatypeFilter(datatype) {
+        if (datatype.termType !== 'NamedNode') {
+            return { kind: 'unknown' };
+        }
+        if (datatype.value === XSD_STRING) {
+            return { kind: 'xsd-string' };
+        }
+        const id = this.requireDictionary().find(datatype);
+        return id === undefined ? { kind: 'unknown' } : { kind: 'id', id };
+    }
+    countDistinctResolvedMembershipTuple(resolved, keys) {
+        const distinctKeys = uniquePatternKeys(keys);
+        if (distinctKeys.length === 0) {
+            return 0;
+        }
+        const { from, whereClause, params } = this.buildMembershipWhere({
+            ids: resolved.ids,
+            ...(resolved.idSets !== undefined ? { idSets: resolved.idSets } : {}),
+            ...(resolved.excludedIdSets !== undefined ? { excludedIdSets: resolved.excludedIdSets } : {}),
+            ...(resolved.graphPrefix !== undefined ? { graphPrefix: resolved.graphPrefix } : {}),
+        });
+        const rangeConditions = [];
+        const rangeParams = [];
+        const rangePlan = [];
+        const rangeJoin = resolved.objectRange
+            ? ' JOIN rdf_terms fanout_object_range ON fanout_object_range.id = membership.object_id'
+            : '';
+        if (resolved.objectRange) {
+            this.appendObjectRangeCondition('fanout_object_range', resolved.objectRange, rangeConditions, rangeParams, rangePlan);
+        }
+        const combinedWhereClause = rangeConditions.length > 0
+            ? `${whereClause || ' WHERE 1 = 1'} AND ${rangeConditions.join(' AND ')}`
+            : whereClause;
+        const projection = distinctKeys
+            .map((key) => `membership.${PATTERN_COLUMNS[key]}`)
+            .join(', ');
+        return this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT DISTINCT ${projection}
+        FROM ${from}
+        ${rangeJoin}
+        ${combinedWhereClause}
+      ) distinct_bound_tuples
+    `).get(...params, ...rangeParams)?.count ?? 0;
+    }
+    estimateObjectRangeCardinality(resolved) {
+        const range = resolved.objectRange;
+        if (!range) {
+            return this.estimateResolvedMembershipCardinality(resolved);
+        }
+        const { from, whereClause, params } = this.buildMembershipWhere({
+            ids: resolved.ids,
+            ...(resolved.idSets !== undefined ? { idSets: resolved.idSets } : {}),
+            ...(resolved.excludedIdSets !== undefined ? { excludedIdSets: resolved.excludedIdSets } : {}),
+            ...(resolved.graphPrefix !== undefined ? { graphPrefix: resolved.graphPrefix } : {}),
+        });
+        const rangeConditions = [];
+        const rangeParams = [];
+        const rangePlan = [];
+        this.appendObjectRangeCondition('object_range', range, rangeConditions, rangeParams, rangePlan);
+        const membershipWhere = whereClause
+            ? `${whereClause} AND ${rangeConditions.join(' AND ')}`
+            : ` WHERE ${rangeConditions.join(' AND ')}`;
+        const matchingQuads = this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM ${from}
+      JOIN rdf_terms object_range ON object_range.id = membership.object_id
+      ${membershipWhere}
+    `).get(...params, ...rangeParams)?.count ?? 0;
+        const uniqueTriples = this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT DISTINCT subject_id, predicate_id, object_id
+        FROM ${from}
+        JOIN rdf_terms object_range ON object_range.id = membership.object_id
+        ${membershipWhere}
+      ) distinct_triples
+    `).get(...params, ...rangeParams)?.count ?? 0;
+        return {
+            uniqueTriples,
+            matchingQuads,
+            source: 'exact-membership',
+            indexChoice: 'source-membership',
+        };
+    }
+    appendObjectRangeCondition(alias, range, conditions, params, queryPlan) {
+        if (range.mode === 'numeric') {
+            conditions.push(`${alias}.kind = ?`);
+            params.push('literal');
+            conditions.push(`${alias}.numeric_value IS NOT NULL`);
+            if (range.min !== undefined) {
+                conditions.push(`${alias}.numeric_value ${range.minInclusive ? '>=' : '>'} ?`);
+                params.push(range.min);
+            }
+            if (range.max !== undefined) {
+                conditions.push(`${alias}.numeric_value ${range.maxInclusive ? '<=' : '<'} ?`);
+                params.push(range.max);
+            }
+            queryPlan.push(`NumericRange(object${rangeSuffix(range)})`);
+            return;
+        }
+        conditions.push(`${alias}.kind IN (${OBJECT_RANGE_KINDS.map(() => '?').join(', ')})`);
+        params.push(...OBJECT_RANGE_KINDS);
+        if (range.min !== undefined) {
+            conditions.push(`${alias}.value ${range.minInclusive ? '>=' : '>'} ?`);
+            params.push(range.min);
+        }
+        if (range.max !== undefined) {
+            conditions.push(`${alias}.value ${range.maxInclusive ? '<=' : '<'} ?`);
+            params.push(range.max);
+        }
+        queryPlan.push(`LexicalRange(object${rangeSuffix(range)})`);
+    }
+    appendTermFilterJoinsAndConditions(resolved, keys, columnForKey, joins, conditions, params, queryPlan, aliasPrefix = 'term_filter') {
+        for (const key of keys) {
+            const filter = resolved.termFilters?.[key];
+            if (!filter) {
+                continue;
+            }
+            const alias = `${aliasPrefix}_${key}`;
+            joins.push(` JOIN rdf_terms ${alias} ON ${alias}.id = ${columnForKey(key)}`);
+            this.appendTermFilterCondition(key, alias, filter, conditions, params, queryPlan);
+        }
+    }
+    appendTermFilterCondition(key, alias, filter, conditions, params, queryPlan) {
+        if (filter.termType !== undefined) {
+            this.appendTermTypeCondition(key, alias, filter.termType, conditions, params);
+            queryPlan?.push(`TermType(${key}:${filter.termType})`);
+        }
+        if (filter.language !== undefined) {
+            this.appendLanguageCondition(key, alias, '$language', filter.language, conditions, params);
+            queryPlan?.push(`Language(${key}$language)`);
+        }
+        if (filter.notLanguage !== undefined) {
+            this.appendLanguageCondition(key, alias, '$notLanguage', filter.notLanguage, conditions, params);
+            queryPlan?.push(`Language(${key}$notLanguage)`);
+        }
+        if (filter.langMatches !== undefined) {
+            this.appendLanguageCondition(key, alias, '$langMatches', filter.langMatches, conditions, params);
+            queryPlan?.push(`Language(${key}$langMatches)`);
+        }
+        if (filter.datatype !== undefined) {
+            this.appendDatatypeCondition(key, alias, '$datatype', filter.datatype, conditions, params);
+            queryPlan?.push(`Datatype(${key}$datatype)`);
+        }
+        if (filter.notDatatype !== undefined) {
+            this.appendDatatypeCondition(key, alias, '$notDatatype', filter.notDatatype, conditions, params);
+            queryPlan?.push(`Datatype(${key}$notDatatype)`);
+        }
+        for (const search of filter.textSearches ?? []) {
+            this.appendTextSearchCondition(key, alias, search, conditions, params, queryPlan);
+        }
+    }
+    appendTextSearchCondition(key, alias, search, conditions, params, queryPlan) {
+        const kinds = termKindsForPatternKey(key);
+        const kindPlaceholders = kinds.map(() => '?').join(', ');
+        const normalized = search.value.toLowerCase();
+        switch (search.operator) {
+            case '$contains':
+                conditions.push(`${alias}.kind IN (${kindPlaceholders})
+          AND ${alias}.normalized_text LIKE ? ESCAPE '\\'
+          AND instr(${alias}.value, ?) > 0`);
+                params.push(...kinds, `%${escapeLikePattern(normalized)}%`, search.value);
+                queryPlan?.push(`TextSearch(${key}$contains)`);
+                return;
+            case '$endsWith':
+                conditions.push(`${alias}.kind IN (${kindPlaceholders})
+          AND ${alias}.normalized_text LIKE ? ESCAPE '\\'
+          AND substr(${alias}.value, -length(?)) = ?`);
+                params.push(...kinds, `%${escapeLikePattern(normalized)}`, search.value, search.value);
+                queryPlan?.push(`TextSearch(${key}$endsWith)`);
+                return;
+            default: {
+                const exhaustive = search.operator;
+                throw new Error(`Unsupported RDF-3X text search operator: ${exhaustive}`);
+            }
+        }
+    }
+    appendTermTypeCondition(key, alias, termType, conditions, params) {
+        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 = ?`);
+        params.push(termType);
+    }
+    appendLanguageCondition(key, alias, operator, language, conditions, params) {
+        if (!termKindsForPatternKey(key).includes('literal')) {
+            conditions.push('1 = 0');
+            return;
+        }
+        if (operator === '$language') {
+            conditions.push(`${alias}.kind = 'literal' AND COALESCE(${alias}.lang, '') = ?`);
+            params.push(language);
+            return;
+        }
+        if (operator === '$notLanguage') {
+            conditions.push(`${alias}.kind = 'literal' AND COALESCE(${alias}.lang, '') != ?`);
+            params.push(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(?) OR lower(${alias}.lang) LIKE lower(?) ESCAPE '\\')`);
+        params.push(language, `${escapeLikePattern(language)}-%`);
+    }
+    appendDatatypeCondition(key, alias, operator, datatype, conditions, params) {
+        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 = ?`
+            : `${alias}.kind = 'literal' AND (${alias}.datatype_id IS NULL OR ${alias}.datatype_id != ?)`);
+        params.push(datatype.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;
+    }
+    choosePermutation(ids, constraints) {
+        const has = (key) => ids[key] !== undefined || Boolean(constraints?.idSets?.[key]?.length);
+        const hasObjectConstraint = has('object')
+            || Boolean(constraints?.objectRange)
+            || Boolean(constraints?.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 RDF-3X permutation: ${name}`);
+        }
+        return permutation;
+    }
+    rowsToQuads(rows) {
+        const termMap = this.requireDictionary().rowsForIds(rows.flatMap((row) => [
+            row.graph_id,
+            row.subject_id,
+            row.predicate_id,
+            row.object_id,
+        ]));
+        return rows.map((row) => n3_1.DataFactory.quad(requiredTerm(termMap, row.subject_id), requiredTerm(termMap, row.predicate_id), requiredTerm(termMap, row.object_id), requiredTerm(termMap, row.graph_id)));
+    }
+    permutationSource(permutation, alias) {
+        return `${RDF_FACTS_TABLE} AS ${alias} INDEXED BY ${permutation.indexName}`;
+    }
+    factSource(alias) {
+        return `${RDF_FACTS_TABLE} AS ${alias}`;
+    }
+    uniqueTripleCount() {
+        return this.requireDb().prepare(`
+      SELECT COUNT(*) AS count
+      FROM (
+        SELECT DISTINCT subject_id, predicate_id, object_id
+        FROM ${RDF_FACTS_TABLE}
+      ) distinct_triples
+    `).get()?.count ?? 0;
+    }
+    rowCount(table) {
+        return this.requireDb().prepare(`SELECT COUNT(*) AS count FROM ${table}`).get()?.count ?? 0;
+    }
+    collectPageCount() {
+        try {
+            return this.requireDb().prepare('PRAGMA page_count').get()?.page_count ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    estimateDatabaseBytes() {
+        const pageSize = this.estimatePageSize();
+        const pageCount = this.collectPageCount();
+        return pageSize * pageCount;
+    }
+    estimateSpaceObjectsFromSchema(schemaRows) {
+        const pageSize = this.estimatePageSize();
+        return schemaRows.map((object) => ({
+            name: object.name,
+            kind: rdf3xSpaceObjectKind(object.name, object.type, object.tbl_name),
+            ...(object.tbl_name && object.tbl_name !== object.name ? { tableName: object.tbl_name } : {}),
+            pages: 1,
+            bytes: pageSize,
+            estimated: true,
+        }));
+    }
+    estimatePageSize() {
+        try {
+            return this.requireDb().prepare('PRAGMA page_size').get()?.page_size ?? 4096;
+        }
+        catch {
+            return 4096;
+        }
+    }
+    metrics(indexChoice, matchedRows, returnedRows, start, queryPlan) {
+        return {
+            engine: 'solid-rdf3x',
+            indexChoice,
+            matchedRows,
+            returnedRows,
+            durationMs: Date.now() - start,
+            queryPlan,
+        };
+    }
+    requireDb() {
+        if (!this.db) {
+            throw new Error('Rdf3xIndex is not open');
+        }
+        return this.db;
+    }
+    requireDictionary() {
+        if (!this.dictionary) {
+            throw new Error('Rdf3xIndex is not open');
+        }
+        return this.dictionary;
+    }
+}
+exports.Rdf3xIndex = Rdf3xIndex;
+function keyForColumn(column) {
+    if (column === 'subject_id')
+        return 'subject';
+    if (column === 'predicate_id')
+        return 'predicate';
+    return 'object';
+}
+function shouldUseMembershipSource(resolved) {
+    return resolved.ids.graph !== undefined
+        || Boolean(resolved.idSets?.graph?.length)
+        || Boolean(resolved.excludedIdSets?.graph?.length)
+        || resolved.graphPrefix !== undefined;
+}
+function requiredTerm(termMap, id) {
+    const term = termMap.get(id);
+    if (!term) {
+        throw new Error(`RDF term not found while reading RDF-3X index: ${id}`);
+    }
+    return term;
+}
+function isRdfTerm(value) {
+    return value !== null && typeof value === 'object' && 'termType' in value;
+}
+function isTermInPattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !('termType' in value)
+        && Object.keys(value).length === 1
+        && Array.isArray(value.$in)
+        && (value.$in).every(isRdfTerm);
+}
+function isTermNotInPattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !('termType' in value)
+        && Object.keys(value).length === 1
+        && Array.isArray(value.$notIn)
+        && (value.$notIn).every(isRdfTerm);
+}
+function isOperatorPattern(value) {
+    return value !== null && typeof value === 'object' && !('termType' in value);
+}
+function isSupportedOperatorPattern(key, value) {
+    const allowed = new Set([
+        '$in',
+        '$notIn',
+        '$termType',
+        '$language',
+        '$notLanguage',
+        '$langMatches',
+        '$datatype',
+        '$notDatatype',
+        ...(key === 'graph' ? ['$startsWith'] : []),
+        ...(key === 'object' ? ['$gt', '$gte', '$lt', '$lte', '$contains', '$endsWith'] : []),
+    ]);
+    if (Object.keys(value).some((operator) => !allowed.has(operator))) {
+        return false;
+    }
+    if (value.$in !== undefined && (!Array.isArray(value.$in) || !value.$in.every(isRdfTerm) || value.$in.length === 0)) {
+        return false;
+    }
+    if (value.$notIn !== undefined && (!Array.isArray(value.$notIn) || !value.$notIn.every(isRdfTerm) || value.$notIn.length === 0)) {
+        return false;
+    }
+    if (value.$startsWith !== undefined && typeof value.$startsWith !== 'string') {
+        return false;
+    }
+    if (value.$termType !== undefined && !['iri', 'blank', 'literal', 'numeric'].includes(value.$termType)) {
+        return false;
+    }
+    for (const languageOperator of ['$language', '$notLanguage', '$langMatches']) {
+        if (value[languageOperator] !== undefined && typeof value[languageOperator] !== 'string') {
+            return false;
+        }
+    }
+    for (const datatypeOperator of ['$datatype', '$notDatatype']) {
+        if (value[datatypeOperator] !== undefined) {
+            const datatype = value[datatypeOperator];
+            if (!isRdfTerm(datatype) || datatype.termType !== 'NamedNode') {
+                return false;
+            }
+        }
+    }
+    if (key === 'object') {
+        for (const rangeOperator of ['$gt', '$gte', '$lt', '$lte']) {
+            const rangeValue = value[rangeOperator];
+            if (rangeValue !== undefined && !isRdf3xObjectRangeValue(rangeValue)) {
+                return false;
+            }
+        }
+        for (const textOperator of ['$contains', '$endsWith']) {
+            if (value[textOperator] !== undefined && typeof value[textOperator] !== 'string') {
+                return false;
+            }
+        }
+    }
+    return Object.keys(value).length > 0;
+}
+function hasObjectRangeOperator(value) {
+    return value.$gt !== undefined
+        || value.$gte !== undefined
+        || value.$lt !== undefined
+        || value.$lte !== 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-3X pattern key: ${exhaustive}`);
+        }
+    }
+}
+function escapeLikePattern(value) {
+    return value.replace(/[\\%_]/g, (char) => `\\${char}`);
+}
+function hasResolvedIdSets(resolved) {
+    return Object.values(resolved.idSets ?? {}).some((ids) => (ids?.length ?? 0) > 0);
+}
+function hasResolvedExcludedIdSets(resolved) {
+    return Object.values(resolved.excludedIdSets ?? {}).some((ids) => (ids?.length ?? 0) > 0);
+}
+function hasResolvedTermFilters(resolved) {
+    return Object.values(resolved.termFilters ?? {}).some(Boolean);
+}
+function uniqueNumbers(values) {
+    return [...new Set(values)];
+}
+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);
+}
+function uniquePatternKeys(values) {
+    return ['graph', 'subject', 'predicate', 'object']
+        .filter((key) => values.includes(key));
+}
+function uniqueVariableNames(values) {
+    return [...new Set(values)];
+}
+function joinSolutionMappingKeyExpression(variableColumns, variables, errorPrefix) {
+    const variableNames = uniqueVariableNames(variables ?? [...variableColumns.keys()]);
+    if (variableNames.length === 0) {
+        return '1';
+    }
+    return variableNames.map((variableName) => {
+        const column = variableColumns.get(variableName);
+        if (!column) {
+            throw new Error(`${errorPrefix} COUNT(DISTINCT *) cannot read unbound variable: ${variableName}`);
+        }
+        return column;
+    }).join(` || ':' || `);
+}
+function rdf3xSpaceObjectKind(name, schemaType, tableName) {
+    if (schemaType === 'table' && name.startsWith('rdf3x_')) {
+        return 'table';
+    }
+    if (schemaType === 'index' && (name.startsWith('rdf3x_') || tableName?.startsWith('rdf3x_'))) {
+        return 'index';
+    }
+    if (name.startsWith('sqlite_')) {
+        return 'internal';
+    }
+    return 'unknown';
+}
+function isGraphPrefixPattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && Object.keys(value).length === 1
+        && '$startsWith' in value
+        && typeof value.$startsWith === 'string';
+}
+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 = options?.orderDirections ?? order.map(() => (options?.reverse ? 'desc' : 'asc'));
+    return order.map((entry, index) => `${directions[index] ?? 'asc'}:${entry}`).join(',');
+}
+function isObjectRangePattern(value) {
+    return value !== null
+        && typeof value === 'object'
+        && !('termType' in value)
+        && ['$gt', '$gte', '$lt', '$lte'].some((operator) => operator in value);
+}
+function isRdf3xObjectRangeValue(value) {
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    if (typeof value === 'string') {
+        return true;
+    }
+    return isRdfTerm(value);
+}
+//# sourceMappingURL=Rdf3xIndex.js.map