@Override public void createTable(TableReference tableRef, byte[] tableMetadata) { delegate1.createTable(tableRef, tableMetadata); delegate2.createTable(tableRef, tableMetadata); }
@Test public void createTableShouldBeIdempotent() { keyValueService.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); keyValueService.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); }
@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); }
@Before public void setUp() throws Exception { keyValueService = kvsManager.getDefaultKvs(); keyValueService.createTable(TEST_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); }
@Override public void createTable(TableReference tableRef, byte[] tableMetadata) { sanityCheckTableName(tableRef); sanityCheckTableMetadata(tableRef, tableMetadata); delegate.createTable(tableRef, tableMetadata); }
@Override public void createTable(TableReference tableRef, byte[] tableMetadata) { TableReference shortName = tableMapper.addTable(tableRef); delegate().createTable(shortName, tableMetadata); }
private void tryInitialize() { keyValueService.createTable(AtlasDbConstants.PERSISTED_LOCKS_TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); if (allLockEntries().isEmpty()) { new LockStorePopulator(keyValueService).populate(); } }
public static Map<String, Object> execute(TransactionManager txnManager, int numClients, int requestsPerClient) { txnManager.getKeyValueService().createTable(TABLE, AtlasDbConstants.GENERIC_TABLE_METADATA); return new KvsWriteBenchmark(txnManager.getKeyValueService(), numClients, requestsPerClient).execute(); }
@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); }
@Test public void sweepPriorityTableNotValidated() { kvs.createTable(SWEEP_PRIORITY, AtlasDbConstants.EMPTY_TABLE_METADATA); assertThat(KeyValueServiceValidators.getValidatableTableNames(kvs, ImmutableSet.of())).isEmpty(); }
@Test public void unmigratableTablesAreNotValidated() { kvs.createTable(OTHER_PRIORITY, AtlasDbConstants.EMPTY_TABLE_METADATA); assertThat(KeyValueServiceValidators.getValidatableTableNames(kvs, ImmutableSet.of(OTHER_PRIORITY))).isEmpty(); } }
@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); }
@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(); }
@Test public void metadataForNewTableMatchesCase() { TableReference userTable = TableReference.createFromFullyQualifiedName("test.xXcOoLtAbLeNaMeXx"); keyValueService.createTable(userTable, ORIGINAL_METADATA); assertThat(keyValueService.getMetadataForTables().keySet().contains(userTable), is(true)); }
private static void createStreamingTable(KeyValueService kvs, TableReference parentTable, String columnName) { StreamStoreDefinition ssd = new StreamStoreDefinitionBuilder(columnName, "Value", ValueType.VAR_LONG) .inMemoryThreshold(1024 * 1024) .build(); ssd.getTables().forEach((tableName, tableDefinition) -> { TableReference streamingTable = TableReference.create(parentTable.getNamespace(), tableName); kvs.createTable(streamingTable, tableDefinition.toTableMetadata().persistToBytes()); }); }
@Test public void transactionTableNotValidated() { kvs.createTable(TransactionConstants.TRANSACTION_TABLE, TransactionConstants.TRANSACTION_TABLE_METADATA.persistToBytes()); assertThat(KeyValueServiceValidators.getValidatableTableNames(kvs, ImmutableSet.of())).isEmpty(); }
@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 oldMixedCaseMetadataStillVisible() { TableReference userTable = TableReference.createFromFullyQualifiedName("test.cAsEsEnSiTiVe"); keyValueService.createTable(userTable, AtlasDbConstants.GENERIC_TABLE_METADATA); clearOutMetadataTable(keyValueService); insertGenericMetadataIntoLegacyCell(keyValueService, userTable, ORIGINAL_METADATA); assertThat( Arrays.equals(keyValueService.getMetadataForTable(userTable), ORIGINAL_METADATA), is(true)); }
@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); }
@Test public void repeatedDropTableDoesNotAccumulateGarbage() { int preExistingGarbageBeforeTest = getAmountOfGarbageInMetadataTable(keyValueService, NEVER_SEEN); for (int i = 0; i < 3; i++) { keyValueService.createTable(NEVER_SEEN, getMetadata()); keyValueService.dropTable(NEVER_SEEN); } int garbageAfterTest = getAmountOfGarbageInMetadataTable(keyValueService, NEVER_SEEN); assertThat(garbageAfterTest, lessThanOrEqualTo(preExistingGarbageBeforeTest)); }