///////////////////////////////// HYPERGRAPH NODE // ///////////////////////////////////////////////// private ISkolemPart generateHyperGraphSkolemFunction( SkolemFunctionGenerator generator, MappingTask mappingTask) { // initialize data structures Map<SetAlias, List<GeneratorWithPath>> generatorsByAlias = new HashMap<SetAlias, List<GeneratorWithPath>>(); Map<SetAlias, ISkolemPart> partsByAlias = new HashMap<SetAlias, ISkolemPart>(); Map<VariableJoinCondition, ISkolemPart> partsForJoins = new HashMap<VariableJoinCondition, ISkolemPart>(); initializeDataStructures( generator, generatorsByAlias, partsByAlias, partsForJoins, mappingTask); // generate tuple strings ISkolemPart partForTuples = generatePartForTuples(partsByAlias, mappingTask); ISkolemPart partForJoins = generatePartForJoins(generator, partsForJoins, mappingTask); ISkolemPart partForVariable = generatePartForVariable(generator, partsForJoins, mappingTask); ISkolemPart result = new AppendSkolemPart(); result.addChild(new StringSkolemPart("SK(")); result.addChild(new StringSkolemPart("Tuples=")); result.addChild(partForTuples); result.addChild(new StringSkolemPart("**Joins=")); result.addChild(partForJoins); if (generator.getTgd().getTargetView().getAllJoinConditions().size() > 1) { result.addChild(new StringSkolemPart("**Var=")); result.addChild(partForVariable); } if (generator.getPosition() != null) { result.addChild(new StringSkolemPart("**Pos=" + generator.getPosition())); } result.addChild(new StringSkolemPart(")")); return result; }
///////////////////////////////// LOCAL NODE ///////////////////////////////////////////////// private ISkolemPart generateLocalSkolemFunction( SkolemFunctionGenerator generator, MappingTask mappingTask) { StringBuilder functionName = new StringBuilder(); functionName.append("SK_"); functionName.append("TGD").append(compactHashCode(generator.getTgd().hashCode())).append("_"); functionName .append("N") .append(compactHashCode(generator.getJoinConditions().toString().hashCode())); if (generator.getPosition() != null) { functionName.append("_Pos=").append(generator.getPosition()); } return generateAppendWithFunctionName(functionName.toString(), generator, mappingTask); }
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); }
///////////////////////////////// KEY NODE ///////////////////////////////////////////////// private ISkolemPart generateSkolemFunctionForKey( SkolemFunctionGenerator generator, MappingTask mappingTask) { StringBuilder functionName = new StringBuilder(); functionName.append("SK_"); // // functionName.append("TGD_").append(compactHashCode(generator.getTgd().hashCode())).append("_"); functionName .append("KEY_") .append(compactHashCode(generator.getFunctionalDependencies().get(0).hashCode())); if (generator.getPosition() != null) { functionName.append("_Pos=").append(generator.getPosition()); } return generateAppendWithFunctionName(functionName.toString(), generator, mappingTask); }
//////////////////////////// third part: variable part private ISkolemPart generatePartForVariable( SkolemFunctionGenerator generator, Map<VariableJoinCondition, ISkolemPart> partsForJoins, MappingTask mappingTask) { if (generator.getJoinConditions().isEmpty()) { return NullSkolemPart.getInstance(); } ISkolemPart append = new AppendSkolemPart(mappingTask.getConfig().useSortInSkolems(), "", "", ", "); for (VariableJoinCondition variableJoinCondition : generator.getJoinConditions()) { append.addChild(partsForJoins.get(variableJoinCondition)); } return append; }
///////////////////////////////// INTERMEDIATE NODE // ///////////////////////////////////////////////// private ISkolemPart generateSkolemFunctionForIntermediateNode( SkolemFunctionGenerator generator, MappingTask mappingTask) { StringBuilder functionName = new StringBuilder(); functionName.append("SK_"); functionName.append(SpicyEngineUtility.removeRootLabel(generator.getName())); return generateAppendWithFunctionName(functionName.toString(), generator, mappingTask); }
private String findGeneratorForVariable( FormulaVariable variable, FORule rule, MappingTask mappingTask) { List<FormulaVariable> universalVariables = rule.getUniversalFormulaVariablesInTarget(mappingTask); TGDGeneratorsMap generatorsMap = rule.getGenerators(mappingTask); for (VariablePathExpression targetPath : variable.getTargetOccurrencePaths()) { IValueGenerator generator = generatorsMap.getGeneratorForLeaf( targetPath, mappingTask.getTargetProxy().getIntermediateSchema()); if (generator != null && generator instanceof SkolemFunctionGenerator) { SkolemFunctionGenerator skolemGenerator = (SkolemFunctionGenerator) generator; return skolemGenerator.toStringWithVariableArguments(universalVariables); } } return NullValueGenerator.getInstance().toString(); // throw new IllegalArgumentException("Unable to find generator for variable: " + // variable.toLongString() + "\nin rule: " + rule + "\n" + // SpicyEngineUtility.printVariableList(rule.getExistentialFormulaVariables(mappingTask)) + // "\nGenerators: " + generatorsMap); }
public ISkolemPart generateSkolemFunction( SkolemFunctionGenerator generator, MappingTask mappingTask) { if (generator.isLeafGenerator()) { if (generator.getType() == SkolemFunctionGenerator.STANDARD) { if (mappingTask.getConfig().useLocalSkolem()) { return generateLocalSkolemFunction(generator, mappingTask); } else { return generateHyperGraphSkolemFunction(generator, mappingTask); } } else if (generator.getType() == SkolemFunctionGenerator.KEY) { return generateSkolemFunctionForKey(generator, mappingTask); } else if (generator.getType() == SkolemFunctionGenerator.EGD_BASED) { return generateEGDSkolemFunction(generator, mappingTask); } throw new IllegalArgumentException( "Incorrect type for leaf generator: " + generator + " - Type: " + generator.getType()); } else { return generateSkolemFunctionForIntermediateNode(generator, mappingTask); } }
private String generateEGDFunctionName( SkolemFunctionGenerator generator, MappingTask mappingTask) { StringBuilder result = new StringBuilder(); List<String> fds = new ArrayList<String>(); for (VariableFunctionalDependency functionalDependency : generator.getFunctionalDependencies()) { fds.add("-" + generateId(functionalDependency)); } Collections.sort(fds); for (int i = 0; i < fds.size(); i++) { result.append(fds.get(i)); } return "SK_EGDs" + compactHashCode(result.toString().hashCode()); }
private Map<SetAlias, List<GeneratorWithPath>> groupGeneratorsByAlias( SkolemFunctionGenerator skolemFunction) { Map<SetAlias, List<GeneratorWithPath>> groups = new HashMap<SetAlias, List<GeneratorWithPath>>(); for (GeneratorWithPath subGenerator : skolemFunction.getSubGenerators()) { SetAlias generatorVariable = subGenerator.getTargetPath().getStartingVariable(); List<GeneratorWithPath> variableGroup = groups.get(generatorVariable); if (variableGroup == null) { variableGroup = new ArrayList<GeneratorWithPath>(); groups.put(generatorVariable, variableGroup); } variableGroup.add(subGenerator); } return groups; }
//////////////////////////// step 1.a: initialize data structures private void initializeDataStructures( SkolemFunctionGenerator generator, Map<SetAlias, List<GeneratorWithPath>> generatorsByAlias, Map<SetAlias, ISkolemPart> partsByAlias, Map<VariableJoinCondition, ISkolemPart> partsForJoin, MappingTask mappingTask) { generatorsByAlias = groupGeneratorsByAlias(generator); for (SetAlias variable : generatorsByAlias.keySet()) { List<GeneratorWithPath> generatorGroup = generatorsByAlias.get(variable); partsByAlias.put(variable, generatePartForAlias(variable, generatorGroup, mappingTask)); } generatePartsForJoins( generator.getTgd().getTargetView().getAllJoinConditions(), partsForJoin, partsByAlias, mappingTask); }
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; }
//////////////////////////// second part: joins part private ISkolemPart generatePartForJoins( SkolemFunctionGenerator generator, Map<VariableJoinCondition, ISkolemPart> partsForJoins, MappingTask mappingTask) { List<VariableJoinCondition> joinConditions = generator.getTgd().getTargetView().getAllJoinConditions(); if (joinConditions.isEmpty()) { return NullSkolemPart.getInstance(); } List<VariableJoinCondition> sortedConditions = new ArrayList<VariableJoinCondition>(joinConditions); Collections.sort(sortedConditions); ISkolemPart append = new AppendSkolemPart(mappingTask.getConfig().useSortInSkolems(), "", "", ", "); for (VariableJoinCondition variableJoinCondition : sortedConditions) { ISkolemPart joinPart = partsForJoins.get(variableJoinCondition); append.addChild(joinPart); } return append; }