@Override public void createTables(Map<TableReference, byte[]> tableRefToTableMetadata) { delegate1.createTables(tableRefToTableMetadata); delegate2.createTables(tableRefToTableMetadata); }
@Override public void createTables(Map<TableReference, byte[]> tableRefToTableMetadata) { delegate().createTables(tableRefToTableMetadata); }
@Override public void createTables(Map<TableReference, byte[]> tableReferencesToTableMetadata) { Map<TableReference, byte[]> tableNameToTableMetadata = Maps.newHashMapWithExpectedSize(tableReferencesToTableMetadata.size()); for (Entry<TableReference, byte[]> tableEntry : tableReferencesToTableMetadata.entrySet()) { tableNameToTableMetadata.put( tableMapper.addTable(tableEntry.getKey()), tableEntry.getValue()); } delegate().createTables(tableNameToTableMetadata); }
public static void createTables(KeyValueService kvs, Map<TableReference, TableDefinition> tableRefToDefinition) { Map<TableReference, byte[]> tableRefToMetadata = Maps.newHashMapWithExpectedSize(tableRefToDefinition.size()); for (Entry<TableReference, TableDefinition> tableEntry : tableRefToDefinition.entrySet()) { tableRefToMetadata.put(tableEntry.getKey(), tableEntry.getValue().toTableMetadata().persistToBytes()); } kvs.createTables(tableRefToMetadata); }
@Override public void createTables(Map<TableReference, byte[]> tableRefToTableMetadata) { if (tableRefToTableMetadata.isEmpty()) { return; } if (tableRefToTableMetadata.size() == 1) { Entry<TableReference, byte[]> element = Iterables.getOnlyElement(tableRefToTableMetadata.entrySet()); createTable(element.getKey(), element.getValue()); return; } tableRefToTableMetadata.keySet().forEach(this::sanityCheckTableName); tableRefToTableMetadata.forEach((key, value) -> sanityCheckTableMetadata(key, value)); delegate.createTables(tableRefToTableMetadata); }
@Override public void createTables(Map<TableReference, byte[]> tableRefToTableMetadata) { maybeLog(() -> delegate.createTables(tableRefToTableMetadata), logTimeAndTableCount("createTables", tableRefToTableMetadata.keySet().size())); }
public static void createIndices(KeyValueService kvs, Map<TableReference, IndexDefinition> fullIndexNameToDefinition) { Map<TableReference, byte[]> fullIndexNameToMetadata = Maps.newHashMapWithExpectedSize( fullIndexNameToDefinition.size()); for (Entry<TableReference, IndexDefinition> indexEntry : fullIndexNameToDefinition.entrySet()) { fullIndexNameToMetadata.put(indexEntry.getKey(), indexEntry.getValue().toIndexMetadata( indexEntry.getKey().getQualifiedName()).getTableMetadata().persistToBytes()); } kvs.createTables(fullIndexNameToMetadata); }
@Override public void createTables(Map<TableReference, byte[]> tableNamesToTableMetadata) { //noinspection unused - try-with-resources closes trace try (CloseableTrace trace = startLocalTrace("createTables({})", LoggingArgs.safeTablesOrPlaceholder(tableNamesToTableMetadata.keySet()))) { delegate().createTables(tableNamesToTableMetadata); } }
private void createTablesIgnoringException() { assertThatThrownBy(() -> kvs.createTables( TABLES.stream().collect(Collectors.toMap(x -> x, no -> AtlasDbConstants.GENERIC_TABLE_METADATA)))) .isInstanceOf(IllegalStateException.class); }
@Test public void createTables() throws Exception { byte[] metadata = new byte[0]; kvs.createTables(ImmutableMap.of(TABLE_REF, metadata)); checkSpan("atlasdb-kvs.createTables([{table}])"); verify(delegate).createTables(ImmutableMap.of(TABLE_REF, metadata)); verifyNoMoreInteractions(delegate); }
@Test public void checkpointTableOnSourceKvsIsIgnored() { fromKvs.createTables(TEST_AND_CHECKPOINT_TABLES); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); migrator.migrate(); verify(fromKvs, never()).get(eq(CHECKPOINT_TABLE), any()); verify(fromKvs, never()).getRange(eq(CHECKPOINT_TABLE), any(), anyLong()); verify(fromKvs, never()).getRows(eq(CHECKPOINT_TABLE), any(), any(), anyLong()); verify(fromKvs, never()).getRowsColumnRange(eq(CHECKPOINT_TABLE), any(), any(), anyLong()); verify(fromKvs, never()).getRowsColumnRange(eq(CHECKPOINT_TABLE), any(), any(), anyInt(), anyLong()); verify(fromKvs, never()).getFirstBatchForRanges(eq(CHECKPOINT_TABLE), any(), anyLong()); }
@Test public void shouldAllowSameTablenameDifferentNamespace() { TableReference fooBar = TableReference.createUnsafe("foo.bar"); TableReference bazBar = TableReference.createUnsafe("baz.bar"); // try create table in same call keyValueService.createTables( ImmutableMap.of( fooBar, AtlasDbConstants.GENERIC_TABLE_METADATA, bazBar, AtlasDbConstants.GENERIC_TABLE_METADATA)); // try create table spanned over different calls keyValueService.createTable(fooBar, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.createTable(bazBar, AtlasDbConstants.GENERIC_TABLE_METADATA); // test tables actually created assertThat(keyValueService.getAllTableNames(), hasItems(fooBar, bazBar)); // clean up keyValueService.dropTables(ImmutableSet.of(fooBar, bazBar)); }
@Test public void setupCreatesAndResetsExistingTables() { fromKvs.createTables(TEST_AND_CHECKPOINT_TABLES); toKvs.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); toKvs.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, TEST_VALUE1), 1); assertThat(toKvs.get(TEST_TABLE, ImmutableMap.of(TEST_CELL, Long.MAX_VALUE))).isNotEmpty(); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); assertThat(toKvs.getAllTableNames()).containsExactlyInAnyOrderElementsOf(fromKvs.getAllTableNames()); assertThat(toKvs.get(TEST_TABLE, ImmutableMap.of(TEST_CELL, Long.MAX_VALUE))).isEmpty(); }
@Test public void cleanupDropsCheckpointTable() { fromKvs.createTables(TEST_AND_CHECKPOINT_TABLES); fromTxManager.runTaskWithRetry(tx -> { tx.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, TEST_VALUE1)); return tx.getTimestamp(); }); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); migrator.migrate(); verify(toKvs, never()).dropTable(CHECKPOINT_TABLE); migrator.cleanup(); verify(toKvs, times(1)).dropTable(CHECKPOINT_TABLE); }
@Test public void testCreateTables() { TableReference tableName1 = TableReference.createWithEmptyNamespace(TABLE_NAME + "1"); TableReference tableName2 = TableReference.createWithEmptyNamespace(TABLE_NAME + "2"); mockery.checking(new Expectations(){{ oneOf(kvs).createTables(with(tableMapContainsEntry(tableName1, getSimpleTableDefinitionAsBytes(tableName1)))); oneOf(kvs).createTables(with(tableMapContainsEntry(tableName2, getSimpleTableDefinitionAsBytes(tableName2)))); }}); Map<TableReference, TableDefinition> tables = Maps.newHashMap(); tables.put(tableName1, getSimpleTableDefinition(tableName1)); tables.put(tableName2, getSimpleTableDefinition(tableName2)); Schemas.createTables(kvs, tables); }
@Test public void setupCopiesTableMetadata() { toKvs.createTables(TEST_AND_CHECKPOINT_TABLES); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); assertThat(fromKvs.getMetadataForTable(TEST_TABLE)).isEqualTo(toKvs.getMetadataForTable(TEST_TABLE)); }
@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); }
@Test public void migrateRevertsUncommittedWritesAndMigratesMostRecentlyCommitted() { fromKvs.createTables(TEST_AND_CHECKPOINT_TABLES); fromTxManager.runTaskWithRetry(tx -> { tx.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, TEST_VALUE1)); return tx.getTimestamp(); }); long uncommittedTs = fromServices.getTimestampService().getFreshTimestamp(); fromKvs.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, TEST_VALUE2), uncommittedTs); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); migrator.migrate(); assertThat(fromServices.getTransactionService().get(uncommittedTs)) .isEqualTo(TransactionConstants.FAILED_COMMIT_TS); assertThat(toKvs.get(TEST_TABLE, ImmutableMap.of(TEST_CELL, Long.MAX_VALUE)).get(TEST_CELL).getContents()) .containsExactly(TEST_VALUE1); }
@Test public void deletedEntriesAreNotMigrated() { fromKvs.createTables(TEST_AND_CHECKPOINT_TABLES); fromTxManager.runTaskWithRetry(tx -> { tx.put(TEST_TABLE, ImmutableMap.of(TEST_CELL, TEST_VALUE1)); return tx.getTimestamp(); }); fromTxManager.runTaskWithRetry(tx -> { tx.delete(TEST_TABLE, ImmutableSet.of(TEST_CELL)); return tx.getTimestamp(); }); KeyValueServiceMigrator migrator = KeyValueServiceMigrators.setupMigrator(migratorSpec); migrator.setup(); migrator.migrate(); assertThat(toKvs.get(TEST_TABLE, ImmutableMap.of(TEST_CELL, Long.MAX_VALUE))).isEmpty(); }
@Test public void testCreateTable() { mockery.checking(new Expectations(){{ oneOf(kvs).createTables(with(tableMapContainsEntry(TABLE_REF, getSimpleTableDefinitionAsBytes(TABLE_REF)))); }}); Schemas.createTable(kvs, TABLE_REF, getSimpleTableDefinition(TABLE_REF)); }