private PlanNodeCostEstimate calculateJoinCost(PlanNode join, PlanNode probe, PlanNode build, boolean replicated) { PlanNodeCostEstimate joinInputCost = calculateJoinInputCost( probe, build, stats, types, replicated, taskCountEstimator.estimateSourceDistributedTaskCount()); PlanNodeCostEstimate joinOutputCost = calculateJoinOutputCost(join); return joinInputCost.add(joinOutputCost); }
public Builder setStatisticsRange(StatisticRange range) { return setLowValue(range.getLow()) .setHighValue(range.getHigh()) .setDistinctValuesCount(range.getDistinctValuesCount()); }
private static SymbolStatsEstimate nullStatsEstimate() { return SymbolStatsEstimate.builder() .setDistinctValuesCount(0) .setNullsFraction(1) .build(); } }
public SymbolStatsAssertion isEqualTo(SymbolStatsEstimate expected) { return nullsFraction(expected.getNullsFraction()) .lowValue(expected.getLowValue()) .highValue(expected.getHighValue()) .distinctValuesCount(expected.getDistinctValuesCount()) .averageRowSize(expected.getAverageRowSize()); } }
private static PlanNodeStatsEstimate statistics(double rowCount, double nullsFraction, double averageRowSize, StatisticRange range) { return PlanNodeStatsEstimate.builder() .setOutputRowCount(rowCount) .addSymbolStatistics(SYMBOL, SymbolStatsEstimate.builder() .setNullsFraction(nullsFraction) .setAverageRowSize(averageRowSize) .setStatisticsRange(range) .build()) .build(); }
@Test public void testNoCapping() { Symbol a = new Symbol("a"); PlanNodeStatsEstimate estimate = PlanNodeStatsEstimate.builder() .setOutputRowCount(30) .addSymbolStatistics(a, SymbolStatsEstimate.builder().setDistinctValuesCount(20).build()) .build(); assertNormalized(estimate) .symbolStats(a, symbolAssert -> symbolAssert.distinctValuesCount(20)); }
private static void assertSubtractRange(double supersetLow, double supersetHigh, double subsetLow, double subsetHigh, double expectedLow, double expectedHigh) { PlanNodeStatsEstimate first = statistics(30, NaN, NaN, new StatisticRange(supersetLow, supersetHigh, 10)); PlanNodeStatsEstimate second = statistics(20, NaN, NaN, new StatisticRange(subsetLow, subsetHigh, 5)); SymbolStatsEstimate statistics = subtractSubsetStats(first, second).getSymbolStatistics(SYMBOL); assertEquals(statistics.getLowValue(), expectedLow); assertEquals(statistics.getHighValue(), expectedHigh); }
public static StatisticRange from(SymbolStatsEstimate estimate) { return new StatisticRange(estimate.getLowValue(), estimate.getHighValue(), estimate.getDistinctValuesCount()); }
private static PlanNodeStatsEstimate planNodeStats(double rowCount, SymbolStatistics... symbolStatistics) { PlanNodeStatsEstimate.Builder builder = PlanNodeStatsEstimate.builder() .setOutputRowCount(rowCount); for (SymbolStatistics symbolStatistic : symbolStatistics) { builder.addSymbolStatistics(symbolStatistic.symbol, symbolStatistic.estimate); } return builder.build(); }
private PlanNodeStatsAssertion assertNormalized(PlanNodeStatsEstimate estimate, TypeProvider types) { PlanNodeStatsEstimate normalized = normalizer.normalize(estimate, estimate.getSymbolsWithKnownStatistics(), types); return PlanNodeStatsAssertion.assertThat(normalized); }
public PlanNodeStatsAssertion symbolStatsUnknown(Symbol symbol) { return symbolStats(symbol, columnStats -> columnStats .lowValueUnknown() .highValueUnknown() .nullsFractionUnknown() .distinctValuesCountUnknown()); }
public PlanNodeStatsAssertion outputRowsCount(double expected) { assertEstimateEquals(actual.getOutputRowCount(), expected, "outputRowsCount mismatch"); return this; }
public SymbolStatsAssertion nullsFraction(double expected) { assertEstimateEquals(statistics.getNullsFraction(), expected, "nullsFraction mismatch"); return this; }
public SymbolStatsAssertion highValue(double expected) { assertEstimateEquals(statistics.getHighValue(), expected, "highValue mismatch"); return this; }
public SymbolStatsAssertion lowValue(double expected) { assertEstimateEquals(statistics.getLowValue(), expected, "lowValue mismatch"); return this; }
public SymbolStatsAssertion distinctValuesCount(double expected) { assertEstimateEquals(statistics.getDistinctValuesCount(), expected, "distinctValuesCount mismatch"); return this; }
public PlanNodeStatsEstimate filterStats( PlanNodeStatsEstimate statsEstimate, Expression predicate, Session session, TypeProvider types) { Expression simplifiedExpression = simplifyExpression(session, predicate, types); return new FilterExpressionStatsCalculatingVisitor(statsEstimate, session, types) .process(simplifiedExpression); }
private static void assertOverlap(StatisticRange a, StatisticRange b, double expected) { assertEstimateEquals(a.overlapPercentWith(b), expected, "overlapPercentWith"); } }
private PlanNodeStatsAssertion assertExpression(Expression expression) { return PlanNodeStatsAssertion.assertThat(statsCalculator.filterStats( standardInputStatistics, expression, session, standardTypes)); } }
public SymbolStatsAssertion averageRowSize(double expected) { assertEstimateEquals(statistics.getAverageRowSize(), expected, "average row size mismatch"); return this; }