@undefineds.co/xpod 0.3.29 → 0.3.31

package/dist/storage/rdf/PostgresRdfEngine.js

@@ -2,16 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresRdfEngine = void 0;
 const node_crypto_1 = require("node:crypto");
-const node_fs_1 = require("node:fs");
-const promises_1 = require("node:fs/promises");
-const node_path_1 = require("node:path");
-const node_os_1 = require("node:os");
 const n3_1 = require("n3");
 const pglite_1 = require("@electric-sql/pglite");
 const PostgresPoolManager_1 = require("../database/PostgresPoolManager");
 const RdfTermDictionary_1 = require("./RdfTermDictionary");
 const RdfTermSemantics_1 = require("./RdfTermSemantics");
-const SolidRdfEngine_1 = require("./SolidRdfEngine");
 const Rdf3xSchema_1 = require("./Rdf3xSchema");
 const types_1 = require("../quint/types");
 const { namedNode, quad } = n3_1.DataFactory;
@@ -412,18 +407,11 @@ class PostgresRdfEngine {
     constructor(options) {
         this.executor = null;
         this.termDictionary = null;
-        this.cacheEngine = null;
-        this.cacheDir = null;
-        this.cachePath = null;
-        this.factsDataVersion = 0;
-        this.cacheDirty = true;
         this.initialized = false;
         this.initializing = null;
         this.sharedPoolConfig = null;
         this.pglite = null;
         this.pgPool = null;
-        this.rdf3xDataVersion = 0;
-        this.rdf3xDirty = true;
         this.pgOptions = {
             ...options,
             driver: options.driver ?? (options.connectionString || options.pool ? 'pg' : 'pglite'),
@@ -442,9 +430,6 @@ class PostgresRdfEngine {
             this.termDictionary = new PostgresRdfTermDictionary(this.requireExecutor());
             await this.termDictionary.initialize();
             await this.initializeSchema();
-            this.factsDataVersion = await this.readFactsDataVersion();
-            this.rdf3xDataVersion = await this.readRdf3xFactsDataVersion();
-            this.rdf3xDirty = this.rdf3xDataVersion !== this.factsDataVersion;
             this.initialized = true;
         })
             .finally(() => {
@@ -456,15 +441,6 @@ class PostgresRdfEngine {
         if (this.initializing) {
             await this.initializing.catch(() => { });
         }
-        if (this.cacheEngine) {
-            await this.cacheEngine.close();
-            this.cacheEngine = null;
-        }
-        if (this.cacheDir) {
-            await (0, promises_1.rm)(this.cacheDir, { recursive: true, force: true });
-            this.cacheDir = null;
-            this.cachePath = null;
-        }
         this.executor = null;
         if (this.pglite) {
             await this.pglite.close();
@@ -482,10 +458,6 @@ class PostgresRdfEngine {
         }
         this.termDictionary = null;
         this.initialized = false;
-        this.cacheDirty = true;
-        this.factsDataVersion = 0;
-        this.rdf3xDataVersion = 0;
-        this.rdf3xDirty = true;
     }
     async put(quads, options) {
         await this.ensureReady();
@@ -499,11 +471,8 @@ class PostgresRdfEngine {
                 await this.insertQuads(tx, scopedDictionary, quadList, sourceId, options?.sourceLineNo ?? null);
                 await this.bumpFactsDataVersion(tx);
             });
-            this.factsDataVersion = await this.readFactsDataVersion();
-            this.markDerivedDirty();
         }
         catch (error) {
-            this.cacheDirty = true;
             throw error;
         }
     }
@@ -519,11 +488,8 @@ class PostgresRdfEngine {
                 await this.insertQuads(tx, scopedDictionary, quads, sourceId, null);
                 await this.bumpFactsDataVersion(tx);
             });
-            this.factsDataVersion = await this.readFactsDataVersion();
-            this.markDerivedDirty();
         }
         catch (error) {
-            this.cacheDirty = true;
             throw error;
         }
     }
@@ -541,12 +507,9 @@ class PostgresRdfEngine {
                 await this.bumpFactsDataVersion(tx);
                 return deleteResult.length;
             });
-            this.factsDataVersion = await this.readFactsDataVersion();
-            this.markDerivedDirty();
             return result;
         }
         catch (error) {
-            this.cacheDirty = true;
             throw error;
         }
     }
@@ -566,12 +529,9 @@ class PostgresRdfEngine {
                 }
                 await this.bumpFactsDataVersion(tx);
             });
-            this.factsDataVersion = await this.readFactsDataVersion();
-            this.markDerivedDirty();
             return scan.quads.length;
         }
         catch (error) {
-            this.cacheDirty = true;
             throw error;
         }
     }
@@ -603,44 +563,31 @@ class PostgresRdfEngine {
                 }
                 return deletedRows;
             });
