@Override public BatchingVisitable<SweepPriorityRowResult> apply(BatchingVisitable<RowResult<byte[]>> visitable) { return BatchingVisitables.transform(visitable, new Function<RowResult<byte[]>, SweepPriorityRowResult>() { @Override public SweepPriorityRowResult apply(RowResult<byte[]> row) { return SweepPriorityRowResult.of(row); } }); } });
public static <T> BatchingVisitableView<T> concat(BatchingVisitable<? extends T>... inputs) { return concat(ImmutableList.copyOf(inputs)); }
protected void verifyMatchingResult(List<Map.Entry<Cell, byte[]>> expected, byte[] row, Map<byte[], BatchingVisitable<Map.Entry<Cell, byte[]>>> columnRange) { assertEquals(1, columnRange.size()); assertArrayEquals(row, Iterables.getOnlyElement(columnRange.keySet())); BatchingVisitable<Map.Entry<Cell, byte[]>> batchingVisitable = Iterables.getOnlyElement(columnRange.values()); List<Map.Entry<Cell, byte[]>> results = BatchingVisitables.copyToList(batchingVisitable); assertEquals(expected.size(), results.size()); for (int i = 0 ; i < expected.size() ; i++) { assertEquals(expected.get(i).getKey(), results.get(i).getKey()); assertArrayEquals(expected.get(i).getValue(), results.get(i).getValue()); } }
@Test public void testEmpty() { assertTrue("empty batching visitable should be empty!", BatchingVisitables.isEmpty(BatchingVisitables.emptyBatchingVisitable())); assertEquals("empty batching visitable should be empty!", 0, BatchingVisitables.count(BatchingVisitables.emptyBatchingVisitable())); BatchingVisitable<Long> bv = ListVisitor.create(Lists.newArrayList(0L, 1L, 2L, 3L)); assertFalse("non-empty batching visitable should not be empty!", BatchingVisitables.isEmpty(bv)); assertEquals("visitable had wrong size", 4, BatchingVisitables.count(bv)); assertTrue("empty visitable should always be true, even when told to visit an always-false place", BatchingVisitables.emptyBatchingVisitable().batchAccept(1, AbortingVisitors.alwaysFalse())); }
/** * @return the first element or null if the visitable is empty */ @Nullable public static <T> T getFirst(BatchingVisitable<T> visitable) { return getFirst(visitable, null); }
Preconditions.checkArgument(limit >= 0); if (limit == 0) { return emptyBatchingVisitable();
public BatchingVisitableView<T> limit(long limit) { return BatchingVisitables.limit(delegate(), limit); }
public BatchingVisitableView<T> visitWhile(Predicate<T> condition) { return BatchingVisitables.visitWhile(delegate(), condition); }
/** * Gets the first element in the visitable. * * @return the first element or <code>null</code> if the visitable is empty */ @Nullable public T getFirst() { return BatchingVisitables.getFirst(delegate()); }
@Override public BatchingVisitable<RowResult<byte[]>> getRange(final TableReference tableRef, final RangeRequest range) { checkGetPreconditions(tableRef); if (range.isEmptyRange()) { return BatchingVisitables.emptyBatchingVisitable(); } hasReads = true; return new AbstractBatchingVisitable<RowResult<byte[]>>() { @Override public <K extends Exception> void batchAcceptSizeHint( int userRequestedSize, ConsistentVisitor<RowResult<byte[]>, K> visitor) throws K { ensureUncommitted(); int requestSize = range.getBatchHint() != null ? range.getBatchHint() : userRequestedSize; int preFilterBatchSize = getRequestHintToKvStore(requestSize); Validate.isTrue(!range.isReverse(), "we currently do not support reverse ranges"); getBatchingVisitableFromIterator( tableRef, range, requestSize, visitor, preFilterBatchSize); } }; }
@Override public RangeToken getRange(TransactionToken token, final TableRange range) { return runReadOnly(token, transaction -> { int limit = range.getBatchSize() + 1; RangeRequest request = RangeRequest.builder() .startRowInclusive(range.getStartRow()) .endRowExclusive(range.getEndRow()) .batchHint(limit) .retainColumns(range.getColumns()) .build(); BatchingVisitable<RowResult<byte[]>> visitable = transaction.getRange(getTableRef(range.getTableName()), request); List<RowResult<byte[]>> results = BatchingVisitables.limit(visitable, limit).immutableCopy(); if (results.size() == limit) { TableRowResult data = new TableRowResult(range.getTableName(), results.subList(0, limit - 1)); RowResult<byte[]> lastResultInBatch = results.get(limit - 1); TableRange nextRange = range.withStartRow(lastResultInBatch.getRowName()); return new RangeToken(data, nextRange); } else { TableRowResult data = new TableRowResult(range.getTableName(), results); return new RangeToken(data, null); } }); }
toRemove = BatchingVisitables.visitWhile( tx.getRange(minusTable, request), lessThan(lastRow)).immutableCopy(); } else {
@Override public BatchingVisitable<KvRowsRowResult> apply(BatchingVisitable<RowResult<byte[]>> visitable) { return BatchingVisitables.transform(visitable, new Function<RowResult<byte[]>, KvRowsRowResult>() { @Override public KvRowsRowResult apply(RowResult<byte[]> row) { return KvRowsRowResult.of(row); } }); } });
public BatchingVisitableView<T> concat(BatchingVisitable<? extends T>... inputs) { return BatchingVisitables.concat(Lists.asList(delegate(), inputs)); }
private void verifyAllGetRangesImplsRangeSizes(Transaction t, RangeRequest templateRangeRequest, int expectedRangeSize) { Iterable<RangeRequest> rangeRequests = Iterables.limit(Iterables.cycle(templateRangeRequest), 1000); List<BatchingVisitable<RowResult<byte[]>>> getRangesWithPrefetchingImpl = ImmutableList.copyOf( t.getRanges(TEST_TABLE, rangeRequests)); List<BatchingVisitable<RowResult<byte[]>>> getRangesInParallelImpl = t.getRanges(TEST_TABLE, rangeRequests, 2, (rangeRequest, visitable) -> visitable).collect(Collectors.toList()); List<BatchingVisitable<RowResult<byte[]>>> getRangesLazyImpl = t.getRangesLazy(TEST_TABLE, rangeRequests).collect(Collectors.toList()); assertEquals(getRangesWithPrefetchingImpl.size(), getRangesLazyImpl.size()); assertEquals(getRangesLazyImpl.size(), getRangesInParallelImpl.size()); for (int i = 0; i < getRangesWithPrefetchingImpl.size(); i++) { assertEquals(expectedRangeSize, BatchingVisitables.copyToList(getRangesWithPrefetchingImpl.get(i)).size()); assertEquals(expectedRangeSize, BatchingVisitables.copyToList(getRangesInParallelImpl.get(i)).size()); assertEquals(expectedRangeSize, BatchingVisitables.copyToList(getRangesLazyImpl.get(i)).size()); } }
/** * Gets the first element in the visitable. * * If a default value of <code>null</code> is wanted, then consider * calling {@link BatchingVisitableView#getFirst()} instead. * * @return the first element or <code>defaultElement</code> if the visitable is empty */ @Nullable public T getFirst(@Nullable T defaultElement) { return BatchingVisitables.getFirst(delegate(), defaultElement); }
@Test public void testAnyAndAllForEmptyLists() { BatchingVisitable<Long> visitor = BatchingVisitables.emptyBatchingVisitable(); BatchingVisitableView<Long> bv = BatchingVisitableView.of(visitor); assertFalse("any(empty-set-of-trues) should be false", bv.any(Predicates.alwaysTrue())); assertTrue("all(empty-set-of-trues) should be true", bv.all(Predicates.alwaysTrue())); assertFalse("any(empty-set-of-falses) should be false", bv.any(Predicates.alwaysFalse())); assertTrue("all(empty-set-of-falses) should be true", bv.all(Predicates.alwaysFalse())); }
public BatchingVisitableView<T> limit(long limit) { return BatchingVisitables.limit(delegate(), limit); }
@Test public void testVisitWhile() { List<Long> longList = Lists.newArrayList(0L, 1L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 9L); BatchingVisitable<Long> visitable = ListVisitor.create(longList); BatchingVisitableView<Long> view = BatchingVisitables.visitWhile( BatchingVisitableView.of(visitable), (input) -> input.longValue() < 5L); assertEquals("visitWhile visited the wrong number of elements", 5L, view.size()); assertEquals("visitWhile visited the wrong element first", 0L, view.getFirst().longValue()); assertEquals("visitWhile visited the wrong element last", 4L, view.getLast().longValue()); assertTrue("visitWhile visited the wrong elements", view.immutableCopy().containsAll(ImmutableSet.of(0L, 1L, 2L, 3L, 4L))); visitable = ListVisitor.create(Lists.reverse(longList)); view = BatchingVisitables.visitWhile( BatchingVisitableView.of(visitable), (input) -> input.longValue() >= 5L); assertEquals("visitWhile visited the wrong number of elements", 5L, view.size()); assertEquals("visitWhile visited the wrong element first", 9L, view.getFirst().longValue()); assertEquals("visitWhile visited the wrong element last", 5L, view.getLast().longValue()); assertTrue("visitWhile visited the wrong elements", view.immutableCopy().containsAll(ImmutableSet.of(5L, 6L, 7L, 8L, 9L))); }
public <T> Stream<T> getRanges(Iterable<RangeRequest> ranges, int concurrencyLevel, BiFunction<RangeRequest, BatchingVisitable<KeyValueRowResult>, T> visitableProcessor) { return t.getRanges(tableRef, ranges, concurrencyLevel, (rangeRequest, visitable) -> visitableProcessor.apply(rangeRequest, BatchingVisitables.transform(visitable, KeyValueRowResult::of))); }