public static TableMetadata getTableMetadataSafe(KeyValueService service, TableReference tableRef) { try { byte[] metadataForTable = service.getMetadataForTable(tableRef); if (metadataForTable == null || metadataForTable.length == 0) { return null; } return TableMetadata.BYTES_HYDRATOR.hydrateFromBytes(metadataForTable); } catch (Exception e) { log.warn("failed to get metadata for table", e); return null; } }
@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); }
@Override public byte[] getMetadataForTable(TableReference tableRef) { return delegate().getMetadataForTable(tableRef); }
@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 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))); }
@Override public byte[] getMetadataForTable(TableReference tableRef) { return maybeLog(() -> delegate.getMetadataForTable(tableRef), logTimeAndTable("getMetadataForTable", tableRef)); }
@Override public TableMetadata load(String tableName) throws Exception { byte[] rawMetadata = kvs.getMetadataForTable(TableReference.createUnsafe(tableName)); if (rawMetadata == null || rawMetadata.length == 0) { return EMPTY; } return TableMetadata.BYTES_HYDRATOR.hydrateFromBytes(rawMetadata); } });
@Override public byte[] getMetadataForTable(TableReference tableRef) { try { return delegate().getMetadataForTable(tableMapper.getMappedTableName(tableRef)); } catch (TableMappingNotFoundException e) { // table does not exist. return AtlasDbConstants.EMPTY_TABLE_METADATA; } }
@Override public byte[] getMetadataForTable(TableReference tableRef) { //noinspection unused - try-with-resources closes trace try (CloseableTrace trace = startLocalTrace("getMetadataForTable({})", LoggingArgs.safeTableOrPlaceholder(tableRef))) { return delegate().getMetadataForTable(tableRef); } }
private TableMetadataPersistence.SweepStrategy getStrategyFromKvs(TableReference tableRef) { try { return TableMetadata.BYTES_HYDRATOR.hydrateFromBytes(kvs.getMetadataForTable(tableRef)).getSweepStrategy(); } catch (Exception e) { log.warn("Failed to obtain sweep strategy for table {}.", LoggingArgs.tableRef(tableRef), e); throw Throwables.rewrapAndThrowUncheckedException(e); } }
@Test public void testDropTableErasesMetadata() { keyValueService.dropTable(TEST_TABLE); assertEquals(0, keyValueService.getMetadataForTable(TEST_TABLE).length); }
@Test public void getMetadataForTable() throws Exception { when(delegate.getMetadataForTable(TABLE_REF)).thenReturn(METADATA_BYTES); byte[] result = kvs.getMetadataForTable(TABLE_REF); assertThat(result, equalTo(METADATA_BYTES)); checkSpan("atlasdb-kvs.getMetadataForTable({table})"); verify(delegate).getMetadataForTable(TABLE_REF); verifyNoMoreInteractions(delegate); }
@Before public void setup() { partitioner = new WriteInfoPartitioner(mockKvs, () -> numShards); when(mockKvs.getMetadataForTable(any(TableReference.class))).thenAnswer(args -> METADATA_MAP.getOrDefault(args.getArguments()[0], AtlasDbConstants.EMPTY_TABLE_METADATA)); }
@Test public void getStrategyQueriesKvsOnlyOnceForEachTable() { for (int i = 0; i < 5; i++) { partitioner.getStrategy(getWriteInfoWithFixedCellHash(NOTHING, i)); partitioner.getStrategy(getWriteInfoWithFixedCellHash(CONSERVATIVE, i)); } verify(mockKvs, times(1)).getMetadataForTable(NOTHING); verify(mockKvs, times(1)).getMetadataForTable(CONSERVATIVE); verifyNoMoreInteractions(mockKvs); }
@Test public void getStrategyThrowsForIllegalMetadata() { when(mockKvs.getMetadataForTable(any())).thenReturn(AtlasDbConstants.EMPTY_TABLE_METADATA); assertThatThrownBy(() -> partitioner.getStrategy(getWriteInfoWithFixedCellHash(getTableRef("a"), 0))) .isInstanceOf(UncheckedExecutionException.class); }
@Test public void getStrategyThrowsOnUncheckedException() { RuntimeException cause = new RuntimeException("cause"); when(mockKvs.getMetadataForTable(any())).thenThrow(cause); assertThatThrownBy(() -> partitioner.getStrategy(getWriteInfoWithFixedCellHash(getTableRef("a"), 0))) .isInstanceOf(UncheckedExecutionException.class) .hasCause(cause); }
@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 nonExistentTablesWithMetadataReturnMetadata() { insertMetadataIntoNewCell(LOWER_UPPER); assertThat(kvs.getMetadataForTable(LOWER_UPPER)).contains(AtlasDbConstants.GENERIC_TABLE_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 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); }