-            this.factsDataVersion = await this.readFactsDataVersion();
-            this.markDerivedDirty();
             return {
                 deletedRows,
                 insertedRows: inserts.length,
             };
         }
         catch (error) {
-            this.cacheDirty = true;
             throw error;
         }
     }
     async scan(query) {
         await this.ensureReady();
-        if (!isPgRdf3xCompatiblePattern(query.pattern)) {
-            await this.ensureCacheReady();
-            const fallback = await this.requireCache().scan(query);
-            fallback.metrics.queryPlan = ['PostgresRdf3xScanFallback', ...(fallback.metrics.queryPlan ?? [])];
-            return fallback;
-        }
-        return this.scanNative(query.pattern, query.options);
+        return isPgSqlScanCompatiblePattern(query.pattern)
+            ? this.scanNative(query.pattern, query.options)
+            : this.scanPostFilter(query.pattern, query.options);
     }
     async query(query) {
         await this.ensureReady();
         const native = await this.queryNative(query);
-        if (native.result) {
-            return native.result;
-        }
-        await this.ensureCacheReady();
-        const fallback = await this.requireCache().query(query);
-        fallback.metrics.plan.unshift('PostgresRdf3xFallback');
-        return fallback;
+        return native ?? this.queryFacts(query);
     }
     async refreshDerivedIndexes() {
         await this.ensureReady();
         const factsDataVersion = await this.readFactsDataVersion();
         const previousFactsDataVersion = await this.readRdf3xFactsDataVersion();
-        if (previousFactsDataVersion === factsDataVersion && !this.rdf3xDirty) {
+        if (previousFactsDataVersion === factsDataVersion) {
             return {
                 derivedIndexProfile: 'rdf3x',
                 factsDataVersion,
@@ -653,8 +600,6 @@ class PostgresRdfEngine {
             };
         }
         const rebuild = await this.rebuildRdf3xDerivedIndexes(factsDataVersion);
-        this.rdf3xDataVersion = factsDataVersion;
-        this.rdf3xDirty = false;
         return {
             derivedIndexProfile: 'rdf3x',
             factsDataVersion,
@@ -952,34 +897,59 @@ class PostgresRdfEngine {
             ]),
         };
     }
+    async scanPostFilter(pattern, options) {
+        const start = Date.now();
+        const rows = await this.requireExecutor().query(`
+      SELECT graph_id, subject_id, predicate_id, object_id
+      FROM ${RDF_FACTS_TABLE}
+      ORDER BY graph_id, subject_id, predicate_id, object_id
+    `);
+        const quads = await this.rowsToQuads(rows);
+        const matched = quads.filter((value) => matchesQuadPattern(value, pattern));
+        const ordered = orderQuads(matched, options);
+        const startOffset = Math.max(0, options?.offset ?? 0);
+        const endOffset = options?.limit === undefined
+            ? undefined
+            : startOffset + Math.max(0, options.limit);
+        const page = ordered.slice(startOffset, endOffset);
+        return {
+            quads: page,
+            metrics: this.indexMetrics('facts-post-filter', matched.length, page.length, start, [
+                'PostgresFactsScan',
+                'PostgresFactsPostFilter',
+                ...(options?.order?.length ? [`PostgresFactsScanOrder(${describeScanOrder(options)})`] : []),
+                ...(options?.limit !== undefined || options?.offset !== undefined ? ['PostgresFactsScanLimit'] : []),
+            ]),
+        };
+    }
     async queryNative(query) {
         if (!this.canTryNativeQuery(query)) {
-            return { unsupported: true };
+            return undefined;
         }
         const start = Date.now();
         const aggregates = queryAggregates(query);
         const requiredPatterns = query.patterns.length > 0 ? query.patterns : [{}];
         const compiledPatterns = await this.compileNativeJoinPatterns(requiredPatterns, query.filters ?? []);
         if (!compiledPatterns) {
-            return { unsupported: true };
+            return undefined;
         }
         if (!this.allFiltersPushed(query.filters ?? [], compiledPatterns)) {
-            return { unsupported: true };
+            return undefined;
         }
         if (aggregates.length > 0) {
             if (!query.patterns.length) {
-                return { unsupported: true };
+                return undefined;
             }
             const aggregateResult = await this.queryNativeAggregate(query, compiledPatterns, aggregates, start);
-            return aggregateResult ? { result: aggregateResult } : { unsupported: true };
+            return aggregateResult;
         }
         const visibleVariables = uniqueStrings(requiredPatterns.flatMap((pattern) => variablesInPattern(pattern)));
         const project = query.select && query.select.length > 0 ? query.select : visibleVariables;
         if (project.some((variableName) => !visibleVariables.includes(variableName))) {
-            return { unsupported: true };
+            return undefined;
         }
         if ((query.orderBy ?? []).some((entry) => !visibleVariables.includes(entry.variable))) {
-            return { unsupported: true };
+            return undefined;
         }
         const compiled = await this.compileJoinSql(compiledPatterns, {
             project,
@@ -991,13 +961,11 @@ class PostgresRdfEngine {
         });
         if (compiled.unresolved) {
             return {
-                result: {
-                    bindings: [],
-                    metrics: this.localMetrics(start, 0, 0, 0, [compiled.indexChoice], [
-                        ...compiled.queryPlan,
-                        `unresolved ${compiled.unresolved}`,
-                    ], query.filters?.length ?? 0),
-                },
+                bindings: [],
+                metrics: this.localMetrics(start, 0, 0, 0, [compiled.indexChoice], [
+                    ...compiled.queryPlan,
+                    `unresolved ${compiled.unresolved}`,
+                ], query.filters?.length ?? 0),
             };
         }
         const rows = await this.requireExecutor().query(compiled.sql, compiled.params);
@@ -1012,12 +980,358 @@ class PostgresRdfEngine {
             ...(query.limit !== undefined || query.offset !== undefined ? ['PostgresRdf3xJoinLimit'] : []),
         ];
         return {
-            result: {
-                bindings,
-                metrics: this.localMetrics(start, matchedRows, matchedRows, bindings.length, [compiled.indexChoice], plan, query.filters?.length ?? 0),
-            },
+            bindings,
+            metrics: this.localMetrics(start, matchedRows, matchedRows, bindings.length, [compiled.indexChoice], plan, query.filters?.length ?? 0),
+        };
+    }
+    async queryFacts(query) {
+        const start = Date.now();
+        const metrics = this.localMetrics(start, 0, 0, 0, ['facts-post-filter'], ['PostgresFactsQuery']);
+        if ((query.textSearch?.length ?? 0) > 0) {
+            throw new Error('RdfQuery textSearch requires a configured RdfTextIndex');
+        }
+        if ((query.vectorSearch?.length ?? 0) > 0) {
+            throw new Error('RdfQuery vectorSearch requires a configured RdfVectorIndex');
+        }
+        const hasNonPatternSource = (query.values?.length ?? 0) > 0
+            || (query.textSearch?.length ?? 0) > 0
+            || (query.vectorSearch?.length ?? 0) > 0;
+        const requiredPatterns = query.patterns.length > 0
+            ? query.patterns
+            : query.unions?.length || hasNonPatternSource
+                ? []
+                : [{}];
+        const aggregates = queryAggregates(query);
+        let bindings = [{}];
+        for (const values of query.values ?? []) {
+            bindings = joinValuesSource(bindings, values);
+            metrics.scannedRows += values.rows.length;
+            metrics.plan.push(`PostgresFactsValues(${values.variables.map((variableName) => `?${variableName}`).join(',')})`);
+            if (bindings.length === 0) {
+                break;
+            }
+        }
+        if (bindings.length > 0) {
+            for (const pattern of requiredPatterns) {
+                bindings = await this.joinFactsPattern(bindings, pattern, query.filters ?? [], metrics, false);
+                metrics.plan.push(`PostgresFactsScan(${describeQueryPattern(pattern)})`);
+                if (bindings.length === 0) {
+                    break;
+                }
+            }
+        }
+        if ((query.binds?.length ?? 0) > 0 && bindings.length > 0) {
+            bindings = this.applyFactsBinds(bindings, query.binds ?? []);
+            metrics.plan.push(`PostgresFactsBind(${(query.binds ?? []).map(describeBind).join(',')})`);
+        }
+        for (const rawOptionalGroup of query.optional ?? []) {
+            bindings = await this.joinFactsOptionalGroup(bindings, normalizeOptionalGroup(rawOptionalGroup), metrics);
+            metrics.plan.push(`PostgresFactsOptionalJoin(${normalizeOptionalGroup(rawOptionalGroup).patterns.map(describeQueryPattern).join(',')})`);
+        }
+        for (const unionGroup of query.unions ?? []) {
+            bindings = await this.joinFactsUnionGroup(bindings, unionGroup.branches, query.filters ?? [], metrics);
+            metrics.plan.push(`PostgresFactsUnion(${unionGroup.branches.map((branch) => branch.patterns.map(describeQueryPattern).join(',')).join('|')})`);
+            if (bindings.length === 0) {
+                break;
+            }
+        }
+        for (const minusGroup of query.minus ?? []) {
+            bindings = await this.applyFactsMinusGroup(bindings, minusGroup, metrics);
+            metrics.plan.push(`PostgresFactsMinus(${minusGroup.patterns.map(describeQueryPattern).join(',')})`);
+            if (bindings.length === 0) {
+                break;
+            }
+        }
+        for (const existsGroup of query.exists ?? []) {
+            bindings = await this.applyFactsExistsGroup(bindings, existsGroup, metrics);
+            metrics.plan.push(`PostgresFactsExists(${existsGroup.patterns.map(describeQueryPattern).join(',')})`);
+            if (bindings.length === 0) {
+                break;
+            }
+        }
+        if ((query.filters?.length ?? 0) > 0) {
+            bindings = bindings.filter((binding) => matchesBindingFilters(binding, query.filters ?? []));
+            metrics.filtersApplied += query.filters?.length ?? 0;
+            metrics.plan.push(`PostgresFactsFilter(${(query.filters ?? []).map(describeFilter).join(',')})`);
+        }
+        if (aggregates.length > 0 && (query.groupBy?.length ?? 0) > 0) {
+            const joinedRows = bindings.length;
+            bindings = groupAggregateBindings(bindings, query.groupBy ?? [], aggregates);
+            metrics.joinedRows = joinedRows;
+            metrics.plan.push(aggregatePlan(aggregates, true));
+            if ((query.having?.length ?? 0) > 0) {
+                bindings = bindings.filter((binding) => matchesBindingFilters(binding, query.having ?? []));
+                metrics.filtersApplied += query.having?.length ?? 0;
+                metrics.plan.push(`PostgresFactsHaving(${(query.having ?? []).map(describeFilter).join(',')})`);
+            }
+        }
+        else if (aggregates.length > 0) {
+            const { binding, firstCount } = aggregateBindings(bindings, aggregates);
+            const having = query.having ?? [];
+            metrics.joinedRows = bindings.length;
+            metrics.plan.push(aggregatePlan(aggregates, false));
+            if (having.length > 0 && !matchesBindingFilters(binding, having)) {
+                metrics.filtersApplied += having.length;
+                metrics.plan.push(`PostgresFactsHaving(${having.map(describeFilter).join(',')})`);
+                metrics.returnedRows = 0;
+                metrics.durationMs = Date.now() - start;
+                return {
+                    bindings: [],
+                    count: firstCount,
+                    metrics,
+                };
+            }
+            if (having.length > 0) {
+                metrics.filtersApplied += having.length;
+                metrics.plan.push(`PostgresFactsHaving(${having.map(describeFilter).join(',')})`);
+            }
+            metrics.returnedRows = 1;
+            metrics.durationMs = Date.now() - start;
+            return {
+                bindings: [binding],
+                count: firstCount,
+                metrics,
+            };
+        }
+        const joinedRows = metrics.joinedRows > 0 ? metrics.joinedRows : bindings.length;
+        if ((query.orderBy?.length ?? 0) > 0) {
+            bindings = [...bindings].sort((left, right) => compareBindings(left, right, query.orderBy ?? []));
+            metrics.plan.push(`PostgresFactsSort(${describeQueryOrder(query.orderBy ?? [])})`);
+        }
+        let projected = query.select && query.select.length > 0
+            ? bindings.map((binding) => projectBinding(binding, query.select ?? []))
+            : bindings;
+        if (query.distinct) {
+            projected = distinctBindings(projected);
+            metrics.plan.push('PostgresFactsDistinct');
+        }
+        if (query.offset !== undefined || query.limit !== undefined) {
+            const startOffset = Math.max(0, query.offset ?? 0);
+            const endOffset = query.limit === undefined
+                ? undefined
+                : startOffset + Math.max(0, query.limit);
+            projected = projected.slice(startOffset, endOffset);
+            metrics.plan.push('PostgresFactsLimit');
+        }
+        metrics.joinedRows = joinedRows;
+        metrics.returnedRows = projected.length;
+        metrics.durationMs = Date.now() - start;
+        return {
+            bindings: projected,
+            metrics,
         };
     }
+    async joinFactsPattern(input, pattern, filters, metrics, optional) {
+        const output = [];
+        for (const binding of input) {
+            const compiled = compilePatternForBinding(pattern, binding);
+            if (!compiled) {
+                if (optional) {
+                    output.push(binding);
+                }
+                continue;
+            }
+            const scan = isPgSqlScanCompatiblePattern(compiled)
+                ? await this.scanNative(compiled)
+                : await this.scanPostFilter(compiled);
+            metrics.scannedRows += scan.metrics.matchedRows;
+            metrics.indexChoices.push(scan.metrics.indexChoice);
+            metrics.plan.push(...storagePlanMarkers(scan.metrics.queryPlan));
+            const before = output.length;
+            for (const value of scan.quads) {
+                const next = bindQuadPattern(pattern, binding, value);
+                if (next && matchesNewlyBoundFilters(next, binding, filters)) {
+                    output.push(next);
+                }
+            }
+            if (optional && output.length === before) {
+                output.push(binding);
+            }
+        }
+        return output;
+    }
+    async joinFactsOptionalGroup(input, optionalGroup, metrics) {
+        const filters = optionalGroup.filters ?? [];
+        const output = [];
+        for (const binding of input) {
+            let matches = [binding];
+            matches = this.applyFactsValues(matches, optionalGroup.values, metrics, 'Optional');
+            if (matches.length > 0) {
+                for (const pattern of optionalGroup.patterns) {
+                    matches = await this.joinFactsPattern(matches, pattern, filters, metrics, false);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+            }
+            if (matches.length > 0) {
+                for (const unionGroup of optionalGroup.unions ?? []) {
+                    matches = await this.joinFactsUnionGroup(matches, unionGroup.branches, filters, metrics);
+                    metrics.plan.push(`PostgresFactsOptionalUnion(${unionGroup.branches.map((branch) => branch.patterns.map(describeQueryPattern).join(',')).join('|')})`);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+            }
+            if (matches.length > 0) {
+                for (const rawNestedOptional of optionalGroup.optional ?? []) {
+                    matches = await this.joinFactsOptionalGroup(matches, normalizeOptionalGroup(rawNestedOptional), metrics);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+            }
+            if (matches.length > 0) {
+                for (const minusGroup of optionalGroup.minus ?? []) {
+                    matches = await this.applyFactsMinusGroup(matches, minusGroup, metrics);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+            }
+            if (matches.length > 0) {
+                for (const existsGroup of optionalGroup.exists ?? []) {
+                    matches = await this.applyFactsExistsGroup(matches, existsGroup, metrics);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+            }
+            if ((optionalGroup.binds?.length ?? 0) > 0 && matches.length > 0) {
+                matches = this.applyFactsBinds(matches, optionalGroup.binds ?? []);
+                metrics.plan.push(`PostgresFactsOptionalBind(${(optionalGroup.binds ?? []).map(describeBind).join(',')})`);
+            }
+            if (filters.length > 0 && matches.length > 0) {
+                matches = matches.filter((match) => matchesBindingFilters(match, filters));
+                metrics.filtersApplied += filters.length;
+                metrics.plan.push(`PostgresFactsOptionalFilter(${filters.map(describeFilter).join(',')})`);
+            }
+            output.push(...(matches.length > 0 ? matches : [binding]));
+        }
+        return output;
+    }
+    async joinFactsUnionGroup(input, branches, outerFilters, metrics) {
+        const output = [];
+        for (const binding of input) {
+            for (const branch of branches) {
+                const branchFilters = [...outerFilters, ...(branch.filters ?? [])];
+                let matches = [binding];
+                matches = this.applyFactsValues(matches, branch.values, metrics, 'Union');
+                if (matches.length === 0) {
+                    continue;
+                }
+                for (const pattern of branch.patterns) {
+                    matches = await this.joinFactsPattern(matches, pattern, branchFilters, metrics, false);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+                if (matches.length === 0) {
+                    continue;
+                }
+                for (const unionGroup of branch.unions ?? []) {
+                    matches = await this.joinFactsUnionGroup(matches, unionGroup.branches, branchFilters, metrics);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+                if (matches.length === 0) {
+                    continue;
+                }
+                if ((branch.binds?.length ?? 0) > 0) {
+                    matches = this.applyFactsBinds(matches, branch.binds ?? []);
+                }
+                for (const rawOptionalGroup of branch.optional ?? []) {
+                    matches = await this.joinFactsOptionalGroup(matches, normalizeOptionalGroup(rawOptionalGroup), metrics);
+                    if (matches.length === 0) {
+                        break;
+                    }
+                }
+                if ((branch.filters?.length ?? 0) > 0) {
+                    matches = matches.filter((match) => matchesBindingFilters(match, branch.filters ?? []));
+                    metrics.filtersApplied += branch.filters?.length ?? 0;
+                    metrics.plan.push(`PostgresFactsUnionFilter(${(branch.filters ?? []).map(describeFilter).join(',')})`);
+                }
+                output.push(...matches);
+            }
+        }
+        return output;
+    }
+    async applyFactsMinusGroup(input, minusGroup, metrics) {
+        const output = [];
+        for (const binding of input) {
+            let matches = await this.evaluateFactsDependentGroup([binding], minusGroup, metrics, 'Minus');
+            if ((minusGroup.filters?.length ?? 0) > 0) {
+                matches = matches.filter((match) => matchesBindingFilters(match, minusGroup.filters ?? []));
+                metrics.filtersApplied += minusGroup.filters?.length ?? 0;
+            }
+            if (matches.length === 0) {
+                output.push(binding);
+            }
+        }
+        return output;
+    }
+    async applyFactsExistsGroup(input, existsGroup, metrics) {
+        const output = [];
+        for (const binding of input) {
+            let matches = await this.evaluateFactsDependentGroup([binding], existsGroup, metrics, 'Exists');
+            if ((existsGroup.filters?.length ?? 0) > 0) {
+                matches = matches.filter((match) => matchesBindingFilters(match, existsGroup.filters ?? []));
+                metrics.filtersApplied += existsGroup.filters?.length ?? 0;
+            }
+            if (matches.length > 0) {
+                output.push(binding);
+            }
+        }
+        return output;
+    }
+    async evaluateFactsDependentGroup(input, group, metrics, label) {
+        let matches = this.applyFactsValues(input, group.values, metrics, label);
+        for (const pattern of group.patterns) {
+            matches = await this.joinFactsPattern(matches, pattern, group.filters ?? [], metrics, false);
+            if (matches.length === 0) {
+                return [];
+            }
+        }
+        for (const unionGroup of group.unions ?? []) {
+            matches = await this.joinFactsUnionGroup(matches, unionGroup.branches, group.filters ?? [], metrics);
+            if (matches.length === 0) {
+                return [];
+            }
+        }
+        for (const rawOptionalGroup of group.optional ?? []) {
+            matches = await this.joinFactsOptionalGroup(matches, normalizeOptionalGroup(rawOptionalGroup), metrics);
+        }
+        if ((group.binds?.length ?? 0) > 0) {
+            matches = this.applyFactsBinds(matches, group.binds ?? []);
+        }
+        return matches;
+    }
+    applyFactsValues(input, sources, metrics, label) {
+        let output = input;
+        for (const source of sources ?? []) {
+            output = joinValuesSource(output, source);
+            metrics.scannedRows += source.rows.length;
+            metrics.plan.push(`PostgresFacts${label}Values(${source.variables.map((variableName) => `?${variableName}`).join(',')})`);
+            if (output.length === 0) {
+                break;
+            }
+        }
+        return output;
+    }
+    applyFactsBinds(input, binds) {
+        let output = input;
+        for (const bind of binds) {
+            output = output.flatMap((binding) => {
+                if (binding[bind.variable]) {
+                    return [];
+                }
+                const value = evaluateBindExpression(bind.expression, binding);
+                return value ? [{ ...binding, [bind.variable]: value }] : [binding];
+            });
+        }
+        return output;
+    }
     async queryNativeAggregate(query, patterns, aggregates, start) {
         if (!this.canNativeAggregate(query, aggregates)) {
             return undefined;
@@ -1985,47 +2299,6 @@ class PostgresRdfEngine {
             filtersPushedDown,
         };
     }
-    async rebuildCacheFromStore() {
-        if (this.cacheEngine) {
-            await this.cacheEngine.close();
-            this.cacheEngine = null;
-        }
-        if (this.cacheDir) {
-            await (0, promises_1.rm)(this.cacheDir, { recursive: true, force: true });
-        }
-        this.cacheDir = (0, node_fs_1.mkdtempSync)((0, node_path_1.join)((0, node_os_1.tmpdir)(), 'xpod-pg-rdf-cache-'));
-        this.cachePath = (0, node_path_1.join)(this.cacheDir, 'rdf-cache.sqlite');
-        this.cacheEngine = new SolidRdfEngine_1.SolidRdfEngine({
-            index: { path: this.cachePath },
-            autoOpen: true,
-        });
-        const sources = await this.requireExecutor().query('SELECT * FROM rdf_sources ORDER BY id');
-        const nullSourceRows = await this.requireExecutor().query('SELECT * FROM rdf_quads WHERE source_file_id IS NULL ORDER BY graph_id, subject_id, predicate_id, object_id');
-        await this.loadCacheQuads(nullSourceRows, undefined);
-        for (const source of sources) {
-            const quadRows = await this.requireExecutor().query('SELECT * FROM rdf_quads WHERE source_file_id = $1 ORDER BY graph_id, subject_id, predicate_id, object_id', [source.id]);
-            await this.loadCacheQuads(quadRows, source);
-        }
-        await this.requireCache().refreshDerivedIndexes();
-        this.factsDataVersion = await this.readFactsDataVersion();
-        this.cacheDirty = false;
-    }
-    async loadCacheQuads(rows, source) {
-        if (rows.length === 0) {
-            return;
-        }
-        const dictionary = this.requireDictionary();
-        const termIds = Array.from(new Set(rows.flatMap((row) => [row.graph_id, row.subject_id, row.predicate_id, row.object_id])));
-        const terms = await dictionary.rowsForIds(termIds);
-        const quads = rows.map((row) => quad(this.requiredTerm(terms, row.subject_id), this.requiredTerm(terms, row.predicate_id), this.requiredTerm(terms, row.object_id), this.requiredTerm(terms, row.graph_id)));
-        const sourceInput = source ? this.sourceRowToInput(source) : undefined;
-        if (sourceInput) {
-            this.requireCache().replaceSource(quads, sourceInput);
-        }
-        else {
-            this.requireCache().put(quads);
-        }
-    }
     async insertQuads(executor, dictionary, quads, sourceId, sourceLineNo) {
         for (const quadValue of quads) {
             const graphId = await dictionary.getOrCreate(quadValue.graph);
@@ -2067,15 +2340,6 @@ class PostgresRdfEngine {
       `, [graphId, subjectId, predicateId, objectId]);
         return result.length;
     }
-    sourceRowToInput(row) {
-        return {
-            source: row.source,
-            workspace: row.workspace,
-            localPath: row.local_path !== null ? row.local_path : undefined,
-            contentType: row.content_type !== null ? row.content_type : undefined,
-            sourceVersion: row.source_version !== null ? row.source_version : undefined,
-        };
-    }
     async upsertSource(source, executor = this.requireExecutor()) {
         const row = await executor.query(`
       INSERT INTO rdf_sources (
@@ -2134,21 +2398,6 @@ class PostgresRdfEngine {
     }
     async ensureReady() {
         await this.open();
-        const currentVersion = await this.readFactsDataVersion();
-        if (currentVersion !== this.factsDataVersion) {
-            this.factsDataVersion = currentVersion;
-            this.markDerivedDirty();
-        }
-    }
-    async ensureCacheReady() {
-        await this.ensureReady();
-        if (this.cacheDirty || !this.cacheEngine) {
-            await this.rebuildCacheFromStore();
-        }
-    }
-    markDerivedDirty() {
-        this.rdf3xDirty = true;
-        this.cacheDirty = true;
     }
     async scalarCount(sql, params = []) {
         const row = await this.requireExecutor().query(sql, params);
@@ -2268,12 +2517,6 @@ class PostgresRdfEngine {
         }
         return this.termDictionary;
     }
-    requireCache() {
-        if (!this.cacheEngine) {
-            throw new Error('PostgresRdfEngine cache is not initialized');
-        }
-        return this.cacheEngine;
-    }
     requiredTerm(termMap, id) {
         const term = termMap.get(id);
         if (!term) {
@@ -2351,6 +2594,12 @@ function variablesInPattern(pattern) {
         .filter(isVariable)
         .map((value) => value.variable));
 }
+function normalizeOptionalGroup(group) {
+    return Array.isArray(group) ? { patterns: group } : group;
+}
+function isPgSqlScanCompatiblePattern(pattern) {
+    return isPgRdf3xCompatiblePattern(pattern);
+}
 function isPgRdf3xCompatiblePattern(pattern) {
     return PATTERN_KEYS.every((key) => {
         const value = pattern[key];
@@ -2452,6 +2701,21 @@ function describeScanOrder(options) {
         : order.map(() => (options?.reverse ? 'desc' : 'asc'));
     return order.map((entry, index) => `${directions[index] ?? 'asc'}:${entry}`).join(',');
 }
+function describeQueryPattern(pattern) {
+    return PATTERN_KEYS
+        .filter((key) => pattern[key])
+        .map((key) => `${key}:${describeQueryPatternValue(pattern[key])}`)
+        .join(',');
+}
+function describeQueryPatternValue(value) {
+    if (!value)
+        return '*';
+    if (isVariable(value))
+        return `?${value.variable}`;
+    if ((0, types_1.isTerm)(value))
+        return (0, n3_1.termToId)(value);
+    return 'op';
+}
 function describePatternSource(source) {
     return PATTERN_KEYS
         .map((key) => {
@@ -2480,7 +2744,7 @@ function aggregatePlan(aggregates, grouped) {
     return `Aggregate(${grouped ? 'group-' : ''}${aggregates.map((aggregate) => (`${aggregate.type}${aggregate.distinct ? ':DISTINCT' : ''}(${aggregate.variable ? `?${aggregate.variable}` : '*'})`)).join(',')})`;
 }
 function describeFilter(filter) {
-    return `?${filter.variable}${filter.operator}`;
+    return `?${filter.variable}${filter.operand ? `:${filter.operand}` : ''}${filter.operator}`;
 }
 function describeQueryOrder(orderBy) {
     return orderBy.map((entry) => `${entry.direction ?? 'asc'}:${entry.variable}`).join(',');
@@ -2536,6 +2800,632 @@ function storagePlanMarkers(queryPlan) {
         || entry.startsWith('Language(')
         || entry.startsWith('Datatype(')));
 }
+function compilePatternForBinding(pattern, binding) {
+    const compiled = {};
+    for (const key of PATTERN_KEYS) {
+        const value = pattern[key];
+        if (!value) {
+            continue;
+        }
+        if (isVariable(value)) {
+            const bound = binding[value.variable];
+            if (bound) {
+                compiled[key] = bound;
+            }
+            continue;
+        }
+        compiled[key] = value;
+    }
+    return compiled;
+}
+function bindQuadPattern(pattern, binding, value) {
+    const next = { ...binding };
+    for (const key of PATTERN_KEYS) {
+        const patternValue = pattern[key];
+        if (!isVariable(patternValue)) {
+            continue;
+        }
+        const term = value[key];
+        const existing = next[patternValue.variable];
+        if (existing && !sameTerm(existing, term)) {
+            return null;
+        }
+        next[patternValue.variable] = term;
+    }
+    return next;
+}
+function matchesQuadPattern(value, pattern) {
+    return PATTERN_KEYS.every((key) => {
+        const match = pattern[key];
+        return !match || matchesTermPattern(value[key], key, match);
+    });
+}
+function matchesTermPattern(term, key, match) {
+    if ((0, types_1.isTerm)(match)) {
+        return sameTerm(term, match);
+    }
+    const operators = match;
+    if (operators.$eq !== undefined && !sameTermOrLexical(term, operators.$eq))
+        return false;
+    if (operators.$ne !== undefined && sameTermOrLexical(term, operators.$ne))
+        return false;
+    if (operators.$in !== undefined && !operators.$in.some((candidate) => sameTermOrLexical(term, candidate)))
+        return false;
+    if (operators.$notIn !== undefined && operators.$notIn.some((candidate) => sameTermOrLexical(term, candidate)))
+        return false;
+    if (operators.$startsWith !== undefined && !term.value.startsWith(operators.$startsWith))
+        return false;
+    if (operators.$contains !== undefined && !term.value.includes(operators.$contains))
+        return false;
+    if (operators.$endsWith !== undefined && !term.value.endsWith(operators.$endsWith))
+        return false;
+    if (operators.$regex !== undefined && !new RegExp(operators.$regex).test(term.value))
+        return false;
+    if (operators.$strStartsWith !== undefined && !term.value.startsWith(operators.$strStartsWith))
+        return false;
+    if (operators.$strContains !== undefined && !term.value.includes(operators.$strContains))
+        return false;
+    if (operators.$strEndsWith !== undefined && !term.value.endsWith(operators.$strEndsWith))
+        return false;
+    if (operators.$strRegex !== undefined && !new RegExp(operators.$strRegex).test(term.value))
+        return false;
+    if (operators.$language !== undefined && !(term.termType === 'Literal' && term.language === operators.$language))
+        return false;
+    if (operators.$notLanguage !== undefined && !(term.termType === 'Literal' && term.language !== operators.$notLanguage))
+        return false;
+    if (operators.$langMatches !== undefined && !(term.termType === 'Literal' && langMatches(term.language, operators.$langMatches)))
+        return false;
+    if (operators.$datatype !== undefined && !(term.termType === 'Literal' && sameTerm(term.datatype, operators.$datatype)))
+        return false;
+    if (operators.$notDatatype !== undefined && !(term.termType === 'Literal' && !sameTerm(term.datatype, operators.$notDatatype)))
+        return false;
+    if (operators.$termType !== undefined && !matchesTermTypeForKey(term, key, operators.$termType))
+        return false;
+    if (operators.$isNull !== undefined)
+        return !operators.$isNull;
+    for (const operator of ['$gt', '$gte', '$lt', '$lte']) {
+        const expected = operators[operator];
+        if (expected === undefined)
+            continue;
+        const comparison = compareFilterValues(term, expected);
+        if (operator === '$gt' && comparison <= 0)
+            return false;
+        if (operator === '$gte' && comparison < 0)
+            return false;
+        if (operator === '$lt' && comparison >= 0)
+            return false;
+        if (operator === '$lte' && comparison > 0)
+            return false;
+    }
+    return true;
+}
+function orderQuads(values, options) {
+    if (!options?.order?.length) {
+        return values;
+    }
+    const directions = 'orderDirections' in options && Array.isArray(options.orderDirections)
+        ? options.orderDirections
+        : options.order.map(() => (options.reverse ? 'desc' : 'asc'));
+    return [...values].sort((left, right) => {
+        for (const [index, key] of (options.order ?? []).entries()) {
+            const comparison = (0, n3_1.termToId)(left[key]).localeCompare((0, n3_1.termToId)(right[key]));
+            if (comparison !== 0) {
+                return directions[index] === 'desc' ? -comparison : comparison;
+            }
+        }
+        return 0;
+    });
+}
+function matchesNewlyBoundFilters(binding, previousBinding, filters) {
+    const newlyBound = filters.filter((filter) => {
+        const variables = filter.variable2 ? [filter.variable, filter.variable2] : [filter.variable];
+        return variables.every((variableName) => binding[variableName])
+            && variables.some((variableName) => !previousBinding[variableName]);
+    });
+    return matchesBindingFilters(binding, newlyBound);
+}
+function matchesBindingFilters(binding, filters) {
+    return filters.every((filter) => matchesBindingFilter(binding, filter));
+}
+function matchesBindingFilter(binding, filter) {
+    const value = binding[filter.variable];
+    if (filter.operator === '$bound') {
+        return Boolean(filter.value) ? Boolean(value) : !value;
+    }
+    if (!value) {
+        return false;
+    }
+    const comparisonValue = filterOperandValue(value, filter.operand);
+    switch (filter.operator) {
+        case '$eq':
+            if (filter.variable2)
+                return compareVariableFilter(binding, comparisonValue, filter, (comparison) => comparison === 0);
+            return filter.value !== undefined && sameTermOrLexical(comparisonValue, filter.value);
+        case '$ne':
+            if (filter.variable2)
+                return compareVariableFilter(binding, comparisonValue, filter, (comparison) => comparison !== 0);
+            return filter.value === undefined || !sameTermOrLexical(comparisonValue, filter.value);
+        case '$gt':
+            if (filter.variable2)
+                return compareVariableFilter(binding, comparisonValue, filter, (comparison) => comparison > 0);
+            return compareTermsForFilter(comparisonValue, filter.value) > 0;
+        case '$gte':
+            if (filter.variable2)
+                return compareVariableFilter(binding, comparisonValue, filter, (comparison) => comparison >= 0);
+            return compareTermsForFilter(comparisonValue, filter.value) >= 0;
+        case '$lt':
+            if (filter.variable2)
+                return compareVariableFilter(binding, comparisonValue, filter, (comparison) => comparison < 0);
+            return compareTermsForFilter(comparisonValue, filter.value) < 0;
+        case '$lte':
+            if (filter.variable2)
+                return compareVariableFilter(binding, comparisonValue, filter, (comparison) => comparison <= 0);
+            return compareTermsForFilter(comparisonValue, filter.value) <= 0;
+        case '$in':
+            return (filter.values ?? []).some((candidate) => sameTermOrLexical(comparisonValue, candidate));
+        case '$notIn':
+            return !(filter.values ?? []).some((candidate) => sameTermOrLexical(comparisonValue, candidate));
+        case '$startsWith':
+            return typeof filter.value === 'string' && filterStringValue(value, comparisonValue).startsWith(filter.value);
+        case '$notStartsWith':
+            return typeof filter.value === 'string' && !filterStringValue(value, comparisonValue).startsWith(filter.value);
+        case '$contains':
+            return typeof filter.value === 'string' && filterStringValue(value, comparisonValue).includes(filter.value);
+        case '$notContains':
+            return typeof filter.value === 'string' && !filterStringValue(value, comparisonValue).includes(filter.value);
+        case '$endsWith':
+            return typeof filter.value === 'string' && filterStringValue(value, comparisonValue).endsWith(filter.value);
+        case '$notEndsWith':
+            return typeof filter.value === 'string' && !filterStringValue(value, comparisonValue).endsWith(filter.value);
+        case '$regex':
+            return typeof filter.value === 'string' && new RegExp(filter.value, filter.flags).test(filterStringValue(value, comparisonValue));
+        case '$notRegex':
+            return typeof filter.value === 'string' && !new RegExp(filter.value, filter.flags).test(filterStringValue(value, comparisonValue));
+        case '$termType':
+            return typeof filter.value === 'string' && matchesTermType(value, filter.value);
+        case '$notTermType':
+            return typeof filter.value === 'string' && !matchesTermType(value, filter.value);
+        case '$sameTerm': {
+            const right = filter.variable2 ? binding[filter.variable2] : filter.value;
+            return Boolean(right && (0, types_1.isTerm)(right) && sameTerm(value, right));
+        }
+        case '$notSameTerm': {
+            const right = filter.variable2 ? binding[filter.variable2] : filter.value;
+            return Boolean(right && (0, types_1.isTerm)(right) && !sameTerm(value, right));
+        }
+        case '$lang':
+            return typeof filter.value === 'string' && value.termType === 'Literal' && value.language === filter.value;
+        case '$notLang':
+            return typeof filter.value === 'string' && value.termType === 'Literal' && value.language !== filter.value;
+        case '$langIn':
+            return value.termType === 'Literal' && (filter.values ?? []).some((candidate) => typeof candidate === 'string' && value.language === candidate);
+        case '$notLangIn':
+            return value.termType === 'Literal' && !(filter.values ?? []).some((candidate) => typeof candidate === 'string' && value.language === candidate);
+        case '$langMatches':
+            return typeof filter.value === 'string' && value.termType === 'Literal' && langMatches(value.language, filter.value);
+        case '$notLangMatches':
+            return typeof filter.value === 'string' && value.termType === 'Literal' && !langMatches(value.language, filter.value);
+        case '$datatype':
+            return filter.value !== undefined && value.termType === 'Literal' && sameTermOrLexical(value.datatype, filter.value);
+        case '$notDatatype':
+            return filter.value !== undefined && value.termType === 'Literal' && !sameTermOrLexical(value.datatype, filter.value);
+        case '$datatypeIn':
+            return value.termType === 'Literal' && (filter.values ?? []).some((candidate) => sameTermOrLexical(value.datatype, candidate));
+        case '$notDatatypeIn':
+            return value.termType === 'Literal' && !(filter.values ?? []).some((candidate) => sameTermOrLexical(value.datatype, candidate));
+        default: {
+            const exhaustive = filter.operator;
+            throw new Error(`Unsupported RDF facts filter operator: ${exhaustive}`);
+        }
+    }
+}
+function compareVariableFilter(binding, comparisonValue, filter, predicate) {
+    if (!filter.variable2) {
+        return false;
+    }
+    const right = binding[filter.variable2];
+    if (!right) {
+        return false;
+    }
+    return predicate(compareFilterValues(comparisonValue, filterOperandValue(right, filter.operand)));
+}
+function filterOperandValue(value, operand) {
+    switch (operand) {
+        case 'stringLength':
+            return value.value.length;
+        case 'stringValue':
+            return value.value;
+        case 'lowerStringValue':
+            return value.value.toLowerCase();
+        case 'upperStringValue':
+            return value.value.toUpperCase();
+        default:
+            return value;
+    }
+}
+function filterStringValue(value, comparisonValue) {
+    return typeof comparisonValue === 'string' ? comparisonValue : value.value;
+}
+function sameTerm(left, right) {
+    return (0, n3_1.termToId)(left) === (0, n3_1.termToId)(right);
+}
+function sameTermOrLexical(left, right) {
+    if (typeof left === 'number') {
+        if (isNumericFilterValue(right)) {
+            return left === (0, RdfTermSemantics_1.rdfNumericValue)((0, types_1.isTerm)(right) ? right.value : String(right));
+        }
+        return String(left) === String(right);
+    }
+    if (typeof left === 'string') {
+        return left === ((0, types_1.isTerm)(right) ? right.value : String(right));
+    }
+    return (0, types_1.isTerm)(right) ? sameTerm(left, right) : left.value === String(right);
+}
+function compareTermsForFilter(left, right) {
+    if (right === undefined) {
+        return 1;
+    }
+    return compareFilterValues(left, right);
+}
+function compareFilterValues(left, right) {
+    if (typeof left === 'number') {
+        if (isNumericFilterValue(right)) {
+            return left - (0, RdfTermSemantics_1.rdfNumericValue)((0, types_1.isTerm)(right) ? right.value : String(right));
+        }
+        return String(left).localeCompare(String(right));
+    }
+    if (typeof left === 'string') {
+        return left.localeCompare((0, types_1.isTerm)(right) ? right.value : String(right));
+    }
+    if ((0, RdfTermSemantics_1.isRdfNumericTerm)(left) && isNumericFilterValue(right)) {
+        return (0, RdfTermSemantics_1.rdfNumericValue)(left.value) - (0, RdfTermSemantics_1.rdfNumericValue)((0, types_1.isTerm)(right) ? right.value : String(right));
+    }
+    return left.value.localeCompare((0, types_1.isTerm)(right) ? right.value : String(right));
+}
+function matchesTermTypeForKey(term, key, expected) {
+    return termKindsForPatternKey(key).includes(expected) && matchesTermType(term, expected);
+}
+function matchesTermType(term, expected) {
+    switch (expected) {
+        case 'iri':
+            return term.termType === 'NamedNode';
+        case 'blank':
+            return term.termType === 'BlankNode';
+        case 'literal':
+            return term.termType === 'Literal';
+        case 'numeric':
+            return (0, RdfTermSemantics_1.isRdfNumericTerm)(term);
+        default:
+            return false;
+    }
+}
+function langMatches(languageTag, languageRange) {
+    if (!languageTag) {
+        return false;
+    }
+    if (languageRange === '*') {
+        return true;
+    }
+    const normalizedTag = languageTag.toLowerCase();
+    const normalizedRange = languageRange.toLowerCase();
+    return normalizedTag === normalizedRange || normalizedTag.startsWith(`${normalizedRange}-`);
+}
+function isNumericFilterValue(value) {
+    return (0, types_1.isTerm)(value)
+        ? (0, RdfTermSemantics_1.isRdfNumericTerm)(value)
+        : (typeof value === 'number' || (typeof value === 'string' && (0, RdfTermSemantics_1.isFiniteNumericLexical)(value)));
+}
+function joinValuesSource(input, source) {
+    const output = [];
+    for (const binding of input) {
+        for (const row of source.rows) {
+            const next = mergeTupleValuesBinding(binding, source.variables, row);
+            if (next) {
+                output.push(next);
+            }
+        }
+    }
+    return output;
+}
+function mergeTupleValuesBinding(binding, variables, row) {
+    const next = { ...binding };
+    for (const variableName of variables) {
+        const value = row[variableName];
+        if (!value) {
+            continue;
+        }
+        const existing = next[variableName];
+        if (existing && !sameTerm(existing, value)) {
+            return null;
+        }
+        next[variableName] = value;
+    }
+    return next;
+}
+function projectBinding(binding, select) {
+    const projected = {};
+    for (const variableName of select) {
+        const value = binding[variableName];
+        if (value) {
+            projected[variableName] = value;
+        }
+    }
+    return projected;
+}
+function compareBindings(left, right, orderBy) {
+    for (const order of orderBy) {
+        const leftValue = left[order.variable] ? (0, n3_1.termToId)(left[order.variable]) : '';
+        const rightValue = right[order.variable] ? (0, n3_1.termToId)(right[order.variable]) : '';
+        const comparison = leftValue.localeCompare(rightValue);
+        if (comparison !== 0) {
+            return order.direction === 'desc' ? -comparison : comparison;
+        }
+    }
+    return 0;
+}
+function bindingKey(binding, variables) {
+    return [...(variables ?? Object.keys(binding))]
+        .sort()
+        .map((key) => {
+        const value = binding[key];
+        return `${key}=${value ? (0, n3_1.termToId)(value) : '__UNBOUND__'}`;
+    })
+        .join('\u001f');
+}
+function distinctBindings(bindings) {
+    const seen = new Set();
+    const output = [];
+    for (const binding of bindings) {
+        const key = bindingKey(binding);
+        if (seen.has(key)) {
+            continue;
+        }
+        seen.add(key);
+        output.push(binding);
+    }
+    return output;
+}
+function aggregateBindings(bindings, aggregates) {
+    const binding = {};
+    let firstCount = 0;
+    aggregates.forEach((aggregate, index) => {
+        const count = aggregate.type === 'count'
+            ? countBindings(bindings, aggregate.variable, aggregate.distinct, aggregate.distinctVariables)
+            : 0;
+        if (index === 0) {
+            firstCount = count;
+        }
+        const term = aggregateLiteral(bindings, aggregate);
+        if (term) {
+            binding[aggregate.as] = term;
+        }
+    });
+    return { binding, firstCount };
+}
+function groupAggregateBindings(bindings, groupBy, aggregates) {
+    const groups = new Map();
+    for (const binding of bindings) {
+        const key = groupBy.map((variableName) => {
+            const value = binding[variableName];
+            return value ? (0, n3_1.termToId)(value) : '__UNBOUND__';
+        }).join('\u001f');
+        groups.set(key, [...(groups.get(key) ?? []), binding]);
+    }
+    return [...groups.values()].map((groupBindings) => {
+        const first = groupBindings[0];
+        const grouped = {};
+        for (const variableName of groupBy) {
+            if (first[variableName]) {
+                grouped[variableName] = first[variableName];
+            }
+        }
+        for (const aggregate of aggregates) {
+            const term = aggregateLiteral(groupBindings, aggregate);
+            if (term) {
+                grouped[aggregate.as] = term;
+            }
+        }
+        return grouped;
+    });
+}
+function countBindings(bindings, variable, distinct, distinctVariables) {
+    if (!distinct) {
+        return variable ? bindings.filter((binding) => binding[variable]).length : bindings.length;
+    }
+    if (!variable) {
+        return new Set(bindings.map((binding) => bindingKey(binding, distinctVariables))).size;
+    }
+    return new Set(bindings
+        .map((binding) => binding[variable])
+        .filter((term) => Boolean(term))
+        .map((term) => (0, n3_1.termToId)(term))).size;
+}
+function aggregateLiteral(bindings, aggregate) {
+    if (aggregate.type === 'count') {
+        return countLiteral(countBindings(bindings, aggregate.variable, aggregate.distinct, aggregate.distinctVariables));
+    }
+    const values = numericAggregateValues(bindings, aggregate.variable, aggregate.distinct);
+    if (values.length === 0) {
+        return aggregate.type === 'sum' ? decimalLiteral(0) : undefined;
+    }
+    switch (aggregate.type) {
+        case 'sum':
+            return decimalLiteral(values.reduce((sum, value) => sum + value, 0));
+        case 'avg':
+            return decimalLiteral(values.reduce((sum, value) => sum + value, 0) / values.length);
+        case 'min':
+            return decimalLiteral(Math.min(...values));
+        case 'max':
+            return decimalLiteral(Math.max(...values));
+        default: {
+            const exhaustive = aggregate.type;
+            throw new Error(`Unsupported RDF facts aggregate type: ${exhaustive}`);
+        }
+    }
+}
+function numericAggregateValues(bindings, variable, distinct) {
+    if (!variable) {
+        return [];
+    }
+    const values = [];
+    const seen = new Set();
+    for (const binding of bindings) {
+        const term = binding[variable];
+        if (!term || !(0, RdfTermSemantics_1.isRdfNumericTerm)(term)) {
+            continue;
+        }
+        if (distinct) {
+            const key = (0, n3_1.termToId)(term);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+        }
+        values.push((0, RdfTermSemantics_1.rdfNumericValue)(term.value));
+    }
+    return values;
+}
+function countLiteral(count) {
+    return n3_1.DataFactory.literal(String(count), n3_1.DataFactory.namedNode(XSD_INTEGER));
+}
+function decimalLiteral(value) {
+    return n3_1.DataFactory.literal(String(value), n3_1.DataFactory.namedNode(XSD_DECIMAL));
+}
+function evaluateBindExpression(expression, binding) {
+    switch (expression.type) {
+        case 'term':
+            return expression.term;
+        case 'variable':
+            return binding[expression.variable];
+        case 'stringValue': {
+            const value = binding[expression.variable];
+            return value ? n3_1.DataFactory.literal(value.value) : undefined;
+        }
+        case 'stringLength': {
+            const value = binding[expression.variable];
+            return value ? countLiteral(value.value.length) : undefined;
+        }
+        case 'lowerCase': {
+            const value = evaluateBindExpression(expression.expression, binding);
+            return value ? n3_1.DataFactory.literal(value.value.toLocaleLowerCase('en-US')) : undefined;
+        }
+        case 'upperCase': {
+            const value = evaluateBindExpression(expression.expression, binding);
+            return value ? n3_1.DataFactory.literal(value.value.toLocaleUpperCase('en-US')) : undefined;
+        }
+        case 'coalesce':
+            for (const item of expression.expressions) {
+                const value = evaluateBindExpression(item, binding);
+                if (value) {
+                    return value;
+                }
+            }
+            return undefined;
+        case 'if':
+            return matchesBindingFilters(binding, expression.condition)
+                ? evaluateBindExpression(expression.then, binding)
+                : evaluateBindExpression(expression.else, binding);
+        case 'substring': {
+            const value = evaluateBindExpression(expression.expression, binding);
+            const startTerm = evaluateBindExpression(expression.start, binding);
+            const start = startTerm ? finiteBindNumber(startTerm) : undefined;
+            const lengthTerm = expression.length ? evaluateBindExpression(expression.length, binding) : undefined;
+            const length = lengthTerm ? finiteBindNumber(lengthTerm) : undefined;
+            if (!value || start === undefined || (expression.length && length === undefined)) {
+                return undefined;
+            }
+            const startIndex = Math.max(0, Math.round(start) - 1);
+            const lengthValue = length === undefined ? undefined : Math.max(0, Math.round(length));
+            return n3_1.DataFactory.literal(value.value.slice(startIndex, lengthValue === undefined ? undefined : startIndex + lengthValue));
+        }
+        case 'concat': {
+            const values = expression.expressions.map((item) => evaluateBindExpression(item, binding));
+            return values.every((value) => Boolean(value))
+                ? n3_1.DataFactory.literal(values.map((value) => value.value).join(''))
+                : undefined;
+        }
+        case 'iri': {
+            const value = evaluateBindExpression(expression.expression, binding);
+            if (!value) {
+                return undefined;
+            }
+            try {
+                return n3_1.DataFactory.namedNode(new URL(value.value, expression.base).href);
+            }
+            catch {
+                return undefined;
+            }
+        }
+        case 'strdt': {
+            const lexical = evaluateBindExpression(expression.lexical, binding);
+            const datatype = evaluateBindExpression(expression.datatype, binding);
+            if (!lexical || !datatype || datatype.termType !== 'NamedNode') {
+                return undefined;
+            }
+            return n3_1.DataFactory.literal(lexical.value, n3_1.DataFactory.namedNode(datatype.value));
+        }
+        case 'strlang': {
+            const lexical = evaluateBindExpression(expression.lexical, binding);
+            const language = evaluateBindExpression(expression.language, binding);
+            if (!lexical || !language) {
+                return undefined;
+            }
+            return n3_1.DataFactory.literal(lexical.value, language.value);
+        }
+        default: {
+            const exhaustive = expression;
+            throw new Error(`Unsupported RDF facts BIND expression: ${JSON.stringify(exhaustive)}`);
+        }
+    }
+}
+function finiteBindNumber(term) {
+    if (term.termType !== 'Literal') {
+        return undefined;
+    }
+    const value = Number(term.value);
+    return Number.isFinite(value) ? value : undefined;
+}
+function describeBind(bind) {
+    return `?${bind.variable}:=${describeBindExpression(bind.expression)}`;
+}
+function describeBindExpression(expression) {
+    switch (expression.type) {
+        case 'term':
+            return (0, n3_1.termToId)(expression.term);
+        case 'variable':
+            return `?${expression.variable}`;
+        case 'stringValue':
+            return `STR(?${expression.variable})`;
+        case 'stringLength':
+            return `STRLEN(?${expression.variable})`;
+        case 'lowerCase':
+            return `LCASE(${describeBindExpression(expression.expression)})`;
+        case 'upperCase':
+            return `UCASE(${describeBindExpression(expression.expression)})`;
+        case 'coalesce':
+            return `COALESCE(${expression.expressions.map(describeBindExpression).join(',')})`;
+        case 'if':
+            return `IF(${expression.condition.map(describeFilter).join('&')},${describeBindExpression(expression.then)},${describeBindExpression(expression.else)})`;
+        case 'substring':
+            return `SUBSTR(${[
+                describeBindExpression(expression.expression),
+                describeBindExpression(expression.start),
+                expression.length ? describeBindExpression(expression.length) : undefined,
+            ].filter(Boolean).join(',')})`;
+        case 'concat':
+            return `CONCAT(${expression.expressions.map(describeBindExpression).join(',')})`;
+        case 'iri':
+            return `IRI(${describeBindExpression(expression.expression)})`;
+        case 'strdt':
+            return `STRDT(${describeBindExpression(expression.lexical)},${describeBindExpression(expression.datatype)})`;
+        case 'strlang':
+            return `STRLANG(${describeBindExpression(expression.lexical)},${describeBindExpression(expression.language)})`;
+        default: {
+            const exhaustive = expression;
+            return JSON.stringify(exhaustive);
+        }
+    }
+}
 function uniqueStrings(values) {
     return [...new Set(values)];
 }