@Test public void truncateShouldBeIdempotent() { TableReference fooBar = TableReference.createUnsafe("foo.bar"); keyValueService.createTable(fooBar, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.truncateTable(fooBar); keyValueService.truncateTable(fooBar); keyValueService.dropTable(fooBar); }
@After public void cleanup() { kvs.dropTables(kvs.getAllTableNames()); kvs.truncateTable(AtlasDbConstants.DEFAULT_METADATA_TABLE); }
@Test public void deleteTimestampRangesLeavesSentinels() { long latestTs = 15L; keyValueService.addGarbageCollectionSentinelValues(TEST_TABLE, ImmutableSet.of(TEST_CELL)); keyValueService.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, val(1, 0)), latestTs); keyValueService.deleteAllTimestamps(TEST_TABLE, ImmutableMap.of(TEST_CELL, latestTs), false); assertThat(getAllTimestampsForTestCell(), contains(Value.INVALID_VALUE_TIMESTAMP, latestTs)); assertThat(keyValueService.get(TEST_TABLE, ImmutableMap.of(TEST_CELL, Value.INVALID_VALUE_TIMESTAMP + 1L)) .get(TEST_CELL), equalTo(Value.create(new byte[0], Value.INVALID_VALUE_TIMESTAMP))); }
@Test public void dontThrowWhenCreatingTheSameLongTable() throws Exception { TableReference longTableName = TableReference.create(TEST_NAMESPACE, TEST_LONG_TABLE_NAME); keyValueService.createTable(longTableName, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.createTable(longTableName, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.dropTable(longTableName); }
@Test public void testTableMetadata() { assertEquals(AtlasDbConstants.GENERIC_TABLE_METADATA.length, keyValueService.getMetadataForTable(TEST_TABLE).length); keyValueService.putMetadataForTable(TEST_TABLE, ArrayUtils.EMPTY_BYTE_ARRAY); assertEquals(0, keyValueService.getMetadataForTable(TEST_TABLE).length); keyValueService.putMetadataForTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); assertTrue(Arrays.equals(AtlasDbConstants.GENERIC_TABLE_METADATA, keyValueService.getMetadataForTable(TEST_TABLE))); }
@Test public void tableReferencesAreCaseSensitiveForDrop() { kvs.createTable(LOWER_UPPER, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.dropTable(LOWER_LOWER); assertThat(kvs.getAllTableNames()).containsExactly(LOWER_UPPER); assertThat(kvs.getMetadataForTable(LOWER_UPPER)).contains(AtlasDbConstants.GENERIC_TABLE_METADATA); }
@Test public void droppedTableHasNoObservableMetadata() { kvs.createTable(LOWER_UPPER, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.dropTable(LOWER_UPPER); assertThat(kvs.getMetadataForTables()).isEmpty(); assertThat(kvs.getMetadataForTable(LOWER_UPPER)).isEmpty(); }
@Test public void tableCreationAppearsToSucceedButIsNoop() { kvs.createTable(UPPER_UPPER, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.createTable(LOWER_LOWER, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.put(UPPER_UPPER, ImmutableMap.of(CELL, BYTE_ARRAY), 1); assertThat(kvs.get(UPPER_UPPER, ImmutableMap.of(CELL, 2L)).get(CELL).getContents()).contains(BYTE_ARRAY); assertThatThrownBy(() -> kvs.get(LOWER_LOWER, ImmutableMap.of(CELL, 2L))) .isInstanceOf(RetryLimitReachedException.class); assertThatThrownBy(() -> kvs.put(LOWER_LOWER, ImmutableMap.of(CELL, SECOND_BYTE_ARRAY), 1)) .isInstanceOf(RetryLimitReachedException.class); }
@Override public long resetStateAndGetFreshTimestamp() { forceInstallNewTransactionsSchemaVersion(1); KeyValueService kvs = transactionManager.getKeyValueService(); kvs.truncateTable(AtlasDbConstants.COORDINATION_TABLE); kvs.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.truncateTable(TEST_TABLE); return timestampService.getFreshTimestamp(); }
@Test public void getMetadataReturnsResultFromNewMetadataCellOnConflict() { kvs.createTable(LOWER_UPPER, ORIGINAL_METADATA); insertGenericMetadataIntoLegacyCell(kvs, LOWER_UPPER); assertThat(kvs.getMetadataForTables().get(LOWER_UPPER)).contains(ORIGINAL_METADATA); assertThat(kvs.getMetadataForTable(LOWER_UPPER)).contains(ORIGINAL_METADATA); }
@Test public void tablesWithDifferentCapitalizationClaimToHaveMetadata() { kvs.createTable(UPPER_UPPER, AtlasDbConstants.GENERIC_TABLE_METADATA); kvs.createTable(LOWER_UPPER, AtlasDbConstants.GENERIC_TABLE_METADATA); TABLES.forEach(table -> assertThat(kvs.getMetadataForTable(table)).isNotEmpty()); assertThat(kvs.getMetadataForTable(TableReference.createFromFullyQualifiedName("other.table"))).isEmpty(); }
Optional<TableReference> get(int tableId) { SweepIdToNameColumn column = SweepIdToNameColumn.of(tableId); Cell cell = Cell.create(rowAsBytes, column.persistToBytes()); Map<Cell, Value> values = kvs.get(ID_TO_NAME, Collections.singletonMap(cell, Long.MAX_VALUE)); return Optional.ofNullable(values.get(cell)) .map(Value::getContents) .map(SweepIdToNameColumnValue::hydrateValue) .map(TableReference::fromString); }
@Test public void setupClearsOutExistingTablesExceptAtomic() { toKvs.createTables(TEST_AND_CHECKPOINT_TABLES); fromKvs.dropTables(fromKvs.getAllTableNames()); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); assertThat(toKvs.getAllTableNames()).containsExactly(TransactionConstants.TRANSACTION_TABLE, AtlasDbConstants.COORDINATION_TABLE); }
@Override public void setupTableData() { getKvs().truncateTable(getTableRef()); Map<Cell, byte[]> batch = Tables.generateRandomBatch(random, 1); getKvs().put(getTableRef(), batch, Tables.DUMMY_TIMESTAMP); data = Multimaps.forMap(Maps.transformValues(batch, $ -> Tables.DUMMY_TIMESTAMP)); }
@Test public void createSyncInitializationTest() { KeyValueService kvs = AsyncInitializeableInMemoryKvs.createAndStartInit(false); assertThat(kvs.isInitialized()).isTrue(); assertThat(kvs.getAllTableNames()).isEmpty(); }
private static Set<TableReference> getExistingTablesAlsoPresentInSchema(Schema schema, KeyValueService kvs) { Set<TableReference> allTables = kvs.getAllTableNames(); Set<TableReference> schemaFullTableNames = Sets.newHashSet(); schemaFullTableNames.addAll(schema.getIndexDefinitions().keySet()); schemaFullTableNames.addAll(schema.getTableDefinitions().keySet()); return schemaFullTableNames.stream().filter(allTables::contains).collect(Collectors.toSet()); }
@Override public void putUnlessExists(TableReference tableRef, Map<Cell, byte[]> values) throws KeyAlreadyExistsException { delegate1.putUnlessExists(tableRef, values); }
@Override public void createTable(TableReference tableRef, byte[] tableMetadata) { sanityCheckTableName(tableRef); sanityCheckTableMetadata(tableRef, tableMetadata); delegate.createTable(tableRef, tableMetadata); }
@Override public void removeTable(TableReference tableRef) { Cell key = Cell.create(getBytesForTableRef(tableRef), AtlasDbConstants.NAMESPACE_SHORT_COLUMN_BYTES); if (kv.getAllTableNames().contains(AtlasDbConstants.NAMESPACE_TABLE)) { kv.delete(AtlasDbConstants.NAMESPACE_TABLE, ImmutableMultimap.of(key, 0L)); } // Need to invalidate the table ref in case we end up re-creating the same table // again. Frequently when we drop one table we end up dropping a bunch of tables, // so just invalidate everything. tableMap.set(HashBiMap.<TableReference, TableReference>create()); }
@Override public void truncateTable(TableReference tableRef) { delegate1.truncateTable(tableRef); delegate2.truncateTable(tableRef); }