public static List<DimFilter> filterNulls(List<DimFilter> optimized) { return Lists.newArrayList(Iterables.filter(optimized, Predicates.notNull())); } }
public void testTryFind() { Iterable<String> list = newArrayList("cool", "pants"); assertThat(Iterables.tryFind(list, Predicates.equalTo("cool"))).hasValue("cool"); assertThat(Iterables.tryFind(list, Predicates.equalTo("pants"))).hasValue("pants"); assertThat(Iterables.tryFind(list, Predicates.alwaysTrue())).hasValue("cool"); assertThat(Iterables.tryFind(list, Predicates.alwaysFalse())).isAbsent(); assertCanIterateAgain(list); }
@Override public String toString() { return MoreObjects.toStringHelper(ServiceManager.class) .add("services", Collections2.filter(services, not(instanceOf(NoOpService.class)))) .toString(); }
@Override public boolean retainAll(Collection<?> c) { return Iterables.removeIf( multimap.unfiltered().entries(), // explicit <Entry<K, V>> is required to build with JDK6 Predicates.<Entry<K, V>>and( multimap.entryPredicate(), Maps.<V>valuePredicateOnEntries(Predicates.not(Predicates.in(c))))); }
private void logIt(String format) { if (t == null) { error(format, description, dataMap); } else { // Filter out the stack trace from the message, because it should be in the logline already if it's wanted. error( t, format, description, Maps.filterKeys(dataMap, Predicates.not(Predicates.equalTo("exceptionStackTrace"))) ); } } }
@Test public void defensive_test_all_values_of_migration_Status_must_be_supported() throws Exception { for (Status status : filter(Arrays.asList(DatabaseMigrationState.Status.values()), not(in(ImmutableList.of(NONE, RUNNING, FAILED, SUCCEEDED))))) { when(migrationState.getStatus()).thenReturn(status); underTest.handle(request, response); } }
Set<String> hiddenColumns = ImmutableSet.of(); if (comment != null && comment.startsWith(PRESTO_COMMENT_METADATA)) { String columnOrderingString = comment.substring(PRESTO_COMMENT_METADATA.length()); List<String> explicitColumnOrder = new ArrayList<>(ImmutableList.copyOf(transform(extras, ExtraColumnMetadata::getName))); hiddenColumns = ImmutableSet.copyOf(transform(filter(extras, ExtraColumnMetadata::isHidden), ExtraColumnMetadata::getName)); Iterables.addAll(explicitColumnOrder, filter(columnNames, not(in(explicitColumnOrder)))); ImmutableList.Builder<CassandraColumnHandle> columnHandles = ImmutableList.builder(); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, true, false, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, false, true, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); boolean hidden = hiddenColumns.contains(columnMeta.getName()); CassandraColumnHandle columnHandle = buildColumnHandle(tableMeta, columnMeta, false, false, columnNames.indexOf(columnMeta.getName()), hidden); columnHandles.add(columnHandle); List<CassandraColumnHandle> sortedColumnHandles = columnHandles.build().stream() .sorted(comparing(CassandraColumnHandle::getOrdinalPosition)) .collect(toList());
@Test public void testInnerJoinWithFalseFilter() { Map<Symbol, ColumnHandle> leftAssignments = Maps.filterKeys(scanAssignments, Predicates.in(ImmutableList.of(A, B, C))); TableScanNode leftScan = tableScanNode(leftAssignments); Map<Symbol, ColumnHandle> rightAssignments = Maps.filterKeys(scanAssignments, Predicates.in(ImmutableList.of(D, E, F))); TableScanNode rightScan = tableScanNode(rightAssignments); PlanNode node = new JoinNode(newId(), JoinNode.Type.INNER, leftScan, rightScan, ImmutableList.of(new JoinNode.EquiJoinClause(A, D)), ImmutableList.<Symbol>builder() .addAll(leftScan.getOutputSymbols()) .addAll(rightScan.getOutputSymbols()) .build(), Optional.of(FALSE_LITERAL), Optional.empty(), Optional.empty(), Optional.empty()); Expression effectivePredicate = effectivePredicateExtractor.extract(node); assertEquals(effectivePredicate, FALSE_LITERAL); }
splitToList(state.getProp(WikipediaExtractor.SOURCE_PAGE_TITLES))); Map<String, LongWatermark> prevHighWatermarks = Maps.newHashMap(); for (Map.Entry<String, Iterable<WorkUnitState>> entry : previousWorkUnits.entrySet()) { Iterable<LongWatermark> watermarks = Iterables.transform(entry.getValue(), new Function<WorkUnitState, LongWatermark>() { @Override public LongWatermark apply(WorkUnitState wus) { watermarks = Iterables.filter(watermarks, Predicates.notNull()); List<LongWatermark> watermarkList = Lists.newArrayList(watermarks); if (watermarkList.size() > 0) { prevHighWatermarks.put(entry.getKey(), Collections.max(watermarkList)); List<WorkUnit> workUnits = Lists.newArrayList();
public void testTryFind_alwaysTrue() { Iterable<String> list = Lists.newArrayList("cool", "pants"); Iterator<String> iterator = list.iterator(); assertThat(Iterators.tryFind(iterator, Predicates.alwaysTrue())).hasValue("cool"); }
static <T> Set<T> filter(final Iterable<T> elements, Predicate<? super T>... predicates) { return isEmpty(predicates) ? Sets.newHashSet(elements) : Sets.newHashSet(Iterables.filter(elements, Predicates.and(predicates))); }
public void testIndexOf_twoElements() { List<String> list = Lists.newArrayList("mary", "bob"); assertEquals(0, Iterables.indexOf(list, Predicates.equalTo("mary"))); assertEquals(1, Iterables.indexOf(list, Predicates.equalTo("bob"))); assertEquals(-1, Iterables.indexOf(list, Predicates.equalTo("jack"))); }
testColumns = ImmutableList.copyOf(filter(testColumns, not(TestColumn::isPartitionKey))); tableProperties.setProperty("columns", Joiner.on(',').join(transform(testColumns, TestColumn::getName))); tableProperties.setProperty("columns.types", Joiner.on(',').join(transform(testColumns, TestColumn::getType))); serDe.initialize(CONFIGURATION, tableProperties); ImmutableList.copyOf(transform(testColumns, TestColumn::getName)), ImmutableList.copyOf(transform(testColumns, TestColumn::getObjectInspector)));
public void testOr_listDefensivelyCopied() { List<Predicate<Object>> list = newArrayList(); Predicate<Object> predicate = Predicates.or(list); assertFalse(predicate.apply(1)); list.add(Predicates.alwaysTrue()); assertFalse(predicate.apply(1)); }
@BeforeMethod public void setUp() { scanAssignments = ImmutableMap.<Symbol, ColumnHandle>builder() .put(A, new TestingColumnHandle("a")) .put(B, new TestingColumnHandle("b")) .put(C, new TestingColumnHandle("c")) .put(D, new TestingColumnHandle("d")) .put(E, new TestingColumnHandle("e")) .put(F, new TestingColumnHandle("f")) .build(); Map<Symbol, ColumnHandle> assignments = Maps.filterKeys(scanAssignments, Predicates.in(ImmutableList.of(A, B, C, D, E, F))); baseTableScan = new TableScanNode( newId(), DUAL_TABLE_HANDLE, ImmutableList.copyOf(assignments.keySet()), assignments); expressionNormalizer = new ExpressionIdentityNormalizer(); }
public void testAny() { List<String> list = newArrayList(); Predicate<String> predicate = Predicates.equalTo("pants"); assertFalse(Iterables.any(list, predicate)); list.add("cool"); assertFalse(Iterables.any(list, predicate)); list.add("pants"); assertTrue(Iterables.any(list, predicate)); }
public void testAnd_listDefensivelyCopied() { List<Predicate<Object>> list = newArrayList(); Predicate<Object> predicate = Predicates.and(list); assertTrue(predicate.apply(1)); list.add(Predicates.alwaysFalse()); assertTrue(predicate.apply(1)); }
splitProperties.setProperty(FILE_INPUT_FORMAT, storageFormat.getInputFormat()); splitProperties.setProperty(SERIALIZATION_LIB, storageFormat.getSerDe()); splitProperties.setProperty("columns", Joiner.on(',').join(transform(filter(testColumns, not(TestColumn::isPartitionKey)), TestColumn::getName))); splitProperties.setProperty("columns.types", Joiner.on(',').join(transform(filter(testColumns, not(TestColumn::isPartitionKey)), TestColumn::getType))); configuration.set("io.compression.codecs", LzoCodec.class.getName() + "," + LzopCodec.class.getName()); Optional<ConnectorPageSource> pageSource = HivePageSourceProvider.createHivePageSource( ImmutableSet.of(cursorProvider), ImmutableSet.of(), configuration, session,
.on(p -> buildProjectedWindow(p, symbol -> symbol.getName().equals("output2") || symbol.getName().equals("unused"), alwaysTrue())) .matches( strictProject( "unused", expression("unused")), window(windowBuilder -> windowBuilder .prePartitionedInputs(ImmutableSet.of()) .specification( ImmutableList.of("partitionKey"), ImmutableList.of("orderKey"), ImmutableMap.of("orderKey", SortOrder.ASC_NULLS_FIRST)) .preSortedOrderPrefix(0) .addFunction( "output2", functionCall("min", ImmutableList.of("input2")), signature, frameProvider2) .hashSymbol("hash"), strictProject( Maps.asMap( Sets.difference(inputSymbolNameSet, ImmutableSet.of("input1", "startValue1", "endValue1")), PlanMatchPattern::expression), values(inputSymbolNameList)))));