default boolean isEmpty() { return writes().isEmpty(); }
@Test public void cannotReadEntryOutOfRange() { SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).isEmpty(); conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, 0L, TS); assertThat(conservativeBatch.writes()).isEmpty(); }
@Test public void cannotReadEntryForWrongPartition() { SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION - 1, 0L, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).isEmpty(); conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION + 1, TS - 1, Long.MAX_VALUE); assertThat(conservativeBatch.writes()).isEmpty(); }
@Test public void cannotReadEntryForWrongShard() { SweepBatch conservativeBatch = readConservative(shardCons + 1, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).isEmpty(); }
@Test public void canReadMultipleEntriesInSingleShardSameTransactionOneDedicated() { List<WriteInfo> writes = writeToCellsInFixedShard(sweepableCells, TS, MAX_CELLS_GENERIC * 2 + 1, TABLE_CONS); SweepBatch conservativeBatch = readConservative(FIXED_SHARD, TS_FINE_PARTITION, TS - 1, TS + 1); assertThat(conservativeBatch.writes().size()).isEqualTo(MAX_CELLS_GENERIC * 2 + 1); assertThat(conservativeBatch.writes()).hasSameElementsAs(writes); }
@Test public void canReadMultipleEntriesInSingleShardSameTransactionNotDedicated() { List<WriteInfo> writes = writeToCellsInFixedShard(sweepableCells, TS, 10, TABLE_CONS); SweepBatch conservativeBatch = readConservative(FIXED_SHARD, TS_FINE_PARTITION, TS - 1, TS + 1); assertThat(conservativeBatch.writes().size()).isEqualTo(10); assertThat(conservativeBatch.writes()).hasSameElementsAs(writes); }
@Test public void canReadMultipleEntriesInSingleShardSameTransactionMultipleDedicated() { useSingleShard(); List<WriteInfo> writes = writeCommittedConservativeRowForTimestamp(TS + 1, MAX_CELLS_DEDICATED + 1); SweepBatch conservativeBatch = readConservative(0, TS_FINE_PARTITION, TS, TS + 2); assertThat(conservativeBatch.writes().size()).isEqualTo(writes.size()); assertThat(conservativeBatch.writes()).contains(writes.get(0), writes.get(writes.size() - 1)); }
@Test public void canReadMultipleEntriesInSingleShardMultipleTransactionsCombined() { List<WriteInfo> first = writeToCellsInFixedShard(sweepableCells, TS, MAX_CELLS_GENERIC * 2 + 1, TABLE_CONS); List<WriteInfo> last = writeToCellsInFixedShard(sweepableCells, TS + 2, 1, TABLE_CONS); List<WriteInfo> middle = writeToCellsInFixedShard(sweepableCells, TS + 1, MAX_CELLS_GENERIC + 1, TABLE_CONS); // The expected list of latest writes contains: // ((0, 0), TS + 2) // ((1, 1), TS + 1) .. ((MAX_CELLS_GENERIC, MAX_CELLS_GENERIC), TS + 1) // ((MAX_CELLS_GENERIC + 1, MAX_CELLS_GENERIC) + 1, TS) .. ((2 * MAX_CELLS_GENERIC, 2 * MAX_CELLS_GENERIC), TS) List<WriteInfo> expectedResult = new ArrayList<>(last); expectedResult.addAll(middle.subList(last.size(), middle.size())); expectedResult.addAll(first.subList(middle.size(), first.size())); SweepBatch conservativeBatch = readConservative(FIXED_SHARD, TS_FINE_PARTITION, TS - 1, TS + 3); assertThat(conservativeBatch.writes().size()).isEqualTo(MAX_CELLS_GENERIC * 2 + 1); assertThat(conservativeBatch.writes()).hasSameElementsAs(expectedResult); }
private void assertSweepableCellsHasNoEntriesInPartitionOfTimestamp(long timestamp) { SweepBatch batch = sweepableCells.getBatchForPartition( ShardAndStrategy.conservative(CONS_SHARD), tsPartitionFine(timestamp), -1L, Long.MAX_VALUE); assertThat(batch.writes()).isEmpty(); }
@Test public void changingNumberOfShardsDoesNotAffectExistingWritesButAffectsFuture() { useSingleShard(); assertThat(readConservative(0, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS).writes()).isEmpty(); writeToDefaultCellCommitted(sweepableCells, TS, TABLE_CONS); assertThat(readConservative(0, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS).writes()) .containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS)); }
private void assertSweepableCellsHasEntryForTimestamp(long timestamp) { SweepBatch batch = sweepableCells.getBatchForPartition( ShardAndStrategy.conservative(CONS_SHARD), tsPartitionFine(timestamp), -1L, timestamp + 1); assertThat(batch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, timestamp)); }
@Test public void readOnlyTombstoneWhenLatestInShardAndRange() { putTombstoneToDefaultCommitted(sweepableCells, TS + 1, TABLE_CONS); SweepBatch batch = readConservative(CONS_SHARD, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS); assertThat(batch.writes()).containsExactly(WriteInfo.tombstone(TABLE_CONS, DEFAULT_CELL, TS + 1)); }
@Test public void readDoesNotReturnValuesFromAbortedTransactions() { writeToDefaultCellAborted(sweepableCells, TS + 1, TABLE_CONS); SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS)); }
@Test public void readDoesNotReturnValuesFromTransactionsCommittedAfterSweepTs() { writeToDefaultCellCommitedAt(sweepableCells, TS + 1, SMALL_SWEEP_TS, TABLE_CONS); SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS)); }
@Test public void canReadSingleEntryInSingleShardForCorrectPartitionAndRange() { SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS)); SweepBatch thoroughBatch = readThorough(TS2_FINE_PARTITION, TS2 - 1, Long.MAX_VALUE); assertThat(thoroughBatch.writes()).containsExactly(WriteInfo.write(TABLE_THOR, DEFAULT_CELL, TS2)); SweepMetricsAssert.assertThat(metricsManager).hasEnqueuedWritesConservativeEqualTo(1); SweepMetricsAssert.assertThat(metricsManager).hasEnqueuedWritesThoroughEqualTo(1); }
@Test public void readDoesNotReturnValuesFromUncommittedTransactionsAndAbortsThem() { writeToDefaultCellUncommitted(sweepableCells, TS + 1, TABLE_CONS); assertThat(!isTransactionAborted(TS + 1)); SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS - 1, SMALL_SWEEP_TS); assertThat(isTransactionAborted(TS + 1)); assertThat(conservativeBatch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS)); }
@Test public void readOnlyMostRecentTimestampForRange() { writeToDefaultCellCommitted(sweepableCells, TS - 1, TABLE_CONS); writeToDefaultCellCommitted(sweepableCells, TS + 2, TABLE_CONS); writeToDefaultCellCommitted(sweepableCells, TS - 2, TABLE_CONS); writeToDefaultCellCommitted(sweepableCells, TS + 1, TABLE_CONS); SweepBatch conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS - 3, TS); assertThat(conservativeBatch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS - 1)); assertThat(conservativeBatch.lastSweptTimestamp()).isEqualTo(TS - 1); conservativeBatch = readConservative(shardCons, TS_FINE_PARTITION, TS - 3, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes()).containsExactly(WriteInfo.write(TABLE_CONS, DEFAULT_CELL, TS + 2)); assertThat(conservativeBatch.lastSweptTimestamp()).isEqualTo(SMALL_SWEEP_TS - 1); }
@Test public void uncommittedWritesInDedicatedRowsGetDeleted() { useSingleShard(); writeWithoutCommitConservative(TS + 1, 0L, MAX_CELLS_DEDICATED + 1); SweepBatch conservativeBatch = readConservative(0, TS_FINE_PARTITION, TS, TS + 2); assertThat(conservativeBatch.writes()).isEmpty(); assertDeletedNumber(TABLE_CONS, MAX_CELLS_DEDICATED + 1); SweepMetricsAssert.assertThat(metricsManager) .hasAbortedWritesDeletedConservativeEquals(MAX_CELLS_DEDICATED + 1); }
@Test public void returnWhenMoreThanSweepBatchSizeWithRepeatsHasFewerEntries() { useSingleShard(); int iterationWrites = 1 + SWEEP_BATCH_SIZE / 5; for (int i = 1; i <= 10; i++) { writeCommittedConservativeRowZero(i, iterationWrites); } SweepBatch conservativeBatch = readConservative(0, 0L, -1L, SMALL_SWEEP_TS); assertThat(conservativeBatch.writes().size()).isEqualTo(iterationWrites); assertThat(conservativeBatch.lastSweptTimestamp()).isEqualTo(5); SweepMetricsAssert.assertThat(metricsManager).hasEnqueuedWritesConservativeEqualTo( 10 * iterationWrites + 1); SweepMetricsAssert.assertThat(metricsManager).hasEntriesReadConservativeEqualTo( 5 * iterationWrites); SweepMetricsAssert.assertThat(metricsManager).hasAbortedWritesDeletedConservativeEquals(0); }
@Test public void canReadMultipleEntriesInSingleShardDifferentTransactions() { writeToCellCommitted(sweepableCells, TS, getCellWithFixedHash(1), TABLE_CONS); writeToCellCommitted(sweepableCells, TS + 1, getCellWithFixedHash(2), TABLE_CONS); SweepBatch conservativeBatch = readConservative(FIXED_SHARD, TS_FINE_PARTITION, TS - 1, TS + 2); assertThat(conservativeBatch.writes()).containsExactlyInAnyOrder( WriteInfo.write(TABLE_CONS, getCellWithFixedHash(1), TS), WriteInfo.write(TABLE_CONS, getCellWithFixedHash(2), TS + 1)); assertThat(conservativeBatch.lastSweptTimestamp()).isEqualTo(TS + 1); }