@undefineds.co/xpod 0.3.75 → 0.4.0-rc.139

package/dist/storage/sparql/QuintQuerySource.js

@@ -1,1069 +0,0 @@
-"use strict";
-/**
- * QuintQuerySource - IQuerySource implementation for QuintStore
- *
- * This implements Comunica's IQuerySource interface to enable proper FILTER pushdown.
- * Unlike RDF.Store.match() which only receives 4 terms, IQuerySource.queryBindings()
- * receives the full SPARQL algebra including FILTER expressions.
- *
- * Design:
- * - Delegates filter extraction to FilterPushdownExtractor
- * - Delegates pattern building to PatternBuilder
- * - Delegates in-memory evaluation to ExpressionEvaluator
- * - Coordinates these components to execute queries efficiently
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuintQuerySource = void 0;
-const asynciterator_1 = require("asynciterator");
-const sparqlalgebrajs_1 = require("sparqlalgebrajs");
-const rdf_data_factory_1 = require("rdf-data-factory");
-const FilterPushdownExtractor_1 = require("./FilterPushdownExtractor");
-const PatternBuilder_1 = require("./PatternBuilder");
-const ExpressionEvaluator_1 = require("./ExpressionEvaluator");
-const AlgebraUtils_1 = require("./AlgebraUtils");
-const serialization_1 = require("../quint/serialization");
-const dataFactory = new rdf_data_factory_1.DataFactory();
-/**
- * QuintQuerySource implements IQuerySource for QuintStore
- *
- * Key features:
- * 1. Declares support for FILTER operations via getSelectorShape()
- * 2. Receives full SPARQL algebra in queryBindings() including FILTERs
- * 3. Extracts filter conditions and pushes them down to QuintStore
- * 4. Applies security filters (ACL) unconditionally
- * 5. Tree-based evaluation for remaining non-pushdownable expressions
- */
-class QuintQuerySource {
-    constructor(store, options) {
-        this.store = store;
-        this.referenceValue = store; // Reference for source identification
-        this.debug = options.debug ?? false;
-        this.bindingsFactory = options.bindingsFactory;
-        this.getSecurityFilters = options.getSecurityFilters;
-        this.getOptimizeParams = options.getOptimizeParams;
-        this.getFilterExpression = options.getFilterExpression;
-        // Initialize delegate components
-        this.filterExtractor = new FilterPushdownExtractor_1.FilterPushdownExtractor();
-        this.patternBuilder = new PatternBuilder_1.PatternBuilder(this.getSecurityFilters);
-        this.expressionEvaluator = new ExpressionEvaluator_1.ExpressionEvaluator(store, this.patternBuilder, this.extractPatternAndFilter.bind(this));
-    }
-    /**
-     * Declare the operations this source supports
-     *
-     * We support:
-     * - Basic quad patterns (for simple queries)
-     * - FILTER operations (for filter pushdown)
-     * - BGP operations (for multi-pattern queries)
-     * - joinBindings: allows Comunica to push JOIN operations down to us
-     *
-     * The joinBindings support enables ActorRdfJoinMultiBindSource to push
-     * multiple patterns to us efficiently, using SQL JOINs instead of
-     * Comunica's nested loop approach.
-     */
-    async getSelectorShape(_context) {
-        // Check if store supports compound queries
-        const supportsCompound = !!this.store.getCompound;
-        return {
-            type: 'disjunction',
-            children: [
-                // Support basic patterns with joinBindings
-                {
-                    type: 'operation',
-                    operation: {
-                        operationType: 'pattern',
-                        pattern: {
-                            type: 'pattern',
-                            subject: dataFactory.variable('s'),
-                            predicate: dataFactory.variable('p'),
-                            object: dataFactory.variable('o'),
-                            graph: dataFactory.variable('g'),
-                        },
-                    },
-                    variablesOptional: [
-                        dataFactory.variable('s'),
-                        dataFactory.variable('p'),
-                        dataFactory.variable('o'),
-                        dataFactory.variable('g'),
-                    ],
-                    // Allow Comunica to push join bindings to us
-                    ...(supportsCompound ? { joinBindings: true } : {}),
-                },
-                // Support BGP operations (multi-pattern queries)
-                {
-                    type: 'operation',
-                    operation: {
-                        operationType: 'type',
-                        type: sparqlalgebrajs_1.Algebra.types.BGP,
-                    },
-                    ...(supportsCompound ? { joinBindings: true } : {}),
-                },
-                // Support FILTER operations
-                {
-                    type: 'operation',
-                    operation: {
-                        operationType: 'type',
-                        type: sparqlalgebrajs_1.Algebra.types.FILTER,
-                    },
-                    ...(supportsCompound ? { joinBindings: true } : {}),
-                },
-                // Support JOIN operations (for receiving compound queries from Comunica)
-                {
-                    type: 'operation',
-                    operation: {
-                        operationType: 'type',
-                        type: sparqlalgebrajs_1.Algebra.types.JOIN,
-                    },
-                    ...(supportsCompound ? { joinBindings: true } : {}),
-                },
-            ],
-        };
-    }
-    /**
-     * Query bindings - main entry point for SPARQL queries
-     *
-     * When Comunica's ActorRdfJoinMultiBindSource selects us for a join operation,
-     * it passes options.joinBindings containing bindings from the first pattern.
-     * We need to use these bindings to filter our query results efficiently.
-     */
-    queryBindings(operation, _context, options) {
-        if (this.debug) {
-            console.log(`[QuintQuerySource] queryBindings() called with operation type: ${operation.type}`);
-            console.log(`[QuintQuerySource] Has joinBindings: ${!!options?.joinBindings}`);
-            console.log(`[QuintQuerySource] Has filterBindings: ${!!options?.filterBindings}`);
-            // Log operation structure
-            if (operation.type === 'join' && operation.input) {
-                console.log(`[QuintQuerySource] JOIN inputs: ${operation.input?.length || 0}`);
-            }
-        }
-        // Wrap async execution in an iterator using wrap()
-        const variables = this.getVariablesFromOperation(operation);
-        const resultIterator = (0, asynciterator_1.wrap)(this.executeQuery(operation, options).then(results => results));
-        // Add metadata for Comunica
-        // Variables must be in format { variable: Variable, canBeUndef: boolean }
-        const variablesMetadata = variables.map(v => ({ variable: v, canBeUndef: false }));
-        resultIterator.setProperty('metadata', {
-            state: { invalidate: () => { }, invalid: false, addInvalidateListener: () => { } },
-            cardinality: { type: 'estimate', value: Number.POSITIVE_INFINITY },
-            variables: variablesMetadata,
-        });
-        return resultIterator;
-    }
-    /**
-     * Execute query and return bindings
-     *
-     * If options.joinBindings is provided, we need to:
-     * 1. Collect bindings from the stream (these are from the first pattern in the JOIN)
-     * 2. Extract variable values that overlap with our patterns
-     * 3. Use those values as IN conditions in our query
-     * 4. JOIN the results with the incoming bindings
-     */
-    async executeQuery(operation, options) {
-        // Handle joinBindings from Comunica (bind join)
-        if (options?.joinBindings && this.store.getCompound) {
-            return this.executeBindJoin(operation, options.joinBindings);
-        }
-        const { pattern, patterns, filter } = this.extractPatternAndFilter(operation);
-        // Check if we can use compound query (multiple patterns with same subject variable)
-        if (patterns && patterns.length > 1 && this.store.getCompound) {
-            const compoundResult = await this.tryCompoundQuery(patterns, filter, operation);
-            if (compoundResult) {
-                return compoundResult;
-            }
-            // Compound query not applicable (e.g. inverse patterns with different subject vars).
-            // Fall back to per-pattern execution with in-memory hash join.
-            const multiResult = await this.executeMultiPatternJoin(patterns, filter);
-            if (multiResult) {
-                return multiResult;
-            }
-        }
-        const variables = (0, AlgebraUtils_1.extractVariables)(pattern);
-        // Try to get pre-extracted filter expressions for variables in this pattern
-        let combinedFilter = filter;
-        if (this.getFilterExpression && !filter) {
-            // Check if any variable in the pattern has a pre-extracted filter
-            for (const variable of variables) {
-                const preExtractedFilter = this.getFilterExpression(variable.value);
-                if (preExtractedFilter) {
-                    if (this.debug) {
-                        console.log(`[QuintQuerySource] Found pre-extracted filter for ?${variable.value}`);
-                    }
-                    if (combinedFilter) {
-                        // Combine with AND
-                        combinedFilter = {
-                            type: 'expression',
-                            expressionType: 'operator',
-                            operator: '&&',
-                            args: [combinedFilter, preExtractedFilter],
-                        };
-                    }
-                    else {
-                        combinedFilter = preExtractedFilter;
-                    }
-                }
-            }
-        }
-        // Extract pushdownable filters
-        let pushdownFilters = {};
-        let remainder = combinedFilter;
-        let orBranches;
-        let orNonPushdownBranches;
-        if (combinedFilter) {
-            const result = this.filterExtractor.extractPushdownFilters(combinedFilter, pattern);
-            pushdownFilters = result.filters;
-            remainder = result.remainder;
-            orBranches = result.orBranches;
-            orNonPushdownBranches = result.orNonPushdownBranches;
-        }
-        if (this.debug) {
-            console.log(`[QuintQuerySource] Pushdown filters:`, JSON.stringify(pushdownFilters, null, 2));
-            console.log(`[QuintQuerySource] OR branches:`, orBranches?.length || 0);
-            console.log(`[QuintQuerySource] OR non-pushdown branches:`, orNonPushdownBranches?.length || 0);
-            console.log(`[QuintQuerySource] Has remainder:`, remainder !== null);
-        }
-        // Get query options
-        // NOTE: Comunica handles OFFSET, we only pass limit to QuintStore
-        // If there's an offset, we need to fetch limit + offset records
-        // and let Comunica skip the first `offset` records
-        const optimizeParams = this.getOptimizeParams();
-        const queryOptions = {};
-        if (optimizeParams?.limit) {
-            // Fetch enough records for Comunica to apply offset
-            queryOptions.limit = optimizeParams.limit + (optimizeParams.offset || 0);
-        }
-        // Don't pass offset to QuintStore - Comunica handles it
-        // 处理 ORDER BY 下推
-        if (optimizeParams?.order) {
-            // 直接使用已映射的 order
-            queryOptions.order = optimizeParams.order;
-        }
-        else if (optimizeParams?.orderVarName) {
-            // 通过 pattern 分析变量绑定位置
-            const orderField = this.findVariableBinding(optimizeParams.orderVarName, pattern);
-            if (orderField) {
-                queryOptions.order = [orderField];
-                if (this.debug) {
-                    console.log(`[QuintQuerySource] ORDER BY ?${optimizeParams.orderVarName} -> ${orderField} (via pattern analysis)`);
-                }
-            }
-        }
-        if (optimizeParams?.reverse)
-            queryOptions.reverse = optimizeParams.reverse;
-        let results;
-        // Handle OR branches (union semantics)
-        if (orBranches && orBranches.length > 0) {
-            results = await this.executeOrBranches(pattern, variables, orBranches, orNonPushdownBranches, queryOptions);
-            if (this.debug) {
-                console.log(`[QuintQuerySource] OR pushdown branches returned ${results.length} unique results`);
-            }
-        }
-        else if (Object.keys(pushdownFilters).length > 0) {
-            // Build pattern with pushdown filters
-            const quintPattern = this.patternBuilder.buildQuintPattern(pattern, pushdownFilters);
-            const quads = await this.store.get(quintPattern, queryOptions);
-            results = this.quadsToBindings(quads, variables, pattern);
-            if (this.debug) {
-                console.log(`[QuintQuerySource] Pushdown query returned ${results.length} results`);
-            }
-        }
-        else {
-            // No pushdown, get all matching quads
-            const quintPattern = this.patternBuilder.buildBasePattern(pattern);
-            const quads = await this.store.get(quintPattern, queryOptions);
-            results = this.quadsToBindings(quads, variables, pattern);
-            if (this.debug) {
-                console.log(`[QuintQuerySource] Base query returned ${results.length} results`);
-            }
-        }
-        // NOTE: We don't apply in-memory filter for pre-extracted filters
-        // because Comunica will handle the final filtering after JOIN
-        // Only apply remainder if it's from the original operation's filter
-        if (remainder && filter) {
-            results = await this.expressionEvaluator.evaluateFilterTree(remainder, results, pattern);
-            if (this.debug) {
-                console.log(`[QuintQuerySource] After in-memory filter: ${results.length} results`);
-            }
-        }
-        return results;
-    }
-    /**
-     * Execute a bind join: use incoming bindings to filter our query
-     *
-     * This is called when Comunica's ActorRdfJoinMultiBindSource pushes bindings to us.
-     * We use SQL IN clause to efficiently query only the rows matching the incoming bindings.
-     */
-    async executeBindJoin(operation, joinBindings) {
-        // Collect all incoming bindings
-        const incomingBindings = [];
-        for await (const binding of joinBindings.bindings) {
-            incomingBindings.push(binding);
-        }
-        if (this.debug) {
-            console.log(`[QuintQuerySource] executeBindJoin: received ${incomingBindings.length} bindings`);
-        }
-        if (incomingBindings.length === 0) {
-            return [];
-        }
-        // Extract patterns from the operation
-        const { pattern, patterns, filter } = this.extractPatternAndFilter(operation);
-        const allPatterns = patterns || [pattern];
-        // Find overlapping variables between incoming bindings and our patterns
-        // These are the JOIN keys
-        const incomingVars = new Set();
-        const firstBinding = incomingBindings[0];
-        for (const key of firstBinding.keys()) {
-            incomingVars.add(key.value);
-        }
-        // Find which pattern variables overlap with incoming bindings
-        // Typically this would be the subject variable
-        const patternVars = new Map();
-        for (let i = 0; i < allPatterns.length; i++) {
-            const p = allPatterns[i];
-            if (p.subject?.termType === 'Variable' && incomingVars.has(p.subject.value)) {
-                patternVars.set(p.subject.value, { patternIdx: i, field: 'subject' });
-            }
-            if (p.predicate?.termType === 'Variable' && incomingVars.has(p.predicate.value)) {
-                patternVars.set(p.predicate.value, { patternIdx: i, field: 'predicate' });
-            }
-            if (p.object?.termType === 'Variable' && incomingVars.has(p.object.value)) {
-                patternVars.set(p.object.value, { patternIdx: i, field: 'object' });
-            }
-            if (p.graph?.termType === 'Variable' && incomingVars.has(p.graph.value)) {
-                patternVars.set(p.graph.value, { patternIdx: i, field: 'graph' });
-            }
-        }
-        if (this.debug) {
-            console.log(`[QuintQuerySource] Overlapping variables:`, [...patternVars.keys()]);
-        }
-        if (patternVars.size === 0) {
-            // No overlapping variables - just execute normally and return cartesian product
-            // This shouldn't happen in typical use cases
-            const results = await this.executeQuery(operation);
-            return this.cartesianJoin(incomingBindings, results);
-        }
-        // Use the first overlapping variable as the join key
-        const [joinVarName, joinInfo] = [...patternVars.entries()][0];
-        // Collect unique values for the join variable from incoming bindings
-        const joinValues = new Set();
-        for (const binding of incomingBindings) {
-            const term = binding.get(dataFactory.variable(joinVarName));
-            if (term) {
-                joinValues.add(term.value);
-            }
-        }
-        if (this.debug) {
-            console.log(`[QuintQuerySource] Join variable: ?${joinVarName}, ${joinValues.size} unique values`);
-        }
-        // Build compound query with IN filter on join variable
-        if (allPatterns.length > 1) {
-            // Multiple patterns - use compound query
-            return this.executeBindJoinCompound(allPatterns, filter, joinVarName, joinInfo.field, [...joinValues], incomingBindings);
-        }
-        else {
-            // Single pattern - use simple query with IN filter
-            return this.executeBindJoinSimple(pattern, filter, joinVarName, joinInfo.field, [...joinValues], incomingBindings);
-        }
-    }
-    /**
-     * Execute bind join for a single pattern using IN filter
-     */
-    async executeBindJoinSimple(pattern, filter, joinVarName, joinField, joinValues, incomingBindings) {
-        const variables = (0, AlgebraUtils_1.extractVariables)(pattern);
-        // Build pattern with IN filter for join values
-        let pushdownFilters = {};
-        if (filter) {
-            const result = this.filterExtractor.extractPushdownFilters(filter, pattern);
-            pushdownFilters = result.filters;
-        }
-        // Add IN filter for join values
-        pushdownFilters[joinField] = {
-            ...pushdownFilters[joinField],
-            $in: joinValues,
-        };
-        const quintPattern = this.patternBuilder.buildQuintPattern(pattern, pushdownFilters);
-        const quads = await this.store.get(quintPattern);
-        const queryResults = this.quadsToBindings(quads, variables, pattern);
-        if (this.debug) {
-            console.log(`[QuintQuerySource] Bind join simple: ${queryResults.length} results from DB`);
-        }
-        // Join with incoming bindings
-        return this.hashJoin(incomingBindings, queryResults, joinVarName);
-    }
-    /**
-     * Execute bind join for multiple patterns using compound query
-     */
-    async executeBindJoinCompound(patterns, filter, joinVarName, joinField, joinValues, incomingBindings) {
-        // Build QuintPattern for each pattern
-        const quintPatterns = [];
-        const filtersByPattern = this.distributeFiltersToPatterns(filter, patterns);
-        for (let i = 0; i < patterns.length; i++) {
-            const pattern = patterns[i];
-            const patternFilters = filtersByPattern.get(i) || {};
-            // Add IN filter for join values on the first pattern
-            if (i === 0) {
-                patternFilters[joinField] = {
-                    ...patternFilters[joinField],
-                    $in: joinValues,
-                };
-            }
-            const quintPattern = this.patternBuilder.buildQuintPattern(pattern, patternFilters);
-            quintPatterns.push(quintPattern);
-        }
-        // Build compound pattern
-        const compound = {
-            patterns: quintPatterns,
-            joinOn: joinField,
-            select: this.buildSelectForPatterns(patterns),
-        };
-        const results = await this.store.getCompound(compound);
-        const queryResults = this.compoundResultsToBindings(results, patterns);
-        if (this.debug) {
-            console.log(`[QuintQuerySource] Bind join compound: ${queryResults.length} results from DB`);
-        }
-        // Join with incoming bindings
-        return this.hashJoin(incomingBindings, queryResults, joinVarName);
-    }
-    /**
-     * Hash join two binding sets on a common variable
-     */
-    hashJoin(left, right, joinVarName) {
-        // Build hash table on right side
-        const rightIndex = new Map();
-        const joinVar = dataFactory.variable(joinVarName);
-        for (const binding of right) {
-            const term = binding.get(joinVar);
-            if (term) {
-                const key = term.value;
-                if (!rightIndex.has(key)) {
-                    rightIndex.set(key, []);
-                }
-                rightIndex.get(key).push(binding);
-            }
-        }
-        // Probe with left side
-        const results = [];
-        for (const leftBinding of left) {
-            const term = leftBinding.get(joinVar);
-            if (term) {
-                const key = term.value;
-                const matches = rightIndex.get(key);
-                if (matches) {
-                    for (const rightBinding of matches) {
-                        // Merge bindings
-                        const merged = this.mergeBindings(leftBinding, rightBinding);
-                        if (merged) {
-                            results.push(merged);
-                        }
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Merge two bindings, returning null if they conflict
-     */
-    mergeBindings(left, right) {
-        const entries = [];
-        // Add all from left
-        for (const key of left.keys()) {
-            const term = left.get(key);
-            if (term) {
-                entries.push([key, term]);
-            }
-        }
-        // Add from right, checking for conflicts
-        for (const key of right.keys()) {
-            const rightTerm = right.get(key);
-            const leftTerm = left.get(key);
-            if (rightTerm) {
-                if (leftTerm) {
-                    // Both have this variable - must match
-                    if (leftTerm.value !== rightTerm.value || leftTerm.termType !== rightTerm.termType) {
-                        return null; // Conflict
-                    }
-                    // Same value, already in entries
-                }
-                else {
-                    // Only right has it
-                    entries.push([key, rightTerm]);
-                }
-            }
-        }
-        return this.bindingsFactory.bindings(entries);
-    }
-    /**
-     * Cartesian product of two binding sets
-     */
-    cartesianJoin(left, right) {
-        const results = [];
-        for (const l of left) {
-            for (const r of right) {
-                const merged = this.mergeBindings(l, r);
-                if (merged) {
-                    results.push(merged);
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Execute OR branches with union semantics
-     */
-    async executeOrBranches(pattern, variables, orBranches, orNonPushdownBranches, queryOptions) {
-        const seen = new Set();
-        const results = [];
-        // Execute each pushdownable branch
-        for (const branchFilters of orBranches) {
-            const quintPattern = this.patternBuilder.buildQuintPattern(pattern, branchFilters);
-            const quads = await this.store.get(quintPattern, queryOptions);
-            const bindings = this.quadsToBindings(quads, variables, pattern);
-            for (const binding of bindings) {
-                const key = this.expressionEvaluator.getBindingKey(binding);
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    results.push(binding);
-                }
-            }
-        }
-        // Handle non-pushdownable OR branches
-        if (orNonPushdownBranches && orNonPushdownBranches.length > 0) {
-            // Get base results without filter for in-memory evaluation
-            const quintPattern = this.patternBuilder.buildBasePattern(pattern);
-            const quads = await this.store.get(quintPattern, queryOptions);
-            const candidates = this.quadsToBindings(quads, variables, pattern);
-            // Evaluate each non-pushdownable branch
-            for (const branchExpr of orNonPushdownBranches) {
-                const branchResults = await this.expressionEvaluator.evaluateFilterTree(branchExpr, candidates, pattern);
-                for (const binding of branchResults) {
-                    const key = this.expressionEvaluator.getBindingKey(binding);
-                    if (!seen.has(key)) {
-                        seen.add(key);
-                        results.push(binding);
-                    }
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Try to execute a compound query for multiple patterns joined by same subject
-     * Returns null if compound query is not applicable
-     */
-    async tryCompoundQuery(patterns, filter, _operation) {
-        // Check if all patterns share the same subject variable
-        const subjectVars = patterns.map(p => p.subject?.termType === 'Variable' ? p.subject.value : null);
-        const uniqueSubjectVars = [...new Set(subjectVars.filter(v => v !== null))];
-        if (uniqueSubjectVars.length !== 1) {
-            // Not all patterns share the same subject variable
-            if (this.debug) {
-                console.log(`[QuintQuerySource] Cannot use compound query: different subject variables`, subjectVars);
-            }
-            return null;
-        }
-        const joinVar = uniqueSubjectVars[0];
-        if (this.debug) {
-            console.log(`[QuintQuerySource] Using compound query with ${patterns.length} patterns, joined on ?${joinVar}`);
-        }
-        // Build QuintPattern for each pattern, including filter conditions
-        const quintPatterns = [];
-        const filtersByPattern = this.distributeFiltersToPatterns(filter, patterns);
-        for (let i = 0; i < patterns.length; i++) {
-            const pattern = patterns[i];
-            const patternFilters = filtersByPattern.get(i) || {};
-            const quintPattern = this.patternBuilder.buildQuintPattern(pattern, patternFilters);
-            quintPatterns.push(quintPattern);
-        }
-        // Build compound pattern
-        const compound = {
-            patterns: quintPatterns,
-            joinOn: 'subject',
-            select: this.buildSelectForPatterns(patterns),
-        };
-        // Execute compound query
-        const optimizeParams = this.getOptimizeParams();
-        const queryOptions = {};
-        if (optimizeParams?.limit) {
-            queryOptions.limit = optimizeParams.limit + (optimizeParams.offset || 0);
-        }
-        const results = await this.store.getCompound(compound, queryOptions);
-        // Convert CompoundResult to Bindings
-        return this.compoundResultsToBindings(results, patterns);
-    }
-    /**
-     * Execute multiple patterns individually and hash-join results on shared variables.
-     * Used when compound query is not applicable (e.g. inverse patterns with different subject vars).
-     */
-    async executeMultiPatternJoin(patterns, filter = null) {
-        if (!patterns || patterns.length < 2)
-            return null;
-        if (this.debug) {
-            console.log(`[QuintQuerySource] executeMultiPatternJoin: ${patterns.length} patterns, hasFilter=${!!filter}`);
-        }
-        // If there's a FILTER like ?subject = <uri>, extract the bound value
-        // so we can push it down to individual pattern queries
-        const filterBindings = this.extractFilterBindings(filter);
-        // Execute each pattern individually and collect bindings
-        const patternBindings = [];
-        for (let i = 0; i < patterns.length; i++) {
-            const p = patterns[i];
-            const vars = (0, AlgebraUtils_1.extractVariables)(p);
-            // Try to apply filter bindings to this pattern
-            let quintPattern;
-            const pushdown = {};
-            if (filterBindings) {
-                // Check if any variable in this pattern matches a filter binding
-                for (const [varName, termValue] of Object.entries(filterBindings)) {
-                    if (p.subject?.termType === 'Variable' && p.subject.value === varName) {
-                        pushdown['subject'] = { $eq: termValue };
-                    }
-                    else if (p.object?.termType === 'Variable' && p.object.value === varName) {
-                        pushdown['object'] = { $eq: termValue };
-                    }
-                }
-            }
-            if (Object.keys(pushdown).length > 0) {
-                quintPattern = this.patternBuilder.buildQuintPattern(p, pushdown);
-            }
-            else {
-                quintPattern = this.patternBuilder.buildBasePattern(p);
-            }
-            const quads = await this.store.get(quintPattern);
-            const bindings = this.quadsToBindings(quads, vars, p);
-            if (this.debug) {
-                console.log(`[QuintQuerySource] Pattern ${i}: ${bindings.length} results, vars=[${vars.map(v => v.value)}]`);
-            }
-            patternBindings.push(bindings);
-        }
-        // Iteratively hash-join all pattern results
-        let result = patternBindings[0];
-        for (let i = 1; i < patternBindings.length; i++) {
-            result = this.hashJoinBindings(result, patternBindings[i]);
-            if (this.debug) {
-                console.log(`[QuintQuerySource] After join with pattern ${i}: ${result.length} results`);
-            }
-            if (result.length === 0)
-                break;
-        }
-        // Apply remaining in-memory filter if needed
-        if (filter && result.length > 0) {
-            result = await this.expressionEvaluator.evaluateFilterTree(filter, result, patterns[0]);
-        }
-        return result;
-    }
-    /**
-     * Extract simple equality bindings from a FILTER expression.
-     * E.g. FILTER(?subject = <uri>) -> { subject: "uri" }
-     */
-    extractFilterBindings(filter) {
-        if (!filter)
-            return null;
-        const bindings = {};
-        const extract = (expr) => {
-            if (!expr)
-                return;
-            if (expr.expressionType === 'operator' && expr.operator === '=') {
-                const args = expr.args || [];
-                if (args.length === 2) {
-                    let varName = null;
-                    let value = null;
-                    for (const arg of args) {
-                        if (arg.expressionType === 'term' && arg.term?.termType === 'Variable') {
-                            varName = arg.term.value;
-                        }
-                        else if (arg.expressionType === 'term' && arg.term?.termType === 'NamedNode') {
-                            value = arg.term.value;
-                        }
-                    }
-                    if (varName && value) {
-                        bindings[varName] = value;
-                    }
-                }
-            }
-            else if (expr.expressionType === 'operator' && expr.operator === '&&') {
-                for (const arg of (expr.args || [])) {
-                    extract(arg);
-                }
-            }
-        };
-        extract(filter);
-        return Object.keys(bindings).length > 0 ? bindings : null;
-    }
-    /**
-     * Hash-join two binding arrays on all shared variables.
-     */
-    hashJoinBindings(left, right) {
-        if (left.length === 0 || right.length === 0)
-            return [];
-        // Find shared variables
-        const leftVars = new Set();
-        for (const k of left[0].keys())
-            leftVars.add(k.value);
-        const rightVars = new Set();
-        for (const k of right[0].keys())
-            rightVars.add(k.value);
-        const sharedVars = [...leftVars].filter(v => rightVars.has(v));
-        if (sharedVars.length === 0) {
-            // No shared variables — cartesian product
-            return this.cartesianJoin(left, right);
-        }
-        // Build hash index on right side using shared vars as key
-        const rightIndex = new Map();
-        for (const binding of right) {
-            const key = sharedVars.map(v => {
-                const t = binding.get(dataFactory.variable(v));
-                return t ? t.value : '';
-            }).join('\0');
-            if (!rightIndex.has(key))
-                rightIndex.set(key, []);
-            rightIndex.get(key).push(binding);
-        }
-        // Probe with left side
-        const results = [];
-        for (const leftBinding of left) {
-            const key = sharedVars.map(v => {
-                const t = leftBinding.get(dataFactory.variable(v));
-                return t ? t.value : '';
-            }).join('\0');
-            const matches = rightIndex.get(key);
-            if (matches) {
-                for (const rightBinding of matches) {
-                    const merged = this.mergeBindings(leftBinding, rightBinding);
-                    if (merged)
-                        results.push(merged);
-                }
-            }
-        }
-        return results;
-    }
-    /**
-     * Distribute filter conditions to their respective patterns
-     * Returns a map of pattern index -> PushdownFilters
-     */
-    distributeFiltersToPatterns(filter, patterns) {
-        const result = new Map();
-        if (!filter)
-            return result;
-        // Build a map of variable name to pattern index
-        const varToPatternIdx = new Map();
-        for (let i = 0; i < patterns.length; i++) {
-            const p = patterns[i];
-            if (p.object?.termType === 'Variable') {
-                varToPatternIdx.set(p.object.value, i);
-            }
-        }
-        // Extract filters and distribute them
-        for (let i = 0; i < patterns.length; i++) {
-            const patternResult = this.filterExtractor.extractPushdownFilters(filter, patterns[i]);
-            if (Object.keys(patternResult.filters).length > 0) {
-                result.set(i, patternResult.filters);
-            }
-        }
-        return result;
-    }
-    /**
-     * Build SELECT clause config for patterns
-     */
-    buildSelectForPatterns(patterns) {
-        const select = [];
-        for (let i = 0; i < patterns.length; i++) {
-            const p = patterns[i];
-            // Select object if it's a variable
-            if (p.object?.termType === 'Variable') {
-                select.push({
-                    pattern: i,
-                    field: 'object',
-                    alias: `p${i}_${p.object.value}`,
-                });
-            }
-            // Select predicate if it's a variable
-            if (p.predicate?.termType === 'Variable') {
-                select.push({
-                    pattern: i,
-                    field: 'predicate',
-                    alias: `p${i}_${p.predicate.value}`,
-                });
-            }
-            // Select graph if it's a variable
-            if (p.graph?.termType === 'Variable') {
-                select.push({
-                    pattern: i,
-                    field: 'graph',
-                    alias: `p${i}_${p.graph.value}`,
-                });
-            }
-        }
-        return select;
-    }
-    /**
-     * Convert CompoundResult array to Bindings array
-     */
-    compoundResultsToBindings(results, patterns) {
-        // Collect all variables from all patterns
-        const variables = [];
-        const varNames = new Set();
-        for (const p of patterns) {
-            if (p.subject?.termType === 'Variable' && !varNames.has(p.subject.value)) {
-                variables.push(p.subject);
-                varNames.add(p.subject.value);
-            }
-            if (p.predicate?.termType === 'Variable' && !varNames.has(p.predicate.value)) {
-                variables.push(p.predicate);
-                varNames.add(p.predicate.value);
-            }
-            if (p.object?.termType === 'Variable' && !varNames.has(p.object.value)) {
-                variables.push(p.object);
-                varNames.add(p.object.value);
-            }
-            if (p.graph?.termType === 'Variable' && !varNames.has(p.graph.value)) {
-                variables.push(p.graph);
-                varNames.add(p.graph.value);
-            }
-        }
-        return results.map(result => {
-            const entries = [];
-            for (const v of variables) {
-                const varName = v.value;
-                // Check if this is the join variable (subject)
-                if (patterns[0].subject?.termType === 'Variable' &&
-                    patterns[0].subject.value === varName) {
-                    // Use joinValue for subject
-                    const term = dataFactory.namedNode(result.joinValue);
-                    entries.push([v, term]);
-                    continue;
-                }
-                // Look for the variable in bindings
-                for (let i = 0; i < patterns.length; i++) {
-                    const p = patterns[i];
-                    if (p.object?.termType === 'Variable' && p.object.value === varName) {
-                        const alias = `p${i}_${varName}`;
-                        const value = result.bindings[alias];
-                        if (value !== undefined) {
-                            // Deserialize the value
-                            const term = this.deserializeValue(value);
-                            entries.push([v, term]);
-                            break;
-                        }
-                    }
-                    if (p.predicate?.termType === 'Variable' && p.predicate.value === varName) {
-                        const alias = `p${i}_${varName}`;
-                        const value = result.bindings[alias];
-                        if (value !== undefined) {
-                            const term = dataFactory.namedNode(value);
-                            entries.push([v, term]);
-                            break;
-                        }
-                    }
-                    if (p.graph?.termType === 'Variable' && p.graph.value === varName) {
-                        const alias = `p${i}_${varName}`;
-                        const value = result.bindings[alias];
-                        if (value !== undefined) {
-                            const term = dataFactory.namedNode(value);
-                            entries.push([v, term]);
-                            break;
-                        }
-                    }
-                }
-            }
-            return this.bindingsFactory.bindings(entries);
-        });
-    }
-    /**
-     * Deserialize a value from storage format to RDF Term
-     * Uses the same deserialization logic as QuintStore
-     */
-    deserializeValue(value) {
-        return (0, serialization_1.deserializeObject)(value);
-    }
-    /**
-     * Convert quads to bindings based on pattern variables
-     */
-    quadsToBindings(quads, variables, pattern) {
-        if (this.debug) {
-            console.log(`[QuintQuerySource] quadsToBindings: ${quads.length} quads, ${variables.length} variables`);
-            console.log(`[QuintQuerySource] Variables:`, variables.map(v => v.value));
-            console.log(`[QuintQuerySource] Pattern:`, {
-                subject: pattern.subject?.termType === 'Variable' ? `?${pattern.subject.value}` : pattern.subject?.value,
-                predicate: pattern.predicate?.termType === 'Variable' ? `?${pattern.predicate.value}` : pattern.predicate?.value,
-                object: pattern.object?.termType === 'Variable' ? `?${pattern.object.value}` : pattern.object?.value,
-                graph: pattern.graph?.termType === 'Variable' ? `?${pattern.graph.value}` : pattern.graph?.value || pattern.graph?.termType,
-            });
-        }
-        return quads.map(quad => {
-            const entries = [];
-            for (const v of variables) {
-                const term = this.getTermForVariable(v, quad, pattern);
-                if (term) {
-                    entries.push([v, term]);
-                }
-            }
-            if (this.debug && entries.length !== variables.length) {
-                console.log(`[QuintQuerySource] Warning: only ${entries.length} of ${variables.length} variables bound`);
-            }
-            return this.bindingsFactory.bindings(entries);
-        });
-    }
-    /**
-     * Get the term from quad that matches the variable position in pattern
-     */
-    getTermForVariable(variable, quad, pattern) {
-        const varName = variable.value;
-        // Check which position in the pattern this variable is in
-        if (pattern.subject?.termType === 'Variable' && pattern.subject.value === varName) {
-            return quad.subject;
-        }
-        if (pattern.predicate?.termType === 'Variable' && pattern.predicate.value === varName) {
-            return quad.predicate;
-        }
-        if (pattern.object?.termType === 'Variable' && pattern.object.value === varName) {
-            return quad.object;
-        }
-        if (pattern.graph?.termType === 'Variable' && pattern.graph.value === varName) {
-            return quad.graph;
-        }
-        return null;
-    }
-    /**
-     * Extract BGP pattern and filter from operation
-     * Returns either a single pattern or multiple patterns (from BGP or JOIN)
-     */
-    extractPatternAndFilter(operation) {
-        let pattern = null;
-        let patterns;
-        let filter = null;
-        // Walk the algebra tree to find pattern(s) and filter
-        sparqlalgebrajs_1.Util.recurseOperation(operation, {
-            [sparqlalgebrajs_1.Algebra.types.JOIN]: (op) => {
-                // JOIN contains multiple patterns - extract them all
-                if (op.input && op.input.length > 0) {
-                    const extractedPatterns = [];
-                    for (const input of op.input) {
-                        if (input.type === sparqlalgebrajs_1.Algebra.types.PATTERN) {
-                            extractedPatterns.push(input);
-                        }
-                        else {
-                            // Recurse into nested operation to find patterns
-                            const nested = this.extractPatternAndFilter(input);
-                            if (nested.patterns) {
-                                extractedPatterns.push(...nested.patterns);
-                            }
-                            else if (nested.pattern) {
-                                extractedPatterns.push(nested.pattern);
-                            }
-                            // Also collect filter from nested operations
-                            if (nested.filter && !filter) {
-                                filter = nested.filter;
-                            }
-                        }
-                    }
-                    if (extractedPatterns.length > 0) {
-                        patterns = extractedPatterns;
-                        if (!pattern) {
-                            pattern = patterns[0];
-                        }
-                    }
-                }
-                return false; // Don't recurse further
-            },
-            [sparqlalgebrajs_1.Algebra.types.BGP]: (op) => {
-                // BGP contains multiple patterns - this is what we want for compound queries
-                if (op.patterns && op.patterns.length > 0) {
-                    patterns = op.patterns;
-                    if (!pattern) {
-                        pattern = patterns[0];
-                    }
-                }
-                return false; // Don't recurse into individual patterns
-            },
-            [sparqlalgebrajs_1.Algebra.types.PATTERN]: (op) => {
-                if (!pattern)
-                    pattern = op;
-                return false;
-            },
-            [sparqlalgebrajs_1.Algebra.types.FILTER]: (op) => {
-                filter = op.expression;
-                return true; // Continue to find pattern inside filter
-            },
-        });
-        if (!pattern) {
-            // Create empty pattern if none found
-            pattern = {
-                type: 'pattern',
-                subject: dataFactory.variable('s'),
-                predicate: dataFactory.variable('p'),
-                object: dataFactory.variable('o'),
-                graph: dataFactory.defaultGraph(),
-            };
-        }
-        return { pattern, patterns, filter };
-    }
-    /**
-     * Get variables from operation
-     */
-    getVariablesFromOperation(operation) {
-        const { pattern, patterns } = this.extractPatternAndFilter(operation);
-        if (patterns && patterns.length > 1) {
-            // Collect variables from all patterns
-            const allVars = [];
-            const seen = new Set();
-            for (const p of patterns) {
-                for (const v of (0, AlgebraUtils_1.extractVariables)(p)) {
-                    if (!seen.has(v.value)) {
-                        seen.add(v.value);
-                        allVars.push(v);
-                    }
-                }
-            }
-            return allVars;
-        }
-        return (0, AlgebraUtils_1.extractVariables)(pattern);
-    }
-    // ============================================================
-    // Required IQuerySource Methods
-    // ============================================================
-    queryQuads(operation, _context) {
-        const { pattern } = this.extractPatternAndFilter(operation);
-        const quintPattern = this.patternBuilder.buildBasePattern(pattern);
-        const resultIterator = (0, asynciterator_1.wrap)(this.store.get(quintPattern));
-        resultIterator.setProperty('metadata', {
-            state: { invalidate: () => { }, invalid: false, addInvalidateListener: () => { } },
-            cardinality: { type: 'estimate', value: Number.POSITIVE_INFINITY },
-        });
-        return resultIterator;
-    }
-    async queryBoolean(operation, _context) {
-        const { pattern } = this.extractPatternAndFilter(operation.input);
-        const quintPattern = this.patternBuilder.buildBasePattern(pattern);
-        const results = await this.store.get(quintPattern, { limit: 1 });
-        return results.length > 0;
-    }
-    queryVoid(_operation, _context) {
-        throw new Error('queryVoid is not implemented');
-    }
-    /**
-     * 在 pattern 中查找变量绑定到哪个位置
-     *
-     * 例如：{ ?s <http://schema.org/name> ?name }
-     * - ?s 绑定到 subject
-     * - ?name 绑定到 object
-     */
-    findVariableBinding(varName, pattern) {
-        if (pattern.subject?.termType === 'Variable' && pattern.subject.value === varName) {
-            return 'subject';
-        }
-        if (pattern.predicate?.termType === 'Variable' && pattern.predicate.value === varName) {
-            return 'predicate';
-        }
-        if (pattern.object?.termType === 'Variable' && pattern.object.value === varName) {
-            return 'object';
-        }
-        if (pattern.graph?.termType === 'Variable' && pattern.graph.value === varName) {
-            return 'graph';
-        }
-        return null;
-    }
-    toString() {
-        return `QuintQuerySource(${this.store.constructor.name})`;
-    }
-}
-exports.QuintQuerySource = QuintQuerySource;
-//# sourceMappingURL=QuintQuerySource.js.map