@quereus/quereus 0.2.1 → 0.4.0

package/dist/src/planner/analysis/constraint-extractor.js

@@ -1,130 +1,394 @@
 /**
- * Constraint extraction utilities for predicate analysis and VTab.xBestIndex
+ * Constraint extraction utilities for predicate analysis and pushdown optimization
  * Converts scalar expressions into constraints that can be pushed down to virtual tables
  */
 import { PlanNodeType } from '../nodes/plan-node-type.js';
+import { BinaryOpNode } from '../nodes/scalar.js';
+import { createLogger } from '../../common/logger.js';
+import { getSyncLiteral } from '../../parser/utils.js';
+import { TableReferenceNode } from '../nodes/reference.js';
+import { CapabilityDetectors } from '../framework/characteristics.js';
+const log = createLogger('planner:analysis:constraint-extractor');
 /**
  * Extract constraints from a scalar predicate expression
- * Currently handles simple binary comparisons and basic boolean logic
+ * Handles binary comparisons, boolean logic (AND/OR), and complex expressions
  */
-export function extractConstraints(predicate, columnAttributeToIndex) {
-    const constraints = [];
+export function extractConstraints(predicate, tableInfos = []) {
+    const constraintsByTable = new Map();
+    const allConstraints = [];
     const residualExpressions = [];
-    // Start extraction process
-    extractFromExpression(predicate, constraints, residualExpressions, columnAttributeToIndex);
-    // Build residual predicate from unmatched expressions
+    log('Extracting constraints from predicate: %s', predicate.toString());
+    // Build attribute-to-table mapping for quick lookups
+    const tableByAttribute = new Map();
+    for (const tableInfo of tableInfos) {
+        for (const attr of tableInfo.attributes) {
+            tableByAttribute.set(attr.id, tableInfo);
+        }
+    }
+    // Start extraction process & build supported fragments per table
+    const perTableParts = new Map();
+    extractFromExpression(predicate, allConstraints, residualExpressions, tableByAttribute, perTableParts);
+    // Group constraints by table instance key
+    for (const constraint of allConstraints) {
+        if (constraint.targetRelation) {
+            if (!constraintsByTable.has(constraint.targetRelation)) {
+                constraintsByTable.set(constraint.targetRelation, []);
+            }
+            constraintsByTable.get(constraint.targetRelation).push(constraint);
+        }
+    }
+    // Build residual predicate from unmatched expressions (combine with AND)
     let residualPredicate;
     if (residualExpressions.length === 1) {
         residualPredicate = residualExpressions[0];
     }
     else if (residualExpressions.length > 1) {
-        // For now, combine with AND - more sophisticated logic can be added later
-        residualPredicate = combineWithAnd(residualExpressions);
+        let acc = residualExpressions[0];
+        for (let i = 1; i < residualExpressions.length; i++) {
+            const right = residualExpressions[i];
+            const ast = { type: 'binary', operator: 'AND', left: acc.expression, right: right.expression };
+            acc = new BinaryOpNode(acc.scope, ast, acc, right);
+        }
+        residualPredicate = acc;
+    }
+    log('Extracted %d constraints across %d tables, %d residual expressions', allConstraints.length, constraintsByTable.size, residualExpressions.length);
+    const supportedPredicateByTable = new Map();
+    for (const [rel, parts] of perTableParts) {
+        const combined = combineParts(parts);
+        if (combined)
+            supportedPredicateByTable.set(rel, combined);
+    }
+    // Compute covered keys per table: collect equality constraints and check against table unique keys
+    const coveredKeysByTable = new Map();
+    for (const [rel, constraints] of constraintsByTable) {
+        const tInfo = tableInfos.find(t => t.relationKey === rel || t.relationName === rel);
+        if (!tInfo || !tInfo.uniqueKeys || tInfo.uniqueKeys.length === 0) {
+            coveredKeysByTable.set(rel, []);
+            continue;
+        }
+        const eqCols = new Set();
+        for (const c of constraints) {
+            if (c.op === '=') {
+                eqCols.add(c.columnIndex);
+            }
+            // Single-value IN could be treated as equality
+            if (c.op === 'IN' && Array.isArray(c.value) && c.value.length === 1) {
+                eqCols.add(c.columnIndex);
+            }
+        }
+        const covered = [];
+        for (const key of tInfo.uniqueKeys) {
+            if (key.length === 0) {
+                // Zero-length key means at most one row; trivially covered
+                covered.push([]);
+                continue;
+            }
+            const allCovered = key.every(idx => eqCols.has(idx));
+            if (allCovered)
+                covered.push([...key]);
+        }
+        coveredKeysByTable.set(rel, covered);
     }
     return {
-        constraints,
-        residualPredicate
+        constraintsByTable,
+        residualPredicate,
+        allConstraints,
+        supportedPredicateByTable,
+        coveredKeysByTable
     };
 }
 /**
  * Recursively extract constraints from an expression
  */
-function extractFromExpression(expr, constraints, residual, columnAttributeToIndex) {
+function extractFromExpression(expr, constraints, residual, attributeToTableMap, perTableParts) {
     // Handle AND expressions - recurse on both sides
     if (isAndExpression(expr)) {
-        const children = getBinaryExpressionChildren(expr);
-        if (children) {
-            extractFromExpression(children.left, constraints, residual, columnAttributeToIndex);
-            extractFromExpression(children.right, constraints, residual, columnAttributeToIndex);
+        const binaryOp = expr;
+        extractFromExpression(binaryOp.left, constraints, residual, attributeToTableMap, perTableParts);
+        extractFromExpression(binaryOp.right, constraints, residual, attributeToTableMap, perTableParts);
+        return;
+    }
+    // Handle OR expressions - for now, treat as residual (could be enhanced later)
+    if (isOrExpression(expr)) {
+        log('OR expression found, treating as residual: %s', expr.toString());
+        residual.push(expr);
+        return;
+    }
+    // BETWEEN → range constraints
+    if (expr.nodeType === PlanNodeType.Between) {
+        const c = extractBetweenConstraints(expr, attributeToTableMap);
+        if (c) {
+            constraints.push(...c);
+            addSupportedPart(expr, attributeToTableMap, perTableParts);
+            return;
+        }
+    }
+    // IN list → IN constraint (literals only)
+    if (expr.nodeType === PlanNodeType.In) {
+        const c = extractInConstraint(expr, attributeToTableMap);
+        if (c) {
+            constraints.push(c);
+            addSupportedPart(expr, attributeToTableMap, perTableParts);
             return;
         }
     }
     // Try to extract constraint from binary comparison
-    const constraint = extractBinaryConstraint(expr, columnAttributeToIndex);
+    const constraint = extractBinaryConstraint(expr, attributeToTableMap);
     if (constraint) {
         constraints.push(constraint);
+        addSupportedPart(expr, attributeToTableMap, perTableParts);
+        log('Extracted constraint: %s %s %s (table: %s)', constraint.attributeId, constraint.op, constraint.value, constraint.targetRelation);
     }
     else {
         // Cannot convert to constraint - add to residual
+        log('Cannot extract constraint from expression, adding to residual: %s', expr.toString());
         residual.push(expr);
     }
 }
+function addSupportedPart(expr, attributeToTableMap, perTableParts) {
+    // Determine target table by first column reference in expr; if absent, skip
+    const relKey = findTargetRelationKey(expr, attributeToTableMap);
+    if (!relKey)
+        return;
+    if (!perTableParts.has(relKey))
+        perTableParts.set(relKey, []);
+    perTableParts.get(relKey).push(expr);
+}
+function findTargetRelationKey(expr, attributeToTableMap) {
+    let found;
+    const stack = [expr];
+    while (stack.length) {
+        const n = stack.pop();
+        if (n.nodeType === PlanNodeType.ColumnReference) {
+            const attrId = n.attributeId;
+            const info = attributeToTableMap.get(attrId);
+            if (info)
+                return info.relationKey ?? info.relationName;
+        }
+        for (const c of n.getChildren()) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            stack.push(c);
+        }
+    }
+    return found;
+}
+function combineParts(parts) {
+    if (parts.length === 0)
+        return undefined;
+    if (parts.length === 1)
+        return parts[0];
+    // Combine with AND
+    let acc = parts[0];
+    for (let i = 1; i < parts.length; i++) {
+        const right = parts[i];
+        const ast = { type: 'binary', operator: 'AND', left: acc.expression, right: right.expression };
+        acc = new BinaryOpNode(acc.scope, ast, acc, right);
+    }
+    return acc;
+}
 /**
  * Extract constraint from binary comparison expression
  */
-function extractBinaryConstraint(expr, columnAttributeToIndex) {
-    const binaryInfo = getBinaryComparisonInfo(expr);
-    if (!binaryInfo) {
+function extractBinaryConstraint(expr, attributeToTableMap) {
+    // Must be a binary operation
+    if (expr.nodeType !== PlanNodeType.BinaryOp) {
         return null;
     }
-    const { left, right, op } = binaryInfo;
+    const binaryOp = expr;
+    const { left, right } = binaryOp;
+    const operator = binaryOp.expression.operator;
     // Try column-constant pattern (column op constant)
     let columnRef = null;
     let constant;
-    let constraintOp = op;
-    if (isColumnReference(left) && isLiteralConstant(right)) {
+    let finalOp = null;
+    if (isColumnReference(left) && (isLiteralConstant(right) || isDynamicValue(right))) {
         columnRef = left;
-        constant = getLiteralValue(right);
+        if (isLiteralConstant(right)) {
+            constant = getLiteralValue(right);
+        }
+        finalOp = mapOperatorToConstraint(operator, constant);
     }
-    else if (isLiteralConstant(left) && isColumnReference(right)) {
+    else if ((isLiteralConstant(left) || isDynamicValue(left)) && isColumnReference(right)) {
         // Reverse pattern (constant op column) - flip operator
         columnRef = right;
-        constant = getLiteralValue(left);
-        constraintOp = flipOperator(op);
+        if (isLiteralConstant(left)) {
+            constant = getLiteralValue(left);
+        }
+        const baseOp = mapOperatorToConstraint(operator, constant);
+        finalOp = baseOp ? flipOperator(baseOp) : null;
     }
-    if (!columnRef) {
+    if (!columnRef || !finalOp) {
+        log('No column-constant pattern found in binary expression');
         return null;
     }
-    // Map attribute ID to column index if mapping provided
-    let columnIndex = -1;
-    if (columnAttributeToIndex) {
-        const mappedIndex = columnAttributeToIndex.get(columnRef.attributeId);
-        if (mappedIndex !== undefined) {
-            columnIndex = mappedIndex;
+    // Map attribute ID to table and column index
+    const tableInfo = attributeToTableMap.get(columnRef.attributeId);
+    if (!tableInfo) {
+        log('No table mapping found for attribute ID %d', columnRef.attributeId);
+        return null;
+    }
+    const columnIndex = tableInfo.columnIndexMap.get(columnRef.attributeId);
+    if (columnIndex === undefined) {
+        log('No column index found for attribute ID %d', columnRef.attributeId);
+        return null;
+    }
+    const result = {
+        columnIndex,
+        attributeId: columnRef.attributeId,
+        op: finalOp,
+        value: constant,
+        usable: true, // Usable since we found table mapping
+        sourceExpression: expr,
+        targetRelation: tableInfo.relationKey
+    };
+    // Attach dynamic binding metadata when RHS/LHS is not a literal
+    const rhs = expr.right;
+    const lhs = expr.left;
+    const nonLiteral = !isLiteralConstant(lhs) || !isLiteralConstant(rhs);
+    if (nonLiteral) {
+        // Determine which side is the value side
+        const valueSide = (columnRef === lhs ? rhs : lhs);
+        if (!isLiteralConstant(valueSide)) {
+            result.valueExpr = valueSide;
+            if (valueSide.nodeType === PlanNodeType.ParameterReference) {
+                result.bindingKind = 'parameter';
+            }
+            else if (valueSide.nodeType === PlanNodeType.ColumnReference) {
+                const rhsAttrId = valueSide.attributeId;
+                const sameTable = tableInfo.columnIndexMap.has(rhsAttrId);
+                result.bindingKind = sameTable ? 'expression' : 'correlated';
+            }
+            else {
+                result.bindingKind = 'expression';
+            }
         }
+        else {
+            result.bindingKind = 'literal';
+        }
+    }
+    else {
+        result.bindingKind = 'literal';
+    }
+    return result;
+}
+function extractBetweenConstraints(expr, attributeToTableMap) {
+    // Only support column BETWEEN literal AND literal
+    const col = expr.expr;
+    const low = expr.lower;
+    const up = expr.upper;
+    const not = !!expr.expression.not;
+    if (col.nodeType !== PlanNodeType.ColumnReference)
+        return null;
+    if (!isLiteralConstant(low) || !isLiteralConstant(up))
+        return null;
+    const columnRef = col;
+    const tableInfo = attributeToTableMap.get(columnRef.attributeId);
+    if (!tableInfo)
+        return null;
+    const columnIndex = tableInfo.columnIndexMap.get(columnRef.attributeId);
+    if (columnIndex === undefined)
+        return null;
+    if (not) {
+        // NOT BETWEEN not expressible as single contiguous range; leave as residual
+        return null;
     }
+    const lowVal = getLiteralValue(low);
+    const upVal = getLiteralValue(up);
+    return [
+        {
+            columnIndex,
+            attributeId: columnRef.attributeId,
+            op: '>=',
+            value: lowVal,
+            usable: true,
+            sourceExpression: expr,
+            targetRelation: tableInfo.relationKey
+        },
+        {
+            columnIndex,
+            attributeId: columnRef.attributeId,
+            op: '<=',
+            value: upVal,
+            usable: true,
+            sourceExpression: expr,
+            targetRelation: tableInfo.relationKey
+        }
+    ];
+}
+function extractInConstraint(expr, attributeToTableMap) {
+    // Only support column IN (literal, ...)
+    if (expr.source)
+        return null;
+    if (!expr.values || expr.values.length === 0)
+        return null;
+    const col = expr.condition;
+    if (col.nodeType !== PlanNodeType.ColumnReference)
+        return null;
+    // Ensure all are literals
+    if (!expr.values.every(v => isLiteralConstant(v)))
+        return null;
+    const columnRef = col;
+    const tableInfo = attributeToTableMap.get(columnRef.attributeId);
+    if (!tableInfo)
+        return null;
+    const columnIndex = tableInfo.columnIndexMap.get(columnRef.attributeId);
+    if (columnIndex === undefined)
+        return null;
+    // Virtual table IN constraint can carry a single array value or multiple equality constraints.
+    // Our API supports op 'IN' with value array.
+    const values = expr.values.map(v => getLiteralValue(v));
     return {
         columnIndex,
         attributeId: columnRef.attributeId,
-        op: constraintOp,
-        value: constant,
-        usable: columnIndex >= 0, // Only usable if we can map to column index
-        sourceExpression: expr
+        op: 'IN',
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        value: values,
+        usable: true,
+        sourceExpression: expr,
+        targetRelation: tableInfo.relationKey
     };
 }
 /**
- * Get information about binary comparison expressions
+ * Map AST operators to constraint operators
  */
-function getBinaryComparisonInfo(expr) {
-    // This is a simplified version - real implementation would need to handle
-    // the actual binary expression node structure
-    if (expr.nodeType === PlanNodeType.BinaryOp) {
-        // Extract from actual binary expression node
-        // This would need to be implemented based on the actual BinaryOpNode structure
-        // For now, return null as placeholder
-        return null;
+function mapOperatorToConstraint(operator, rightValue) {
+    switch (operator) {
+        case '=': return '=';
+        case '>': return '>';
+        case '>=': return '>=';
+        case '<': return '<';
+        case '<=': return '<=';
+        case 'LIKE': return 'LIKE';
+        case 'GLOB': return 'GLOB';
+        case 'MATCH': return 'MATCH';
+        case 'IN': return 'IN';
+        case 'NOT IN': return 'NOT IN';
+        case 'IS':
+            return rightValue === null ? 'IS NULL' : null;
+        case 'IS NOT':
+            return rightValue === null ? 'IS NOT NULL' : null;
+        default: return null;
     }
-    return null;
 }
 /**
  * Check if expression is an AND operation
  */
 function isAndExpression(expr) {
-    // Simplified check - would need actual implementation
-    return expr.nodeType === PlanNodeType.BinaryOp;
+    return expr.nodeType === PlanNodeType.BinaryOp &&
+        expr.expression.operator === 'AND';
 }
 /**
- * Get children of binary expression
+ * Check if expression is an OR operation
  */
-function getBinaryExpressionChildren(_expr) {
-    // Simplified - would need actual implementation
-    return null;
+function isOrExpression(expr) {
+    return expr.nodeType === PlanNodeType.BinaryOp &&
+        expr.expression.operator === 'OR';
 }
 /**
  * Check if node is a column reference
  */
 function isColumnReference(node) {
-    return node.nodeType === PlanNodeType.ColumnReference;
+    return CapabilityDetectors.isColumnReference(node);
 }
 /**
  * Check if node is a literal constant
@@ -132,12 +396,16 @@ function isColumnReference(node) {
 function isLiteralConstant(node) {
     return node.nodeType === PlanNodeType.Literal;
 }
+function isDynamicValue(node) {
+    // Parameter or column reference from any table (correlation handled later)
+    return node.nodeType === PlanNodeType.ParameterReference || node.nodeType === PlanNodeType.ColumnReference;
+}
 /**
  * Get literal value from literal node
  */
-function getLiteralValue(_node) {
-    // Simplified - would need actual implementation
-    return null;
+function getLiteralValue(node) {
+    const literalNode = node;
+    return getSyncLiteral(literalNode.expression);
 }
 /**
  * Flip comparison operator for reversed operand order
@@ -149,45 +417,206 @@ function flipOperator(op) {
         case '>': return '<';
         case '>=': return '<=';
         case '=': return '=';
+        case 'LIKE': return 'LIKE'; // Not flippable
+        case 'GLOB': return 'GLOB'; // Not flippable
+        case 'MATCH': return 'MATCH'; // Not flippable
+        case 'IN': return 'IN'; // Not flippable in this context
+        case 'NOT IN': return 'NOT IN'; // Not flippable in this context
         default: return op;
     }
 }
 /**
- * Combine multiple expressions with AND logic
+ * Extract constraints for a specific table from a relational plan
+ * Analyzes all Filter nodes and join conditions that reference the table
  */
-function combineWithAnd(expressions) {
-    // This would need to create an actual AND expression node
-    // For now, return the first expression as placeholder
-    return expressions[0];
+export function extractConstraintsForTable(plan, targetTableRelationKey) {
+    const constraints = [];
+    // Walk the plan tree looking for filter predicates
+    walkPlanForPredicates(plan, (predicate, sourceNode) => {
+        // Create table info for the target table only
+        const tableInfos = createTableInfosFromPlan(plan).filter(info => info.relationKey === targetTableRelationKey);
+        if (tableInfos.length > 0) {
+            const result = extractConstraints(predicate, tableInfos);
+            const tableConstraints = result.constraintsByTable.get(targetTableRelationKey);
+            if (tableConstraints) {
+                constraints.push(...tableConstraints);
+                log('Found %d constraints for table %s from %s', tableConstraints.length, targetTableRelationKey, sourceNode);
+            }
+        }
+    });
+    return constraints;
 }
 /**
- * Create a residual filter predicate from constraints that weren't handled
- * This allows creating a filter function that can be applied at runtime
+ * Extract constraints and combined residual predicate for a specific table
  */
-export function createResidualFilter(originalPredicate, handledConstraints) {
-    // If all constraints were handled, no residual filter needed
-    if (handledConstraints.length === 0) {
-        // Return a simple function that evaluates the original predicate
-        // This is a placeholder - real implementation would need to compile the predicate
-        return (_row) => true;
+export function extractConstraintsAndResidualForTable(plan, targetTableRelationKey) {
+    const constraints = [];
+    const residuals = [];
+    walkPlanForPredicates(plan, (predicate) => {
+        const tableInfos = createTableInfosFromPlan(plan).filter(info => info.relationKey === targetTableRelationKey);
+        if (tableInfos.length === 0)
+            return;
+        const result = extractConstraints(predicate, tableInfos);
+        const tableConstraints = result.constraintsByTable.get(targetTableRelationKey);
+        if (tableConstraints && tableConstraints.length) {
+            constraints.push(...tableConstraints);
+        }
+        if (result.residualPredicate) {
+            residuals.push(result.residualPredicate);
+        }
+    });
+    return { constraints, residualPredicate: combineResiduals(residuals) };
+}
+/**
+ * Compute which unique keys are fully covered by equality constraints for a table within a plan.
+ * Returns a list of covered keys (each key is a list of column indexes in the table output order).
+ */
+export function extractCoveredKeysForTable(plan, targetTableRelationKey) {
+    const constraints = extractConstraintsForTable(plan, targetTableRelationKey);
+    const tInfos = createTableInfosFromPlan(plan).filter(info => info.relationKey === targetTableRelationKey);
+    if (tInfos.length === 0)
+        return [];
+    const uniqueKeys = tInfos[0].uniqueKeys ?? [];
+    return computeCoveredKeysForConstraints(constraints, uniqueKeys);
+}
+/**
+ * Given a set of constraints and a table's unique keys, compute which keys are fully covered by equality.
+ */
+export function computeCoveredKeysForConstraints(constraints, tableUniqueKeys) {
+    const eqCols = new Set();
+    for (const c of constraints) {
+        if (c.op === '=') {
+            eqCols.add(c.columnIndex);
+        }
+        if (c.op === 'IN' && Array.isArray(c.value) && c.value.length === 1) {
+            eqCols.add(c.columnIndex);
+        }
     }
-    // For now, return undefined to indicate no residual filter
-    // Real implementation would create a runtime-evaluable filter function
-    return undefined;
+    const covered = [];
+    for (const key of tableUniqueKeys) {
+        if (key.length === 0) {
+            covered.push([]);
+            continue;
+        }
+        const allCovered = key.every(idx => eqCols.has(idx));
+        if (allCovered)
+            covered.push([...key]);
+    }
+    return covered;
 }
 /**
- * Utility to map table schema columns to attribute IDs
- * Used when extracting constraints for specific tables
+ * Analyze plan to classify each TableReference instance as 'row' (row-specific) or 'global'.
+ * Row-specific means equality constraints fully cover at least one unique key at that reference.
  */
-export function createColumnMapping(tableColumns, nodeAttributes) {
-    const mapping = new Map();
-    // Simple name-based mapping
-    for (const attr of nodeAttributes) {
-        const columnIndex = tableColumns.findIndex(col => col.name === attr.name);
-        if (columnIndex >= 0) {
-            mapping.set(attr.id, columnIndex);
+export function analyzeRowSpecific(plan) {
+    const result = new Map();
+    const infos = createTableInfosFromPlan(plan);
+    for (const info of infos) {
+        const covered = extractCoveredKeysForTable(plan, info.relationKey);
+        result.set(info.relationKey, covered.length > 0 ? 'row' : 'global');
+    }
+    return result;
+}
+function combineResiduals(predicates) {
+    if (predicates.length === 0)
+        return undefined;
+    if (predicates.length === 1)
+        return predicates[0];
+    let acc = predicates[0];
+    for (let i = 1; i < predicates.length; i++) {
+        const right = predicates[i];
+        const ast = { type: 'binary', operator: 'AND', left: acc.expression, right: right.expression };
+        acc = new BinaryOpNode(acc.scope, ast, acc, right);
+    }
+    return acc;
+}
+/**
+ * Walk a plan tree and call callback for each predicate found
+ */
+function walkPlanForPredicates(plan, callback) {
+    if (!plan)
+        return;
+    // If node exposes predicates via characteristic, collect them
+    if (CapabilityDetectors.isPredicateSource(plan)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const preds = plan.getPredicates();
+        for (const p of preds) {
+            callback(p, 'PredicateSource');
         }
     }
-    return mapping;
+    // Recurse into all children (scalar and relational)
+    for (const child of plan.getChildren()) {
+        walkPlanForPredicates(child, callback);
+    }
+}
+/**
+ * Create table information from a relational plan
+ */
+function createTableInfosFromPlan(plan) {
+    const tableInfos = [];
+    const seen = new Set();
+    function visitAny(node) {
+        const id = node.id ?? null;
+        if (id !== null) {
+            const k = String(id);
+            if (seen.has(k))
+                return;
+            seen.add(k);
+        }
+        if (node instanceof TableReferenceNode) {
+            const tr = node;
+            tableInfos.push(createTableInfoFromNode(node, `${tr.tableSchema.schemaName}.${tr.tableSchema.name}`));
+        }
+        for (const rel of node.getRelations()) {
+            visitAny(rel);
+        }
+        for (const child of node.getChildren()) {
+            visitAny(child);
+        }
+    }
+    visitAny(plan);
+    return tableInfos;
+}
+/**
+ * Utility to create table info from a table reference node
+ */
+export function createTableInfoFromNode(node, relationName) {
+    const attributes = node.getAttributes();
+    const columnIndexMap = new Map();
+    // Map attribute IDs to column indices
+    attributes.forEach((attr, index) => {
+        columnIndexMap.set(attr.id, index);
+    });
+    // Extract logical unique keys from relation type, map ColRef[] to plain column indexes
+    const relType = node.getType();
+    const uniqueKeys = Array.isArray(relType?.keys)
+        ? relType.keys.map(key => key.map(ref => ref.index))
+        : undefined;
+    const relName = relationName || node.toString();
+    const relationKey = `${relName}#${node.id ?? 'unknown'}`;
+    return {
+        relationName: relName,
+        relationKey,
+        attributes: attributes.map(attr => ({ id: attr.id, name: attr.name })),
+        columnIndexMap,
+        uniqueKeys
+    };
+}
+/**
+ * Create a residual filter predicate from constraints that weren't handled
+ * This allows creating a filter function that can be applied at runtime
+ */
+export function createResidualFilter(originalPredicate, handledConstraints) {
+    // If no constraints were handled, return undefined (original predicate still needed)
+    if (handledConstraints.length === 0) {
+        return undefined;
+    }
+    // TODO: Implement sophisticated residual filter construction
+    // This would need to:
+    // 1. Identify which parts of the original predicate were handled
+    // 2. Construct a new predicate with only the unhandled parts
+    // 3. Compile that predicate to a runtime function
+    log('Residual filter construction not yet implemented - using original predicate');
+    return undefined;
 }
 //# sourceMappingURL=constraint-extractor.js.map