private String generateEqualityString(
List<Expression> equalities, List<List<FormulaVariable>> variables, boolean with) {
StringBuilder localResult = new StringBuilder();
StringBuilder prefix = new StringBuilder();
if (useSaveFormat) {
if (with) {
prefix.append("\n").append(generateIndent()).append("with ");
} else {
prefix.append(",\n").append(generateIndent());
}
} else {
prefix.append(",\n").append(generateIndent());
}
for (int i = 0; i < equalities.size(); i++) {
Expression expression = equalities.get(i).clone();
if (utility.setVariableDescriptions(expression, variables)) {
if (useSaveFormat) {
String expressionString = expression.toSaveString();
if (with) {
expressionString = expressionString.replaceAll("==", "=");
}
localResult.append(expressionString);
} else {
localResult.append(expression.toString());
}
if (i != equalities.size() - 1) {
localResult.append(", ");
}
}
}
if (!localResult.toString().isEmpty()) {
localResult.insert(0, prefix.toString());
}
return localResult.toString();
}
public void visitComplexConjunctiveQuery(ComplexConjunctiveQuery complexQuery) {
stack.add(0, complexQuery);
// List<FormulaVariable> universalVariables =
// variableFinder.getUniversalVariables(variableMaps, stack);
// variables.add(0, universalVariables);
result.append(
generateConjunctionString(
complexQuery.getGenerators(),
variables,
mappingTask.getSourceProxy().getIntermediateSchema()));
result.append(generateBuiltinsForSelections(complexQuery));
List<Expression> equalities = variableFinder.getEqualities(variableMaps, stack);
if (!equalities.isEmpty()) {
result.append(generateEqualityString(equalities, variables, false));
}
// intersection
if (complexQuery.hasIntersection()) {
if (useSaveFormat) {
result.append(", \n");
} else {
result
.append("\n")
.append(generateIndent())
.append(utility.SECONDARY_INDENT)
.append("and ");
}
SimpleConjunctiveQuery intersectionQuery = complexQuery.getConjunctionForIntersection();
stack.add(0, intersectionQuery);
List<FormulaVariable> existentialVariables =
variableFinder.getExistentialVariables(variableMaps, stack);
variables.add(0, existentialVariables);
if (!existentialVariables.isEmpty() && !useSaveFormat) {
result.append("exist ");
result.append(utility.printVariables(existentialVariables));
}
if (!useSaveFormat) {
result.append(" (// base view ").append(intersectionQuery.getId()).append("\n");
}
result.append(
generateConjunctionString(
intersectionQuery.getGenerators(),
variables,
mappingTask.getSourceProxy().getIntermediateSchema()));
List<Expression> intersectionEqualities = variableFinder.getEqualities(variableMaps, stack);
if (!intersectionEqualities.isEmpty()) {
result.append(generateEqualityString(intersectionEqualities, variables, false));
}
variables.remove(0);
stack.remove(0);
if (!useSaveFormat) {
result.append("\n").append(generateIndent()).append(utility.SECONDARY_INDENT).append(")");
}
}
// variables.remove(0);
stack.remove(0);
}
//////////////////////////////// PREMISE ////////////////////////////////////////////////
private String premiseString(FORule rule, MappingTask mappingTask, String indent) {
StringBuilder result = new StringBuilder();
List<List<FormulaVariable>> variables = new ArrayList<List<FormulaVariable>>();
List<FormulaVariable> universalVariables = rule.getUniversalFormulaVariables(mappingTask);
variables.add(0, universalVariables);
if (!useSaveFormat) {
result.append(indent).append("for each ");
result.append(utility.printVariables(universalVariables));
result.append("\n");
}
result.append(runVisitor(rule, mappingTask, indent));
variables.remove(0);
return result.toString();
}
private String generateConjunctionString(
List<SetAlias> setVariables, List<List<FormulaVariable>> variables, INode schema) {
StringBuilder localResult = new StringBuilder();
List<SetAlias> sortedAliases = new ArrayList<SetAlias>(setVariables);
Collections.sort(sortedAliases);
for (int i = 0; i < sortedAliases.size(); i++) {
SetAlias sourceVariable = sortedAliases.get(i);
localResult.append(generateIndent());
if (!useSaveFormat) {
localResult.append(
utility.printAtomName(sourceVariable, mappingTask.getSourceProxy().isNested()));
} else {
localResult.append(
utility.printAtomNameForSaveFormat(
sourceVariable, mappingTask.getSourceProxy().isNested()));
}
List<VariablePathExpression> attributePaths = sourceVariable.getFirstLevelAttributes(schema);
for (int j = 0; j < attributePaths.size(); j++) {
VariablePathExpression attributePath = attributePaths.get(j);
FormulaVariable attributeVariable = findVariableForPath(attributePath, variables);
localResult.append(attributePath.getLastStep()).append(": ");
if (useSaveFormat) {
localResult.append("$");
}
localResult.append(attributeVariable.toShortString());
if (j != attributePaths.size() - 1) {
localResult.append(", ");
}
}
localResult.append(")");
if (i != sortedAliases.size() - 1) {
localResult.append(", \n");
}
}
return localResult.toString();
}
private String generateBuiltinsForSelections(ComplexConjunctiveQuery query) {
StringBuilder localResult = new StringBuilder();
if (query.getAllSelections().size() > 0) {
localResult.append(", ");
}
for (int i = 0; i < query.getAllSelections().size(); i++) {
VariableSelectionCondition selection = query.getAllSelections().get(i);
Expression expression = selection.getCondition().clone();
utility.setVariableDescriptions(expression, variables);
if (useSaveFormat) {
String expressionString = expression.toSaveString();
localResult.append(expressionString);
} else {
localResult.append(expression.toString());
}
if (i != query.getAllSelections().size() - 1) {
localResult.append(", ");
}
}
return localResult.toString();
}
public void visitNegatedComplexQuery(NegatedComplexQuery negatedQuery) {
stack.add(0, negatedQuery);
List<FormulaVariable> existentialVariables =
variableFinder.getExistentialVariables(variableMaps, stack);
variables.add(0, existentialVariables);
result
.append("\n")
.append(generateIndent())
.append(utility.SECONDARY_INDENT)
.append("and not ");
if (useSaveFormat) {
result.append("exists ");
} else {
if (!existentialVariables.isEmpty()) {
result.append("exist ");
result.append(utility.printVariables(existentialVariables));
}
}
ComplexQueryWithNegations childQuery = negatedQuery.getComplexQuery();
result.append(" (");
if (!useSaveFormat) {
result
.append("//")
.append(negatedQuery.getProvenance())
.append(" - ")
.append(childQuery.getId());
}
result.append("\n");
childQuery.accept(this);
List<Expression> equalities = variableFinder.getEqualities(variableMaps, stack);
if (!equalities.isEmpty()) {
result.append(generateEqualityString(equalities, variables, true));
}
result.append("\n").append(generateIndent()).append(utility.SECONDARY_INDENT).append(")");
variables.remove(0);
stack.remove(0);
}
//////////////////////////////// CONCLUSION ////////////////////////////////////////////////
public String conclusionString(FORule tgd, MappingTask mappingTask, String indent) {
// giannisk
// find target paths that have a constant value correspondence
List<VariablePathExpression> constantTargetPaths = new ArrayList<VariablePathExpression>();
HashMap<VariablePathExpression, ISourceValue> constantValueMap =
new HashMap<VariablePathExpression, ISourceValue>();
for (VariableCorrespondence varCor : tgd.getCoveredCorrespondences()) {
if (varCor.isConstant()) {
constantTargetPaths.add(varCor.getTargetPath());
constantValueMap.put(varCor.getTargetPath(), varCor.getSourceValue());
}
}
StringBuilder result = new StringBuilder();
List<FormulaVariable> universalVariables = tgd.getUniversalFormulaVariables(mappingTask);
List<FormulaVariable> existentialVariables = tgd.getExistentialFormulaVariables(mappingTask);
if (!useSaveFormat
&& (!existentialVariables.isEmpty() || mappingTask.getTargetProxy().isNested())) {
result.append("exist ");
if (mappingTask.getTargetProxy().isNested()) {
utility.printOIDVariables(tgd.getTargetView());
}
if (!existentialVariables.isEmpty()) {
result.append(utility.printVariables(existentialVariables));
}
}
result.append("\n");
for (int i = 0; i < tgd.getTargetView().getGenerators().size(); i++) {
SetAlias targetVariable = tgd.getTargetView().getGenerators().get(i);
result.append(indent).append(utility.INDENT);
if (!useSaveFormat) {
result.append(
utility.printAtomName(targetVariable, mappingTask.getTargetProxy().isNested()));
} else {
result.append(
utility.printAtomNameForSaveFormat(
targetVariable, mappingTask.getTargetProxy().isNested()));
}
List<VariablePathExpression> attributePaths =
targetVariable.getFirstLevelAttributes(
mappingTask.getTargetProxy().getIntermediateSchema());
for (int j = 0; j < attributePaths.size(); j++) {
VariablePathExpression attributePath = attributePaths.get(j);
result.append(attributePath.getLastStep()).append(": ");
FormulaVariable attributeVariable =
findUniversalVariableForTargetPath(attributePath, universalVariables);
Expression transformation = null;
if (!constantTargetPaths.contains(attributePath)) {
if (attributeVariable == null) {
attributeVariable =
findExistentialVariable(
attributePath, tgd.getExistentialFormulaVariables(mappingTask));
}
transformation = attributeVariable.getTransformationFunction(attributePath);
}
if (transformation == null) {
if (!constantTargetPaths.contains(attributePath)) {
if (useSaveFormat) {
result.append("$");
}
result.append(attributeVariable.toShortString());
} else { // constant
result.append(constantValueMap.get(attributePath));
}
} else { // function
List<List<FormulaVariable>> variables = new ArrayList<List<FormulaVariable>>();
variables.add(tgd.getUniversalFormulaVariables(mappingTask));
utility.setVariableDescriptions(transformation, variables);
result.append(transformation);
}
if (j != attributePaths.size() - 1) {
result.append(", ");
}
}
result.append(")");
if (i != tgd.getTargetView().getGenerators().size() - 1) {
result.append(", \n");
}
}
return result.toString();
}
