@simonecoelhosfo/optimizely-mcp-server/dist/analytics/intelligent-query-engine/QueryPlanner.d.ts

Optimizely MCP Server for AI assistants with integrated CLI tools

/**
 * Query Planner - Intelligent Query Execution Planning
 *
 * The Query Planner analyzes queries and creates optimal execution plans.
 * It determines the best strategy (pure SQL, pure JSONata, or hybrid)
 * based on query complexity, data locations, and adapter capabilities.
 */
import { FieldCatalog } from './FieldCatalog.js';
import type { UniversalQuery, ExecutionPlan, ExecutionStrategy, DataModelAdapter } from './types.js';
import { type MultiEntityQuery } from './MultiTableSQLBuilder.js';
/**
 * Configuration for Query Planner
 */
export interface QueryPlannerConfig {
    defaultStrategy?: ExecutionStrategy;
    enableParallel?: boolean;
    costThreshold?: number;
    complexityThreshold?: number;
}
/**
 * Query Planner implementation
 */
export declare class QueryPlanner {
    private fieldCatalog;
    private adapters;
    private config;
    private joinPathPlanner;
    private multiTableSQLBuilder;
    constructor(fieldCatalog: FieldCatalog, adapters: Map<string, DataModelAdapter>, config?: QueryPlannerConfig);
    /**
     * Create an execution plan for a query
     */
    createPlan(query: UniversalQuery): Promise<ExecutionPlan>;
    /**
     * Analyze query complexity
     */
    private analyzeQueryComplexity;
    /**
     * Determine optimal execution strategy
     */
    private determineStrategy;
    /**
     * Build execution phases based on strategy
     */
    private buildExecutionPhases;
    /**
     * Build phases for pure SQL execution
     */
    private buildPureSQLPhases;
    /**
     * Build phases for pure JSONata execution
     */
    private buildPureJSONataPhases;
    /**
     * Build phases for hybrid SQL-first execution
     */
    private buildHybridSQLFirstPhases;
    /**
     * Build phases for hybrid JSONata-first execution
     */
    private buildHybridJSONataFirstPhases;
    /**
     * Build phases for parallel execution
     */
    private buildParallelPhases;
    /**
     * Check if conditions are complex (nested, JSON paths, etc.)
     */
    private hasComplexConditions;
    /**
     * Build JSONata expression from query
     */
    private buildJSONataExpression;
    /**
     * Estimate plan execution cost
     */
    private estimatePlanCost;
    /**
     * Estimate row count for query
     */
    private estimateRowCount;
    /**
     * Check if plan requires post-processing
     */
    private requiresPostProcessing;
    /**
     * Get primary adapter for entity
     */
    private getPrimaryAdapter;
    /**
     * Check if a field is an aggregate function
     */
    private isAggregateFunction;
    /**
     * Check if a value is a valid ExecutionStrategy
     */
    private isExecutionStrategy;
    /**
     * Check if strategy can be used with given capabilities
     */
    private canUseStrategy;
    /**
     * Create execution plan for multi-entity queries
     */
    createMultiEntityPlan(query: MultiEntityQuery): Promise<ExecutionPlan>;
    /**
     * Discover required entities from multi-entity query
     */
    private discoverRequiredEntities;
    /**
     * Analyze complexity for multi-entity queries
     */
    private analyzeMultiEntityComplexity;
    /**
     * Determine strategy for multi-entity queries
     */
    private determineMultiEntityStrategy;
    /**
     * Build execution phases for multi-entity queries
     */
    private buildMultiEntityExecutionPhases;
    /**
     * Estimate cost for multi-entity plans
     */
    private estimateMultiEntityPlanCost;
    /**
     * Get join path planner statistics
     */
    getJoinPlannerStatistics(): {
        totalEntities: number;
        totalRelationships: number;
        avgRelationshipsPerEntity: number;
        relationshipTypes: Record<string, number>;
    };
}
//# sourceMappingURL=QueryPlanner.d.ts.map