private byte[] getNextColumnRangeColumn(boolean completedCell, byte[] lastCol) { if (!completedCell) { return lastCol; } else { return RangeRequests.nextLexicographicName(lastCol); } }
private static boolean isForSingleRow(byte[] startInclusive, byte[] endExclusive) { if (startInclusive.length == 0 || endExclusive.length == 0) { return false; } return Arrays.equals(endExclusive, RangeRequests.nextLexicographicName(startInclusive)); }
private byte[] getNextRowName(byte[] lastRow) { if (isRangeDone(lastRow)) { return new byte[0]; } return RangeRequests.nextLexicographicName(lastRow); }
public static byte[] getNextStartRow(boolean reverse, @Nonnull byte[] rowName) { if (reverse) { return previousLexicographicName(rowName); } else { return nextLexicographicName(rowName); } }
private byte[] getNextRowName(byte[] lastRow) { if (isRangeDone(lastRow)) { return new byte[0]; } return RangeRequests.nextLexicographicName(lastRow); }
private boolean isEndOfColumnRange(byte[] lastCol, byte[] endCol) { return RangeRequests.isLastRowName(lastCol) || Arrays.equals(RangeRequests.nextLexicographicName(lastCol), endCol); }
@Override public boolean hasNext(byte[] lastToken) { if (RangeRequests.isLastRowName(lastToken)) { return false; } else { return !Arrays.equals(RangeRequests.nextLexicographicName(lastToken), columnRangeSelection.getEndCol()); } }
@Override protected List<CandidateRowForSweeping> computeNext() { List<CandidateRowForSweeping> batch = getCandidateCellsForSweepingBatch(); if (batch.isEmpty()) { return endOfData(); } nextStartRow = RangeRequests.nextLexicographicName( Iterables.getLast(batch).rowName()); return batch; }
private boolean isEndOfColumnRange(boolean completedCell, byte[] lastCol, int numRawResults, BatchColumnRangeSelection columnRangeSelection) { return (numRawResults < columnRangeSelection.getBatchHint()) || (completedCell && (RangeRequests.isLastRowName(lastCol) || Arrays.equals( RangeRequests.nextLexicographicName(lastCol), columnRangeSelection.getEndCol()))); }
public static <T> TokenBackedBasicResultsPage<RowResult<T>, byte[]> getRowResults( byte[] endExclusive, byte[] lastRow, SortedMap<byte[], SortedMap<byte[], T>> resultsByRow) { SortedMap<byte[], RowResult<T>> ret = RowResults.viewOfSortedMap(resultsByRow); if (lastRow == null || RangeRequests.isLastRowName(lastRow)) { return new SimpleTokenBackedResultsPage<>(endExclusive, ret.values(), false); } byte[] nextStart = RangeRequests.nextLexicographicName(lastRow); if (Arrays.equals(nextStart, endExclusive)) { return new SimpleTokenBackedResultsPage<>(endExclusive, ret.values(), false); } return new SimpleTokenBackedResultsPage<>(nextStart, ret.values(), true); }
@Override public ClosableIterator<Map.Entry<Cell, Value>> getBatch(int batchSize, @Nullable byte[] lastToken) { byte[] startCol = columnRangeSelection.getStartCol(); if (lastToken != null) { startCol = RangeRequests.nextLexicographicName(lastToken); } BatchColumnRangeSelection newRange = BatchColumnRangeSelection.create(startCol, columnRangeSelection.getEndCol(), batchSize); Map<byte[], RowColumnRangeIterator> range = keyValueService.getRowsColumnRange( tableRef, ImmutableList.of(row), newRange, timestamp); if (range.isEmpty()) { return ClosableIterators.wrap(ImmutableList.<Map.Entry<Cell, Value>>of().iterator()); } return ClosableIterators.wrap(Iterables.getOnlyElement(range.values())); }
private long visitInternal(Transaction tx, Visitor visitor, RangeRequest request, MutableRange range) { final AtomicLong numVisited = new AtomicLong(); boolean isEmpty = tx.getRange(tableRef, request).batchAccept(range.getBatchSize(), batch -> { visitor.visit(tx, batch); if (batch.size() < range.getBatchSize()) { range.setStartRow(null); } else { byte[] lastRow = batch.get(batch.size() - 1).getRowName(); range.setStartRow(RangeRequests.nextLexicographicName(lastRow)); } numVisited.set(batch.size()); return false; }); if (isEmpty) { range.setStartRow(null); } return numVisited.get(); }
private void assertNextPrevEqualsOrig(byte[] value) { Assert.assertTrue(Arrays.equals(value, RangeRequests.nextLexicographicName(RangeRequests.previousLexicographicName(value)))); Assert.assertTrue(Arrays.equals(value, RangeRequests.previousLexicographicName(RangeRequests.nextLexicographicName(value)))); } }
static RangeRequest metadataRangeRequestForTable(TableReference tableRef) { byte[] startRow = upperCaseTableReferenceToBytes(tableRef); byte[] endRow = lowerCaseTableReferenceToBytes(tableRef); return RangeRequest.builder() .startRowInclusive(startRow) .endRowExclusive(RangeRequests.nextLexicographicName(endRow)) .retainColumns(ImmutableSet.of(METADATA_COL)) .build(); }
private void verifyRowsDeletedFromSweepQueue(List<SweepableCellsRow> rows) { ArgumentCaptor<RangeRequest> captor = ArgumentCaptor.forClass(RangeRequest.class); verify(spiedKvs, atLeast(0)).deleteRange(eq(SWEEP_QUEUE_TABLE), captor.capture()); List<RangeRequest> expectedRangesToDelete = rows.stream() .map(row -> RangeRequest.builder() .startRowInclusive(row) .endRowExclusive(RangeRequests.nextLexicographicName(row.persistToBytes())) .build()) .collect(Collectors.toList()); assertThat(captor.getAllValues()).hasSameElementsAs(expectedRangesToDelete); }
private RangeRequest computeRangeRequestForRows(byte[] startRowInclusive, byte[] endRowInclusive) { return RangeRequest.builder() .startRowInclusive(startRowInclusive) .endRowExclusive(RangeRequests.nextLexicographicName(endRowInclusive)) .retainColumns(ColumnSelection.all()) .build(); }
@Test public void testDeleteRangeSingleRow() { // should delete row0 only setupTestRowsZeroOneAndTwoAndDeleteFrom(row(0), RangeRequests.nextLexicographicName(row(0))); checkThatTableIsNowOnly(row(1), row(2)); }
/** * Deletes the entire row of the Sweepable Timestamps table. * @param shardStrategy desired shard and strategy * @param partitionCoarse coarse partition for which the row should be deleted */ void deleteRow(ShardAndStrategy shardStrategy, long partitionCoarse) { byte[] rowBytes = computeRowBytes(shardStrategy, partitionCoarse); RangeRequest request = RangeRequest.builder() .startRowInclusive(rowBytes) .endRowExclusive(RangeRequests.nextLexicographicName(rowBytes)) .retainColumns(ColumnSelection.all()) .build(); deleteRange(request); } }
@Test public void testGetRangesPaging() { Transaction t = startTransaction(); byte[] row0Bytes = PtBytes.toBytes("row0"); byte[] row00Bytes = PtBytes.toBytes("row00"); byte[] colBytes = PtBytes.toBytes("col"); Cell k1 = Cell.create(row00Bytes, colBytes); byte[] row1Bytes = PtBytes.toBytes("row1"); Cell k2 = Cell.create(row1Bytes, colBytes); byte[] v = PtBytes.toBytes("v"); t.put(TEST_TABLE, ImmutableMap.of(Cell.create(row0Bytes, colBytes), v)); t.put(TEST_TABLE, ImmutableMap.of(k1, v)); t.put(TEST_TABLE, ImmutableMap.of(k2, v)); t.commit(); t = startTransaction(); t.delete(TEST_TABLE, ImmutableSet.of(k1)); t.commit(); t = startTransaction(); byte[] rangeEnd = RangeRequests.nextLexicographicName(row00Bytes); List<RangeRequest> ranges = ImmutableList.of(RangeRequest.builder().prefixRange(row0Bytes).endRowExclusive(rangeEnd).batchHint(1).build()); verifyAllGetRangesImplsNumRanges(t, ranges, ImmutableList.of("v")); }
@Test public void testGetRowColumnRangeCellBatchMultipleHistorical() { keyValueService.put(TEST_TABLE, ImmutableMap.of(Cell.create(row(1), column(0)), val(0, 5)), TEST_TIMESTAMP); keyValueService.put(TEST_TABLE, ImmutableMap.of(Cell.create(row(1), column(0)), val(0, 7)), TEST_TIMESTAMP + 1); keyValueService.put(TEST_TABLE, ImmutableMap.of(Cell.create(row(1), column(1)), val(0, 5)), TEST_TIMESTAMP); keyValueService.put(TEST_TABLE, ImmutableMap.of(Cell.create(row(1), column(1)), val(0, 7)), TEST_TIMESTAMP + 1); RowColumnRangeIterator values = keyValueService.getRowsColumnRange(TEST_TABLE, ImmutableList.of(row(1)), new ColumnRangeSelection(PtBytes.EMPTY_BYTE_ARRAY, RangeRequests.nextLexicographicName(column(1))), 2, TEST_TIMESTAMP + 1); assertNextElementMatches(values, Cell.create(row(1), column(0)), val(0, 5)); assertNextElementMatches(values, Cell.create(row(1), column(1)), val(0, 5)); assertFalse(values.hasNext()); }