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

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

@@ -1,54 +0,0 @@
-/**
- * ExpressionEvaluator - In-memory SPARQL expression evaluation
- *
- * Evaluates SPARQL expressions that cannot be pushed down to the database.
- * Used for filtering bindings after initial pattern matching.
- */
-import type { Term, Bindings } from '@rdfjs/types';
-import type { Algebra } from 'sparqlalgebrajs';
-import type { QuintStore } from '../quint/types';
-import type { PatternBuilder } from './PatternBuilder';
-/**
- * Callback for extracting pattern from operation
- */
-export type ExtractPatternFn = (operation: Algebra.Operation) => {
-    pattern: Algebra.Pattern;
-    filter: Algebra.Expression | null;
-};
-/**
- * ExpressionEvaluator handles in-memory evaluation of SPARQL expressions
- */
-export declare class ExpressionEvaluator {
-    private readonly store;
-    private readonly patternBuilder;
-    private readonly extractPatternAndFilter;
-    constructor(store: QuintStore, patternBuilder: PatternBuilder, extractPatternAndFilter: ExtractPatternFn);
-    /**
-     * Evaluate filter expression tree against candidate bindings
-     */
-    evaluateFilterTree(expr: Algebra.Expression, candidates: Bindings[], pattern: Algebra.Pattern): Promise<Bindings[]>;
-    /**
-     * Evaluate operator expression
-     */
-    private evaluateOperator;
-    /**
-     * Union multiple binding sets
-     */
-    private unionBindings;
-    /**
-     * Evaluate EXISTS/NOT EXISTS
-     */
-    private evaluateExistence;
-    private checkExists;
-    /**
-     * Evaluate single binding against operator
-     */
-    evaluateSingleBinding(expr: Algebra.OperatorExpression, binding: Bindings): boolean;
-    getTermValue(expr: Algebra.Expression, binding: Bindings): Term | null;
-    getNumericValue(expr: Algebra.Expression, binding: Bindings): number | null;
-    getStringValue(expr: Algebra.Expression, binding: Bindings): string | null;
-    compareTerms(left: Term | null, right: Term | null, op: string): boolean;
-    isNumericLiteral(lit: any): boolean;
-    effectiveBooleanValue(term: Term): boolean;
-    getBindingKey(binding: Bindings): string;
-}

package/dist/storage/sparql/ExpressionEvaluator.js

