@VisibleForTesting Set<LockEntry> allLockEntries() { Set<RowResult<Value>> results = ImmutableSet.copyOf(keyValueService.getRange( AtlasDbConstants.PERSISTED_LOCKS_TABLE, RangeRequest.all(), AtlasDbConstants.TRANSACTION_TS + 1)); return results.stream().map(LockEntry::fromRowResult).collect(Collectors.toSet()); }
private Set<Cell> getAllCells(TableReference tableRef) { try (ClosableIterator<RowResult<Value>> iterator = kvs.get() .getRange(tableRef, RangeRequest.all(), Long.MAX_VALUE)) { return iterator.stream() .map(RowResult::getCells) .flatMap(Streams::stream) .map(Map.Entry::getKey) .collect(Collectors.toSet()); } }
@Override public void deleteAllRowsInTables(Set<TableReference> tables) { execute(tables, filtered -> filtered.forEach(table -> kvs.deleteRange(table, RangeRequest.all()))); }
public List<Todo> getTodoList() { ImmutableList<RowResult<byte[]>> results = transactionManager.runTaskWithRetry((transaction) -> { BatchingVisitable<RowResult<byte[]>> rowResultBatchingVisitable = transaction.getRange( TodoSchema.todoTable(), RangeRequest.all()); ImmutableList.Builder<RowResult<byte[]>> rowResults = ImmutableList.builder(); rowResultBatchingVisitable.batchAccept(1000, items -> { rowResults.addAll(items); return true; }); return rowResults.build(); }); return results.stream() .map(RowResult::getOnlyColumnValue) .map(ValueType.STRING::convertToString) .map(ImmutableTodo::of) .collect(Collectors.toList()); }
private void checkThatTableIsNowOnly(byte[]... rows) { List<byte[]> keys = Lists.newArrayList(); keyValueService.getRange(TEST_TABLE, RangeRequest.all(), AtlasDbConstants.MAX_TS) .forEachRemaining(row -> keys.add(row.getRowName())); assertTrue(Arrays.deepEquals(keys.toArray(), rows)); }
void verifyTableSwept(TableReference tableRef, int expectedCells, boolean conservative) { try (ClosableIterator<RowResult<Set<Long>>> iter = kvs.getRangeOfTimestamps(tableRef, RangeRequest.all(), Long.MAX_VALUE)) { int numCells = 0; while (iter.hasNext()) { RowResult<Set<Long>> rr = iter.next(); numCells += rr.getColumns().size(); Assert.assertTrue(String.format("Found unswept values in %s!", tableRef.getQualifiedName()), rr.getColumns().values().stream() .allMatch(s -> s.size() == 1 || (conservative && s.size() == 2 && s.contains(-1L)))); } Assert.assertEquals(expectedCells, numCells); } }
@Override public void deleteRange(TableReference table, RangeRequest range) { if (range.equals(RangeRequest.all())) { tableClearer.deleteAllRowsInTables(table); } else { super.deleteRange(table, range); } } }
@Test(expected = RuntimeException.class) public void testGetRangeOfTimestampsThrowsOnError() { keyValueService.getRangeOfTimestamps(TEST_NONEXISTING_TABLE, RangeRequest.all(), AtlasDbConstants.MAX_TS) .hasNext(); }
private Object doDeleteRange(ConsecutiveNarrowTable table, int numBatches) { Iterable<RangeRequest> rangeRequests = numBatches == 1 ? ImmutableList.of(RangeRequest.all()) : table.getRangeRequests(1, table.getNumRows() / numBatches, true); rangeRequests.forEach(rangeRequest -> table.getKvs().deleteRange(table.getTableRef(), rangeRequest)); return rangeRequests; }
@Test public void testGetRangeThrowsOnError() { try { keyValueService.getRange(TEST_NONEXISTING_TABLE, RangeRequest.all(), AtlasDbConstants.MAX_TS).hasNext(); Assert.fail("getRange must throw on failure"); } catch (RuntimeException e) { // Expected } }
@Test public void testDeleteMultipleVersions() { putTestDataForMultipleTimestamps(); ClosableIterator<RowResult<Value>> result = keyValueService.getRange( TEST_TABLE, RangeRequest.all(), TEST_TIMESTAMP + 1); assertTrue(result.hasNext()); keyValueService.delete(TEST_TABLE, ImmutableMultimap.of(TEST_CELL, TEST_TIMESTAMP)); result = keyValueService.getRange(TEST_TABLE, RangeRequest.all(), TEST_TIMESTAMP + 1); assertFalse(result.hasNext()); result = keyValueService.getRange(TEST_TABLE, RangeRequest.all(), TEST_TIMESTAMP + 2); assertTrue(result.hasNext()); }
@Override public void deleteRange(TableReference tableRef, RangeRequest range) { delegate().deleteRange(tableRef, range); if (RangeRequest.all().equals(range)) { // This is equivalent to truncate. recordClear(tableRef); } }
@Test public void testDeleteRangeAll() { putTestDataForRowsZeroOneAndTwo(); keyValueService.deleteRange(TEST_TABLE, RangeRequest.all()); checkThatTableIsNowOnly(); }
private void verifyCheckAndSet(Cell key, byte[] expectedValue) { Multimap<Cell, Long> timestamps = keyValueService.getAllTimestamps(TEST_TABLE, ImmutableSet.of(key), 1L); assertEquals(1, timestamps.size()); assertTrue(timestamps.containsEntry(key, AtlasDbConstants.TRANSACTION_TS)); ClosableIterator<RowResult<Value>> result = keyValueService.getRange(TEST_TABLE, RangeRequest.all(), AtlasDbConstants.TRANSACTION_TS + 1); // Check result is right byte[] actual = result.next().getColumns().get(key.getColumnName()).getContents(); assertArrayEquals(String.format("Value \"%s\" different from expected \"%s\"", new String(actual, StandardCharsets.UTF_8), new String(expectedValue, StandardCharsets.UTF_8)), expectedValue, actual); // Check no more results assertFalse(result.hasNext()); }
private byte[] getOnlyItemInTableRange() { try (ClosableIterator<RowResult<Value>> rangeIterator = keyValueService.getRange(TEST_TABLE, RangeRequest.all(), TEST_TIMESTAMP + 3)) { byte[] contents = rangeIterator.next().getOnlyColumnValue().getContents(); assertFalse("There should only be one row in the table", rangeIterator.hasNext()); return contents; } }
private void assertSweepableCellsHasNoDedicatedRowsForShard(int shard) { TableReference sweepableCellsTable = TargetedSweepTableFactory.of().getSweepableCellsTable(null).getTableRef(); try (ClosableIterator<RowResult<Value>> iterator = spiedKvs.getRange(sweepableCellsTable, RangeRequest.all(), Long.MAX_VALUE)) { assertThat(iterator.stream() .map(RowResult::getRowName) .map(SweepableCellsTable.SweepableCellsRow.BYTES_HYDRATOR::hydrateFromBytes) .map(SweepableCellsTable.SweepableCellsRow::getMetadata) .map(TargetedSweepMetadata.BYTES_HYDRATOR::hydrateFromBytes) .filter(TargetedSweepMetadata::dedicatedRow) .filter(metadata -> metadata.shard() == shard) .collect(Collectors.toList())) .isEmpty(); } }
@Test public void doesNotLeaveSentinelsIfTableDestroyed() { enqueueWriteCommitted(TABLE_CONS, 10); immutableTs = 11; unreadableTs = 11; spiedKvs.truncateTable(TABLE_CONS); assertThat(spiedKvs.getRange(TABLE_CONS, RangeRequest.all(), Long.MAX_VALUE)).isEmpty(); sweepQueue.sweepNextBatch(ShardAndStrategy.conservative(CONS_SHARD)); assertThat(spiedKvs.getRange(TABLE_CONS, RangeRequest.all(), Long.MAX_VALUE)).isEmpty(); }
@Test public void testGetRangeOfTimestampsReturnsAllRows() { keyValueService.put(TEST_TABLE, ImmutableMap.of( Cell.create(row(0), column(0)), val(0, 5), Cell.create(row(1), column(0)), val(0, 5), Cell.create(row(2), column(0)), val(0, 5)), TEST_TIMESTAMP); RangeRequest range = RangeRequest.all().withBatchHint(1); List<RowResult<Set<Long>>> results = ImmutableList.copyOf( keyValueService.getRangeOfTimestamps(TEST_TABLE, range, TEST_TIMESTAMP + 1)); assertEquals(3, results.size()); assertArrayEquals(row(0), results.get(0).getRowName()); assertArrayEquals(row(1), results.get(1).getRowName()); assertArrayEquals(row(2), results.get(2).getRowName()); }
@Test public void deleteRangeAllCountsAsClearingTheTable() throws Exception { kvs.deleteRange(TABLE, RangeRequest.all()); assertTrue(kvs.hasBeenCleared(TABLE)); }
@Test public void fromRowResultProducesLockEntry() { KeyValueService kvs = new InMemoryKeyValueService(false); kvs.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.checkAndSet(CheckAndSetRequest.newCell(TEST_TABLE, LOCK_ENTRY.cell(), LOCK_ENTRY.value())); Iterator<RowResult<Value>> range = kvs.getRange(TEST_TABLE, RangeRequest.all(), AtlasDbConstants.TRANSACTION_TS + 1); RowResult<Value> onlyEntry = Iterables.getOnlyElement(ImmutableSet.copyOf(range)); LockEntry lockEntry = LockEntry.fromRowResult(onlyEntry); assertEquals(LOCK_ENTRY, lockEntry); }