public CachingStatsProvider(StatsCalculator statsCalculator, Session session, TypeProvider types) { this(statsCalculator, Optional.empty(), noLookup(), session, types); }
/** * Builds all (distinct) {@link JoinGraph}-es whole plan tree. */ public static List<JoinGraph> buildFrom(PlanNode plan) { return buildFrom(plan, Lookup.noLookup()); }
@Override public Lookup getLookup() { return noLookup(); }
public static boolean isAtMostScalar(PlanNode node) { return isAtMostScalar(node, noLookup()); }
public static List<Expression> extractExpressions(PlanNode plan) { return extractExpressions(plan, noLookup()); }
public static PlanNodeSearcher searchFrom(PlanNode node) { return searchFrom(node, noLookup()); }
public static Set<Symbol> extractOutputSymbols(PlanNode planNode) { return extractOutputSymbols(planNode, noLookup()); }
public static Range<Long> extractCardinality(PlanNode node) { return extractCardinality(node, noLookup()); }
public static boolean isScalar(PlanNode node) { return isScalar(node, noLookup()); }
public static List<Expression> extractExpressionsNonRecursive(PlanNode plan) { ImmutableList.Builder<Expression> expressionsBuilder = ImmutableList.builder(); plan.accept(new Visitor(false, noLookup()), expressionsBuilder); return expressionsBuilder.build(); }
public static void assertPlan(Session session, Metadata metadata, StatsCalculator statsCalculator, Plan actual, PlanMatchPattern pattern) { assertPlan(session, metadata, statsCalculator, actual, noLookup(), pattern); }
public StatsCalculatorAssertion check(Rule<?> rule, Consumer<PlanNodeStatsAssertion> statisticsAssertionConsumer) { Optional<PlanNodeStatsEstimate> statsEstimate = calculatedStats(rule, planNode, this::getSourceStats, noLookup(), session, types); checkState(statsEstimate.isPresent(), "Expected stats estimates to be present"); statisticsAssertionConsumer.accept(PlanNodeStatsAssertion.assertThat(statsEstimate.get())); return this; }
public StatsCalculatorAssertion check(Consumer<PlanNodeStatsAssertion> statisticsAssertionConsumer) { PlanNodeStatsEstimate statsEstimate = statsCalculator.calculateStats(planNode, this::getSourceStats, noLookup(), session, types); statisticsAssertionConsumer.accept(PlanNodeStatsAssertion.assertThat(statsEstimate)); return this; }
@Test(expectedExceptions = IllegalStateException.class) public void testDoesNotAllowOuterJoin() { PlanBuilder p = planBuilder(); Symbol a1 = p.symbol("A1"); Symbol b1 = p.symbol("B1"); JoinNode outerJoin = p.join( FULL, p.values(a1), p.values(b1), ImmutableList.of(equiJoinClause(a1, b1)), ImmutableList.of(a1, b1), Optional.empty()); toMultiJoinNode(outerJoin, noLookup(), DEFAULT_JOIN_LIMIT); }
@Test public void testDoesNotConvertNestedOuterJoins() { PlanBuilder p = planBuilder(); Symbol a1 = p.symbol("A1"); Symbol b1 = p.symbol("B1"); Symbol c1 = p.symbol("C1"); JoinNode leftJoin = p.join( LEFT, p.values(a1), p.values(b1), ImmutableList.of(equiJoinClause(a1, b1)), ImmutableList.of(a1, b1), Optional.empty()); ValuesNode valuesC = p.values(c1); JoinNode joinNode = p.join( INNER, leftJoin, valuesC, ImmutableList.of(equiJoinClause(a1, c1)), ImmutableList.of(a1, b1, c1), Optional.empty()); MultiJoinNode expected = MultiJoinNode.builder() .setSources(leftJoin, valuesC).setFilter(createEqualsExpression(a1, c1)) .setOutputSymbols(a1, b1, c1) .build(); assertEquals(toMultiJoinNode(joinNode, noLookup(), DEFAULT_JOIN_LIMIT), expected); }
.setOutputSymbols(a1, b1) .build(); assertEquals(toMultiJoinNode(joinNode, noLookup(), DEFAULT_JOIN_LIMIT), expected);
.setOutputSymbols(a1, b1, c1, d1, d2, e1, e2) .build(); assertEquals(toMultiJoinNode(joinNode, noLookup(), 2), expected);
.setOutputSymbols(a1, b1, c1, d1, d2, e1, e2) .build(); assertEquals(toMultiJoinNode(joinNode, noLookup(), 5), expected);
queryRunner.getStatsCalculator(), Optional.empty(), noLookup(), queryRunner.getDefaultSession(), symbolAllocator.getTypes());
and(new ComparisonExpression(EQUAL, b1.toSymbolReference(), c1.toSymbolReference()), new ComparisonExpression(EQUAL, a1.toSymbolReference(), b1.toSymbolReference()), bcFilter, abcFilter), ImmutableList.of(a1, b1, b2, c1, c2)); assertEquals(toMultiJoinNode(joinNode, noLookup(), DEFAULT_JOIN_LIMIT), expected);