@@ -1,340 +0,0 @@
-"use strict";
-/**
- * ExpressionEvaluator - In-memory SPARQL expression evaluation
- *
- * Evaluates SPARQL expressions that cannot be pushed down to the database.
- * Used for filtering bindings after initial pattern matching.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpressionEvaluator = void 0;
-const rdf_data_factory_1 = require("rdf-data-factory");
-const serialization_1 = require("../quint/serialization");
-const dataFactory = new rdf_data_factory_1.DataFactory();
-/**
- * ExpressionEvaluator handles in-memory evaluation of SPARQL expressions
- */
-class ExpressionEvaluator {
-    constructor(store, patternBuilder, extractPatternAndFilter) {
-        this.store = store;
-        this.patternBuilder = patternBuilder;
-        this.extractPatternAndFilter = extractPatternAndFilter;
-    }
-    /**
-     * Evaluate filter expression tree against candidate bindings
-     */
-    async evaluateFilterTree(expr, candidates, pattern) {
-        if (candidates.length === 0)
-            return [];
-        switch (expr.expressionType) {
-            case 'operator':
-                return this.evaluateOperator(expr, candidates, pattern);
-            case 'existence':
-                return this.evaluateExistence(expr, candidates, pattern);
-            case 'term':
-                const termExpr = expr;
-                return this.effectiveBooleanValue(termExpr.term) ? candidates : [];
-            default:
-                return candidates; // Unknown: be permissive
-        }
-    }
-    /**
-     * Evaluate operator expression
-     */
-    async evaluateOperator(expr, candidates, pattern) {
-        const op = expr.operator.toLowerCase();
-        // Logical AND
-        if (op === '&&') {
-            let result = candidates;
-            for (const arg of expr.args) {
-                result = await this.evaluateFilterTree(arg, result, pattern);
-            }
-            return result;
-        }
-        // Logical OR
-        if (op === '||') {
-            const resultSets = await Promise.all(expr.args.map(arg => this.evaluateFilterTree(arg, candidates, pattern)));
-            return this.unionBindings(resultSets);
-        }
-        // Logical NOT
-        if (op === '!') {
-            const positives = await this.evaluateFilterTree(expr.args[0], candidates, pattern);
-            const positiveKeys = new Set(positives.map(b => this.getBindingKey(b)));
-            return candidates.filter(b => !positiveKeys.has(this.getBindingKey(b)));
-        }
-        // Other operators: evaluate each binding individually
-        return candidates.filter(b => this.evaluateSingleBinding(expr, b));
-    }
-    /**
-     * Union multiple binding sets
-     */
-    unionBindings(sets) {
-        const seen = new Set();
-        const result = [];
-        for (const set of sets) {
-            for (const binding of set) {
-                const key = this.getBindingKey(binding);
-                if (!seen.has(key)) {
-                    seen.add(key);
-                    result.push(binding);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * Evaluate EXISTS/NOT EXISTS
-     */
-    async evaluateExistence(expr, candidates, _pattern) {
-        const results = [];
-        for (const binding of candidates) {
-            const exists = await this.checkExists(expr.input, binding);
-            if (expr.not ? !exists : exists) {
-                results.push(binding);
-            }
-        }
-        return results;
-    }
-    async checkExists(subOperation, binding) {
-        const { pattern: subPattern } = this.extractPatternAndFilter(subOperation);
-        const quintPattern = this.patternBuilder.buildExistsPattern(subPattern, binding);
-        const results = await this.store.get(quintPattern, { limit: 1 });
-        return results.length > 0;
-    }
-    /**
-     * Evaluate single binding against operator
-     */
-    evaluateSingleBinding(expr, binding) {
-        const op = expr.operator.toLowerCase();
-        // Comparison
-        if (['=', '!=', '<', '>', '<=', '>='].includes(op)) {
-            const left = this.getTermValue(expr.args[0], binding);
-            const right = this.getTermValue(expr.args[1], binding);
-            if (left === null || right === null)
-                return false;
-            return this.compareTerms(left, right, op);
-        }
-        // BOUND
-        if (op === 'bound') {
-            const varExpr = expr.args[0];
-            if (varExpr.expressionType === 'term') {
-                const term = varExpr.term;
-                if (term.termType === 'Variable') {
-                    return binding.get(term) !== undefined;
-                }
-            }
-            return false;
-        }
-        // String functions
-        if (op === 'strstarts') {
-            const str = this.getStringValue(expr.args[0], binding);
-            const prefix = this.getStringValue(expr.args[1], binding);
-            return str !== null && prefix !== null && str.startsWith(prefix);
-        }
-        if (op === 'strends') {
-            const str = this.getStringValue(expr.args[0], binding);
-            const suffix = this.getStringValue(expr.args[1], binding);
-            return str !== null && suffix !== null && str.endsWith(suffix);
-        }
-        if (op === 'contains') {
-            const str = this.getStringValue(expr.args[0], binding);
-            const substr = this.getStringValue(expr.args[1], binding);
-            return str !== null && substr !== null && str.includes(substr);
-        }
-        if (op === 'regex') {
-            const str = this.getStringValue(expr.args[0], binding);
-            const pattern = this.getStringValue(expr.args[1], binding);
-            if (str === null || pattern === null)
-                return false;
-            try {
-                const flags = expr.args[2] ? this.getStringValue(expr.args[2], binding) || '' : '';
-                return new RegExp(pattern, flags).test(str);
-            }
-            catch {
-                return false;
-            }
-        }
-        // Type checking functions
-        if (op === 'isiri' || op === 'isuri') {
-            const term = this.getTermValue(expr.args[0], binding);
-            return term !== null && term.termType === 'NamedNode';
-        }
-        if (op === 'isblank') {
-            const term = this.getTermValue(expr.args[0], binding);
-            return term !== null && term.termType === 'BlankNode';
-        }
-        if (op === 'isliteral') {
-            const term = this.getTermValue(expr.args[0], binding);
-            return term !== null && term.termType === 'Literal';
-        }
-        if (op === 'isnumeric') {
-            const term = this.getTermValue(expr.args[0], binding);
-            if (term?.termType === 'Literal') {
-                const lit = term;
-                return lit.datatype && serialization_1.NUMERIC_TYPES.has(lit.datatype.value);
-            }
-            return false;
-        }
-        // LANGMATCHES
-        if (op === 'langmatches') {
-            const langExpr = expr.args[0];
-            if (langExpr.expressionType === 'operator' && langExpr.operator.toLowerCase() === 'lang') {
-                const term = this.getTermValue(langExpr.args[0], binding);
-                if (term?.termType === 'Literal') {
-                    const lit = term;
-                    const lang = lit.language || '';
-                    const pattern = this.getStringValue(expr.args[1], binding);
-                    if (pattern === '*')
-                        return lang.length > 0;
-                    if (pattern)
-                        return lang.toLowerCase() === pattern.toLowerCase();
-                }
-            }
-            return false;
-        }
-        // IN / NOT IN
-        if (op === 'in') {
-            const value = this.getTermValue(expr.args[0], binding);
-            if (value === null)
-                return false;
-            for (let i = 1; i < expr.args.length; i++) {
-                if (this.compareTerms(value, this.getTermValue(expr.args[i], binding), '='))
-                    return true;
-            }
-            return false;
-        }
-        if (op === 'notin') {
-            const value = this.getTermValue(expr.args[0], binding);
-            if (value === null)
-                return true;
-            for (let i = 1; i < expr.args.length; i++) {
-                if (this.compareTerms(value, this.getTermValue(expr.args[i], binding), '='))
-                    return false;
-            }
-            return true;
-        }
-        return true; // Unknown: be permissive
-    }
-    // ============================================================
-    // Helper Methods
-    // ============================================================
-    getTermValue(expr, binding) {
-        if (expr.expressionType === 'term') {
-            const termExpr = expr;
-            if (termExpr.term.termType === 'Variable') {
-                return binding.get(termExpr.term) || null;
-            }
-            return termExpr.term;
-        }
-        if (expr.expressionType === 'operator') {
-            const opExpr = expr;
-            const op = opExpr.operator.toLowerCase();
-            // STR function
-            if (op === 'str') {
-                const inner = this.getTermValue(opExpr.args[0], binding);
-                if (inner)
-                    return dataFactory.literal(inner.value);
-            }
-            // STRLEN function - returns integer
-            if (op === 'strlen') {
-                const str = this.getStringValue(opExpr.args[0], binding);
-                if (str !== null) {
-                    return dataFactory.literal(str.length.toString(), dataFactory.namedNode('http://www.w3.org/2001/XMLSchema#integer'));
-                }
-            }
-            // Numeric functions
-            if (op === 'abs') {
-                const val = this.getNumericValue(opExpr.args[0], binding);
-                if (val !== null) {
-                    return dataFactory.literal(Math.abs(val).toString(), dataFactory.namedNode('http://www.w3.org/2001/XMLSchema#decimal'));
-                }
-            }
-            if (op === 'round') {
-                const val = this.getNumericValue(opExpr.args[0], binding);
-                if (val !== null) {
-                    return dataFactory.literal(Math.round(val).toString(), dataFactory.namedNode('http://www.w3.org/2001/XMLSchema#decimal'));
-                }
-            }
-            if (op === 'floor') {
-                const val = this.getNumericValue(opExpr.args[0], binding);
-                if (val !== null) {
-                    return dataFactory.literal(Math.floor(val).toString(), dataFactory.namedNode('http://www.w3.org/2001/XMLSchema#decimal'));
-                }
-            }
-            if (op === 'ceil') {
-                const val = this.getNumericValue(opExpr.args[0], binding);
-                if (val !== null) {
-                    return dataFactory.literal(Math.ceil(val).toString(), dataFactory.namedNode('http://www.w3.org/2001/XMLSchema#decimal'));
-                }
-            }
-        }
-        return null;
-    }
-    getNumericValue(expr, binding) {
-        const term = this.getTermValue(expr, binding);
-        if (term?.termType === 'Literal') {
-            const val = parseFloat(term.value);
-            if (!isNaN(val))
-                return val;
-        }
-        return null;
-    }
-    getStringValue(expr, binding) {
-        const term = this.getTermValue(expr, binding);
-        return term?.value ?? null;
-    }
-    compareTerms(left, right, op) {
-        if (left === null || right === null)
-            return false;
-        if (left.termType === 'Literal' && right.termType === 'Literal') {
-            const leftLit = left;
-            const rightLit = right;
-            if (this.isNumericLiteral(leftLit) && this.isNumericLiteral(rightLit)) {
-                const l = parseFloat(leftLit.value), r = parseFloat(rightLit.value);
-                switch (op) {
-                    case '=': return l === r;
-                    case '!=': return l !== r;
-                    case '<': return l < r;
-                    case '>': return l > r;
-                    case '<=': return l <= r;
-                    case '>=': return l >= r;
-                }
-            }
-            const cmp = leftLit.value.localeCompare(rightLit.value);
-            switch (op) {
-                case '=': return cmp === 0;
-                case '!=': return cmp !== 0;
-                case '<': return cmp < 0;
-                case '>': return cmp > 0;
-                case '<=': return cmp <= 0;
-                case '>=': return cmp >= 0;
-            }
-        }
-        switch (op) {
-            case '=': return left.value === right.value;
-            case '!=': return left.value !== right.value;
-            default: return false;
-        }
-    }
-    isNumericLiteral(lit) {
-        return lit.datatype && serialization_1.NUMERIC_TYPES.has(lit.datatype.value);
-    }
-    effectiveBooleanValue(term) {
-        if (term.termType === 'Literal') {
-            const lit = term;
-            if (lit.datatype?.value === 'http://www.w3.org/2001/XMLSchema#boolean') {
-                return lit.value === 'true';
-            }
-            return lit.value.length > 0;
-        }
-        return true;
-    }
-    getBindingKey(binding) {
-        const parts = [];
-        binding.forEach((value, key) => {
-            parts.push(`${key.value}=${value.value}`);
-        });
-        return parts.sort().join('|');
-    }
-}
-exports.ExpressionEvaluator = ExpressionEvaluator;
-//# sourceMappingURL=ExpressionEvaluator.js.map

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

@@ -1,74 +0,0 @@
-/**
- * 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
- */
-import type { Algebra } from 'sparqlalgebrajs';
-import type { TermOperators } from '../quint/types';
-/**
- * Pushdown filters extracted from SPARQL FILTER clauses
- * Maps variable names to their filter conditions
- */
-export interface PushdownFilters {
-    [varName: string]: TermOperators;
-}
-/**
- * Result of extracting pushdown filters from an expression
- */
-export interface PushdownResult {
-    filters: PushdownFilters;
-    remainder: Algebra.Expression | null;
-    orBranches?: PushdownFilters[];
-    orNonPushdownBranches?: Algebra.Expression[];
-}
-/**
- * FilterPushdownExtractor extracts pushdownable conditions from FILTER expressions
- */
-export declare class FilterPushdownExtractor {
-    /**
-     * Extract pushdownable filters from an expression
-     * Returns filters that can be pushed down and the remaining expression
-     */
-    extractPushdownFilters(expr: Algebra.Expression, pattern: Algebra.Pattern): PushdownResult;
-    /**
-     * Handle OR expression pushdown
-     * - Same variable equality: convert to $in
-     * - Different variables: create OR branches for separate queries
-     * - Mixed (pushdownable + non-pushdownable): orBranches + orNonPushdownBranches
-     */
-    private extractOrPushdown;
-    /**
-     * Try to convert same-variable equalities to $in
-     */
-    private tryConvertToIn;
-    /**
-     * Try to extract pushdown filter from a single operator expression
-     */
-    tryExtractSinglePushdown(expr: Algebra.OperatorExpression, pattern: Algebra.Pattern): PushdownFilters | null;
-    /**
-     * Extract comparison operator info
-     */
-    private extractComparison;
-    private mapComparisonOp;
-    private reverseComparisonOp;
-    /**
-     * 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: string, datatype: string | undefined, filterOp: string): string;
-    serializeExactValue(value: string, datatype?: string): string;
-}