use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.
the class ClassificationHandler method getSourceExpressionAsCQL.
/**
* @see eu.esdihumboldt.hale.io.appschema.writer.internal.AbstractPropertyTransformationHandler#getSourceExpressionAsCQL()
*/
@Override
protected String getSourceExpressionAsCQL() {
Property source = AppSchemaMappingUtils.getSourceProperty(propertyCell);
PropertyDefinition sourceDef = source.getDefinition().getDefinition();
Property target = AppSchemaMappingUtils.getTargetProperty(propertyCell);
PropertyDefinition targetDef = target.getDefinition().getDefinition();
String sourceName = source.getDefinition().getDefinition().getName().getLocalPart();
ListMultimap<String, ParameterValue> parameters = propertyCell.getTransformationParameters();
LookupTable lookup = ClassificationMappingUtil.getClassificationLookup(parameters, new ServiceManager(ServiceManager.SCOPE_PROJECT));
if (lookup == null) {
log.warn("No classification specified");
return "''";
} else {
String cqlTemplate = "if_then_else(in(%s), Recode(%s,%s), %s)";
// build args to Recode function
StringBuilder recodeArgsBuilder = new StringBuilder();
Map<Value, Value> valueMap = lookup.asMap();
int counter = 0;
for (Value sourceValue : valueMap.keySet()) {
Value targetValue = valueMap.get(sourceValue);
String sourceLiteral = asCqlLiteral(sourceDef, sourceValue.as(String.class));
String targetLiteral = asCqlLiteral(targetDef, targetValue.as(String.class));
recodeArgsBuilder.append(sourceLiteral).append(",").append(targetLiteral);
if (counter < valueMap.size() - 1) {
recodeArgsBuilder.append(",");
}
counter++;
}
String recodeArgs = recodeArgsBuilder.toString();
// build args for in function
List<String> values = new ArrayList<String>();
for (Value v : valueMap.keySet()) {
String valueLiteral = asCqlLiteral(sourceDef, v.as(String.class));
values.add(valueLiteral);
}
values.add(0, sourceName);
String inArgs = Joiner.on(",").join(values);
// determine what to put in the "else" branch, based on
// transformation parameters
String elsePart = null;
List<ParameterValue> notClassifiedParam = parameters.get(PARAMETER_NOT_CLASSIFIED_ACTION);
String notClassifiedAction = null;
if (notClassifiedParam != null && notClassifiedParam.size() > 0) {
notClassifiedAction = notClassifiedParam.get(0).as(String.class);
} else {
notClassifiedAction = USE_NULL_ACTION;
}
if (USE_SOURCE_ACTION.equals(notClassifiedAction))
elsePart = sourceName;
else if (notClassifiedAction.startsWith(USE_FIXED_VALUE_ACTION_PREFIX))
elsePart = asCqlLiteral(targetDef, notClassifiedAction.substring(notClassifiedAction.indexOf(':') + 1));
else if (USE_NULL_ACTION.equals(notClassifiedAction))
elsePart = "Expression.NIL";
return String.format(cqlTemplate, inArgs, sourceName, recodeArgs, elsePart);
}
}
use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.
the class JoinHandler method handleTypeTransformation.
/**
* @see eu.esdihumboldt.hale.io.appschema.writer.internal.TypeTransformationHandler#handleTypeTransformation(eu.esdihumboldt.hale.common.align.model.Cell,
* eu.esdihumboldt.hale.io.appschema.writer.internal.mapping.AppSchemaMappingContext)
*/
@Override
public FeatureTypeMapping handleTypeTransformation(Cell typeCell, AppSchemaMappingContext context) {
AppSchemaMappingWrapper mapping = context.getMappingWrapper();
Alignment alignment = context.getAlignment();
FeatureChaining featureChaining = context.getFeatureChaining();
final JoinParameter joinParameter = typeCell.getTransformationParameters().get(PARAMETER_JOIN).get(0).as(JoinParameter.class);
String validation = joinParameter.validate();
if (validation != null)
throw new IllegalArgumentException("Join parameter invalid: " + validation);
// check only single predicate conditions have been used
int[] conditionCount = new int[joinParameter.getTypes().size()];
List<JoinCondition> joinConditions = getSortedJoinConditions(joinParameter);
for (JoinCondition joinCondition : joinConditions) {
TypeEntityDefinition joinType = AlignmentUtil.getTypeEntity(joinCondition.joinProperty);
int typeIdx = joinParameter.getTypes().indexOf(joinType);
conditionCount[typeIdx]++;
if (conditionCount[typeIdx] > 1) {
throw new IllegalArgumentException("Only single condition joins are supported so far");
}
}
FeatureTypeMapping topMostMapping = null;
for (int chainIdx = 0; chainIdx < joinParameter.getTypes().size() - 1; chainIdx++) {
ChainConfiguration previousChainConf = null;
ChainConfiguration chainConf = null;
if (featureChaining != null) {
chainConf = featureChaining.getChain(typeCell.getId(), chainIdx);
if (chainConf != null && chainConf.getPrevChainIndex() >= 0) {
previousChainConf = featureChaining.getChain(typeCell.getId(), chainConf.getPrevChainIndex());
}
}
// join is done pair-wise: I assume the first type is the container
// type, whereas the second type is nested in the first
JoinCondition joinCondition = joinConditions.get(chainIdx);
baseProperty = joinCondition.baseProperty;
joinProperty = joinCondition.joinProperty;
TypeEntityDefinition containerType = AlignmentUtil.getTypeEntity(baseProperty);
TypeEntityDefinition nestedType = AlignmentUtil.getTypeEntity(joinProperty);
// build FeatureTypeMapping for container type
// Entity containerTypeTarget = typeCell.getTarget().values().iterator().next();
// TypeDefinition containerTypeTargetType = containerTypeTarget.getDefinition().getType();
EntityDefinition containerTypeTarget = null;
TypeDefinition containerTypeTargetType = null;
String containerTypeTargetMappingName = null;
if (previousChainConf == null) {
containerTypeTarget = getTargetType(typeCell).getDefinition();
containerTypeTargetType = containerTypeTarget.getType();
} else {
containerTypeTarget = previousChainConf.getNestedTypeTarget();
containerTypeTargetType = previousChainConf.getNestedTypeTarget().getDefinition().getPropertyType();
containerTypeTargetMappingName = previousChainConf.getMappingName();
}
String containerMappingName = null;
if (previousChainConf != null) {
containerMappingName = previousChainConf.getMappingName();
}
FeatureTypeMapping containerFTMapping = context.getOrCreateFeatureTypeMapping(containerTypeTargetType, containerMappingName);
containerFTMapping.setSourceType(containerType.getDefinition().getName().getLocalPart());
// build FeatureTypeMapping for nested type
TypeDefinition nestedFT = null;
List<ChildContext> nestedFTPath = null;
FeatureTypeMapping nestedFTMapping = null;
if (chainConf != null) {
nestedFT = chainConf.getNestedTypeTarget().getDefinition().getPropertyType();
nestedFTPath = chainConf.getNestedTypeTarget().getPropertyPath();
// remove last element
nestedFTPath = nestedFTPath.subList(0, nestedFTPath.size() - 1);
nestedFTMapping = context.getOrCreateFeatureTypeMapping(nestedFT, chainConf.getMappingName());
nestedFTMapping.setSourceType(nestedType.getDefinition().getName().getLocalPart());
} else {
if (joinParameter.getTypes().size() > 2) {
throw new IllegalArgumentException("If no feature chaining configuration is provided, only join between 2 types is supported");
}
// do your best to figure it out on your own... good luck!
Collection<? extends Cell> propertyCells = alignment.getPropertyCells(typeCell);
for (Cell propertyCell : propertyCells) {
Property sourceProperty = AppSchemaMappingUtils.getSourceProperty(propertyCell);
if (sourceProperty != null) {
TypeDefinition sourceType = sourceProperty.getDefinition().getDefinition().getParentType();
if (sourceType.getName().equals(nestedType.getDefinition().getName())) {
// source property belongs to nested type: determine
// target type
Property targetProperty = getTargetProperty(propertyCell);
// nestedFT =
// findOwningFeatureType(targetProperty.getDefinition());
nestedFT = findOwningType(targetProperty.getDefinition(), context.getRelevantTargetTypes());
if (nestedFT != null && !nestedFT.getName().equals(containerTypeTargetType.getName())) {
// target property belongs to a feature type
// different from the already mapped one: build
// a new mapping
nestedFTPath = findOwningTypePath(targetProperty.getDefinition(), context.getRelevantTargetTypes());
nestedFTMapping = context.getOrCreateFeatureTypeMapping(nestedFT);
nestedFTMapping.setSourceType(nestedType.getDefinition().getName().getLocalPart());
// in the join
break;
} else if (isHRefAttribute(targetProperty.getDefinition().getDefinition())) {
// check if target property is a href attribute
Property hrefProperty = targetProperty;
List<ChildContext> hrefPropertyPath = hrefProperty.getDefinition().getPropertyPath();
List<ChildContext> hrefContainerPath = hrefPropertyPath.subList(0, hrefPropertyPath.size() - 1);
TypeDefinition hrefParentType = hrefProperty.getDefinition().getDefinition().getParentType();
// TypeDefinition childFT =
// findChildFeatureType(hrefParentType);
TypeDefinition childFT = AppSchemaMappingUtils.findChildType(hrefParentType, context.getRelevantTargetTypes());
if (childFT != null) {
nestedFTPath = hrefContainerPath;
nestedFTMapping = context.getOrCreateFeatureTypeMapping(childFT);
nestedFTMapping.setSourceType(nestedType.getDefinition().getName().getLocalPart());
// involved in the join
break;
}
}
}
}
}
}
// build join mapping
if (nestedFTMapping != null && nestedFTPath != null) {
AttributeMappingType containerJoinMapping = context.getOrCreateAttributeMapping(containerTypeTargetType, containerTypeTargetMappingName, nestedFTPath);
containerJoinMapping.setTargetAttribute(mapping.buildAttributeXPath(containerTypeTargetType, nestedFTPath));
// set isMultiple attribute
PropertyDefinition targetPropertyDef = nestedFTPath.get(nestedFTPath.size() - 1).getChild().asProperty();
if (AppSchemaMappingUtils.isMultiple(targetPropertyDef)) {
containerJoinMapping.setIsMultiple(true);
}
AttributeExpressionMappingType containerSourceExpr = new AttributeExpressionMappingType();
// join column extracted from join condition
containerSourceExpr.setOCQL(baseProperty.getDefinition().getName().getLocalPart());
containerSourceExpr.setLinkElement(getLinkElementValue(nestedFTMapping));
String linkField = context.getUniqueFeatureLinkAttribute(nestedFT, nestedFTMapping.getMappingName());
containerSourceExpr.setLinkField(linkField);
containerJoinMapping.setSourceExpression(containerSourceExpr);
AttributeMappingType nestedJoinMapping = new AttributeMappingType();
AttributeExpressionMappingType nestedSourceExpr = new AttributeExpressionMappingType();
// join column extracted from join condition
nestedSourceExpr.setOCQL(joinProperty.getDefinition().getName().getLocalPart());
nestedJoinMapping.setSourceExpression(nestedSourceExpr);
nestedJoinMapping.setTargetAttribute(linkField);
nestedFTMapping.getAttributeMappings().getAttributeMapping().add(nestedJoinMapping);
}
if (chainIdx == 0) {
topMostMapping = containerFTMapping;
}
}
return topMostMapping;
}
use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.
the class DefaultAlignmentIOTest method testCellDisableSaveLoad.
/**
* Tests cell disable save and load.
*
* @throws Exception if an error occurs
*/
@Test
public void testCellDisableSaveLoad() throws Exception {
DefaultAlignment baseAlignment = new DefaultAlignment();
MutableAlignment alignment = new DefaultAlignment();
Schema schema = TestUtil.loadSchema(getClass().getResource("/testdata/simple/t1.xsd").toURI());
Iterator<? extends TypeDefinition> iter = schema.getMappingRelevantTypes().iterator();
TypeDefinition t = iter.next();
if (!t.getName().getLocalPart().equals("T1")) {
t = iter.next();
}
// generate base alignment
DefaultCell cell1 = new DefaultCell();
cell1.setTransformationIdentifier("trans1");
ListMultimap<String, Type> source = ArrayListMultimap.create();
source.put(null, new DefaultType(new TypeEntityDefinition(t, SchemaSpaceID.SOURCE, null)));
cell1.setSource(source);
ListMultimap<String, Type> target = ArrayListMultimap.create();
target.put(null, new DefaultType(new TypeEntityDefinition(t, SchemaSpaceID.TARGET, null)));
cell1.setTarget(target);
DefaultCell cell2 = new DefaultCell();
cell2.setTransformationIdentifier("trans2");
List<ChildContext> childContext2 = new ArrayList<ChildContext>();
PropertyDefinition child2 = DefinitionUtil.getChild(t, new QName("a1")).asProperty();
childContext2.add(new ChildContext(child2));
ListMultimap<String, Property> source2 = ArrayListMultimap.create();
source2.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext2, SchemaSpaceID.SOURCE, null)));
cell2.setSource(source2);
ListMultimap<String, Property> target2 = ArrayListMultimap.create();
target2.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext2, SchemaSpaceID.TARGET, null)));
cell2.setTarget(target2);
DefaultCell cell3 = new DefaultCell();
cell3.setTransformationIdentifier("trans3");
List<ChildContext> childContext3 = new ArrayList<ChildContext>();
PropertyDefinition child3 = DefinitionUtil.getChild(t, new QName("b1")).asProperty();
childContext3.add(new ChildContext(child3));
ListMultimap<String, Property> source3 = ArrayListMultimap.create();
source3.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext3, SchemaSpaceID.SOURCE, null)));
cell3.setSource(source3);
ListMultimap<String, Property> target3 = ArrayListMultimap.create();
target3.put(null, new DefaultProperty(new PropertyEntityDefinition(t, childContext3, SchemaSpaceID.TARGET, null)));
cell3.setTarget(target3);
baseAlignment.addCell(cell1);
baseAlignment.addCell(cell2);
String baseDisableCellId = cell2.getId();
baseAlignment.addCell(cell3);
String extendedDisableCellId = cell3.getId();
assertEquals(3, baseAlignment.getCells().size());
Cell typeCell = baseAlignment.getTypeCells().iterator().next();
assertEquals(2, baseAlignment.getPropertyCells(typeCell).size());
// test disable, it should not be with the related property cells
cell2.setDisabledFor(cell1, true);
assertEquals(1, baseAlignment.getPropertyCells(typeCell).size());
assertTrue(cell2.getDisabledFor().contains(cell1.getId()));
cell2.setDisabledFor(cell1, false);
assertFalse(cell2.getDisabledFor().contains(cell1.getId()));
cell2.setDisabledFor(cell1, true);
assertEquals(1, baseAlignment.getPropertyCells(typeCell).size());
// save base alignment
File baseAlignmentFile = tmp.newFile("alignment_base.xml");
System.out.println(baseAlignmentFile.getAbsolutePath());
saveAlignment(baseAlignment, new BufferedOutputStream(new FileOutputStream(baseAlignmentFile)));
// load base alignment
MutableAlignment baseAlignment2 = loadAlignment(new FileInputStream(baseAlignmentFile), schema, schema);
typeCell = baseAlignment2.getTypeCells().iterator().next();
assertEquals(3, baseAlignment2.getCells().size());
// test again that it is still disabled
assertEquals(1, baseAlignment2.getPropertyCells(typeCell).size());
// disable the remaining enabled cell in extended alignment
addBaseAlignment(alignment, baseAlignmentFile.toURI(), schema, schema);
assertEquals(1, alignment.getBaseAlignments().size());
String usedPrefix = alignment.getBaseAlignments().keySet().iterator().next();
File alignmentFile = tmp.newFile("alignment_extended.xml");
// check cells
typeCell = alignment.getTypeCells().iterator().next();
assertEquals(3, alignment.getCells().size());
assertEquals(1, alignment.getPropertyCells(typeCell).size());
// disable remaining cell
((ModifiableCell) alignment.getPropertyCells(typeCell, false, false).iterator().next()).setDisabledFor(typeCell, true);
assertEquals(0, alignment.getPropertyCells(typeCell).size());
// save / load extended alignment
System.out.println(alignmentFile.getAbsolutePath());
saveAlignment(alignment, new BufferedOutputStream(new FileOutputStream(alignmentFile)));
// load extended
MutableAlignment alignment2 = loadAlignment(new FileInputStream(alignmentFile), schema, schema);
typeCell = alignment2.getTypeCells().iterator().next();
// test disabled again
assertEquals(3, alignment2.getCells().size());
// test again that it is still disabled
assertEquals(0, alignment2.getPropertyCells(typeCell).size());
// more specifically test whether the disables come from base alignment
// or extended alignment
Cell baseDisableCell = alignment2.getCell(usedPrefix + ":" + baseDisableCellId);
Cell extendedDisableCell = alignment2.getCell(usedPrefix + ":" + extendedDisableCellId);
assertTrue(baseDisableCell instanceof BaseAlignmentCell);
assertEquals(1, baseDisableCell.getDisabledFor().size());
assertEquals(1, ((BaseAlignmentCell) baseDisableCell).getBaseDisabledFor().size());
assertEquals(0, ((BaseAlignmentCell) baseDisableCell).getAdditionalDisabledFor().size());
assertTrue(extendedDisableCell instanceof BaseAlignmentCell);
assertEquals(1, extendedDisableCell.getDisabledFor().size());
assertEquals(0, ((BaseAlignmentCell) extendedDisableCell).getBaseDisabledFor().size());
assertEquals(1, ((BaseAlignmentCell) extendedDisableCell).getAdditionalDisabledFor().size());
}
use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.
the class PropertyEntitySelector method createFilters.
private static ViewerFilter[] createFilters(PropertyParameterDefinition field) {
// if no condition is present add a filter that allows all properties
ViewerFilter propertyFilter = new ViewerFilter() {
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
return element instanceof PropertyEntityDefinition;
}
};
if (field == null) {
return new ViewerFilter[] { propertyFilter };
}
List<PropertyCondition> conditions = field.getConditions();
if (conditions == null || conditions.isEmpty())
return new ViewerFilter[] { propertyFilter };
ViewerFilter[] filters = new ViewerFilter[conditions.size()];
int i = 0;
for (final PropertyCondition condition : conditions) {
filters[i] = new ViewerFilter() {
@Override
public boolean select(Viewer viewer, Object parentElement, Object element) {
if (element instanceof PropertyEntityDefinition) {
Property property = new DefaultProperty((PropertyEntityDefinition) element);
return condition.accept(property);
} else
return false;
}
};
}
return filters;
}
use of eu.esdihumboldt.hale.common.align.model.Property in project hale by halestudio.
the class EntityDefinitionServiceImpl method replace.
/**
* Creates a new ListMultimap with all occurrences of originalDef replaced
* by newDef. newDef must be a sibling of originalDef.
*
* @param entities the original list
* @param originalDef the entity definition to be replaced
* @param newDef the entity definition to use
* @return a new list
*/
private ListMultimap<String, ? extends Entity> replace(ListMultimap<String, ? extends Entity> entities, EntityDefinition originalDef, EntityDefinition newDef) {
ListMultimap<String, Entity> newList = ArrayListMultimap.create();
for (Entry<String, ? extends Entity> entry : entities.entries()) {
EntityDefinition entryDef = entry.getValue().getDefinition();
Entity newEntry;
if (AlignmentUtil.isParent(originalDef, entryDef)) {
if (entry.getValue() instanceof Type) {
// entry is a Type, so the changed Definition must be a
// Type, too.
newEntry = new DefaultType((TypeEntityDefinition) newDef);
} else if (entry.getValue() instanceof Property) {
// entry is a Property, check changed Definition.
if (originalDef.getPropertyPath().isEmpty()) {
// Type changed.
newEntry = new DefaultProperty(new PropertyEntityDefinition(newDef.getType(), entryDef.getPropertyPath(), entryDef.getSchemaSpace(), newDef.getFilter()));
} else {
// Some element of the property path changed.
List<ChildContext> newPath = new ArrayList<ChildContext>(entryDef.getPropertyPath());
int lastIndexOfChangedDef = newDef.getPropertyPath().size() - 1;
newPath.set(lastIndexOfChangedDef, newDef.getPropertyPath().get(lastIndexOfChangedDef));
newEntry = new DefaultProperty(new PropertyEntityDefinition(entryDef.getType(), newPath, entryDef.getSchemaSpace(), entryDef.getFilter()));
}
} else {
throw new IllegalStateException("Entity is neither a Type nor a Property.");
}
} else {
newEntry = entry.getValue();
}
newList.put(entry.getKey(), newEntry);
}
return newList;
}
Aggregations