@undefineds.co/xpod 0.1.0-local.202602081751

package/dist/storage/sparql/PatternBuilder.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * PatternBuilder - QuintPattern construction from SPARQL algebra
+ *
+ * Builds QuintPattern objects from SPARQL algebra patterns,
+ * applying security filters and pushdown conditions.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternBuilder = void 0;
+/**
+ * PatternBuilder constructs QuintPattern objects from SPARQL algebra
+ */
+class PatternBuilder {
+    constructor(getSecurityFilters) {
+        this.getSecurityFilters = getSecurityFilters;
+    }
+    /**
+     * Build base QuintPattern from SPARQL pattern (without pushdown filters)
+     */
+    buildBasePattern(pattern) {
+        const quintPattern = {};
+        if (pattern.subject && pattern.subject.termType !== 'Variable') {
+            quintPattern.subject = pattern.subject;
+        }
+        if (pattern.predicate && pattern.predicate.termType !== 'Variable') {
+            quintPattern.predicate = pattern.predicate;
+        }
+        if (pattern.object && pattern.object.termType !== 'Variable') {
+            quintPattern.object = pattern.object;
+        }
+        if (pattern.graph && pattern.graph.termType !== 'Variable' && pattern.graph.termType !== 'DefaultGraph') {
+            quintPattern.graph = pattern.graph;
+        }
+        // Apply security filters
+        const securityFilters = this.getSecurityFilters();
+        if (securityFilters) {
+            if (securityFilters.subject && !quintPattern.subject) {
+                quintPattern.subject = securityFilters.subject;
+            }
+            if (securityFilters.predicate && !quintPattern.predicate) {
+                quintPattern.predicate = securityFilters.predicate;
+            }
+            if (securityFilters.object && !quintPattern.object) {
+                quintPattern.object = securityFilters.object;
+            }
+            if (securityFilters.graph && !quintPattern.graph) {
+                quintPattern.graph = securityFilters.graph;
+            }
+        }
+        return quintPattern;
+    }
+    /**
+     * Build QuintPattern with pushdown filters applied
+     */
+    buildQuintPattern(pattern, pushdownFilters) {
+        const quintPattern = this.buildBasePattern(pattern);
+        // Apply pushdown filters to appropriate positions
+        if (pattern.subject?.termType === 'Variable' && pushdownFilters[pattern.subject.value]) {
+            quintPattern.subject = this.mergeFilters(quintPattern.subject, pushdownFilters[pattern.subject.value]);
+        }
+        if (pattern.predicate?.termType === 'Variable' && pushdownFilters[pattern.predicate.value]) {
+            quintPattern.predicate = this.mergeFilters(quintPattern.predicate, pushdownFilters[pattern.predicate.value]);
+        }
+        if (pattern.object?.termType === 'Variable' && pushdownFilters[pattern.object.value]) {
+            quintPattern.object = this.mergeFilters(quintPattern.object, pushdownFilters[pattern.object.value]);
+        }
+        if (pattern.graph?.termType === 'Variable' && pushdownFilters[pattern.graph.value]) {
+            quintPattern.graph = this.mergeFilters(quintPattern.graph, pushdownFilters[pattern.graph.value]);
+        }
+        return quintPattern;
+    }
+    /**
+     * Build pattern for EXISTS subquery with bound variables
+     */
+    buildExistsPattern(subPattern, binding) {
+        const quintPattern = {};
+        const getBound = (term) => {
+            if (!term)
+                return undefined;
+            if (term.termType === 'Variable') {
+                return binding.get(term) || undefined;
+            }
+            return term;
+        };
+        const subject = getBound(subPattern.subject);
+        if (subject && subject.termType !== 'Variable')
+            quintPattern.subject = subject;
+        const predicate = getBound(subPattern.predicate);
+        if (predicate && predicate.termType !== 'Variable')
+            quintPattern.predicate = predicate;
+        const object = getBound(subPattern.object);
+        if (object && object.termType !== 'Variable')
+            quintPattern.object = object;
+        const graph = getBound(subPattern.graph);
+        if (graph && graph.termType !== 'Variable' && graph.termType !== 'DefaultGraph') {
+            quintPattern.graph = graph;
+        }
+        // Apply security filters
+        const securityFilters = this.getSecurityFilters();
+        if (securityFilters?.graph && !quintPattern.graph) {
+            quintPattern.graph = securityFilters.graph;
+        }
+        return quintPattern;
+    }
+    /**
+     * Merge existing filter with new filter
+     * Concrete terms take precedence over operators
+     */
+    mergeFilters(existing, newFilter) {
+        if (!existing)
+            return newFilter;
+        if ('termType' in existing)
+            return existing; // Concrete term takes precedence
+        return { ...existing, ...newFilter };
+    }
+}
+exports.PatternBuilder = PatternBuilder;
+//# sourceMappingURL=PatternBuilder.js.map

