Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package it.unibz.krdb.obda.owlrefplatform.core.translator;
  
  /*
   * #%L
   * ontop-reformulation-core
   * %%
   * Copyright (C) 2009 - 2014 Free University of Bozen-Bolzano
   * %%
   * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  * 
  *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  * #L%
  */
 
 
 import java.util.List;
 import java.util.Set;
 
This is a hack class that helps fix and OBDA model in which the mappings include predicates that have not been properly typed.

Author(s):
mariano
 
 public class MappingVocabularyRepair {
 
 	private static OBDADataFactory dfac = OBDADataFactoryImpl.getInstance();
 
 	Logger log = LoggerFactory.getLogger(MappingVocabularyRepair.class);
 
 	public void fixOBDAModel(OBDAModel modelSet<Predicatevocabulary) {
 		.debug("Fixing OBDA Model");
 		for (OBDADataSource source : model.getSources()) {
 			model.removeAllMappings(source.getSourceID());
 			try {
 				model.addMappings(source.getSourceID(), fixMappingPredicates(mappingsvocabulary));
 			} catch (Exception e) {
 				throw new RuntimeException(e);
 			}
 		}
 	}

Makes sure that the mappings given are correctly typed w.r.t. the given vocabualry.

Parameters:
originalMappings
equivalencesMap
Returns:
 
 //		log.debug("Reparing/validating {} mappings", originalMappings.size());
 		HashMap<StringPredicateurimap = new HashMap<StringPredicate>();
 		for (Predicate p : vocabulary) {
 			urimap.put(p.getName(), p);
 		}
 
 		for (OBDAMappingAxiom mapping : originalMappings) {
 			CQIE targetQuery = (CQIEmapping.getTargetQuery();
 			List<Functionbody = targetQuery.getBody();
 			List<Functionnewbody = new LinkedList<Function>();
 
 			for (Function atom : body) {
 				Predicate p = atom.getPredicate();
 				
 				Function newatom = null;
 				Predicate predicate = urimap.get(p.getName());
 				if (predicate == null) {
ignore triple
					//if (!p.equals(OBDAVocabulary.QUEST_TRIPLE_PRED)){
						throw new RuntimeException("ERROR: Mapping references an unknown class/property: " + p.getName());
					}else{
					}
				}
				/* Fixing terms */
				LinkedList<TermnewTerms = new LinkedList<Term>();
				for (Term term : atom.getTerms()) {
					newTerms.add(fixTerm(term));
				}
				/*
				 * Fixing wrapping each variable with a URI function if the
				 * position corresponds to an URI only position
				 */
				Term t0 = newTerms.get(0);
				if (!(t0 instanceof Function)){
				}
				if (predicate.isObjectProperty() && !(newTerms.get(1) instanceof Function)) {
					newTerms.set(1, .getFunction(.getUriTemplatePredicate(1), newTerms.get(1)));
				}
				newatom = .getFunction(predicatenewTerms);
				newbody.add(newatom);
			}
			CQIE newTargetQuery = .getCQIE(targetQuery.getHead(), newbody);
			result.add(.getRDBMSMappingAxiom(mapping.getId(), ((OBDASQLQuerymapping.getSourceQuery()).toString(), newTargetQuery));
		}
//		log.debug("Repair done. Returning {} mappings", result.size());
		return result;
	}

Fixes any issues with the terms in mappings

Parameters:
term
Returns:
	public Term fixTerm(Term term) {
		Term result = term;
		if (term instanceof Function) {
			result = fixTerm((Functionterm);
		}
		return result;
	}

Fix functions that represent URI templates. Currently,the only fix necessary is replacing the old-style template function with the new one, that uses a string tempalte and placeholders.

Parameters:
term
Returns:
	public Function fixTerm(Function term) {
		Predicate predicate = term.getFunctionSymbol();
		if (predicate instanceof DataTypePredicate) {
			// no fix nexessary
			return term;
		}
			// no fix necessary
			return term;
		}
		// We have a function that is not a built-in, hence its an old-style uri
		// template function(parm1,parm2,...)
		Predicate uriFunction = .getUriTemplatePredicate(term.getArity() + 1);
		StringBuilder newTemplate = new StringBuilder();
		newTemplate.append(predicate.getName().toString());
		for (int i = 0; i < term.getArity(); i++) {
			newTemplate.append("-{}");
		}
		LinkedList<TermnewTerms = new LinkedList<Term>();
		newTerms.add(.getConstantLiteral(newTemplate.toString()));
		newTerms.addAll(term.getTerms());
		return .getFunction(uriFunctionnewTerms);
	}
New to GrepCode? Check out our FAQ X