how to get a simplified pushdown optimizers?

[lschampion]

now i simplified the class "PlanOptimizers"
and i got put "PushPredicateIntoTableScan" to builder, but the it doesnt work. i want know the routine to accomplish it.

code below:

public class PlanOptimizersUDF
implements PlanOptimizersFactory {
private final List optimizers;
private final List adaptivePlanOptimizers;
private final RuleStatsRecorder ruleStats;
private final OptimizerStatsRecorder optimizerStats = new OptimizerStatsRecorder();

@Inject
public PlanOptimizersUDF(
        PlannerContext plannerContext,
        TaskManagerConfig taskManagerConfig,
        SplitManager splitManager,
        PageSourceManager pageSourceManager,
        StatsCalculator statsCalculator,
        ScalarStatsCalculator scalarStatsCalculator,
        CostCalculator costCalculatorWithoutEstimatedExchanges,
        @EstimatedExchanges CostCalculator costCalculatorWithEstimatedExchanges,
        CostComparator costComparator,
        TaskCountEstimator taskCountEstimator,
        NodePartitioningManager nodePartitioningManager,
        RuleStatsRecorder ruleStats) {
    this(plannerContext,
            taskManagerConfig,
            false,
            splitManager,
            pageSourceManager,
            statsCalculator,
            scalarStatsCalculator,
            costCalculatorWithoutEstimatedExchanges,
            costCalculatorWithEstimatedExchanges,
            costComparator,
            taskCountEstimator,
            nodePartitioningManager,
            ruleStats);
}

public PlanOptimizersUDF(
        PlannerContext plannerContext,
        TaskManagerConfig taskManagerConfig,
        boolean forceSingleNode,
        SplitManager splitManager,
        PageSourceManager pageSourceManager,
        StatsCalculator statsCalculator,
        ScalarStatsCalculator scalarStatsCalculator,
        CostCalculator costCalculatorWithoutEstimatedExchanges,
        CostCalculator costCalculatorWithEstimatedExchanges,
        CostComparator costComparator,
        TaskCountEstimator taskCountEstimator,
        NodePartitioningManager nodePartitioningManager,
        RuleStatsRecorder ruleStats) {
    CostCalculator costCalculator = costCalculatorWithEstimatedExchanges;

    this.ruleStats = requireNonNull(ruleStats, "ruleStats is null");
    ImmutableList.Builder<PlanOptimizer> builder = ImmutableList.builder();

    Metadata metadata = plannerContext.getMetadata();


    Set<Rule<?>> pushIntoTableScanRulesExceptJoins = ImmutableSet.<Rule<?>>builder()
            .add(new ApplyTableScanRedirection(plannerContext))
            .addAll(new PushCastIntoRow().rules())
            .addAll(new UnwrapCastInComparison(plannerContext).rules())
            .add(new PushProjectionIntoTableScan(plannerContext, scalarStatsCalculator))
            .add(new PushLimitIntoTableScan(metadata))
            .add(new PushPredicateIntoTableScan(plannerContext, false))
            .add(new PushAggregationIntoTableScan(plannerContext))
            .add(new RewriteTableFunctionToTableScan(plannerContext)) // must run after ImplementTableFunctionSource
            .build();
    IterativeOptimizer pushIntoTableScanOptimizer = new IterativeOptimizer(
            plannerContext,
            ruleStats,
            statsCalculator,
            costCalculator,
            pushIntoTableScanRulesExceptJoins);
    builder.add(pushIntoTableScanOptimizer);

    builder.add(new IterativeOptimizer(
            plannerContext,
            ruleStats,
            statsCalculator,
            costCalculator,
            ImmutableSet.of(
                    // Must run before AddExchanges
                    new DetermineTableScanNodePartitioning(metadata, nodePartitioningManager, taskCountEstimator)
                    // Must run after join reordering because join reordering creates
                    // new join nodes without JoinNode.maySkipOutputDuplicates flag set
            )));

    builder.add(new BeginTableWrite(metadata, plannerContext.getFunctionManager())); // HACK! see comments in BeginTableWrite

    // TODO: consider adding a formal final plan sanitization optimizer that prepares the plan for transmission/execution/logging
    // TODO: figure out how to improve the set flattening optimizer so that it can run at any point

    this.optimizers = builder.build();

    // Adaptive optimization rules for FTE
    ImmutableList.Builder<AdaptivePlanOptimizer> adaptivePlanOptimizers = ImmutableList.builder();
    this.adaptivePlanOptimizers = adaptivePlanOptimizers.build();
}

@Override
public List<PlanOptimizer> getPlanOptimizers() {
    return optimizers;
}

@Override
public List<AdaptivePlanOptimizer> getAdaptivePlanOptimizers() {
    return adaptivePlanOptimizers;
}

@Override
public Map<Class<?>, OptimizerStats> getOptimizerStats() {
    return optimizerStats.getStats();
}

@Override
public Map<Class<?>, RuleStats> getRuleStats() {
    return ruleStats.getStats();
}