diff --git a/presto-main/src/main/java/com/facebook/presto/cost/AggregationStatsRule.java b/presto-main/src/main/java/com/facebook/presto/cost/AggregationStatsRule.java index 59dd8c7265f6e..6f69e0bd178c3 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/AggregationStatsRule.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/AggregationStatsRule.java @@ -97,6 +97,6 @@ private static SymbolStatsEstimate estimateAggregationStats(Aggregation aggregat requireNonNull(sourceStats, "sourceStats is null"); // TODO implement simple aggregations like: min, max, count, sum - return SymbolStatsEstimate.UNKNOWN_STATS; + return SymbolStatsEstimate.unknown(); } } diff --git a/presto-main/src/main/java/com/facebook/presto/cost/CachingCostProvider.java b/presto-main/src/main/java/com/facebook/presto/cost/CachingCostProvider.java index c029f3b5e7f07..90754efa3f83f 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/CachingCostProvider.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/CachingCostProvider.java @@ -23,7 +23,6 @@ import java.util.Map; import java.util.Optional; -import static com.facebook.presto.cost.PlanNodeCostEstimate.ZERO_COST; import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; @@ -93,7 +92,7 @@ private PlanNodeCostEstimate calculateCumulativeCost(PlanNode node) PlanNodeCostEstimate sourcesCost = node.getSources().stream() .map(this::getCumulativeCost) - .reduce(ZERO_COST, PlanNodeCostEstimate::add); + .reduce(PlanNodeCostEstimate.zero(), PlanNodeCostEstimate::add); PlanNodeCostEstimate cumulativeCost = localCosts.add(sourcesCost); return cumulativeCost; diff --git a/presto-main/src/main/java/com/facebook/presto/cost/CachingStatsProvider.java b/presto-main/src/main/java/com/facebook/presto/cost/CachingStatsProvider.java index d9b823af51e6c..e78c478faf0bd 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/CachingStatsProvider.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/CachingStatsProvider.java @@ -25,7 +25,6 @@ import java.util.Optional; import static com.facebook.presto.SystemSessionProperties.isEnableStatsCalculator; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.sql.planner.iterative.Lookup.noLookup; import static com.google.common.base.Verify.verify; import static java.util.Objects.requireNonNull; @@ -59,7 +58,7 @@ public CachingStatsProvider(StatsCalculator statsCalculator, Optional memo public PlanNodeStatsEstimate getStats(PlanNode node) { if (!isEnableStatsCalculator(session)) { - return UNKNOWN_STATS; + return PlanNodeStatsEstimate.unknown(); } requireNonNull(node, "node is null"); diff --git a/presto-main/src/main/java/com/facebook/presto/cost/ComposableStatsCalculator.java b/presto-main/src/main/java/com/facebook/presto/cost/ComposableStatsCalculator.java index 7895df4baff4c..8fa93978aeb78 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/ComposableStatsCalculator.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/ComposableStatsCalculator.java @@ -72,7 +72,7 @@ public PlanNodeStatsEstimate calculateStats(PlanNode node, StatsProvider sourceS return calculatedStats.get(); } } - return PlanNodeStatsEstimate.UNKNOWN_STATS; + return PlanNodeStatsEstimate.unknown(); } private static Optional calculateStats(Rule rule, PlanNode node, StatsProvider sourceStats, Lookup lookup, Session session, TypeProvider types) diff --git a/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorUsingExchanges.java b/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorUsingExchanges.java index 97130280a1f5a..a50059b8a994b 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorUsingExchanges.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorUsingExchanges.java @@ -47,8 +47,6 @@ import java.util.Set; import java.util.function.IntSupplier; -import static com.facebook.presto.cost.PlanNodeCostEstimate.UNKNOWN_COST; -import static com.facebook.presto.cost.PlanNodeCostEstimate.ZERO_COST; import static com.facebook.presto.cost.PlanNodeCostEstimate.cpuCost; import static com.facebook.presto.sql.planner.plan.AggregationNode.Step.FINAL; import static com.facebook.presto.sql.planner.plan.AggregationNode.Step.SINGLE; @@ -115,7 +113,7 @@ private static class CostEstimator @Override protected PlanNodeCostEstimate visitPlan(PlanNode node, Void context) { - return UNKNOWN_COST; + return PlanNodeCostEstimate.unknown(); } @Override @@ -133,7 +131,7 @@ public PlanNodeCostEstimate visitAssignUniqueId(AssignUniqueId node, Void contex @Override public PlanNodeCostEstimate visitOutput(OutputNode node, Void context) { - return ZERO_COST; + return PlanNodeCostEstimate.zero(); } @Override @@ -159,7 +157,7 @@ public PlanNodeCostEstimate visitProject(ProjectNode node, Void context) public PlanNodeCostEstimate visitAggregation(AggregationNode node, Void context) { if (node.getStep() != FINAL && node.getStep() != SINGLE) { - return UNKNOWN_COST; + return PlanNodeCostEstimate.unknown(); } PlanNodeStatsEstimate aggregationStats = getStats(node); PlanNodeStatsEstimate sourceStats = getStats(node.getSource()); @@ -230,13 +228,13 @@ public PlanNodeCostEstimate visitSpatialJoin(SpatialJoinNode node, Void context) @Override public PlanNodeCostEstimate visitValues(ValuesNode node, Void context) { - return ZERO_COST; + return PlanNodeCostEstimate.zero(); } @Override public PlanNodeCostEstimate visitEnforceSingleRow(EnforceSingleRowNode node, Void context) { - return ZERO_COST; + return PlanNodeCostEstimate.zero(); } @Override diff --git a/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorWithEstimatedExchanges.java b/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorWithEstimatedExchanges.java index 9dfa34ee4feda..354279fe8b11d 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorWithEstimatedExchanges.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/CostCalculatorWithEstimatedExchanges.java @@ -36,7 +36,6 @@ import java.util.function.IntSupplier; import static com.facebook.presto.cost.CostCalculatorUsingExchanges.currentNumberOfWorkerNodes; -import static com.facebook.presto.cost.PlanNodeCostEstimate.ZERO_COST; import static com.facebook.presto.sql.planner.plan.ExchangeNode.Scope.LOCAL; import static com.facebook.presto.sql.planner.plan.ExchangeNode.Scope.REMOTE; import static com.facebook.presto.sql.planner.plan.ExchangeNode.Type.REPARTITION; @@ -90,8 +89,8 @@ private static class ExchangeCostEstimator @Override protected PlanNodeCostEstimate visitPlan(PlanNode node, Void context) { - // TODO implement logic for other node types and return UNKNOWN_COST here (or throw) - return ZERO_COST; + // TODO implement logic for other node types and return PlanNodeCostEstimate.unknown() here (or throw) + return PlanNodeCostEstimate.zero(); } @Override diff --git a/presto-main/src/main/java/com/facebook/presto/cost/FilterStatsCalculator.java b/presto-main/src/main/java/com/facebook/presto/cost/FilterStatsCalculator.java index 920f42d311dc9..11e95f62834d3 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/FilterStatsCalculator.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/FilterStatsCalculator.java @@ -54,8 +54,6 @@ import static com.facebook.presto.cost.PlanNodeStatsEstimateMath.differenceInNonRangeStats; import static com.facebook.presto.cost.PlanNodeStatsEstimateMath.differenceInStats; import static com.facebook.presto.cost.StatsUtil.toStatsRepresentation; -import static com.facebook.presto.cost.SymbolStatsEstimate.UNKNOWN_STATS; -import static com.facebook.presto.cost.SymbolStatsEstimate.ZERO_STATS; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.sql.ExpressionUtils.and; import static com.facebook.presto.sql.tree.ComparisonExpression.Operator.EQUAL; @@ -163,7 +161,7 @@ protected Optional visitExpression(Expression node, Void private Optional filterForFalseExpression() { PlanNodeStatsEstimate.Builder falseStatsBuilder = PlanNodeStatsEstimate.builder(); - input.getSymbolsWithKnownStatistics().forEach(symbol -> falseStatsBuilder.addSymbolStatistics(symbol, ZERO_STATS)); + input.getSymbolsWithKnownStatistics().forEach(symbol -> falseStatsBuilder.addSymbolStatistics(symbol, SymbolStatsEstimate.zero())); return Optional.of(falseStatsBuilder .setOutputRowCount(0.0) .build()); @@ -318,7 +316,7 @@ protected Optional visitInPredicate(InPredicate node, Voi Optional inValueSymbol = asSymbol(node.getValue()); SymbolStatsEstimate inValueStats = getExpressionStats(node.getValue()); - if (Objects.equals(inValueStats, UNKNOWN_STATS)) { + if (Objects.equals(inValueStats, SymbolStatsEstimate.unknown())) { return Optional.empty(); } @@ -355,7 +353,7 @@ protected Optional visitComparisonExpression(ComparisonEx Optional leftSymbol = asSymbol(left); SymbolStatsEstimate leftStats = getExpressionStats(left); - if (Objects.equals(leftStats, UNKNOWN_STATS)) { + if (Objects.equals(leftStats, SymbolStatsEstimate.unknown())) { return visitExpression(node, context); } @@ -367,7 +365,7 @@ protected Optional visitComparisonExpression(ComparisonEx Optional rightSymbol = asSymbol(right); SymbolStatsEstimate rightStats = getExpressionStats(right); - if (Objects.equals(rightStats, UNKNOWN_STATS)) { + if (Objects.equals(rightStats, SymbolStatsEstimate.unknown())) { return visitExpression(node, context); } diff --git a/presto-main/src/main/java/com/facebook/presto/cost/JoinStatsRule.java b/presto-main/src/main/java/com/facebook/presto/cost/JoinStatsRule.java index 2c1c9684624ab..f5dc33e3fbb85 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/JoinStatsRule.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/JoinStatsRule.java @@ -32,7 +32,6 @@ import java.util.stream.IntStream; import static com.facebook.presto.cost.FilterStatsCalculator.UNKNOWN_FILTER_COEFFICIENT; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.cost.SymbolStatsEstimate.buildFrom; import static com.facebook.presto.sql.planner.plan.Patterns.join; import static com.facebook.presto.sql.tree.ComparisonExpression.Operator.EQUAL; @@ -247,7 +246,7 @@ PlanNodeStatsEstimate calculateJoinComplementStats( if (criteria.isEmpty()) { // TODO: account for non-equi conditions if (filter.isPresent()) { - return UNKNOWN_STATS; + return PlanNodeStatsEstimate.unknown(); } return leftStats.mapOutputRowCount(rowCount -> 0.0); @@ -312,7 +311,7 @@ else if (leftNDV <= matchingRightNDV) { } else { // either leftNDV or rightNDV is NaN - return UNKNOWN_STATS; + return PlanNodeStatsEstimate.unknown(); } // limit the number of complement rows (to left row count) and account for remaining clauses diff --git a/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeCostEstimate.java b/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeCostEstimate.java index 77d1de92542cb..cbb97ef5d8750 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeCostEstimate.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeCostEstimate.java @@ -26,9 +26,28 @@ public final class PlanNodeCostEstimate { - public static final PlanNodeCostEstimate INFINITE_COST = new PlanNodeCostEstimate(POSITIVE_INFINITY, POSITIVE_INFINITY, POSITIVE_INFINITY); - public static final PlanNodeCostEstimate UNKNOWN_COST = new PlanNodeCostEstimate(NaN, NaN, NaN); - public static final PlanNodeCostEstimate ZERO_COST = new PlanNodeCostEstimate(0, 0, 0); + private static final PlanNodeCostEstimate INFINITE = new PlanNodeCostEstimate(POSITIVE_INFINITY, POSITIVE_INFINITY, POSITIVE_INFINITY); + private static final PlanNodeCostEstimate UNKNOWN = new PlanNodeCostEstimate(NaN, NaN, NaN); + private static final PlanNodeCostEstimate ZERO = new PlanNodeCostEstimate(0, 0, 0); + + private final double cpuCost; + private final double memoryCost; + private final double networkCost; + + public static PlanNodeCostEstimate infinite() + { + return INFINITE; + } + + public static PlanNodeCostEstimate unknown() + { + return UNKNOWN; + } + + public static PlanNodeCostEstimate zero() + { + return ZERO; + } public static PlanNodeCostEstimate cpuCost(double cpuCost) { @@ -45,10 +64,6 @@ public static PlanNodeCostEstimate networkCost(double networkCost) return new PlanNodeCostEstimate(0, 0, networkCost); } - private final double cpuCost; - private final double memoryCost; - private final double networkCost; - @JsonCreator public PlanNodeCostEstimate( @JsonProperty("cpuCost") double cpuCost, diff --git a/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeStatsEstimate.java b/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeStatsEstimate.java index 4180e813e1965..449c34a304418 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeStatsEstimate.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/PlanNodeStatsEstimate.java @@ -20,6 +20,7 @@ import com.facebook.presto.sql.planner.TypeProvider; import com.fasterxml.jackson.annotation.JsonCreator; import com.fasterxml.jackson.annotation.JsonProperty; +import com.google.common.collect.ImmutableMap; import org.pcollections.HashTreePMap; import org.pcollections.PMap; @@ -39,11 +40,16 @@ public class PlanNodeStatsEstimate { private static final double DEFAULT_DATA_SIZE_PER_COLUMN = 50; - public static final PlanNodeStatsEstimate UNKNOWN_STATS = builder().build(); + private static final PlanNodeStatsEstimate UNKNOWN = new PlanNodeStatsEstimate(NaN, ImmutableMap.of()); private final double outputRowCount; private final PMap symbolStatistics; + public static PlanNodeStatsEstimate unknown() + { + return UNKNOWN; + } + @JsonCreator public PlanNodeStatsEstimate( @JsonProperty("outputRowCount") double outputRowCount, @@ -52,9 +58,7 @@ public PlanNodeStatsEstimate( this(outputRowCount, HashTreePMap.from(requireNonNull(symbolStatistics, "symbolStatistics is null"))); } - private PlanNodeStatsEstimate( - double outputRowCount, - PMap symbolStatistics) + private PlanNodeStatsEstimate(double outputRowCount, PMap symbolStatistics) { checkArgument(isNaN(outputRowCount) || outputRowCount >= 0, "outputRowCount cannot be negative"); this.outputRowCount = outputRowCount; @@ -128,7 +132,7 @@ public PlanNodeStatsEstimate mapSymbolColumnStatistics(Symbol symbol, Function getSymbolsWithKnownStatistics() return symbolStatistics.keySet(); } + public boolean isOutputRowCountUnknown() + { + return isNaN(outputRowCount); + } + @Override public String toString() { diff --git a/presto-main/src/main/java/com/facebook/presto/cost/ScalarStatsCalculator.java b/presto-main/src/main/java/com/facebook/presto/cost/ScalarStatsCalculator.java index 6ad355038551c..fdf034ecd3fda 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/ScalarStatsCalculator.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/ScalarStatsCalculator.java @@ -77,7 +77,7 @@ private class Visitor @Override protected SymbolStatsEstimate visitNode(Node node, Void context) { - return SymbolStatsEstimate.UNKNOWN_STATS; + return SymbolStatsEstimate.unknown(); } @Override diff --git a/presto-main/src/main/java/com/facebook/presto/cost/SpatialJoinStatsRule.java b/presto-main/src/main/java/com/facebook/presto/cost/SpatialJoinStatsRule.java index 1245ee15c5b18..30ebe02cc464d 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/SpatialJoinStatsRule.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/SpatialJoinStatsRule.java @@ -21,7 +21,6 @@ import java.util.Optional; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.sql.planner.plan.Patterns.spatialJoin; import static java.util.Objects.requireNonNull; @@ -49,7 +48,7 @@ protected Optional doCalculate(SpatialJoinNode node, Stat case INNER: return Optional.of(statsCalculator.filterStats(crossJoinStats, node.getFilter(), session, types)); case LEFT: - return Optional.of(UNKNOWN_STATS); + return Optional.of(PlanNodeStatsEstimate.unknown()); default: throw new IllegalArgumentException("Unknown spatial join type: " + node.getType()); } diff --git a/presto-main/src/main/java/com/facebook/presto/cost/StatsNormalizer.java b/presto-main/src/main/java/com/facebook/presto/cost/StatsNormalizer.java index c606ee2de1df7..40517b82ed8ad 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/StatsNormalizer.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/StatsNormalizer.java @@ -30,8 +30,6 @@ import java.util.Optional; import java.util.function.Predicate; -import static com.facebook.presto.cost.SymbolStatsEstimate.UNKNOWN_STATS; -import static com.facebook.presto.cost.SymbolStatsEstimate.ZERO_STATS; import static java.lang.Double.NaN; import static java.lang.Double.isNaN; import static java.lang.Math.floor; @@ -70,7 +68,7 @@ private PlanNodeStatsEstimate normalize(PlanNodeStatsEstimate stats, Optional mappi return buildFrom(this).setDistinctValuesCount(mappingFunction.apply(distinctValuesCount)).build(); } + public boolean isUnknown() + { + return this.equals(UNKNOWN); + } + @Override public boolean equals(Object o) { diff --git a/presto-main/src/main/java/com/facebook/presto/cost/TableScanStatsRule.java b/presto-main/src/main/java/com/facebook/presto/cost/TableScanStatsRule.java index 19c7faf74af90..3913cecf3dca5 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/TableScanStatsRule.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/TableScanStatsRule.java @@ -29,7 +29,6 @@ import java.util.Map; import java.util.Optional; -import static com.facebook.presto.cost.SymbolStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.sql.planner.plan.Patterns.tableScan; import static java.util.Objects.requireNonNull; @@ -64,7 +63,7 @@ protected Optional doCalculate(TableScanNode node, StatsP for (Map.Entry entry : node.getAssignments().entrySet()) { Symbol symbol = entry.getKey(); Optional columnStatistics = Optional.ofNullable(tableStatistics.getColumnStatistics().get(entry.getValue())); - outputSymbolStats.put(symbol, columnStatistics.map(statistics -> toSymbolStatistics(tableStatistics, statistics)).orElse(UNKNOWN_STATS)); + outputSymbolStats.put(symbol, columnStatistics.map(statistics -> toSymbolStatistics(tableStatistics, statistics)).orElse(SymbolStatsEstimate.unknown())); } return Optional.of(PlanNodeStatsEstimate.builder() diff --git a/presto-main/src/main/java/com/facebook/presto/cost/ValuesStatsRule.java b/presto-main/src/main/java/com/facebook/presto/cost/ValuesStatsRule.java index c09e38ac25b77..bcf1fe16e26e5 100644 --- a/presto-main/src/main/java/com/facebook/presto/cost/ValuesStatsRule.java +++ b/presto-main/src/main/java/com/facebook/presto/cost/ValuesStatsRule.java @@ -92,7 +92,7 @@ private SymbolStatsEstimate buildSymbolStatistics(List values, Session s .collect(toImmutableList()); if (nonNullValues.isEmpty()) { - return SymbolStatsEstimate.ZERO_STATS; + return SymbolStatsEstimate.zero(); } double[] valuesAsDoubles = nonNullValues.stream() diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/ReorderJoins.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/ReorderJoins.java index 0e91c8e9ad01d..b5db17db354d0 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/ReorderJoins.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/iterative/rule/ReorderJoins.java @@ -55,8 +55,6 @@ import static com.facebook.presto.SystemSessionProperties.getJoinDistributionType; import static com.facebook.presto.SystemSessionProperties.getJoinReorderingStrategy; import static com.facebook.presto.SystemSessionProperties.getMaxReorderedJoins; -import static com.facebook.presto.cost.PlanNodeCostEstimate.INFINITE_COST; -import static com.facebook.presto.cost.PlanNodeCostEstimate.UNKNOWN_COST; import static com.facebook.presto.sql.ExpressionUtils.and; import static com.facebook.presto.sql.ExpressionUtils.combineConjuncts; import static com.facebook.presto.sql.ExpressionUtils.extractConjuncts; @@ -544,8 +542,8 @@ public MultiJoinNode build() @VisibleForTesting static class JoinEnumerationResult { - public static final JoinEnumerationResult UNKNOWN_COST_RESULT = new JoinEnumerationResult(Optional.empty(), UNKNOWN_COST); - public static final JoinEnumerationResult INFINITE_COST_RESULT = new JoinEnumerationResult(Optional.empty(), INFINITE_COST); + public static final JoinEnumerationResult UNKNOWN_COST_RESULT = new JoinEnumerationResult(Optional.empty(), PlanNodeCostEstimate.unknown()); + public static final JoinEnumerationResult INFINITE_COST_RESULT = new JoinEnumerationResult(Optional.empty(), PlanNodeCostEstimate.infinite()); private final Optional planNode; private final PlanNodeCostEstimate cost; @@ -554,8 +552,8 @@ private JoinEnumerationResult(Optional planNode, PlanNodeCostEstimate { this.planNode = requireNonNull(planNode, "planNode is null"); this.cost = requireNonNull(cost, "cost is null"); - checkArgument((cost.hasUnknownComponents() || cost.equals(INFINITE_COST)) && !planNode.isPresent() - || (!cost.hasUnknownComponents() || !cost.equals(INFINITE_COST)) && planNode.isPresent(), + checkArgument((cost.hasUnknownComponents() || cost.equals(PlanNodeCostEstimate.infinite())) && !planNode.isPresent() + || (!cost.hasUnknownComponents() || !cost.equals(PlanNodeCostEstimate.infinite())) && planNode.isPresent(), "planNode should be present if and only if cost is known"); } @@ -574,7 +572,7 @@ static JoinEnumerationResult createJoinEnumerationResult(Optional plan if (cost.hasUnknownComponents()) { return UNKNOWN_COST_RESULT; } - if (cost.equals(INFINITE_COST)) { + if (cost.equals(PlanNodeCostEstimate.infinite())) { return INFINITE_COST_RESULT; } return new JoinEnumerationResult(planNode, cost); diff --git a/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java b/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java index 4d7b5c6a8be01..fcdfbd7b062e6 100644 --- a/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java +++ b/presto-main/src/main/java/com/facebook/presto/sql/planner/planPrinter/PlanPrinter.java @@ -116,8 +116,6 @@ import java.util.stream.Collectors; import java.util.stream.Stream; -import static com.facebook.presto.cost.PlanNodeCostEstimate.UNKNOWN_COST; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.execution.StageInfo.getAllStages; import static com.facebook.presto.spi.type.VarcharType.VARCHAR; import static com.facebook.presto.sql.planner.SystemPartitioningHandle.SINGLE_DISTRIBUTION; @@ -1386,9 +1384,9 @@ private void printPlanNodesStatsAndCost(int indent, PlanNode... nodes) private Optional formatPlanNodeStatsAndCost(PlanNode node) { - PlanNodeStatsEstimate stats = estimatedStatsAndCosts.getStats().getOrDefault(node.getId(), UNKNOWN_STATS); - PlanNodeCostEstimate cost = estimatedStatsAndCosts.getCosts().getOrDefault(node.getId(), UNKNOWN_COST); - if (stats.equals(UNKNOWN_STATS) || cost.equals(UNKNOWN_COST)) { + PlanNodeStatsEstimate stats = estimatedStatsAndCosts.getStats().getOrDefault(node.getId(), PlanNodeStatsEstimate.unknown()); + PlanNodeCostEstimate cost = estimatedStatsAndCosts.getCosts().getOrDefault(node.getId(), PlanNodeCostEstimate.unknown()); + if (stats.isOutputRowCountUnknown() || cost.equals(PlanNodeCostEstimate.unknown())) { return Optional.empty(); } return Optional.of(String.format("{rows: %s (%s), cpu: %s, memory: %s, network: %s}", diff --git a/presto-main/src/test/java/com/facebook/presto/cost/StatsCalculatorAssertion.java b/presto-main/src/test/java/com/facebook/presto/cost/StatsCalculatorAssertion.java index 354297a3fb0b6..1455302b94eba 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/StatsCalculatorAssertion.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/StatsCalculatorAssertion.java @@ -26,7 +26,6 @@ import java.util.Optional; import java.util.function.Consumer; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.sql.planner.iterative.Lookup.noLookup; import static com.google.common.base.Preconditions.checkArgument; import static com.google.common.base.Preconditions.checkState; @@ -49,7 +48,7 @@ public StatsCalculatorAssertion(StatsCalculator statsCalculator, Session session this.types = requireNonNull(types, "types is null"); sourcesStats = new HashMap<>(); - planNode.getSources().forEach(child -> sourcesStats.put(child, UNKNOWN_STATS)); + planNode.getSources().forEach(child -> sourcesStats.put(child, PlanNodeStatsEstimate.unknown())); } public StatsCalculatorAssertion withSourceStats(PlanNodeStatsEstimate sourceStats) diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java b/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java index 9c5ad81b35b6a..230ad442bd513 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestCostCalculator.java @@ -70,10 +70,7 @@ import java.util.Optional; import java.util.function.Function; -import static com.facebook.presto.cost.PlanNodeCostEstimate.UNKNOWN_COST; -import static com.facebook.presto.cost.PlanNodeCostEstimate.ZERO_COST; import static com.facebook.presto.cost.PlanNodeCostEstimate.cpuCost; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.metadata.FunctionKind.AGGREGATE; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; @@ -413,7 +410,7 @@ private CostAssertionBuilder assertCostFragmentedPlan( StatsProvider statsProvider = new CachingStatsProvider(statsCalculator(stats), session, typeProvider); CostProvider costProvider = new TestingCostProvider(costs, costCalculatorUsingExchanges, statsProvider, session, typeProvider); SubPlan subPlan = fragment(new Plan(node, typeProvider, StatsAndCosts.create(node, statsProvider, costProvider))); - return new CostAssertionBuilder(subPlan.getFragment().getStatsAndCosts().getCosts().getOrDefault(node.getId(), UNKNOWN_COST)); + return new CostAssertionBuilder(subPlan.getFragment().getStatsAndCosts().getCosts().getOrDefault(node.getId(), PlanNodeCostEstimate.unknown())); } private static class TestingCostProvider @@ -447,7 +444,7 @@ private PlanNodeCostEstimate calculateCumulativeCost(PlanNode node) { PlanNodeCostEstimate sourcesCost = node.getSources().stream() .map(this::getCumulativeCost) - .reduce(ZERO_COST, PlanNodeCostEstimate::add); + .reduce(PlanNodeCostEstimate.zero(), PlanNodeCostEstimate::add); return costCalculator.calculateCost(node, statsProvider, session, types).add(sourcesCost); } @@ -474,15 +471,15 @@ private void assertCostHasUnknownComponentsForUnknownStats(PlanNode node, Map UNKNOWN_COST, - planNode -> UNKNOWN_STATS, + planNode -> PlanNodeCostEstimate.unknown(), + planNode -> PlanNodeStatsEstimate.unknown(), types)) .hasUnknownComponents(); new CostAssertionBuilder(calculateCumulativeCost( costCalculatorWithEstimatedExchanges, node, - planNode -> UNKNOWN_COST, - planNode -> UNKNOWN_STATS, + planNode -> PlanNodeCostEstimate.unknown(), + planNode -> PlanNodeStatsEstimate.unknown(), types)) .hasUnknownComponents(); } @@ -517,7 +514,7 @@ private PlanNodeCostEstimate calculateCumulativeCost( PlanNodeCostEstimate sourcesCost = node.getSources().stream() .map(source -> requireNonNull(costs.apply(source), format("no cost for source: %s", source.getId()))) - .reduce(ZERO_COST, PlanNodeCostEstimate::add); + .reduce(PlanNodeCostEstimate.zero(), PlanNodeCostEstimate::add); return sourcesCost.add(localCost); } @@ -537,7 +534,7 @@ private PlanNodeCostEstimate calculateCumulativeCostFragmentedPlan(PlanNode node StatsProvider statsProvider = new CachingStatsProvider(statsCalculator, session, typeProvider); CostProvider costProvider = new CachingCostProvider(costCalculatorUsingExchanges, statsProvider, Optional.empty(), session, typeProvider); SubPlan subPlan = fragment(new Plan(node, typeProvider, StatsAndCosts.create(node, statsProvider, costProvider))); - return subPlan.getFragment().getStatsAndCosts().getCosts().getOrDefault(node.getId(), UNKNOWN_COST); + return subPlan.getFragment().getStatsAndCosts().getCosts().getOrDefault(node.getId(), PlanNodeCostEstimate.unknown()); } private static class CostAssertionBuilder diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestCostComparator.java b/presto-main/src/test/java/com/facebook/presto/cost/TestCostComparator.java index 3ddf807c22069..a8c961c3924bc 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestCostComparator.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestCostComparator.java @@ -16,8 +16,6 @@ import com.facebook.presto.Session; import org.testng.annotations.Test; -import static com.facebook.presto.cost.PlanNodeCostEstimate.UNKNOWN_COST; -import static com.facebook.presto.cost.PlanNodeCostEstimate.ZERO_COST; import static com.facebook.presto.testing.TestingSession.testSessionBuilder; import static com.google.common.base.Preconditions.checkState; import static org.testng.Assert.assertThrows; @@ -71,9 +69,9 @@ public void testUnknownCost() { CostComparator costComparator = new CostComparator(1.0, 1.0, 1.0); Session session = testSessionBuilder().build(); - assertThrows(IllegalArgumentException.class, () -> costComparator.compare(session, ZERO_COST, UNKNOWN_COST)); - assertThrows(IllegalArgumentException.class, () -> costComparator.compare(session, UNKNOWN_COST, ZERO_COST)); - assertThrows(IllegalArgumentException.class, () -> costComparator.compare(session, UNKNOWN_COST, UNKNOWN_COST)); + assertThrows(IllegalArgumentException.class, () -> costComparator.compare(session, PlanNodeCostEstimate.zero(), PlanNodeCostEstimate.unknown())); + assertThrows(IllegalArgumentException.class, () -> costComparator.compare(session, PlanNodeCostEstimate.unknown(), PlanNodeCostEstimate.zero())); + assertThrows(IllegalArgumentException.class, () -> costComparator.compare(session, PlanNodeCostEstimate.unknown(), PlanNodeCostEstimate.unknown())); } private static class CostComparisonAssertion diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestJoinStatsRule.java b/presto-main/src/test/java/com/facebook/presto/cost/TestJoinStatsRule.java index 909ace664b853..02a756d9a4118 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestJoinStatsRule.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestJoinStatsRule.java @@ -26,7 +26,6 @@ import static com.facebook.presto.cost.FilterStatsCalculator.UNKNOWN_FILTER_COEFFICIENT; import static com.facebook.presto.cost.PlanNodeStatsAssertion.assertThat; -import static com.facebook.presto.cost.SymbolStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.metadata.MetadataManager.createTestMetadataManager; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.DoubleType.DOUBLE; @@ -252,12 +251,12 @@ public void testLeftJoinMissingStats() { PlanNodeStatsEstimate leftStats = planNodeStats( 0, - new SymbolStatistics(LEFT_JOIN_COLUMN, UNKNOWN_STATS), - new SymbolStatistics(LEFT_OTHER_COLUMN, UNKNOWN_STATS)); + new SymbolStatistics(LEFT_JOIN_COLUMN, SymbolStatsEstimate.unknown()), + new SymbolStatistics(LEFT_OTHER_COLUMN, SymbolStatsEstimate.unknown())); PlanNodeStatsEstimate rightStats = planNodeStats( 0, - new SymbolStatistics(RIGHT_JOIN_COLUMN, UNKNOWN_STATS), - new SymbolStatistics(RIGHT_OTHER_COLUMN, UNKNOWN_STATS)); + new SymbolStatistics(RIGHT_JOIN_COLUMN, SymbolStatsEstimate.unknown()), + new SymbolStatistics(RIGHT_OTHER_COLUMN, SymbolStatsEstimate.unknown())); assertJoinStats(LEFT, leftStats, rightStats, leftStats); } diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestScalarStatsCalculator.java b/presto-main/src/test/java/com/facebook/presto/cost/TestScalarStatsCalculator.java index e17f9b04d93ae..412fce380096f 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestScalarStatsCalculator.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestScalarStatsCalculator.java @@ -27,7 +27,6 @@ import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.sql.ExpressionUtils.rewriteIdentifiersToSymbolReferences; import static com.facebook.presto.testing.TestingSession.testSessionBuilder; import static java.lang.Double.NEGATIVE_INFINITY; @@ -89,7 +88,7 @@ public void testSymbolReference() .build(); assertCalculate(expression("x"), inputStatistics).isEqualTo(xStats); - assertCalculate(expression("y"), inputStatistics).isEqualTo(SymbolStatsEstimate.UNKNOWN_STATS); + assertCalculate(expression("y"), inputStatistics).isEqualTo(SymbolStatsEstimate.unknown()); } @Test @@ -178,7 +177,7 @@ public void testCastBigintToDouble() @Test public void testCastUnknown() { - assertCalculate(new Cast(new SymbolReference("a"), "bigint"), UNKNOWN_STATS) + assertCalculate(new Cast(new SymbolReference("a"), "bigint"), PlanNodeStatsEstimate.unknown()) .lowValueUnknown() .highValueUnknown() .distinctValuesCountUnknown() @@ -188,7 +187,7 @@ public void testCastUnknown() private SymbolStatsAssertion assertCalculate(Expression scalarExpression) { - return assertCalculate(scalarExpression, UNKNOWN_STATS); + return assertCalculate(scalarExpression, PlanNodeStatsEstimate.unknown()); } private SymbolStatsAssertion assertCalculate(Expression scalarExpression, PlanNodeStatsEstimate inputStatistics) diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestSemiJoinStatsCalculator.java b/presto-main/src/test/java/com/facebook/presto/cost/TestSemiJoinStatsCalculator.java index 35a10a4f1826f..bd234325f91df 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestSemiJoinStatsCalculator.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestSemiJoinStatsCalculator.java @@ -21,7 +21,6 @@ import static com.facebook.presto.cost.PlanNodeStatsAssertion.assertThat; import static com.facebook.presto.cost.SemiJoinStatsCalculator.computeAntiJoin; import static com.facebook.presto.cost.SemiJoinStatsCalculator.computeSemiJoin; -import static com.facebook.presto.cost.SymbolStatsEstimate.UNKNOWN_STATS; import static java.lang.Double.NEGATIVE_INFINITY; import static java.lang.Double.NaN; import static java.lang.Double.POSITIVE_INFINITY; @@ -127,7 +126,7 @@ public void setUp() .addSymbolStatistics(rightOpen, rightOpenStats) .addSymbolStatistics(unknownRange, unknownRangeStats) .addSymbolStatistics(emptyRange, emptyRangeStats) - .addSymbolStatistics(unknown, UNKNOWN_STATS) + .addSymbolStatistics(unknown, SymbolStatsEstimate.unknown()) .setOutputRowCount(1000.0) .build(); } diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestStatsNormalizer.java b/presto-main/src/test/java/com/facebook/presto/cost/TestStatsNormalizer.java index 493fc89ff6beb..234111111211b 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestStatsNormalizer.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestStatsNormalizer.java @@ -30,7 +30,6 @@ import java.time.LocalDate; import static com.facebook.presto.cost.StatsUtil.toStatsRepresentation; -import static com.facebook.presto.cost.SymbolStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.spi.type.BigintType.BIGINT; import static com.facebook.presto.spi.type.BooleanType.BOOLEAN; import static com.facebook.presto.spi.type.DateType.DATE; @@ -73,7 +72,7 @@ public void testDropNonOutputSymbols() PlanNodeStatsEstimate estimate = PlanNodeStatsEstimate.builder() .addSymbolStatistics(a, SymbolStatsEstimate.builder().setDistinctValuesCount(20).build()) .addSymbolStatistics(b, SymbolStatsEstimate.builder().setDistinctValuesCount(30).build()) - .addSymbolStatistics(c, SymbolStatsEstimate.buildFrom(UNKNOWN_STATS).build()) + .addSymbolStatistics(c, SymbolStatsEstimate.unknown()) .build(); PlanNodeStatsAssertion.assertThat(normalizer.normalize(estimate, ImmutableList.of(b, c), TypeProvider.copyOf(ImmutableMap.of(b, BIGINT, c, BIGINT)))) @@ -90,7 +89,7 @@ public void tesCapDistinctValuesByOutputRowCount() PlanNodeStatsEstimate estimate = PlanNodeStatsEstimate.builder() .addSymbolStatistics(a, SymbolStatsEstimate.builder().setNullsFraction(0).setDistinctValuesCount(20).build()) .addSymbolStatistics(b, SymbolStatsEstimate.builder().setNullsFraction(0.4).setDistinctValuesCount(20).build()) - .addSymbolStatistics(c, SymbolStatsEstimate.builder().build()) + .addSymbolStatistics(c, SymbolStatsEstimate.unknown()) .setOutputRowCount(10) .build(); diff --git a/presto-main/src/test/java/com/facebook/presto/cost/TestValuesNodeStats.java b/presto-main/src/test/java/com/facebook/presto/cost/TestValuesNodeStats.java index 9629dad08fb5b..d7322db9b5e83 100644 --- a/presto-main/src/test/java/com/facebook/presto/cost/TestValuesNodeStats.java +++ b/presto-main/src/test/java/com/facebook/presto/cost/TestValuesNodeStats.java @@ -81,7 +81,7 @@ public void testStatsForValuesNodeWithJustNulls() { PlanNodeStatsEstimate nullAStats = PlanNodeStatsEstimate.builder() .setOutputRowCount(1) - .addSymbolStatistics(new Symbol("a"), SymbolStatsEstimate.ZERO_STATS) + .addSymbolStatistics(new Symbol("a"), SymbolStatsEstimate.zero()) .build(); tester().assertStatsFor(pb -> pb @@ -112,7 +112,7 @@ public void testStatsForEmptyValues() .check(outputStats -> outputStats.equalTo( PlanNodeStatsEstimate.builder() .setOutputRowCount(0) - .addSymbolStatistics(new Symbol("a"), SymbolStatsEstimate.ZERO_STATS) + .addSymbolStatistics(new Symbol("a"), SymbolStatsEstimate.zero()) .build())); } } diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestJoinEnumerator.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestJoinEnumerator.java index 217a4dc12b3d0..bca5d1981377e 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestJoinEnumerator.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestJoinEnumerator.java @@ -19,6 +19,7 @@ import com.facebook.presto.cost.CachingStatsProvider; import com.facebook.presto.cost.CostComparator; import com.facebook.presto.cost.CostProvider; +import com.facebook.presto.cost.PlanNodeCostEstimate; import com.facebook.presto.cost.StatsProvider; import com.facebook.presto.sql.planner.PlanNodeIdAllocator; import com.facebook.presto.sql.planner.Symbol; @@ -39,7 +40,6 @@ import java.util.LinkedHashSet; import java.util.Optional; -import static com.facebook.presto.cost.PlanNodeCostEstimate.INFINITE_COST; import static com.facebook.presto.sql.planner.iterative.Lookup.noLookup; import static com.facebook.presto.sql.planner.iterative.rule.ReorderJoins.JoinEnumerator.generatePartitions; import static com.facebook.presto.sql.tree.BooleanLiteral.TRUE_LITERAL; @@ -102,7 +102,7 @@ public void testDoesNotCreateJoinWhenPartitionedOnCrossJoin() createContext()); JoinEnumerationResult actual = joinEnumerator.createJoinAccordingToPartitioning(multiJoinNode.getSources(), multiJoinNode.getOutputSymbols(), ImmutableSet.of(0)); assertFalse(actual.getPlanNode().isPresent()); - assertEquals(actual.getCost(), INFINITE_COST); + assertEquals(actual.getCost(), PlanNodeCostEstimate.infinite()); } private Rule.Context createContext() diff --git a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestReorderJoins.java b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestReorderJoins.java index e69b60c256c93..eb9c155060255 100644 --- a/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestReorderJoins.java +++ b/presto-main/src/test/java/com/facebook/presto/sql/planner/iterative/rule/TestReorderJoins.java @@ -309,7 +309,7 @@ public void testDoesNotFireWithNoStats() ImmutableList.of(new EquiJoinClause(p.symbol("A1"), p.symbol("B1"))), ImmutableList.of(p.symbol("A1")), Optional.empty())) - .overrideStats("valuesA", PlanNodeStatsEstimate.UNKNOWN_STATS) + .overrideStats("valuesA", PlanNodeStatsEstimate.unknown()) .doesNotFire(); } diff --git a/presto-tests/src/main/java/com/facebook/presto/tests/statistics/MetricComparator.java b/presto-tests/src/main/java/com/facebook/presto/tests/statistics/MetricComparator.java index f55da142e78a4..900165831a7ef 100644 --- a/presto-tests/src/main/java/com/facebook/presto/tests/statistics/MetricComparator.java +++ b/presto-tests/src/main/java/com/facebook/presto/tests/statistics/MetricComparator.java @@ -26,7 +26,6 @@ import java.util.List; import java.util.OptionalDouble; -import static com.facebook.presto.cost.PlanNodeStatsEstimate.UNKNOWN_STATS; import static com.facebook.presto.transaction.TransactionBuilder.transaction; import static com.google.common.collect.ImmutableList.toImmutableList; import static com.google.common.collect.Iterables.getOnlyElement; @@ -65,7 +64,7 @@ private static List getEstimatedValuesInternal(List metr { Plan queryPlan = runner.createPlan(session, query); OutputNode outputNode = (OutputNode) queryPlan.getRoot(); - PlanNodeStatsEstimate outputNodeStats = queryPlan.getStatsAndCosts().getStats().getOrDefault(queryPlan.getRoot().getId(), UNKNOWN_STATS); + PlanNodeStatsEstimate outputNodeStats = queryPlan.getStatsAndCosts().getStats().getOrDefault(queryPlan.getRoot().getId(), PlanNodeStatsEstimate.unknown()); StatsContext statsContext = buildStatsContext(queryPlan, outputNode); return getEstimatedValues(metrics, outputNodeStats, statsContext); }