private static Set<Set<String>> deepImmutableCopy(List<Set<String>> indexableKeys) { return indexableKeys.stream().map(ImmutableSet::copyOf).collect(toImmutableSet()); } }
private static Set<SymbolReference> getSymbolReferences(Collection<Symbol> symbols) { return symbols.stream().map(Symbol::toSymbolReference).collect(toImmutableSet()); } }
public static Set<Symbol> extractOutputSymbols(PlanNode planNode, Lookup lookup) { return searchFrom(planNode, lookup) .findAll() .stream() .flatMap(node -> node.getOutputSymbols().stream()) .collect(toImmutableSet()); }
@Override public ImmutableSet<BugCheckerInfo> getEnabledChecks() { return getAllChecks().values().stream() .filter(input -> !disabled.contains(input.canonicalName())) .collect(ImmutableSet.toImmutableSet()); }
@Override protected Optional<PlanNode> pushDownProjectOff(PlanNodeIdAllocator idAllocator, FilterNode filterNode, Set<Symbol> referencedOutputs) { Set<Symbol> prunedFilterInputs = Streams.concat( referencedOutputs.stream(), SymbolsExtractor.extractUnique(filterNode.getPredicate()).stream()) .collect(toImmutableSet()); return restrictChildOutputs(idAllocator, filterNode, prunedFilterInputs); } }
private Set<Symbol> canonicalize(Set<Symbol> symbols) { return symbols.stream() .map(this::canonicalize) .collect(toImmutableSet()); }
private Set<SymbolReference> getSymbolReferences(Collection<Symbol> symbols) { return symbols.stream().map(Symbol::toSymbolReference).collect(toImmutableSet()); }
private BugCheckerInfo(Class<? extends BugChecker> checker, BugPattern pattern) { this( checker, pattern.name(), ImmutableSet.<String>builder().add(pattern.name()).add(pattern.altNames()).build(), pattern.summary(), pattern.severity(), createLinkUrl(pattern), Stream.of(pattern.suppressionAnnotations()).anyMatch(a -> isSuppressWarnings(a)), Stream.of(pattern.suppressionAnnotations()) .filter(a -> !isSuppressWarnings(a)) .collect(toImmutableSet()), ImmutableSet.copyOf(pattern.tags()), pattern.disableable()); }
@Override public Result apply(AggregationNode aggregationNode, Captures captures, Context context) { Set<Symbol> requiredInputs = Streams.concat( aggregationNode.getGroupingKeys().stream(), aggregationNode.getHashSymbol().map(Stream::of).orElse(Stream.empty()), aggregationNode.getAggregations().values().stream() .flatMap(PruneAggregationSourceColumns::getAggregationInputs)) .collect(toImmutableSet()); return restrictChildOutputs(context.getIdAllocator(), aggregationNode, requiredInputs) .map(Result::ofPlanNode) .orElse(Result.empty()); }
public Set<Symbol> getColumns() { return arguments.stream() .filter(ArgumentBinding::isVariable) .map(ArgumentBinding::getColumn) .collect(toImmutableSet()); }
private static ImmutableSet<String> enabledCheckNames() { return StreamSupport.stream( Iterables.concat( ENABLED_ERRORS, ENABLED_WARNINGS) .spliterator(), false) .map(BugCheckerInfo::canonicalName) .collect(toImmutableSet()); }
private ProjectNode buildProjectedTopN(PlanBuilder planBuilder, Predicate<Symbol> projectionTopN) { Symbol a = planBuilder.symbol("a"); Symbol b = planBuilder.symbol("b"); return planBuilder.project( Assignments.identity(ImmutableList.of(a, b).stream().filter(projectionTopN).collect(toImmutableSet())), planBuilder.topN( COUNT, ImmutableList.of(b), planBuilder.values(a, b))); } }
@Test public void testAllRegistered() { Set<Type> allTypes = metadata.getTypeManager().getTypes().stream().collect(toImmutableSet()); for (Type valueType : allTypes) { assertNotNull(metadata.getFunctionRegistry().getAggregateFunctionImplementation(new Signature("arbitrary", AGGREGATE, valueType.getTypeSignature(), valueType.getTypeSignature()))); } }
public Set<String> getVariableNames() { return fragments.stream() .filter(NameFragment::isVariable) .map(NameFragment::getVariable) .collect(toImmutableSet()); }
public static Set<Expression> extract(Expression expression) { return AstUtils.preOrder(expression) .map(Expression.class::cast) .collect(ImmutableSet.toImmutableSet()); } }
private ProjectNode buildProjectedLimit(PlanBuilder planBuilder, Predicate<Symbol> projectionFilter) { Symbol a = planBuilder.symbol("a"); Symbol b = planBuilder.symbol("b"); return planBuilder.project( Assignments.identity(Stream.of(a, b).filter(projectionFilter).collect(toImmutableSet())), planBuilder.limit(1, planBuilder.values(a, b))); } }
private static Set<String> columnNames(Set<ColumnHandle> columns) { return columns.stream() .map(ThriftColumnHandle.class::cast) .map(ThriftColumnHandle::getColumnName) .collect(toImmutableSet()); }
private static Predicate<Symbol> matchesSymbols(Collection<String> symbols) { final Set<Symbol> symbolSet = symbols.stream() .map(Symbol::new) .collect(toImmutableSet()); return Predicates.in(symbolSet); }
private ProjectNode buildProjectedFilter(PlanBuilder planBuilder, Predicate<Symbol> projectionFilter) { Symbol a = planBuilder.symbol("a"); Symbol b = planBuilder.symbol("b"); return planBuilder.project( Assignments.identity(Stream.of(a, b).filter(projectionFilter).collect(toImmutableSet())), planBuilder.filter( planBuilder.expression("b > 5"), planBuilder.values(a, b))); } }
public BuildSymbolReferenceFinder(Set<Symbol> buildSymbols) { this.buildSymbols = requireNonNull(buildSymbols, "buildSymbols is null").stream() .map(Symbol::getName) .collect(toImmutableSet()); }