Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package it.unibz.krdb.obda.owlrefplatform.core.reformulation;
  
  /*
   * #%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;
 
 
 
 public class TreeWitnessRewriter implements QueryRewriter {
 	private static final long serialVersionUID = 1L;
 
 	private static OBDADataFactory fac = OBDADataFactoryImpl.getInstance();
 	private static final Logger log = LoggerFactory.getLogger(TreeWitnessRewriter.class);
 
 	
 	private Ontology sigma = null;
 
 	public TreeWitnessRewriter() {
 	}
 	
 	public void setTBox(Ontology ontology) {
 		double startime = System.currentTimeMillis();
 
 		.setTBox(ontology);
 		
 		double endtime = System.currentTimeMillis();
 		double tm = (endtime - startime) / 1000;
 		 += tm;
 		.debug(String.format("setTBox time: %.3f s (total %.3f s)"tm));
 	}
 	
 	public void setCBox(Ontology sigma) {
 		.debug("SET SIGMA");
 		for (Axiom ax : sigma.getAssertions()) {
 			.debug("SIGMA: " + ax);
 		}
 		this. = sigma;
 		.setSigma(sigma);
 	}
 
 	public void initialize() {
 	}
 	
 	
 	public static String getIRI(String baseString suffix) {
 		return base + suffix;
	}
	/*
	 * returns an atom with given arguments and the predicate name formed by the given URI basis and string fragment
	 */
	private static Function getHeadAtom(String baseString suffixList<Termarguments) {
		Predicate predicate = .getPredicate(getIRI(basesuffix), arguments.size(), null);
		return .getFunction(predicatearguments);
	}
	/*
	 * returns atoms E of a given collection of tree witness generators; 
	 * the `free' variable of the generators is replaced by the term r0;
	 */
		Collection<BasicClassDescriptionconcepts = TreeWitnessGenerator.getMaximalBasicConcepts(gens);		
		List<FunctiongenAtoms = new ArrayList<Function>(concepts.size());
		for (BasicClassDescription con : concepts) {
			.debug("  BASIC CONCEPT: {}"con);
			Function atom
			if (con instanceof OClass) {
				atom = .getFunction(((OClass)con).getPredicate(), r0);
			}
			else {
				atom = (!some.isInverse()) ?  .getFunction(some.getPredicate(), r0x) : .getFunction(some.getPredicate(), xr0);  						 
			}
			genAtoms.add(atom);
		}
		return genAtoms;
	}
	/*
	 * rewrites a given connected CQ with the rules put into output
	 */
	private void rewriteCC(QueryConnectedComponent ccFunction headAtomDatalogProgram outputExtPredicateCache cacheDatalogProgram edgeDP) {
		String headURI = headAtom.getFunctionSymbol().getName();
		TreeWitnessSet tws = TreeWitnessSet.getTreeWitnesses(cc);
		if (cc.hasNoFreeTerms()) {  
				output.appendRule(.getCQIE(headAtomcache.getExtAtom(a))); 
			}
		}
		// COMPUTE AND STORE TREE WITNESS FORMULAS
		for (TreeWitness tw : tws.getTWs()) {
			.debug("TREE WITNESS: {}"tw);		
			// equality atoms
			Term r0 = i.next();
			while (i.hasNext()) 
			// root atoms
			for (Function a : tw.getRootAtoms()) {
				Predicate predicate = a.getFunctionSymbol();
				twf.add((predicate.getArity() == 1) ? .getFunction(predicater0) : .getFunction(predicater0r0));
			}
			boolean subsumes = false;
			for (Function a : genAtoms
				if (twf.subsumes(a)) {
					subsumes = true;
					.debug("TWF {} SUBSUMES {}"twf.getAtoms(), a);
					break;
				}
			List<List<Function>> twfs = new ArrayList<List<Function>>(subsumes ? 1 : genAtoms.size());			
			if (!subsumes) {
				for (Function a : genAtoms) {				
					twfa.add(a); // 
					twfs.add(cache.getExtAtoms(twfa));
				}
			}
			else
				twfs.add(cache.getExtAtoms(twf));
			tw.setFormula(twfs);
		}
		if (!cc.isDegenerate()) {			
			if (tws.hasConflicts()) { 
				// there are conflicting tree witnesses
				// use compact exponential rewriting by enumerating all compatible subsets of tree witnesses
				while (iterator.hasNext()) {
					Collection<TreeWitnesscompatibleTWs = iterator.next();
					.debug("COMPATIBLE: {}"compatibleTWs);
					for (Edge edge : cc.getEdges()) {
						boolean contained = false;
						for (TreeWitness tw : compatibleTWs)
							if (tw.getDomain().contains(edge.getTerm0()) && tw.getDomain().contains(edge.getTerm1())) {
								contained = true;
								.debug("EDGE {} COVERED BY {}"edgetw);
								break;
							}
						if (!contained) {
							.debug("EDGE {} NOT COVERED BY ANY TW",  edge);
							mainbody.addAll(edge.getAtoms());
						}
					}
					for (TreeWitness tw : compatibleTWs) {
						Function twAtom = getHeadAtom(headURI"_TW_" + (edgeDP.getRules().size() + 1), cc.getVariables());
						mainbody.addNoCheck(twAtom);				
						for (List<Functiontwfa : tw.getFormula())
							edgeDP.appendRule(.getCQIE(twAtomtwfa));
					}	
					output.appendRule(.getCQIE(headAtomcache.getExtAtoms(mainbody))); 
				}
			}
			else {
				// no conflicting tree witnesses
				// use polynomial tree witness rewriting by treating each edge independently 
				for (Edge edge : cc.getEdges()) {
					.debug("EDGE {}"edge);
					Function edgeAtom = null;
					for (TreeWitness tw : tws.getTWs())
						if (tw.getDomain().contains(edge.getTerm0()) && tw.getDomain().contains(edge.getTerm1())) {
							if (edgeAtom == null) {
								//IRI atomURI = edge.getBAtoms().iterator().next().getPredicate().getName();
								edgeAtom = getHeadAtom(headURI
										"_EDGE_" + (edgeDP.getRules().size() + 1) /*+ "_" + atomURI.getRawFragment()*/cc.getVariables());
								mainbody.addNoCheck(edgeAtom);				
								edgeAtoms.addAll(edge.getAtoms());
								edgeDP.appendRule(.getCQIE(edgeAtomcache.getExtAtoms(edgeAtoms)));													
							}
							for (List<Functiontwfa : tw.getFormula())
								edgeDP.appendRule(.getCQIE(edgeAtomtwfa));
						}
					if (edgeAtom == null// no tree witnesses -- direct insertion into the main body
						mainbody.addAll(edge.getAtoms());
				}
				output.appendRule(.getCQIE(headAtomcache.getExtAtoms(mainbody))); 
			}
		}
		else {
			// degenerate connected component
			Loop loop = cc.getLoop();
			.debug("LOOP {}"loop);
			if (loop != null)
				loopbody.addAll(loop.getAtoms());
			output.appendRule(.getCQIE(headAtomcache.getExtAtoms(loopbody))); 
		}
	}
	private double time = 0;
	public OBDAQuery rewrite(OBDAQuery input) {
		double startime = System.currentTimeMillis();
		DatalogProgram ccDP = null;
		for (CQIE cqie : dp.getRules()) {
			List<QueryConnectedComponentccs = QueryConnectedComponent.getConnectedComponents(cqie);	
			Function cqieAtom = cqie.getHead();
			if (ccs.size() == 1) {
				.debug("CONNECTED COMPONENT ({})" + " EXISTS {}"cc.getFreeVariables(), cc.getQuantifiedVariables());
				.debug("     WITH EDGES {} AND LOOP {}"cc.getEdges(), cc.getLoop());
				.debug("     NON-DL ATOMS {}"cc.getNonDLAtoms());
				rewriteCC(cccqieAtomoutputcacheedgeDP); 				
			}
			else {
				if (ccDP == null)
				String cqieURI = cqieAtom.getFunctionSymbol().getName();
				List<FunctionccBody = new ArrayList<Function>(ccs.size());
				for (QueryConnectedComponent cc : ccs) {
					.debug("CONNECTED COMPONENT ({})" + " EXISTS {}"cc.getFreeVariables(), cc.getQuantifiedVariables());
					.debug("     WITH EDGES {} AND LOOP {}"cc.getEdges(), cc.getLoop());
					.debug("     NON-DL ATOMS {}"cc.getNonDLAtoms());
					Function ccAtom = getHeadAtom(cqieURI"_CC_" + (ccDP.getRules().size() + 1), cc.getFreeVariables());
					rewriteCC(ccccAtomccDPcacheedgeDP); 
					ccBody.add(ccAtom);
				}
				output.appendRule(.getCQIE(cqieAtomccBody));
			}
		}
		.debug("REWRITTEN PROGRAM\n{}CC DEFS\n{}"outputccDP);
		if (!edgeDP.getRules().isEmpty()) {
			.debug("EDGE DEFS\n{}"edgeDP);			
			output = DatalogQueryServices.plugInDefinitions(outputedgeDP);
			if (ccDP != null)
				ccDP = DatalogQueryServices.plugInDefinitions(ccDPedgeDP);
			.debug("INLINE EDGE PROGRAM\n{}CC DEFS\n{}"outputccDP);
		}
		if (ccDP != null) {
			output = DatalogQueryServices.plugInDefinitions(outputccDP);
			.debug("INLINE CONNECTED COMPONENTS PROGRAM\n{}"output);
		}
		DatalogProgram extDP = cache.getExtDP();
		if (extDP != null) {
			output = DatalogQueryServices.plugInDefinitions(outputextDP);
			.debug("INLINE EXT PROGRAM\n{}"output);
		}
		// extra CQC 
		if (output.getRules().size() > 1)
			output = .getDatalogProgram(CQCUtilities.removeContainedQueries(output.getRules(), true));
		QueryUtils.copyQueryModifiers(inputoutput);
		double endtime = System.currentTimeMillis();
		double tm = (endtime - startime) / 1000;
		 += tm;
		.debug(String.format("Rewriting time: %.3f s (total %.3f s)"tm));
		.debug("Final rewriting:\n{}"output);
		return output;
	}


cache for the Ext_E predicates and Datalog programs they are defined by

Author(s):
Roman Kontchakov
	private static class ExtPredicateCache {
		//private Set<Predicate> usedExts = new HashSet<Predicate>();
		private boolean usedExts = false;
		final private ExtDatalogProgram extDP;
			this. = extDP;
		}
			List<FunctionextAtoms = new ArrayList<Function>(atoms.getAtoms().size() + atoms.getNoCheckAtoms().size());
			extAtoms.addAll(atoms.getNoCheckAtoms());
			for (Function a : atoms.getAtoms()) 
				extAtoms.add(getExtAtom(a));
			return extAtoms;
		}
			if (ext != null) {
				 = true;        // usedExts.add(ext);
				if (a.getArity() == 1) 
					return .getFunction(exta.getTerm(0));
				else {
					assert (a.getArity() == 2);
					return .getFunction(exta.getTerm(0), a.getTerm(1));
				}
			}
			return a;
		}

Returns:
Datalog program containing definitions for all Ext_E in usedExts
			if (!
				return null;
			//DatalogProgram dp = fac.getDatalogProgram();		
			//for (Predicate pred : usedExts) { 
			//	List<CQIE> extDef = extDP.getDP(pred);			 
			//	dp.appendRule(extDef);		 
			//}
			return .getFullDP(); 
		}
	}
New to GrepCode? Check out our FAQ X