/**
* Validates a new table layout against a reference layout for mutual compatibility.
*
* @param reference the reference layout against which to validate.
* @param layout the new layout to validate.
* @throws IOException in case of an IO Error reading from the schema table. Throws
* InvalidLayoutException if the layouts are incompatible.
*/
public void validate(KijiTableLayout reference, KijiTableLayout layout) throws IOException {
final ProtocolVersion layoutVersion = ProtocolVersion.parse(layout.getDesc().getVersion());
if (layoutVersion.compareTo(Versions.LAYOUT_VALIDATION_VERSION) < 0) {
// Layout versions older than layout-1.3.0 do not require validation
return;
}
// Accumulator for error messages which will be used to create an exception if errors occur.
final List<String> incompatabilityMessages = Lists.newArrayList();
// Iterate through all families/columns in the new layout,
// find a potential matching reference family/column,
// and validate the reader/writer schema sets.
// If no matching family/column exists in the reference layout the newly create column is valid.
for (FamilyLayout flayout : layout.getFamilies()) {
final ColumnId lgid = flayout.getLocalityGroup().getId();
LocalityGroupLayout refLGLayout = null;
if (reference != null) {
// If there is a reference layout, check for a locality group matching the ID of the LG for
// this family. Locality Group IDs should not change between layouts.
final String refLGName = reference.getLocalityGroupIdNameMap().get(lgid);
if (refLGName != null) {
// If there is a matching reference LG get its layout by name.
refLGLayout = reference.getLocalityGroupMap().get(refLGName);
}
}
// The ColumnId of the FamilyLayout from the table layout. Also matches the FamilyLayout for
// this family in the reference layout if present.
final ColumnId familyId = flayout.getId();
if (flayout.isMapType()) {
// If the family is map-type, get the CellSchema for all values in the family.
final CellSchema cellSchema = flayout.getDesc().getMapSchema();
FamilyLayout refFamilyLayout = null;
if (refLGLayout != null) {
// If there is a matching reference LG, check for the existence of this family.
final String refFamilyName = refLGLayout.getFamilyIdNameMap().get(familyId);
if (refFamilyName != null) {
refFamilyLayout = refLGLayout.getFamilyMap().get(refFamilyName);
}
}
if (refFamilyLayout != null) {
if (refFamilyLayout.isMapType()) {
// If the FamilyLayout from both table layouts are map type, compare their CellSchemas.
final CellSchema refCellSchema = refFamilyLayout.getDesc().getMapSchema();
incompatabilityMessages.addAll(
addColumnNamestoIncompatibilityMessages(
flayout.getName(), null, validateCellSchema(refCellSchema, cellSchema)));
} else if (refFamilyLayout.isGroupType()) {
// If the FamilyLayout changed from group-type to map-type between table layout versions
// that is an incompatible change.
incompatabilityMessages.add(
String.format(
"Family: %s changed from group-type to map-type.", refFamilyLayout.getName()));
} else {
throw new InternalKijiError(
String.format(
"Family: %s is neither map-type nor group-type.", refFamilyLayout.getName()));
}
} else {
// If the reference FamilyLayout is null this indicates a new family, which is inherently
// compatible, but we still have to validate that the new readers and writers are
// internally compatible.
incompatabilityMessages.addAll(
addColumnNamestoIncompatibilityMessages(
flayout.getName(), null, validateCellSchema(null, cellSchema)));
}
} else if (flayout.isGroupType()) {
// Check for a matching family from the reference layout.
FamilyLayout refFamilyLayout = null;
if (refLGLayout != null) {
final String refFamilyName = refLGLayout.getFamilyIdNameMap().get(familyId);
if (refFamilyName != null) {
refFamilyLayout = refLGLayout.getFamilyMap().get(refFamilyName);
}
}
if (refFamilyLayout != null) {
if (refFamilyLayout.isGroupType()) {
// If there is a matching reference family and it is the same family type, iterate
// through the columns checking schema compatibility. Only checks columns from the new
// layout because removed columns are inherently valid.
for (ColumnLayout columnLayout : flayout.getColumns()) {
final CellSchema cellSchema = columnLayout.getDesc().getColumnSchema();
final String refColumnName =
refFamilyLayout.getColumnIdNameMap().get(columnLayout.getId());
ColumnLayout refColumnLayout = null;
if (refColumnName != null) {
// If there is a column from the reference layout with the same column ID, get its
// layout.
refColumnLayout = refFamilyLayout.getColumnMap().get(refColumnName);
}
// If there is a column from the reference layout with the same column ID, get its
// CellSchema.
final CellSchema refCellSchema =
(refColumnLayout == null) ? null : refColumnLayout.getDesc().getColumnSchema();
// If there is no matching column, refCellSchema will be null and this will only test
// that the new reader and writer schemas are internally compatible.
incompatabilityMessages.addAll(
addColumnNamestoIncompatibilityMessages(
flayout.getName(),
columnLayout.getName(),
validateCellSchema(refCellSchema, cellSchema)));
}
} else if (refFamilyLayout.isMapType()) {
// If the FamilyLayout changed from map-type to group-type between table layout versions
// that is an incompatible change.
incompatabilityMessages.add(
String.format(
"Family: %s changed from map-type to group-type.", refFamilyLayout.getName()));
} else {
throw new InternalKijiError(
String.format(
"Family: %s is neither map-type nor group-type.", refFamilyLayout.getName()));
}
} else {
// If the reference FamilyLayout is null this indicates a new family, which is inherently
// compatible, but we still have to validate that the new readers and writers are
// internally compatible.
for (ColumnLayout columnLayout : flayout.getColumns()) {
final CellSchema cellSchema = columnLayout.getDesc().getColumnSchema();
incompatabilityMessages.addAll(
addColumnNamestoIncompatibilityMessages(
flayout.getName(),
columnLayout.getName(),
validateCellSchema(null, cellSchema)));
}
}
} else {
throw new InternalKijiError(
String.format("Family: %s is neither map-type nor group-type.", flayout.getName()));
}
}
// If there were any incompatibility errors, throw an exception.
if (incompatabilityMessages.size() != 0) {
throw new InvalidLayoutSchemaException(incompatabilityMessages);
}
}
/**
* Initializes a new specification for an Entity from an annotated Java class.
*
* @param klass Annotated Java class to derive an entity specification from.
* @param kiji Kiji instance where to fetch entities from.
* @throws IOException on I/O error.
*/
public EntitySpec(Class<T> klass, Kiji kiji) throws IOException {
mClass = klass;
final KijiEntity entity = klass.getAnnotation(KijiEntity.class);
Preconditions.checkArgument(
entity != null, "Class '{}' has no @KijiEntity annotation.", klass);
mTableName = entity.table();
final KijiTable table = kiji.openTable(mTableName);
try {
final KijiTableLayout layout = table.getLayout();
// TODO: Support deprecated RowKeyFormat?
final RowKeyFormat2 rowKeyFormat = (RowKeyFormat2) layout.getDesc().getKeysFormat();
final Map<String, RowKeyComponent> rkcMap = Maps.newHashMap();
final Map<String, Integer> rkcIndexMap = Maps.newHashMap();
for (int index = 0; index < rowKeyFormat.getComponents().size(); ++index) {
final RowKeyComponent rkc = rowKeyFormat.getComponents().get(index);
rkcMap.put(rkc.getName(), rkc);
rkcIndexMap.put(rkc.getName(), index);
}
mRowKeyComponentMap = ImmutableMap.copyOf(rkcMap);
mRowKeyComponentIndexMap = ImmutableMap.copyOf(rkcIndexMap);
// --------------------------------------------------------------------
// Parse fields with annotations from the entity class:
final List<Field> columnFields = Lists.newArrayList();
final List<Field> entityIdFields = Lists.newArrayList();
for (final Field field : mClass.getDeclaredFields()) {
final KijiColumn column = field.getAnnotation(KijiColumn.class);
final EntityIdField eidField = field.getAnnotation(EntityIdField.class);
if ((column != null) && (eidField != null)) {
throw new IllegalArgumentException(
String.format(
"Field '%s' cannot have both @KijiColumn and @EntityIdField annotations.",
field));
} else if (column != null) {
LOG.debug("Validating column field '{}'.", field);
field.setAccessible(true);
columnFields.add(field);
final FamilyLayout flayout = layout.getFamilyMap().get(column.family());
Preconditions.checkArgument(
flayout != null,
"Field '%s' maps to non-existing family '%s' from table '%s'.",
field,
column.family(),
mTableName);
if (column.qualifier().isEmpty()) {
// Request for a map-type family:
Preconditions.checkArgument(
flayout.isMapType(),
"Field '%s' maps to family '%s' from table '%s' which is not a map-type family.",
field,
column.family(),
mTableName);
// Validate field type:
if (column.pageSize() > 0) {
Preconditions.checkArgument(
MapFamilyVersionIterator.class.isAssignableFrom(field.getType()),
"Fields mapped to map-type family with paging enabled must be "
+ "MapFamilyVersionIterator, got '{}'.",
field.getType());
} else {
// TODO Validate type when no paging enabled on map-type family.
}
} else {
// Request for a fully-qualified column:
final ColumnLayout clayout = flayout.getColumnMap().get(column.qualifier());
Preconditions.checkArgument(
flayout != null,
"Field '%s' maps to non-existing column '%s:%s' from table '%s'.",
field,
column.family(),
column.qualifier(),
mTableName);
// Validate field type:
if (column.pageSize() > 0) {
Preconditions.checkArgument(
ColumnVersionIterator.class.isAssignableFrom(field.getType()),
"Fields mapped to column with paging enabled must be "
+ "ColumnVersionIterator, got '{}'.",
field.getType());
} else {
// TODO Validate type when no paging enabled on the column.
}
}
} else if (eidField != null) {
LOG.debug("Validating entity ID field '{}'.", field);
field.setAccessible(true);
entityIdFields.add(field);
final RowKeyComponent rkc = mRowKeyComponentMap.get(eidField.component());
Preconditions.checkArgument(
rkc != null,
"Field '%s' maps to unknown entity ID component '%s'.",
field,
eidField.component());
} else {
LOG.debug("Ignoring field '{}' with no annotation.", field);
}
}
mColumnFields = ImmutableList.copyOf(columnFields);
mEntityIdFields = ImmutableList.copyOf(entityIdFields);
} finally {
table.release();
}
}