package/dist/storage/sparql/PatternBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PatternBuilder.js","sourceRoot":"","sources":["../../../src/storage/sparql/PatternBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * PatternBuilder - QuintPattern construction from SPARQL algebra\n * \n * Builds QuintPattern objects from SPARQL algebra patterns,\n * applying security filters and pushdown conditions.\n */\n\nimport type { Term, Variable, Bindings } from '@rdfjs/types';\nimport type { Algebra } from 'sparqlalgebrajs';\n\nimport type { QuintPattern, TermOperators } from '../quint/types';\nimport type { SecurityFilters } from './ComunicaQuintEngine';\n\n/**\n * Pushdown filters extracted from SPARQL FILTER clauses\n * Maps variable names to their filter conditions\n */\nexport interface PushdownFilters {\n  [varName: string]: TermOperators;\n}\n\n/**\n * PatternBuilder constructs QuintPattern objects from SPARQL algebra\n */\nexport class PatternBuilder {\n  constructor(\n    private readonly getSecurityFilters: () => SecurityFilters | undefined\n  ) {}\n\n  /**\n   * Build base QuintPattern from SPARQL pattern (without pushdown filters)\n   */\n  buildBasePattern(pattern: Algebra.Pattern): QuintPattern {\n    const quintPattern: QuintPattern = {};\n    \n    if (pattern.subject && pattern.subject.termType !== 'Variable') {\n      quintPattern.subject = pattern.subject;\n    }\n    if (pattern.predicate && pattern.predicate.termType !== 'Variable') {\n      quintPattern.predicate = pattern.predicate;\n    }\n    if (pattern.object && pattern.object.termType !== 'Variable') {\n      quintPattern.object = pattern.object;\n    }\n    if (pattern.graph && pattern.graph.termType !== 'Variable' && pattern.graph.termType !== 'DefaultGraph') {\n      quintPattern.graph = pattern.graph;\n    }\n\n    // Apply security filters\n    const securityFilters = this.getSecurityFilters();\n    if (securityFilters) {\n      if (securityFilters.subject && !quintPattern.subject) {\n        quintPattern.subject = securityFilters.subject;\n      }\n      if (securityFilters.predicate && !quintPattern.predicate) {\n        quintPattern.predicate = securityFilters.predicate;\n      }\n      if (securityFilters.object && !quintPattern.object) {\n        quintPattern.object = securityFilters.object;\n      }\n      if (securityFilters.graph && !quintPattern.graph) {\n        quintPattern.graph = securityFilters.graph;\n      }\n    }\n\n    return quintPattern;\n  }\n\n  /**\n   * Build QuintPattern with pushdown filters applied\n   */\n  buildQuintPattern(pattern: Algebra.Pattern, pushdownFilters: PushdownFilters): QuintPattern {\n    const quintPattern = this.buildBasePattern(pattern);\n\n    // Apply pushdown filters to appropriate positions\n    if (pattern.subject?.termType === 'Variable' && pushdownFilters[pattern.subject.value]) {\n      quintPattern.subject = this.mergeFilters(quintPattern.subject, pushdownFilters[pattern.subject.value]);\n    }\n    if (pattern.predicate?.termType === 'Variable' && pushdownFilters[pattern.predicate.value]) {\n      quintPattern.predicate = this.mergeFilters(quintPattern.predicate, pushdownFilters[pattern.predicate.value]);\n    }\n    if (pattern.object?.termType === 'Variable' && pushdownFilters[pattern.object.value]) {\n      quintPattern.object = this.mergeFilters(quintPattern.object, pushdownFilters[pattern.object.value]);\n    }\n    if (pattern.graph?.termType === 'Variable' && pushdownFilters[pattern.graph.value]) {\n      quintPattern.graph = this.mergeFilters(quintPattern.graph, pushdownFilters[pattern.graph.value]);\n    }\n\n    return quintPattern;\n  }\n\n  /**\n   * Build pattern for EXISTS subquery with bound variables\n   */\n  buildExistsPattern(subPattern: Algebra.Pattern, binding: Bindings): QuintPattern {\n    const quintPattern: QuintPattern = {};\n    \n    const getBound = (term: Term | undefined): Term | undefined => {\n      if (!term) return undefined;\n      if (term.termType === 'Variable') {\n        return binding.get(term as Variable) || undefined;\n      }\n      return term;\n    };\n\n    const subject = getBound(subPattern.subject);\n    if (subject && subject.termType !== 'Variable') quintPattern.subject = subject;\n    \n    const predicate = getBound(subPattern.predicate);\n    if (predicate && predicate.termType !== 'Variable') quintPattern.predicate = predicate;\n    \n    const object = getBound(subPattern.object);\n    if (object && object.termType !== 'Variable') quintPattern.object = object;\n    \n    const graph = getBound(subPattern.graph);\n    if (graph && graph.termType !== 'Variable' && graph.termType !== 'DefaultGraph') {\n      quintPattern.graph = graph;\n    }\n\n    // Apply security filters\n    const securityFilters = this.getSecurityFilters();\n    if (securityFilters?.graph && !quintPattern.graph) {\n      quintPattern.graph = securityFilters.graph;\n    }\n\n    return quintPattern;\n  }\n\n  /**\n   * Merge existing filter with new filter\n   * Concrete terms take precedence over operators\n   */\n  private mergeFilters(existing: Term | TermOperators | undefined, newFilter: TermOperators): Term | TermOperators {\n    if (!existing) return newFilter;\n    if ('termType' in existing) return existing; // Concrete term takes precedence\n    return { ...existing, ...newFilter };\n  }\n}\n"]}

package/dist/storage/sparql/QueryOptimizer.d.ts

@@ -0,0 +1,125 @@
+/**
+ * QueryOptimizer - 统一的查询优化层
+ *
+ * 职责：
+ * 1. 分析 SPARQL algebra，识别可优化的模式
+ * 2. 选择最优执行策略
+ * 3. 执行优化后的查询
+ *
+ * 支持的优化：
+ * - OPTIONAL 优化：批量获取属性，避免指数级 LEFT JOIN
+ * - Compound Query：多 pattern SQL JOIN，避免 JS 层 hash join
+ * - FILTER 下推：条件下推到 SQL 层
+ *
+ * 设计原则：
+ * - 所有优化逻辑集中在此类
+ * - 对外暴露统一的接口
+ * - 优化失败时优雅降级到 Comunica 默认行为
+ */
+import type { Bindings } from '@rdfjs/types';
+import type { Algebra } from 'sparqlalgebrajs';
+import type { QuintStore } from '../quint/types';
+/**
+ * OPTIONAL 优化分析结果
+ */
+export interface OptionalAnalysis {
+    /** 是否可优化 */
+    canOptimize: boolean;
+    /** 核心查询（不含 OPTIONAL） */
+    coreOperation?: Algebra.Operation;
+    /** subject 变量名 */
+    subjectVar?: string;
+    /** 要获取的属性 predicates */
+    optionalPredicates?: string[];
+    /** 各 OPTIONAL 的变量名 */
+    optionalVars?: Map<string, string>;
+    /** 不能优化的原因 */
+    reason?: string;
+}
+/**
+ * Compound Query 优化分析结果
+ */
+export interface CompoundAnalysis {
+    /** 是否可优化 */
+    canOptimize: boolean;
+    /** 所有 patterns */
+    patterns?: Algebra.Pattern[];
+    /** JOIN 变量名 */
+    joinVar?: string;
+    /** JOIN 字段 */
+    joinField?: 'subject' | 'predicate' | 'object' | 'graph';
+    /** 不能优化的原因 */
+    reason?: string;
+}
+/**
+ * 查询优化结果
+ */
+export interface OptimizationResult {
+    /** 优化类型 */
+    type: 'optional' | 'compound' | 'none';
+    /** 分析结果 */
+    analysis: OptionalAnalysis | CompoundAnalysis | null;
+}
+export interface QueryOptimizerOptions {
+    debug?: boolean;
+    bindingsFactory: any;
+}
+/**
+ * QueryOptimizer - 查询优化器
+ */
+export declare class QueryOptimizer {
+    private readonly store;
+    private readonly debug;
+    private readonly bindingsFactory;
+    constructor(store: QuintStore, options: QueryOptimizerOptions);
+    /**
+     * 分析查询，确定最佳优化策略
+     */
+    analyzeQuery(algebra: Algebra.Operation): OptimizationResult;
+    /**
+     * 执行 OPTIONAL 优化查询
+     *
+     * @param analysis OPTIONAL 分析结果
+     * @param coreBindings 核心查询的绑定结果
+     * @param orderOptions 排序选项（可选）
+     */
+    executeOptionalOptimized(analysis: OptionalAnalysis, coreBindings: Bindings[], orderOptions?: {
+        varName: string;
+        reverse?: boolean;
+    }): Promise<Bindings[]>;
+    /**
+     * 对 Bindings 数组按指定变量排序
+     */
+    private sortBindings;
+    /**
+     * 分析查询是否可以进行 OPTIONAL 优化
+     *
+     * 可优化条件：
+     * 1. 有核心条件（BGP 或带 FILTER 的 BGP）
+     * 2. 有 OPTIONAL（>= 1 个）
+     * 3. 所有 OPTIONAL 都是简单的属性获取：?s <pred> ?var
+     * 4. 所有 OPTIONAL 使用同一个 subject 变量
+     * 5. OPTIONAL 内部没有额外的 FILTER
+     */
+    analyzeOptional(algebra: Algebra.Operation): OptionalAnalysis;
+    /**
+     * 分析查询是否可以进行 Compound Query 优化
+     */
+    analyzeCompound(algebra: Algebra.Operation): CompoundAnalysis;
+    /**
+     * 从核心操作提取 subject 变量
+     */
+    private extractSubjectVariable;
+    /**
+     * 从 OPTIONAL 的右操作数提取简单 pattern 信息
+     */
+    private extractSimplePattern;
+    /**
+     * 从 JOIN 操作提取所有 patterns
+     */
+    private extractPatternsFromJoin;
+    /**
+     * 组装 OPTIONAL 优化结果
+     */
+    private assembleOptionalResults;
+}

package/dist/storage/sparql/QueryOptimizer.js

@@ -0,0 +1,363 @@
+"use strict";
+/**
+ * QueryOptimizer - 统一的查询优化层
+ *
+ * 职责：
+ * 1. 分析 SPARQL algebra，识别可优化的模式
+ * 2. 选择最优执行策略
+ * 3. 执行优化后的查询
+ *
+ * 支持的优化：
+ * - OPTIONAL 优化：批量获取属性，避免指数级 LEFT JOIN
+ * - Compound Query：多 pattern SQL JOIN，避免 JS 层 hash join
+ * - FILTER 下推：条件下推到 SQL 层
+ *
+ * 设计原则：
+ * - 所有优化逻辑集中在此类
+ * - 对外暴露统一的接口
+ * - 优化失败时优雅降级到 Comunica 默认行为
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryOptimizer = void 0;
+const rdf_data_factory_1 = require("rdf-data-factory");
+const dataFactory = new rdf_data_factory_1.DataFactory();
+/**
+ * QueryOptimizer - 查询优化器
+ */
+class QueryOptimizer {
+    constructor(store, options) {
+        this.store = store;
+        this.debug = options.debug ?? false;
+        this.bindingsFactory = options.bindingsFactory;
+    }
+    // ============================================================
+    // 公共接口
+    // ============================================================
+    /**
+     * 分析查询，确定最佳优化策略
+     */
+    analyzeQuery(algebra) {
+        // 先检查 OPTIONAL 优化（优先级最高）
+        if (this.store.getAttributes) {
+            const optionalAnalysis = this.analyzeOptional(algebra);
+            if (optionalAnalysis.canOptimize) {
+                return { type: 'optional', analysis: optionalAnalysis };
+            }
+        }
+        // 检查 Compound Query 优化
+        if (this.store.getCompound) {
+            const compoundAnalysis = this.analyzeCompound(algebra);
+            if (compoundAnalysis.canOptimize) {
+                return { type: 'compound', analysis: compoundAnalysis };
+            }
+        }
+        return { type: 'none', analysis: null };
+    }
+    /**
+     * 执行 OPTIONAL 优化查询
+     *
+     * @param analysis OPTIONAL 分析结果
+     * @param coreBindings 核心查询的绑定结果
+     * @param orderOptions 排序选项（可选）
+     */
+    async executeOptionalOptimized(analysis, coreBindings, orderOptions) {
+        const { subjectVar, optionalPredicates, optionalVars } = analysis;
+        if (!subjectVar || !optionalPredicates || !optionalVars) {
+            throw new Error('Invalid OptionalAnalysis');
+        }
+        if (coreBindings.length === 0) {
+            return [];
+        }
+        // 提取所有 subject 值
+        const subjects = [];
+        for (const binding of coreBindings) {
+            const subjectTerm = binding.get(dataFactory.variable(subjectVar));
+            if (subjectTerm && subjectTerm.termType === 'NamedNode') {
+                subjects.push(subjectTerm.value);
+            }
+        }
+        if (this.debug) {
+            console.log(`[QueryOptimizer] OPTIONAL: ${coreBindings.length} bindings, ${subjects.length} subjects`);
+        }
+        // 批量获取属性
+        const attributeMap = await this.store.getAttributes(subjects, optionalPredicates, undefined // TODO: 支持 graph 过滤
+        );
+        if (this.debug) {
+            console.log(`[QueryOptimizer] getAttributes returned data for ${attributeMap.size} subjects`);
+        }
+        // 组装结果
+        let results = this.assembleOptionalResults(coreBindings, attributeMap, subjectVar, optionalVars);
+        // 应用排序
+        if (orderOptions?.varName && results.length > 1) {
+            results = this.sortBindings(results, orderOptions.varName, orderOptions.reverse ?? false);
+            if (this.debug) {
+                console.log(`[QueryOptimizer] Applied ORDER BY ?${orderOptions.varName} ${orderOptions.reverse ? 'DESC' : 'ASC'}`);
+            }
+        }
+        return results;
+    }
+    /**
+     * 对 Bindings 数组按指定变量排序
+     */
+    sortBindings(bindings, varName, reverse) {
+        const orderVar = dataFactory.variable(varName);
+        return [...bindings].sort((a, b) => {
+            const aVal = a.get(orderVar);
+            const bVal = b.get(orderVar);
+            // null/undefined 值排在最后
+            if (!aVal && !bVal)
+                return 0;
+            if (!aVal)
+                return 1;
+            if (!bVal)
+                return -1;
+            // 比较值
+            let cmp;
+            if (aVal.termType === 'Literal' && bVal.termType === 'Literal') {
+                // 对于字面量，先尝试数值比较
+                const aNum = parseFloat(aVal.value);
+                const bNum = parseFloat(bVal.value);
+                if (!isNaN(aNum) && !isNaN(bNum)) {
+                    cmp = aNum - bNum;
+                }
+                else {
+                    // 字符串比较
+                    cmp = aVal.value.localeCompare(bVal.value);
+                }
+            }
+            else {
+                // 其他类型用字符串比较
+                cmp = aVal.value.localeCompare(bVal.value);
+            }
+            return reverse ? -cmp : cmp;
+        });
+    }
+    // ============================================================
+    // OPTIONAL 优化
+    // ============================================================
+    /**
+     * 分析查询是否可以进行 OPTIONAL 优化
+     *
+     * 可优化条件：
+     * 1. 有核心条件（BGP 或带 FILTER 的 BGP）
+     * 2. 有 OPTIONAL（>= 1 个）
+     * 3. 所有 OPTIONAL 都是简单的属性获取：?s <pred> ?var
+     * 4. 所有 OPTIONAL 使用同一个 subject 变量
+     * 5. OPTIONAL 内部没有额外的 FILTER
+     */
+    analyzeOptional(algebra) {
+        // 从 project -> slice -> orderby -> ... 找到实际的查询结构
+        let current = algebra;
+        while (current.type === 'project' || current.type === 'slice' ||
+            current.type === 'distinct' || current.type === 'reduced' ||
+            current.type === 'orderby') {
+            current = current.input;
+        }
+        // 收集所有 leftjoin（OPTIONAL）和核心操作
+        const leftJoins = [];
+        let coreOp = null;
+        const collectLeftJoins = (op) => {
+            if (op.type === 'leftjoin') {
+                const lj = op;
+                leftJoins.push(lj);
+                collectLeftJoins(lj.input[0]);
+            }
+            else {
+                coreOp = op;
+            }
+        };
+        collectLeftJoins(current);
+        if (leftJoins.length < 1) {
+            return { canOptimize: false, reason: 'No OPTIONAL found' };
+        }
+        if (!coreOp) {
+            return { canOptimize: false, reason: 'No core operation found' };
+        }
+        // 分析核心操作获取 subject 变量
+        const subjectVar = this.extractSubjectVariable(coreOp);
+        if (!subjectVar) {
+            return { canOptimize: false, reason: 'Cannot determine subject variable from core operation' };
+        }
+        // 分析所有 OPTIONAL
+        const optionalPredicates = [];
+        const optionalVars = new Map();
+        for (const lj of leftJoins) {
+            // 检查是否有额外的 filter
+            if (lj.expression) {
+                return { canOptimize: false, reason: 'OPTIONAL contains FILTER expression' };
+            }
+            const patternInfo = this.extractSimplePattern(lj.input[1]);
+            if (!patternInfo) {
+                return { canOptimize: false, reason: 'OPTIONAL is not a simple pattern' };
+            }
+            if (patternInfo.subjectVar !== subjectVar) {
+                return {
+                    canOptimize: false,
+                    reason: `OPTIONAL subject ?${patternInfo.subjectVar} doesn't match core subject ?${subjectVar}`
+                };
+            }
+            if (!patternInfo.predicate) {
+                return { canOptimize: false, reason: 'OPTIONAL predicate must be a constant' };
+            }
+            optionalPredicates.push(patternInfo.predicate);
+            if (patternInfo.objectVar) {
+                optionalVars.set(patternInfo.predicate, patternInfo.objectVar);
+            }
+        }
+        return {
+            canOptimize: true,
+            coreOperation: coreOp,
+            subjectVar,
+            optionalPredicates,
+            optionalVars,
+        };
+    }
+    // ============================================================
+    // Compound Query 优化
+    // ============================================================
+    /**
+     * 分析查询是否可以进行 Compound Query 优化
+     */
+    analyzeCompound(algebra) {
+        // 从 project -> slice -> ... 找到实际的查询结构
+        let current = algebra;
+        while (current.type === 'project' || current.type === 'slice' ||
+            current.type === 'distinct' || current.type === 'reduced' ||
+            current.type === 'filter') {
+            current = current.input;
+        }
+        // 检查是否是 BGP 或 JOIN
+        let patterns = [];
+        if (current.type === 'bgp') {
+            const bgp = current;
+            patterns = bgp.patterns;
+        }
+        else if (current.type === 'join') {
+            const join = current;
+            patterns = this.extractPatternsFromJoin(join);
+        }
+        if (patterns.length < 2) {
+            return { canOptimize: false, reason: 'Need at least 2 patterns for compound query' };
+        }
+        // 检查所有 pattern 是否共享同一个 subject 变量
+        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) {
+            return { canOptimize: false, reason: 'Patterns do not share the same subject variable' };
+        }
+        return {
+            canOptimize: true,
+            patterns,
+            joinVar: uniqueSubjectVars[0],
+            joinField: 'subject',
+        };
+    }
+    // ============================================================
+    // 辅助方法
+    // ============================================================
+    /**
+     * 从核心操作提取 subject 变量
+     */
+    extractSubjectVariable(op) {
+        if (op.type === 'pattern') {
+            const pattern = op;
+            if (pattern.subject?.termType === 'Variable') {
+                return pattern.subject.value;
+            }
+        }
+        else if (op.type === 'bgp') {
+            const bgp = op;
+            if (bgp.patterns.length > 0) {
+                const firstPattern = bgp.patterns[0];
+                if (firstPattern.subject?.termType === 'Variable') {
+                    return firstPattern.subject.value;
+                }
+            }
+        }
+        else if (op.type === 'filter') {
+            return this.extractSubjectVariable(op.input);
+        }
+        else if (op.type === 'join') {
+            const join = op;
+            if (join.input && join.input.length > 0) {
+                return this.extractSubjectVariable(join.input[0]);
+            }
+        }
+        return null;
+    }
+    /**
+     * 从 OPTIONAL 的右操作数提取简单 pattern 信息
+     */
+    extractSimplePattern(op) {
+        if (op.type === 'pattern') {
+            const pattern = op;
+            if (pattern.subject?.termType !== 'Variable') {
+                return null;
+            }
+            return {
+                subjectVar: pattern.subject.value,
+                predicate: pattern.predicate?.termType === 'NamedNode' ? pattern.predicate.value : null,
+                objectVar: pattern.object?.termType === 'Variable' ? pattern.object.value : null,
+            };
+        }
+        else if (op.type === 'bgp') {
+            const bgp = op;
+            if (bgp.patterns.length === 1) {
+                return this.extractSimplePattern(bgp.patterns[0]);
+            }
+        }
+        return null;
+    }
+    /**
+     * 从 JOIN 操作提取所有 patterns
+     */
+    extractPatternsFromJoin(join) {
+        const patterns = [];
+        for (const input of join.input) {
+            if (input.type === 'pattern') {
+                patterns.push(input);
+            }
+            else if (input.type === 'bgp') {
+                patterns.push(...input.patterns);
+            }
+            else if (input.type === 'join') {
+                patterns.push(...this.extractPatternsFromJoin(input));
+            }
+        }
+        return patterns;
+    }
+    /**
+     * 组装 OPTIONAL 优化结果
+     */
+    assembleOptionalResults(coreBindings, attributeMap, subjectVar, optionalVars) {
+        const results = [];
+        for (const coreBinding of coreBindings) {
+            const subjectTerm = coreBinding.get(dataFactory.variable(subjectVar));
+            if (!subjectTerm || subjectTerm.termType !== 'NamedNode') {
+                results.push(coreBinding);
+                continue;
+            }
+            const subjectAttrs = attributeMap.get(subjectTerm.value);
+            // 创建包含所有 OPTIONAL 变量的新 binding
+            const entries = [];
+            // 复制核心 binding 的所有变量
+            for (const v of coreBinding.keys()) {
+                const term = coreBinding.get(v);
+                if (term) {
+                    entries.push([v, term]);
+                }
+            }
+            // 添加 OPTIONAL 变量
+            for (const [predicate, varName] of optionalVars) {
+                const values = subjectAttrs?.get(predicate);
+                if (values && values.length > 0) {
+                    entries.push([dataFactory.variable(varName), values[0]]);
+                }
+            }
+            results.push(this.bindingsFactory.bindings(entries));
+        }
+        return results;
+    }
+}
+exports.QueryOptimizer = QueryOptimizer;
+//# sourceMappingURL=QueryOptimizer.js.map