/** * Utility method that checks whether all tasks succeeded from the output of {@link #executeAndGetResults()}. * @return true if all tasks succeeded. */ public static <T> boolean verifyAllSuccessful(List<Either<T, ExecutionException>> results) { return Iterables.all(results, new Predicate<Either<T, ExecutionException>>() { @Override public boolean apply(@Nullable Either<T, ExecutionException> input) { return input instanceof Either.Left; } }); }
/** * Returns {@code true} if every element in this fluent iterable satisfies the predicate. If this * fluent iterable is empty, {@code true} is returned. * * <p><b>{@code Stream} equivalent:</b> {@link Stream#allMatch} (same). */ public final boolean allMatch(Predicate<? super E> predicate) { return Iterables.all(getDelegate(), predicate); }
private static Predicate<Expression> symbolToExpressionPredicate(final Predicate<Symbol> symbolScope) { return expression -> Iterables.all(SymbolsExtractor.extractUnique(expression), symbolScope); }
/** * Returns {@code true} if every element in this fluent iterable satisfies the predicate. If this * fluent iterable is empty, {@code true} is returned. * * <p><b>{@code Stream} equivalent:</b> {@link Stream#allMatch} (same). */ public final boolean allMatch(Predicate<? super E> predicate) { return Iterables.all(getDelegate(), predicate); }
/** * Returns {@code true} if every element in this fluent iterable satisfies the predicate. If this * fluent iterable is empty, {@code true} is returned. * * <p><b>{@code Stream} equivalent:</b> {@link Stream#allMatch} (same). */ public final boolean allMatch(Predicate<? super E> predicate) { return Iterables.all(getDelegate(), predicate); }
/** * Given a {@link Multimap} of {@link Extract}s to {@link WorkUnitState}s, filter out any {@link Extract}s where all * of the corresponding {@link WorkUnitState}s do not meet the given {@link Predicate}. */ public static Multimap<Extract, WorkUnitState> getExtractsForPredicate( Multimap<Extract, WorkUnitState> extractToWorkUnitStateMap, Predicate<WorkUnitState> predicate) { Multimap<Extract, WorkUnitState> successfulExtracts = ArrayListMultimap.create(); for (Map.Entry<Extract, Collection<WorkUnitState>> entry : extractToWorkUnitStateMap.asMap().entrySet()) { if (Iterables.all(entry.getValue(), predicate)) { successfulExtracts.putAll(entry.getKey(), entry.getValue()); } } return successfulExtracts; }
private static Predicate<Expression> joinEqualityExpression(final Collection<Symbol> leftSymbols) { return expression -> { // At this point in time, our join predicates need to be deterministic if (isDeterministic(expression) && expression instanceof ComparisonExpression) { ComparisonExpression comparison = (ComparisonExpression) expression; if (comparison.getOperator() == ComparisonExpression.Operator.EQUAL) { Set<Symbol> symbols1 = SymbolsExtractor.extractUnique(comparison.getLeft()); Set<Symbol> symbols2 = SymbolsExtractor.extractUnique(comparison.getRight()); if (symbols1.isEmpty() || symbols2.isEmpty()) { return false; } return (Iterables.all(symbols1, in(leftSymbols)) && Iterables.all(symbols2, not(in(leftSymbols)))) || (Iterables.all(symbols2, in(leftSymbols)) && Iterables.all(symbols1, not(in(leftSymbols)))); } } return false; }; }
private static <T> void assertTaskWrapped(Collection<? extends Callable<T>> tasks) { Predicate<Object> p = Predicates.instanceOf(WrappedCallable.class); assertTrue(Iterables.all(tasks, p)); } }
/** * Given a {@link Multimap} of {@link Extract}s to {@link WorkUnitState}s, filter out any {@link Extract}s where all * of the corresponding {@link WorkUnitState}s do not meet the given {@link Predicate}. * <ul> * <li> The filtered {@link Extract}s will be available in {@link SplitExtractsResult#getFiltered()}</li> * <li> The {@link Extract}s satisfying the predicated will be available in {@link SplitExtractsResult#getRetained()}</li> * </ul> * */ public static SplitExtractsResult splitExtractsByPredicate( Multimap<Extract, WorkUnitState> extractToWorkUnitStateMap, Predicate<WorkUnitState> predicate) { Multimap<Extract, WorkUnitState> retained = ArrayListMultimap.create(); Multimap<Extract, WorkUnitState> filtered = ArrayListMultimap.create(); for (Map.Entry<Extract, Collection<WorkUnitState>> entry : extractToWorkUnitStateMap.asMap().entrySet()) { if (Iterables.all(entry.getValue(), predicate)) { retained.putAll(entry.getKey(), entry.getValue()); } else { filtered.putAll(entry.getKey(), entry.getValue()); } } return new SplitExtractsResult(retained, filtered); }
private static Predicate<Expression> matchesSymbolScope(final Predicate<Symbol> symbolScope) { return expression -> Iterables.all(SymbolsExtractor.extractUnique(expression), symbolScope); }
private static Optional<TableScanNode> findTableScan(PlanNode source) { while (true) { // allow any chain of linear transformations if (source instanceof MarkDistinctNode || source instanceof FilterNode || source instanceof LimitNode || source instanceof TopNNode || source instanceof SortNode) { source = source.getSources().get(0); } else if (source instanceof ProjectNode) { // verify projections are deterministic ProjectNode project = (ProjectNode) source; if (!Iterables.all(project.getAssignments().getExpressions(), DeterminismEvaluator::isDeterministic)) { return Optional.empty(); } source = project.getSource(); } else if (source instanceof TableScanNode) { return Optional.of((TableScanNode) source); } else { return Optional.empty(); } } } }
@Override public Ordering<Element> enclosedBy(Element element) { if (element instanceof ElementImpl && Iterables.all(element.getEnclosedElements(), Predicates.instanceOf(ElementImpl.class))) { ElementImpl implementation = (ElementImpl) element; if (implementation._binding instanceof SourceTypeBinding) { SourceTypeBinding sourceBinding = (SourceTypeBinding) implementation._binding; return Ordering.natural().onResultOf( Functions.compose(bindingsToSourceOrder(sourceBinding), this)); } } return DEFAULT_PROVIDER.enclosedBy(element); }
private static InnerJoinPushDownResult processInnerJoin(Expression inheritedPredicate, Expression leftEffectivePredicate, Expression rightEffectivePredicate, Expression joinPredicate, Collection<Symbol> leftSymbols) checkArgument(Iterables.all(SymbolsExtractor.extractUnique(leftEffectivePredicate), in(leftSymbols)), "leftEffectivePredicate must only contain symbols from leftSymbols"); checkArgument(Iterables.all(SymbolsExtractor.extractUnique(rightEffectivePredicate), not(in(leftSymbols))), "rightEffectivePredicate must not contain symbols from leftSymbols");
private static OuterJoinPushDownResult processLimitedOuterJoin(Expression inheritedPredicate, Expression outerEffectivePredicate, Expression innerEffectivePredicate, Expression joinPredicate, Collection<Symbol> outerSymbols) checkArgument(Iterables.all(SymbolsExtractor.extractUnique(outerEffectivePredicate), in(outerSymbols)), "outerEffectivePredicate must only contain symbols from outerSymbols"); checkArgument(Iterables.all(SymbolsExtractor.extractUnique(innerEffectivePredicate), not(in(outerSymbols))), "innerEffectivePredicate must not contain symbols from outerSymbols");
if (columnPositionsList.hasNextPosition() && !Iterables.all(positionsList, equalTo(0))) { throw new InvalidCheckpointException(format("Column %s, of type %s, contains %s offset positions, but only %s positions were consumed", column,
if (Iterables.all(arguments, instanceOf(ConstantExpression.class)) && function.isDeterministic()) { MethodHandle method = function.getMethodHandle();
ComparisonExpression equality = (ComparisonExpression) conjunct; boolean alignedComparison = Iterables.all(SymbolsExtractor.extractUnique(equality.getLeft()), in(node.getLeft().getOutputSymbols())); Expression leftExpression = (alignedComparison) ? equality.getLeft() : equality.getRight(); Expression rightExpression = (alignedComparison) ? equality.getRight() : equality.getLeft();
assertTrue(Iterables.all(equalityPartition.getScopeEqualities(), matchesSymbolScope(symbolBeginsWith("a", "b")))); assertTrue(Iterables.all(equalityPartition.getScopeEqualities(), EqualityInference.isInferenceCandidate())); assertTrue(Iterables.all(equalityPartition.getScopeComplementEqualities(), matchesSymbolScope(not(symbolBeginsWith("a", "b"))))); assertTrue(Iterables.all(equalityPartition.getScopeComplementEqualities(), EqualityInference.isInferenceCandidate())); assertTrue(Iterables.all(equalityPartition.getScopeStraddlingEqualities(), EqualityInference.isInferenceCandidate()));
assertTrue(Iterables.all(equalityPartition.getScopeEqualities(), matchesSymbolScope(matchesSymbols("c1")))); assertTrue(Iterables.all(equalityPartition.getScopeEqualities(), EqualityInference.isInferenceCandidate())); assertTrue(Iterables.all(equalityPartition.getScopeComplementEqualities(), matchesSymbolScope(not(matchesSymbols("c1"))))); assertTrue(Iterables.all(equalityPartition.getScopeComplementEqualities(), EqualityInference.isInferenceCandidate())); assertTrue(Iterables.all(equalityPartition.getScopeStraddlingEqualities(), EqualityInference.isInferenceCandidate()));