Package com.facebook.presto.sql.planner.optimizations

Examples of com.facebook.presto.sql.planner.optimizations.PruneUnreferencedOutputs$Rewriter

64
65
66
67
68
69
70
71
72
73
74
                new PredicatePushDown(metadata, splitManager, analyzerConfig.isApproximateQueriesEnabled()),
                new PredicatePushDown(metadata, splitManager, analyzerConfig.isApproximateQueriesEnabled()), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
61
62
63
64
65
66
67
68
69
70
71
                new PredicatePushDown(metadata, splitManager),
                new PredicatePushDown(metadata, splitManager), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
                new PredicatePushDown(metadata, splitManager, featuresConfig.isExperimentalSyntaxEnabled()), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new IndexJoinOptimizer(indexManager), // Run this after projections and filters have been fully simplified and pushed down
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
60
61
62
63
64
65
66
67
68
69
70
                new PredicatePushDown(metadata, sqlParser, splitManager, featuresConfig.isExperimentalSyntaxEnabled()), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata, sqlParser), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new IndexJoinOptimizer(indexManager), // Run this after projections and filters have been fully simplified and pushed down
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
62
63
64
65
66
67
68
69
70
71
72
                new SimplifyExpressions(metadata, sqlParser), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new IndexJoinOptimizer(indexManager), // Run this after projections and filters have been fully simplified and pushed down
                new CountConstantOptimizer(),
                new WindowFilterPushDown(metadata), // This must run after PredicatePushDown so that it squashes any successive filter nodes
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
        ImmutableList.Builder<PlanOptimizer> builder = ImmutableList.builder();

        builder.add(new ImplementSampleAsFilter(),
                new SimplifyExpressions(metadata),
                new PruneUnreferencedOutputs(),
                new UnaliasSymbolReferences(),
                new PruneRedundantProjections(),
                new SetFlatteningOptimizer(),
                new LimitPushDown(), // Run the LimitPushDown after flattening set operators to make it easier to do the set flattening
                new PredicatePushDown(metadata),
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new PruneUnreferencedOutputs(), // Prune outputs again in case predicate pushdown move predicates all the way into the table scan
                new PruneRedundantProjections()); // Run again because predicate pushdown might add more projections
        // TODO: figure out how to improve the set flattening optimizer so that it can run at any point

        this.optimizers = builder.build();
    }
View Full Code Here
62
63
64
65
66
67
68
69
70
71
72
                new SimplifyExpressions(metadata, sqlParser), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new IndexJoinOptimizer(indexManager), // Run this after projections and filters have been fully simplified and pushed down
                new CountConstantOptimizer(),
                new WindowFilterPushDown(), // This must run after PredicatePushDown so that it squashes any successive filter nodes
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
54
55
56
57
58
59
60
61
62
63
64
                new PredicatePushDown(metadata, splitManager, analyzerConfig.isExperimentalSyntaxEnabled()),
                new PredicatePushDown(metadata, splitManager, analyzerConfig.isExperimentalSyntaxEnabled()), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
62
63
64
65
66
67
68
69
70
71
72
                new PredicatePushDown(metadata, splitManager), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new PruneRedundantProjections(), // Run again because predicate pushdown might add more projections
                new PruneUnreferencedOutputs()); // Make sure to run this last to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
        // 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();
    }
View Full Code Here
54
55
56
57
58
59
60
61
62
63
64
                new PredicatePushDown(metadata, splitManager, featuresConfig.isExperimentalSyntaxEnabled()),
                new PredicatePushDown(metadata, splitManager, featuresConfig.isExperimentalSyntaxEnabled()), // Run predicate push down one more time in case we can leverage new information from generated partitions
                new MergeProjections(),
                new SimplifyExpressions(metadata), // Re-run the SimplifyExpressions to simplify any recomposed expressions from other optimizations
                new UnaliasSymbolReferences(), // Run again because predicate pushdown might add more projections
                new PruneUnreferencedOutputs(), // Make sure to run this at the end to help clean the plan for logging/execution and not remove info that other optimizers might need at an earlier point
                new PruneRedundantProjections()); // This MUST run after PruneUnreferencedOutputs as it may introduce new redundant projections
        // 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();
View Full Code Here
TOP

Related Classes of com.facebook.presto.sql.planner.optimizations.PruneUnreferencedOutputs$Rewriter

  • com.facebook.presto.metadata.PartitionResult
  • com.facebook.presto.metadata.Signature
  • com.facebook.presto.metadata.TableAlias
  • com.facebook.presto.metadata.TableMetadata
  • com.facebook.presto.operator.window.WindowFunction
  • com.facebook.presto.spi.ColumnHandle
  • com.facebook.presto.spi.ColumnMetadata
  • com.facebook.presto.spi.ConnectorTableMetadata
  • com.facebook.presto.spi.PartitionResult
  • com.facebook.presto.spi.SchemaTableName
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.