use of bio.terra.common.Column in project jade-data-repo by DataBiosphere.
the class SnapshotMapTableDao method retrieveMapColumns.
public List<SnapshotMapColumn> retrieveMapColumns(UUID mapTableId, Table fromTable, Table toTable) {
String sql = "SELECT id, from_column_id, to_column_id" + " FROM snapshot_map_column WHERE map_table_id = :map_table_id";
List<SnapshotMapColumn> mapColumns = jdbcTemplate.query(sql, new MapSqlParameterSource().addValue("map_table_id", mapTableId), (rs, rowNum) -> {
UUID fromId = rs.getObject("from_column_id", UUID.class);
Optional<Column> datasetColumn = fromTable.getColumnById(fromId);
if (!datasetColumn.isPresent()) {
throw new CorruptMetadataException("Dataset column referenced by snapshot source map column was not found");
}
UUID toId = rs.getObject("to_column_id", UUID.class);
Optional<Column> snapshotColumn = toTable.getColumnById(toId);
if (!snapshotColumn.isPresent()) {
throw new CorruptMetadataException("Snapshot column referenced by snapshot source map column was not found");
}
return new SnapshotMapColumn().id(rs.getObject("from_column_id", UUID.class)).fromColumn(datasetColumn.get()).toColumn(snapshotColumn.get());
});
return mapColumns;
}
use of bio.terra.common.Column in project jade-data-repo by DataBiosphere.
the class SnapshotService method createSnapshotRelationships.
/**
* Map from a list of source relationships (from a dataset or asset) into snapshot relationships.
*
* @param sourceRelationships relationships from a dataset or asset
* @param snapshotSource source with mapping between dataset tables and columns -> snapshot tables and columns
* @return a list of relationships tied to the snapshot tables
*/
public List<Relationship> createSnapshotRelationships(List<Relationship> sourceRelationships, SnapshotSource snapshotSource) {
// We'll copy the asset relationships into the snapshot.
List<Relationship> snapshotRelationships = new ArrayList<>();
// Create lookups from dataset table and column ids -> snapshot tables and columns, respectively
Map<UUID, Table> tableLookup = new HashMap<>();
Map<UUID, Column> columnLookup = new HashMap<>();
for (SnapshotMapTable mapTable : snapshotSource.getSnapshotMapTables()) {
tableLookup.put(mapTable.getFromTable().getId(), mapTable.getToTable());
for (SnapshotMapColumn mapColumn : mapTable.getSnapshotMapColumns()) {
columnLookup.put(mapColumn.getFromColumn().getId(), mapColumn.getToColumn());
}
}
for (Relationship sourceRelationship : sourceRelationships) {
UUID fromTableId = sourceRelationship.getFromTable().getId();
UUID fromColumnId = sourceRelationship.getFromColumn().getId();
UUID toTableId = sourceRelationship.getToTable().getId();
UUID toColumnId = sourceRelationship.getToColumn().getId();
if (tableLookup.containsKey(fromTableId) && tableLookup.containsKey(toTableId) && columnLookup.containsKey(fromColumnId) && columnLookup.containsKey(toColumnId)) {
Table fromTable = tableLookup.get(fromTableId);
Column fromColumn = columnLookup.get(fromColumnId);
Table toTable = tableLookup.get(toTableId);
Column toColumn = columnLookup.get(toColumnId);
snapshotRelationships.add(new Relationship().name(sourceRelationship.getName()).fromTable(fromTable).fromColumn(fromColumn).toTable(toTable).toColumn(toColumn));
}
}
return snapshotRelationships;
}
use of bio.terra.common.Column in project jade-data-repo by DataBiosphere.
the class SnapshotTableDao method createColumns.
private void createColumns(UUID tableId, Collection<Column> columns) {
MapSqlParameterSource params = new MapSqlParameterSource();
params.addValue("table_id", tableId);
DaoKeyHolder keyHolder = new DaoKeyHolder();
for (Column column : columns) {
params.addValue("name", column.getName());
params.addValue("type", column.getType());
params.addValue("array_of", column.isArrayOf());
jdbcTemplate.update(sqlInsertColumn, params, keyHolder);
UUID columnId = keyHolder.getId();
column.id(columnId);
}
}
use of bio.terra.common.Column in project jade-data-repo by DataBiosphere.
the class SnapshotTableDao method retrieveTables.
public List<SnapshotTable> retrieveTables(UUID parentId) {
MapSqlParameterSource params = new MapSqlParameterSource().addValue("parent_id", parentId);
return jdbcTemplate.query(sqlSelectTable, params, (rs, rowNum) -> {
SnapshotTable table = new SnapshotTable().id(rs.getObject("id", UUID.class)).name(rs.getString("name")).rowCount(rs.getLong("row_count"));
List<Column> columns = retrieveColumns(table);
return table.columns(columns);
});
}
use of bio.terra.common.Column in project jade-data-repo by DataBiosphere.
the class SnapshotDaoTest method happyInOutTest.
@Test
public void happyInOutTest() throws Exception {
snapshotRequest.name(snapshotRequest.getName() + UUID.randomUUID().toString());
String flightId = "happyInOutTest_flightId";
Snapshot snapshot = snapshotService.makeSnapshotFromSnapshotRequest(snapshotRequest);
snapshotId = snapshotDao.createAndLock(snapshot, flightId);
snapshotDao.unlock(snapshotId, flightId);
Snapshot fromDB = snapshotDao.retrieveSnapshot(snapshotId);
assertThat("snapshot name set correctly", fromDB.getName(), equalTo(snapshot.getName()));
assertThat("snapshot description set correctly", fromDB.getDescription(), equalTo(snapshot.getDescription()));
assertThat("correct number of tables created", fromDB.getTables().size(), equalTo(2));
assertThat("correct number of sources created", fromDB.getSnapshotSources().size(), equalTo(1));
// verify source and map
SnapshotSource source = fromDB.getSnapshotSources().get(0);
assertThat("source points back to snapshot", source.getSnapshot().getId(), equalTo(snapshot.getId()));
assertThat("source points to the asset spec", source.getAssetSpecification().getId(), equalTo(dataset.getAssetSpecifications().get(0).getId()));
assertThat("correct number of map tables", source.getSnapshotMapTables().size(), equalTo(2));
// Verify map table
SnapshotMapTable mapTable = source.getSnapshotMapTables().stream().filter(t -> t.getFromTable().getName().equals("thetable")).findFirst().orElseThrow(AssertionError::new);
Table datasetTable = dataset.getTables().stream().filter(t -> t.getName().equals("thetable")).findFirst().orElseThrow(AssertionError::new);
Table snapshotTable = snapshot.getTables().stream().filter(t -> t.getName().equals("thetable")).findFirst().orElseThrow(AssertionError::new);
assertThat("correct map table dataset table", mapTable.getFromTable().getId(), equalTo(datasetTable.getId()));
assertThat("correct map table snapshot table", mapTable.getToTable().getId(), equalTo(snapshotTable.getId()));
assertThat("correct number of map columns", mapTable.getSnapshotMapColumns().size(), equalTo(1));
// Verify map columns
SnapshotMapColumn mapColumn = mapTable.getSnapshotMapColumns().get(0);
// Why is dataset columns Collection and not List?
Column datasetColumn = datasetTable.getColumns().iterator().next();
Column snapshotColumn = snapshotTable.getColumns().get(0);
assertThat("correct map column dataset column", mapColumn.getFromColumn().getId(), equalTo(datasetColumn.getId()));
assertThat("correct map column snapshot column", mapColumn.getToColumn().getId(), equalTo(snapshotColumn.getId()));
List<Relationship> relationships = fromDB.getRelationships();
assertThat("a relationship comes back", relationships.size(), equalTo(1));
Relationship relationship = relationships.get(0);
Table fromTable = relationship.getFromTable();
Column fromColumn = relationship.getFromColumn();
Table toTable = relationship.getToTable();
Column toColumn = relationship.getToColumn();
assertThat("from table name matches", fromTable.getName(), equalTo("thetable"));
assertThat("from column name matches", fromColumn.getName(), equalTo("thecolumn"));
assertThat("to table name matches", toTable.getName(), equalTo("anothertable"));
assertThat("to column name matches", toColumn.getName(), equalTo("anothercolumn"));
assertThat("relationship points to the snapshot table", fromTable.getId(), equalTo(snapshotTable.getId()));
}
Aggregations