private String generateId(VariableFunctionalDependency dependency) { StringBuilder result = new StringBuilder(); for (VariablePathExpression leftPath : dependency.getLeftPaths()) { result.append(leftPath.getAbsolutePath()); } result.append(" => "); for (VariablePathExpression rightPath : dependency.getRightPaths()) { result.append(rightPath.getAbsolutePath()); } return "" + compactHashCode(result.toString().hashCode()); }
private ISkolemPart generatePartForPaths(List<VariablePathExpression> paths) { ISkolemPart append = new AppendSkolemPart(false, "", "", "-", "-"); List<String> pathStrings = new ArrayList<String>(); for (VariablePathExpression path : paths) { pathStrings.add(SpicyEngineUtility.removeRootLabel(path.getAbsolutePath()).toString()); } Collections.sort(pathStrings); for (String pathString : pathStrings) { append.addChild(new StringSkolemPart(pathString)); } return append; }
public static String generateCasting( VariablePathExpression attributePath, String columnName, MappingTask mappingTask) { INode attributeNode = new FindNode() .findNodeInSchema(attributePath.getAbsolutePath(), mappingTask.getTargetProxy()); String value = attributeNode.getChild(0).getLabel(); String castedColumnName = mappingTask.getDBMSHandler().forceCast(columnName, value); return castedColumnName; }
private ISkolemPart generateAppendsForSubGenerator( SkolemFunctionGenerator generator, MappingTask mappingTask) { ISkolemPart append = new AppendSkolemPart(mappingTask.getConfig().useSortInSkolems(), "(", ")", ", "); for (GeneratorWithPath subGeneratorWithPath : generator.getSubGenerators()) { VariablePathExpression subGeneratorPath = subGeneratorWithPath.getTargetPath(); IValueGenerator subGenerator = subGeneratorWithPath.getGenerator(); ISkolemPart appendForGenerator = new AppendSkolemPart(false, "", "", ": "); StringSkolemPart stringPart = new StringSkolemPart( SpicyEngineUtility.removeRootLabel(subGeneratorPath.getAbsolutePath())); SubGeneratorSkolemPart generatorPart = new SubGeneratorSkolemPart(subGenerator); appendForGenerator.addChild(stringPart); appendForGenerator.addChild(generatorPart); append.addChild(appendForGenerator); } return append; }
private static String sqlString(Expression expression) { String result = ""; List<VariablePathExpression> attributePaths = expression.getAttributePaths(); if (expression.toString().startsWith("isNull(")) { String attributeName = extractAttributeNameFromExpression(attributePaths.get(0)); return attributeName + " IS NULL"; } if (expression.toString().startsWith("isNotNull(")) { String attributeName = extractAttributeNameFromExpression(attributePaths.get(0)); return attributeName + " IS NOT NULL"; } for (VariablePathExpression attributePath : attributePaths) { String attributeName = extractAttributeNameFromExpression(attributePaths.get(0)); result = expression.toString().replaceAll(attributePath.toString(), attributeName); } result = result.replaceAll("==", "="); result = result.replaceAll("\"", "\'"); return result.replaceAll("&&", "AND"); }
private String findGeneratorForPath( VariablePathExpression setPath, FORule rule, MappingTask mappingTask) { List<FormulaVariable> universalVariables = rule.getUniversalFormulaVariables(mappingTask); TGDGeneratorsMap generatorsMap = rule.getGenerators(mappingTask); IValueGenerator generator = generatorsMap.getGeneratorForSetPath(setPath); if (generator == null) { return "SK_" + setPath.toString() + "()"; } if (generator instanceof NullValueGenerator) { return NullValueGenerator.getInstance().toString(); } SkolemFunctionGenerator skolemGenerator = (SkolemFunctionGenerator) generator; return skolemGenerator.toStringWithVariableArguments(universalVariables); }
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(); }
public String convertToPostgres(Expression transformationFunctionExpression, boolean withRel) { String functionExpression = transformationFunctionExpression.getJepExpression().toStringForSql(); // first fix attribute names for (VariablePathExpression vpe : transformationFunctionExpression.getAttributePaths()) { if (functionExpression.contains(vpe.toString())) { String expressionToCheckForSigns = transformationFunctionExpression.getJepExpression().toString(); int startIndex = expressionToCheckForSigns.indexOf(vpe.toString()); int endIndex = startIndex + vpe.toString().length(); boolean castToFloat = false; // check so that the String index will not get out of bounds if (startIndex - 2 >= 0) { if (math_sign.contains(expressionToCheckForSigns.charAt(startIndex - 2))) { castToFloat = true; } // to catch the '>=' or '<=' case else if (expressionToCheckForSigns.charAt(startIndex - 2) == '=' && startIndex - 3 >= 0) { if (expressionToCheckForSigns.charAt(startIndex - 3) == '<' || expressionToCheckForSigns.charAt(startIndex - 3) == '>') { castToFloat = true; } } } if (endIndex + 2 <= expressionToCheckForSigns.length()) { if (math_sign.contains(expressionToCheckForSigns.charAt(endIndex + 1))) { castToFloat = true; } } String newAttrName; // replace them with the corresponding attribute name if (withRel) { newAttrName = GenerateSQL.attributeNameWithVariable(vpe); } else { newAttrName = GenerateSQL.attributeNameInVariable(vpe); } // if previous or next character is one of {+,-,*,/,<,>} cast it to float if (castToFloat) { functionExpression = functionExpression.replaceAll(vpe.toString(), "cast(" + newAttrName + " as float)"); } else { functionExpression = functionExpression.replaceAll(vpe.toString(), newAttrName); } } } return replaceExpression(functionExpression); }
private static String extractAttributeNameFromExpression(VariablePathExpression attributePath) { String variableName = attributePath.getStartingVariable().toShortString(); String lastStep = attributePath.getLastStep(); return GenerateSQL.RELATION_ALIAS_PREFIX + variableName + "." + lastStep; }
public static String attributeNameWithVariable(VariablePathExpression attributePath) { return RELATION_ALIAS_PREFIX + attributePath.getStartingVariable().toShortString() + "." + attributePath.getLastStep(); }
public static String attributeNameInVariable(VariablePathExpression attributePath) { return attributePath.getStartingVariable().toShortString() + attributePath.getLastStep(); }
//////////////////////////////// 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(); }