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

package/dist/storage/sparql/FilterPushdownExtractor.js

@@ -1,421 +0,0 @@
-"use strict";
-/**
- * FilterPushdownExtractor - Extract pushdownable conditions from SPARQL FILTER
- *
- * Analyzes SPARQL FILTER expressions and extracts conditions that can be
- * pushed down to the database layer for efficient query execution.
- *
- * Supported pushdown operations:
- * - Comparison: =, !=, <, >, <=, >=
- * - String functions: STRSTARTS, STRENDS, CONTAINS, REGEX
- * - Type checking: isIRI, isBlank, isLiteral, isNumeric
- * - Language: LANGMATCHES
- * - Logical: AND, OR (with $in optimization)
- * - Set operations: IN, NOT IN
- * - Existence: BOUND, !BOUND
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FilterPushdownExtractor = void 0;
-const rdf_data_factory_1 = require("rdf-data-factory");
-const serialization_1 = require("../quint/serialization");
-const AlgebraUtils_1 = require("./AlgebraUtils");
-const dataFactory = new rdf_data_factory_1.DataFactory();
-/**
- * FilterPushdownExtractor extracts pushdownable conditions from FILTER expressions
- */
-class FilterPushdownExtractor {
-    /**
-     * Extract pushdownable filters from an expression
-     * Returns filters that can be pushed down and the remaining expression
-     */
-    extractPushdownFilters(expr, pattern) {
-        if (expr.expressionType !== 'operator') {
-            // Can't pushdown non-operator expressions
-            return { filters: {}, remainder: expr };
-        }
-        const opExpr = expr;
-        const op = opExpr.operator.toLowerCase();
-        // Handle AND: recursively extract from both sides
-        if (op === '&&') {
-            const filters = {};
-            const remainders = [];
-            for (const arg of opExpr.args) {
-                const result = this.extractPushdownFilters(arg, pattern);
-                // Merge filters
-                for (const [varName, ops] of Object.entries(result.filters)) {
-                    filters[varName] = { ...filters[varName], ...ops };
-                }
-                if (result.remainder) {
-                    remainders.push(result.remainder);
-                }
-            }
-            // Combine remainders with AND
-            let remainder = null;
-            if (remainders.length === 1) {
-                remainder = remainders[0];
-            }
-            else if (remainders.length > 1) {
-                remainder = {
-                    type: 'expression',
-                    expressionType: 'operator',
-                    operator: '&&',
-                    args: remainders,
-                };
-            }
-            return { filters, remainder };
-        }
-        // Handle OR: try to convert to $in or OR branches
-        if (op === '||') {
-            return this.extractOrPushdown(opExpr, pattern);
-        }
-        // Try to extract single pushdown condition
-        const result = this.tryExtractSinglePushdown(opExpr, pattern);
-        if (result) {
-            return { filters: result, remainder: null };
-        }
-        // Can't pushdown
-        return { filters: {}, remainder: expr };
-    }
-    /**
-     * Handle OR expression pushdown
-     * - Same variable equality: convert to $in
-     * - Different variables: create OR branches for separate queries
-     * - Mixed (pushdownable + non-pushdownable): orBranches + orNonPushdownBranches
-     */
-    extractOrPushdown(expr, pattern) {
-        // Flatten OR tree and collect all branches
-        const branches = [];
-        const collectBranches = (e) => {
-            if (e.expressionType === 'operator') {
-                const op = e;
-                if (op.operator.toLowerCase() === '||') {
-                    op.args.forEach(collectBranches);
-                    return;
-                }
-            }
-            branches.push(e);
-        };
-        collectBranches(expr);
-        // Try to extract pushdown from each branch
-        const pushdownable = [];
-        const nonPushdownable = [];
-        for (const branch of branches) {
-            if (branch.expressionType === 'operator') {
-                const branchFilters = this.tryExtractSinglePushdown(branch, pattern);
-                if (branchFilters && Object.keys(branchFilters).length > 0) {
-                    pushdownable.push({ filters: branchFilters, expr: branch });
-                    continue;
-                }
-            }
-            nonPushdownable.push(branch);
-        }
-        // If nothing pushdownable, return as remainder
-        if (pushdownable.length === 0) {
-            return { filters: {}, remainder: expr };
-        }
-        // Check if all are same-variable equality (can use $in)
-        const inResult = this.tryConvertToIn(pushdownable);
-        if (inResult && nonPushdownable.length === 0) {
-            return { filters: inResult, remainder: null };
-        }
-        // Different variables or mixed: use OR branches
-        const orBranches = pushdownable.map(p => p.filters);
-        // Non-pushdownable branches need OR semantics (not AND), so use orNonPushdownBranches
-        return {
-            filters: {},
-            remainder: null,
-            orBranches,
-            orNonPushdownBranches: nonPushdownable.length > 0 ? nonPushdownable : undefined
-        };
-    }
-    /**
-     * Try to convert same-variable equalities to $in
-     */
-    tryConvertToIn(branches) {
-        // Check if all branches are single-variable equality
-        const varValues = new Map();
-        for (const { filters } of branches) {
-            const keys = Object.keys(filters);
-            if (keys.length !== 1)
-                return null;
-            const varName = keys[0];
-            const ops = filters[varName];
-            const opKeys = Object.keys(ops);
-            if (opKeys.length !== 1 || !('$eq' in ops))
-                return null;
-            if (!varValues.has(varName)) {
-                varValues.set(varName, []);
-            }
-            varValues.get(varName).push(ops.$eq);
-        }
-        // Must be single variable
-        if (varValues.size !== 1)
-            return null;
-        const [varName, values] = [...varValues.entries()][0];
-        return { [varName]: { $in: values } };
-    }
-    /**
-     * Try to extract pushdown filter from a single operator expression
-     */
-    tryExtractSinglePushdown(expr, pattern) {
-        const op = expr.operator.toLowerCase();
-        const filters = {};
-        // Comparison: =, !=, <, >, <=, >=
-        if (['=', '!=', '<', '>', '<=', '>='].includes(op) && expr.args.length === 2) {
-            const result = this.extractComparison(expr, op);
-            if (result) {
-                // Only pushdown if the variable is in the pattern
-                if ((0, AlgebraUtils_1.isVariableInPattern)(result.varName, pattern)) {
-                    filters[result.varName] = { [result.op]: result.value };
-                    return filters;
-                }
-            }
-        }
-        // STRSTARTS, STRENDS, CONTAINS
-        // Subject/predicate/graph columns store raw IRI strings. Object string
-        // operators are explicit lexical STR(?object) pushdowns so the store can
-        // route text literals to object_text and IRIs/blank nodes to object_key.
-        if (['strstarts', 'strends', 'contains'].includes(op) && expr.args.length === 2) {
-            const varName = (0, AlgebraUtils_1.extractStrVariable)(expr.args[0]);
-            const value = (0, AlgebraUtils_1.extractLiteralValue)(expr.args[1]);
-            if (varName && value && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                const position = (0, AlgebraUtils_1.getVariablePosition)(varName, pattern);
-                const startsWithOp = position === 'object' ? '$strStartsWith' : '$startsWith';
-                const endsWithOp = position === 'object' ? '$strEndsWith' : '$endsWith';
-                const containsOp = position === 'object' ? '$strContains' : '$contains';
-                if (op === 'strstarts') {
-                    filters[varName] = { [startsWithOp]: value };
-                }
-                else if (op === 'strends') {
-                    filters[varName] = { [endsWithOp]: value };
-                }
-                else {
-                    filters[varName] = { [containsOp]: value };
-                }
-                return filters;
-            }
-        }
-        // REGEX
-        if (op === 'regex' && expr.args.length >= 2) {
-            const varName = (0, AlgebraUtils_1.extractStrVariable)(expr.args[0]);
-            const regexPattern = (0, AlgebraUtils_1.extractLiteralValue)(expr.args[1]);
-            if (varName && regexPattern && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                const position = (0, AlgebraUtils_1.getVariablePosition)(varName, pattern);
-                filters[varName] = position === 'object'
-                    ? { $strRegex: regexPattern }
-                    : { $regex: regexPattern };
-                return filters;
-            }
-        }
-        // IN
-        if (op === 'in' && expr.args.length >= 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                const values = [];
-                for (let i = 1; i < expr.args.length; i++) {
-                    const lit = (0, AlgebraUtils_1.extractLiteral)(expr.args[i]);
-                    if (lit) {
-                        values.push(this.serializeExactValue(lit.value, lit.datatype));
-                    }
-                }
-                if (values.length > 0) {
-                    filters[varName] = { $in: values };
-                    return filters;
-                }
-            }
-        }
-        // NOT IN
-        if (op === 'notin' && expr.args.length >= 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                const values = [];
-                for (let i = 1; i < expr.args.length; i++) {
-                    const lit = (0, AlgebraUtils_1.extractLiteral)(expr.args[i]);
-                    if (lit) {
-                        values.push(this.serializeExactValue(lit.value, lit.datatype));
-                    }
-                }
-                if (values.length > 0) {
-                    filters[varName] = { $notIn: values };
-                    return filters;
-                }
-            }
-        }
-        // BOUND
-        if (op === 'bound' && expr.args.length === 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                filters[varName] = { $isNull: false };
-                return filters;
-            }
-        }
-        // !BOUND
-        if (op === '!' && expr.args.length === 1) {
-            const inner = expr.args[0];
-            if (inner.expressionType === 'operator') {
-                const innerOp = inner;
-                if (innerOp.operator.toLowerCase() === 'bound' && innerOp.args.length === 1) {
-                    const varName = (0, AlgebraUtils_1.extractVariable)(innerOp.args[0]);
-                    if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                        filters[varName] = { $isNull: true };
-                        return filters;
-                    }
-                }
-            }
-        }
-        // Type checking functions
-        // isiri/isuri: In Solid, IRIs are http:// or https://
-        if ((op === 'isiri' || op === 'isuri') && expr.args.length === 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                filters[varName] = { $startsWith: 'http' };
-                return filters;
-            }
-        }
-        // isblank: Blank nodes start with _:
-        if (op === 'isblank' && expr.args.length === 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                filters[varName] = { $startsWith: '_:' };
-                return filters;
-            }
-        }
-        // isliteral: Literals start with " (or N\0 for numeric, D\0 for datetime)
-        if (op === 'isliteral' && expr.args.length === 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                // Match strings starting with ", N (numeric), or D (datetime)
-                filters[varName] = { $regex: '^["ND]' };
-                return filters;
-            }
-        }
-        // isnumeric: Our numeric literals start with N\0
-        if (op === 'isnumeric' && expr.args.length === 1) {
-            const varName = (0, AlgebraUtils_1.extractVariable)(expr.args[0]);
-            if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                filters[varName] = { $startsWith: 'N\0' };
-                return filters;
-            }
-        }
-        // LANGMATCHES(LANG(?x), "en") - language tagged literals end with @lang"
-        if (op === 'langmatches' && expr.args.length === 2) {
-            const langExpr = expr.args[0];
-            const langPattern = expr.args[1];
-            // First arg should be LANG(?var)
-            if (langExpr.expressionType === 'operator' &&
-                langExpr.operator === 'lang' &&
-                langExpr.args.length === 1) {
-                const varName = (0, AlgebraUtils_1.extractVariable)(langExpr.args[0]);
-                if (varName && (0, AlgebraUtils_1.isVariableInPattern)(varName, pattern)) {
-                    const position = (0, AlgebraUtils_1.getVariablePosition)(varName, pattern);
-                    if (position === 'object') {
-                        if (langPattern.termType === 'Literal') {
-                            const lang = langPattern.value.toLowerCase();
-                            filters[varName] = { $language: lang };
-                            return filters;
-                        }
-                    }
-                    // Get the language pattern
-                    if (langPattern.termType === 'Literal') {
-                        const lang = langPattern.value.toLowerCase();
-                        if (lang === '*') {
-                            // Match any language tagged literal - ends with @something"
-                            // Use regex to match @[a-z]+" pattern at end
-                            filters[varName] = { $regex: '@[a-zA-Z]+"$' };
-                        }
-                        else {
-                            // Match specific language - ends with @lang"
-                            filters[varName] = { $endsWith: `@${lang}"` };
-                        }
-                        return filters;
-                    }
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Extract comparison operator info
-     */
-    extractComparison(expr, op) {
-        const [left, right] = expr.args;
-        // ?var op literal
-        const leftVar = (0, AlgebraUtils_1.extractVariable)(left);
-        const rightLiteral = (0, AlgebraUtils_1.extractLiteral)(right);
-        if (leftVar && rightLiteral) {
-            const filterOp = this.mapComparisonOp(op);
-            const value = this.serializeForComparison(rightLiteral.value, rightLiteral.datatype, filterOp);
-            return { varName: leftVar, op: filterOp, value };
-        }
-        // literal op ?var (reverse)
-        const leftLiteral = (0, AlgebraUtils_1.extractLiteral)(left);
-        const rightVar = (0, AlgebraUtils_1.extractVariable)(right);
-        if (leftLiteral && rightVar) {
-            const reversedOp = this.reverseComparisonOp(op);
-            const filterOp = this.mapComparisonOp(reversedOp);
-            const value = this.serializeForComparison(leftLiteral.value, leftLiteral.datatype, filterOp);
-            return { varName: rightVar, op: filterOp, value };
-        }
-        // ?var = <namedNode>
-        const leftVarForTerm = (0, AlgebraUtils_1.extractVariable)(left);
-        const rightTerm = (0, AlgebraUtils_1.extractTerm)(right);
-        if (leftVarForTerm && rightTerm && (op === '=' || op === '!=')) {
-            const filterOp = op === '=' ? '$eq' : '$ne';
-            return { varName: leftVarForTerm, op: filterOp, value: rightTerm };
-        }
-        return null;
-    }
-    mapComparisonOp(op) {
-        const map = {
-            '=': '$eq', '!=': '$ne', '<': '$lt', '>': '$gt', '<=': '$lte', '>=': '$gte'
-        };
-        return map[op] || '$eq';
-    }
-    reverseComparisonOp(op) {
-        const map = {
-            '<': '>', '>': '<', '<=': '>=', '>=': '<=', '=': '=', '!=': '!='
-        };
-        return map[op] || op;
-    }
-    /**
-     * Serialize value for comparison
-     *
-     * Range comparison handling:
-     * - $gt, $lte: Use fpstring + max suffix to be >= all values with same fpstring
-     * - $lt, $gte: Use fpstring only (prefix), stored values are always > prefix
-     * - $eq, $ne: Use exact serialization
-     */
-    serializeForComparison(value, datatype, filterOp) {
-        // Exact match uses full serialization
-        if (filterOp === '$eq' || filterOp === '$ne') {
-            return this.serializeExactValue(value, datatype);
-        }
-        // Range comparison
-        if (datatype && serialization_1.NUMERIC_TYPES.has(datatype)) {
-            const fpValue = `N${serialization_1.SEP}${(0, serialization_1.fpEncode)(value)}`;
-            // $gt and $lte need max suffix to compare correctly
-            if (filterOp === '$gt' || filterOp === '$lte') {
-                return fpValue + serialization_1.SEP + '\uffff';
-            }
-            // $lt and $gte use prefix only
-            return fpValue;
-        }
-        if (datatype === serialization_1.DATETIME_TYPE) {
-            const fpValue = `D${serialization_1.SEP}${(0, serialization_1.fpEncode)(new Date(value).valueOf())}`;
-            if (filterOp === '$gt' || filterOp === '$lte') {
-                return fpValue + serialization_1.SEP + '\uffff';
-            }
-            return fpValue;
-        }
-        // For non-numeric types, use exact value (string comparison)
-        return this.serializeExactValue(value, datatype);
-    }
-    serializeExactValue(value, datatype) {
-        const lit = datatype
-            ? dataFactory.literal(value, dataFactory.namedNode(datatype))
-            : dataFactory.literal(value);
-        return (0, serialization_1.serializeObject)(lit);
-    }
-}
-exports.FilterPushdownExtractor = FilterPushdownExtractor;
-//# sourceMappingURL=FilterPushdownExtractor.js.map

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

@@ -1,65 +0,0 @@
-/**
- * OptimizedQuadstoreEngine - 优化的 SPARQL 查询引擎
- *
- * 在 quadstore-comunica Engine 基础上增加查询优化：
- * - 对于简单查询（单 BGP），直接使用 quadstore API，支持 LIMIT/ORDER BY 下推
- * - 对于复杂查询（JOIN/OPTIONAL/UNION/FILTER），委托给 Comunica
- */
-import type { Quad, Term, Variable } from '@rdfjs/types';
-import type { ResultStream, Bindings } from '@rdfjs/types';
-import { Quadstore } from 'quadstore';
-/**
- * 简单的 Bindings 实现
- */
-export declare class SimpleBindings extends Map<string, Term> {
-    get(key: string | Variable): Term | undefined;
-    has(key: string | Variable): boolean;
-}
-/**
- * 优化的 Quadstore SPARQL 引擎
- */
-export declare class OptimizedQuadstoreEngine {
-    private readonly comunica;
-    private readonly quadstore;
-    private readonly debug;
-    constructor(store: Quadstore, debug?: boolean);
-    private log;
-    /**
-     * 获取底层 quadstore
-     */
-    getStore(): Quadstore;
-    /**
-     * 执行 SELECT 查询
-     */
-    queryBindings(query: string, context?: any): Promise<ResultStream<Bindings>>;
-    /**
-     * 执行 ASK 查询
-     */
-    queryBoolean(query: string, context?: any): Promise<boolean>;
-    /**
-     * 执行 CONSTRUCT/DESCRIBE 查询
-     */
-    queryQuads(query: string, context?: any): Promise<ResultStream<Quad>>;
-    /**
-     * 执行 UPDATE 查询
-     */
-    queryVoid(query: string, context?: any): Promise<void>;
-    /**
-     * 分析查询，判断是否可以优化
-     */
-    private analyzeQuery;
-    /**
-     * 分析 Algebra 树
-     */
-    private analyzeAlgebra;
-    /**
-     * 从 BGP pattern 提取匹配条件
-     */
-    private extractPattern;
-    /**
-     * 执行优化的 SELECT
-     */
-    private executeOptimizedSelect;
-    private varNameToTermName;
-    private streamToArray;
-}