private static Optional<SymbolReference> asBuildSymbolReference(Set<Symbol> buildLayout, Expression expression) { // Currently only we support only symbol as sort expression on build side if (expression instanceof SymbolReference) { SymbolReference symbolReference = (SymbolReference) expression; if (buildLayout.contains(new Symbol(symbolReference.getName()))) { return Optional.of(symbolReference); } } return Optional.empty(); }
public static Symbol from(Expression expression) { checkArgument(expression instanceof SymbolReference, "Unexpected expression: %s", expression); return new Symbol(((SymbolReference) expression).getName()); }
private static Symbol symbol(String name) { return new Symbol(name); }
@Override public Expression rewriteSymbolReference(SymbolReference node, Context context, ExpressionTreeRewriter<Context> treeRewriter) { context.getReferencedSymbols().add(new Symbol(node.getName())); return null; } }
@Override protected Object visitIdentifier(Identifier node, Object context) { // Identifier only exists before planning. // ExpressionInterpreter should only be invoked after planning. // As a result, this method should be unreachable. // However, RelationPlanner.visitUnnest and visitValues invokes evaluateConstantExpression. return ((SymbolResolver) context).getValue(new Symbol(node.getValue())); }
protected void addSymbol(String name, Type type) { Symbol symbol = new Symbol(name); symbols.put(name, symbol); symbolTypes.put(symbol, type); sourceLayout.put(symbol, types.size()); types.add(type); }
public Symbol symbol(String name, Type type) { Symbol symbol = new Symbol(name); Type old = symbols.put(symbol, type); if (old != null && !old.equals(type)) { throw new IllegalArgumentException(format("Symbol '%s' already registered with type '%s'", name, old)); } if (old == null) { symbols.put(symbol, type); } return symbol; }
public PlanNodeStatsAssertion symbolStats(String symbolName, Consumer<SymbolStatsAssertion> symbolStatsAssertionConsumer) { return symbolStats(new Symbol(symbolName), symbolStatsAssertionConsumer); }
public PlanNodeStatsAssertion symbolStatsUnknown(String symbolName) { return symbolStatsUnknown(new Symbol(symbolName)); }
private PlanNode projectNode(PlanNode source, String symbol, Expression expression) { return new ProjectNode( idAllocator.getNextId(), source, Assignments.of(new Symbol(symbol), expression)); }
private PlanNode project(String id, PlanNode source, String symbol, Expression expression) { return new ProjectNode( new PlanNodeId(id), source, Assignments.of(new Symbol(symbol), expression)); }
private PlanNodeCostEstimate calculateCumulativeCost(PlanNode node, CostCalculator costCalculator, StatsCalculator statsCalculator, Map<String, Type> types) { TypeProvider typeProvider = TypeProvider.copyOf(types.entrySet().stream() .collect(ImmutableMap.toImmutableMap(entry -> new Symbol(entry.getKey()), Map.Entry::getValue))); StatsProvider statsProvider = new CachingStatsProvider(statsCalculator, session, typeProvider); CostProvider costProvider = new CachingCostProvider(costCalculator, statsProvider, Optional.empty(), session, typeProvider); return costProvider.getCumulativeCost(node); }
private static SymbolStatistics symbolStatistics(String symbolName, double low, double high, double nullsFraction, double ndv) { return new SymbolStatistics( new Symbol(symbolName), SymbolStatsEstimate.builder() .setLowValue(low) .setHighValue(high) .setNullsFraction(nullsFraction) .setDistinctValuesCount(ndv) .build()); }
private PlanNodeCostEstimate calculateCumulativeCostFragmentedPlan(PlanNode node, StatsCalculator statsCalculator, Map<String, Type> types) { TypeProvider typeProvider = TypeProvider.copyOf(types.entrySet().stream() .collect(ImmutableMap.toImmutableMap(entry -> new Symbol(entry.getKey()), Map.Entry::getValue))); 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(), PlanNodeCostEstimate.unknown()); }
@Test public void testIsNullFilter() { assertExpression("x IS NULL") .outputRowsCount(250.0) .symbolStats(new Symbol("x"), symbolStats -> symbolStats.distinctValuesCount(0) .emptyRange() .nullsFraction(1.0)); assertExpression("emptyRange IS NULL") .outputRowsCount(1000.0) .symbolStats(new Symbol("emptyRange"), SymbolStatsAssertion::empty); }
@Test public void testDoesNotFire() { Symbol symbol = new Symbol("x"); tester() .assertThat(new TransformUncorrelatedLateralToJoin()) .on(p -> p.lateral(ImmutableList.of(symbol), p.values(symbol), p.values())) .doesNotFire(); } }
@Test public void testStatsForEmptyValues() { tester().assertStatsFor(pb -> pb .values(ImmutableList.of(pb.symbol("a", BIGINT)), ImmutableList.of())) .check(outputStats -> outputStats.equalTo( PlanNodeStatsEstimate.builder() .setOutputRowCount(0) .addSymbolStatistics(new Symbol("a"), SymbolStatsEstimate.zero()) .build())); } }
private PlanNodeStatsEstimate xyStats(double lowX, double highX, double lowY, double highY) { return PlanNodeStatsEstimate.builder() .addSymbolStatistics(new Symbol("x"), SymbolStatsEstimate.builder() .setLowValue(lowX) .setHighValue(highX) .build()) .addSymbolStatistics(new Symbol("y"), SymbolStatsEstimate.builder() .setLowValue(lowY) .setHighValue(highY) .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 PlanFragment createTableScanPlanFragment(String name) { Symbol symbol = new Symbol("column"); PlanNode planNode = new TableScanNode( new PlanNodeId(name), new TableHandle(new ConnectorId("test"), new TestingTableHandle()), ImmutableList.of(symbol), ImmutableMap.of(symbol, new TestingColumnHandle("column"))); return createFragment(planNode); }