@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/storage/sparql/QuintQuerySource.js

@@ -0,0 +1,918 @@
+"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;
+            }
+            // Fall back to single pattern execution if compound query not applicable
+        }
+        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);
+    }
+    /**
+     * 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