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;
 import java.util.Set;
 
 
 public class TreeRedReformulator implements QueryRewriter {

 
 	private static final long serialVersionUID = -5839664343260233946L;
 	private static final QueryAnonymizer anonymizer = new QueryAnonymizer();
 	// private static final AtomUnifier unifier = new AtomUnifier();
 
 	private static final Logger log = LoggerFactory.getLogger(TreeRedReformulator.class);
 
 	private static final OBDADataFactory fac = OBDADataFactoryImpl.getInstance();
 
 	private static final SemanticQueryOptimizer sqoOptimizer = null;
 
The TBox used for reformulating.
 
 	private Ontology ontology = null;

The set of ABox dependencies that will be used to optimize the reformulation.
 
 	private Ontology sigma = null;
 
 	public TreeRedReformulator() {
 
 		// sqoOptimizer = new SemanticQueryOptimizer(fac, rightAssertionIndex);
 
 	}
 
 	public OBDAQuery rewrite(OBDAQuery inputthrows OBDAException {
 		//
 
 		.debug("Query reformulation started...");
 
 		// Runtime.getRuntime().runFinalization ();
 		// Runtime.getRuntime().gc ();
 		// Thread.currentThread ().yield ();
 
 		double starttime = System.currentTimeMillis();
 
 		if (!(input instanceof DatalogProgram)) {
 			throw new OBDAException("Rewriting exception: The input must be a DatalogProgram instance");
 		}
		DatalogProgram prog = (DatalogPrograminput;
		// log.debug("Starting query rewrting. Received query: \n{}", prog);
		if (!prog.isUCQ()) {
			throw new OBDAException("Rewriting exception: The input is not a valid union of conjuctive queries");
		}
		/* Query preprocessing */
		DatalogProgram anonymizedProgram = .anonymize(prog);
		// log.debug("Removing redundant atoms by query containment");
		/* Simpliying the query by removing redundant atoms w.r.t. to CQC */
		HashSet<CQIEoldqueries = new HashSet<CQIE>(5000);
		for (CQIE q : anonymizedProgram.getRules()) {
			oldqueries.add(CQCUtilities.removeRundantAtoms(q));
		}
		oldqueries.addAll(anonymizedProgram.getRules());
		HashSet<CQIEresult = new HashSet<CQIE>(5000);
		result.addAll(oldqueries);
		/*
		 * Main loop of the rewriter
		 */
		// log.debug("Starting maing rewriting loop");
		boolean loop = true;
		while (loop) {
			// /*
			// * This is a safety check to avoid running out of memory during a
			// * reformulation.
			// */
			// try {
			// MemoryUtils.checkAvailableMemory();
			// } catch (MemoryLowException e) {
			// // TODO Auto-generated catch block
			// e.printStackTrace();
			// }
			loop = false;
			HashSet<CQIEnewqueriesbyPI = new HashSet<CQIE>(1000);
			/*
			 * Handling simple inclusions, none involves existentials on the
			 * right side of an inclusion
			 */
			for (CQIE oldquery : oldqueries) {
				HashSet<SubDescriptionAxiomrelevantInclusions = new HashSet<SubDescriptionAxiom>(1000);
				for (Function atom : oldquery.getBody()) {
					if (inclusions != null)
						relevantInclusions.addAll(.getByIncludingNoExist(((Functionatom).getPredicate()));
				}
				for (CQIE newcq : .apply(oldqueryrelevantInclusions)) {
					newqueriesbyPI.add(.anonymize(newcq));
				}
			}
			/*
			 * Optimizing the set
			 */
			newqueriesbyPI = CQCUtilities.removeDuplicateAtoms(newqueriesbyPI);
			/*
			 * Handling existential inclusions, and unification We will collect
			 * all predicates mantioned in the old queries, we will collect all
			 * the existential inclusions relevant for those predicates and sort
			 * them by inverse and not inverse. Last we apply these groups of
			 * inclusions at the same time. All of them will share one single
			 * unification atempt.
			 */
			HashSet<CQIEnewqueriesbyunificationandPI = new HashSet<CQIE>(1000);
			// Collecting relevant predicates
			HashSet<Predicatepredicates = new HashSet<Predicate>(1000);
			for (CQIE oldquery : oldqueries) {
				for (Function atom : oldquery.getBody()) {
					predicates.add(((Functionatom).getPredicate());
				}
			}
			for (CQIE oldquery : newqueriesbyPI) {
				for (Function atom : oldquery.getBody()) {
					predicates.add(((Functionatom).getPredicate());
				}
			}
			// Collecting relevant inclusion
			for (Predicate predicate : predicates) {
				Set<SubDescriptionAxiomrelevantInclusion = .getByIncludingExistOnly(predicate);
				if (relevantInclusion == null)
					continue;
				// sorting inverse and not inverse
				Set<SubDescriptionAxiomrelevantinverse = new HashSet<SubDescriptionAxiom>(1000);
				Set<SubDescriptionAxiomrelevantnotinverse = new HashSet<SubDescriptionAxiom>(1000);
				for (SubDescriptionAxiom inc : relevantInclusion) {
					if (ex.isInverse())
						relevantinverse.add(inc);
					else
						relevantnotinverse.add(inc);
				}
				/*
				 * Collecting the relevant queries from the old set, and the
				 * queries that have been just produced
				 */
				Set<CQIErelevantQueries = new HashSet<CQIE>(1000);
				for (CQIE query : oldqueries) {
					if (containsPredicate(querypredicate))
						relevantQueries.add(query);
				}
				for (CQIE query : newqueriesbyPI) {
					if (containsPredicate(querypredicate))
						relevantQueries.add(query);
				}
				/*
				 * Applying the existential inclusions and unifications
				 * (targeted) removing duplicate atoms before adding the queries
				 * to the set.
				 */
				newqueriesbyunificationandPI.addAll(CQCUtilities.removeDuplicateAtoms(.applyExistentialInclusions(
						relevantQueriesrelevantinverse)));
				newqueriesbyunificationandPI.addAll(CQCUtilities.removeDuplicateAtoms(.applyExistentialInclusions(
						relevantQueriesrelevantnotinverse)));
			}
			/*
			 * Removing duplicated atoms in each of the queries to simplify
			 */
			newqueriesbyPI = CQCUtilities.removeDuplicateAtoms(newqueriesbyPI);
			/* These queries are final, no need for new passes on these */
			if ( != null) {
				result.addAll(.optimizeBySQO(newqueriesbyPI));
else {
				result.addAll(newqueriesbyPI);
			}
			/*
			 * Preparing the set of queries for the next iteration.
			 */
			newqueriesbyunificationandPI = CQCUtilities.removeDuplicateAtoms(newqueriesbyunificationandPI);
			LinkedList<CQIEnewquerieslist = new LinkedList<CQIE>();
			if ( != null) {
				newquerieslist.addAll(.optimizeBySQO(newqueriesbyunificationandPI));
else {
				newquerieslist.addAll(newqueriesbyunificationandPI);
			}
			oldqueries = new HashSet<CQIE>(newquerieslist.size() * 2);
			for (CQIE newquery : newquerieslist) {
				if (result.add(newquery)) {
					loop = true;
					oldqueries.add(newquery);
				}
			}
		}
		List<CQIEresultlist = new ArrayList<CQIE>((int) (result.size() * 1.5));
		resultlist.addAll(result);
		.debug("Main loop ended. Queries produced: {}"resultlist.size());
		// log.debug("Removing auxiliary queries...");
		resultlist = cleanAuxiliaryQueries(resultlist);
		.debug("Removed auxiliary queries. New size: {}"resultlist.size());
		resultlist = cleanEmptyQueries(resultlist);
		.debug("Removed empty queries. New size: {}"resultlist.size());
		// log.debug("Reformulation: {}", resultlist);
		/* One last pass of the syntactic containment checker */
		// log.debug("Removing trivially contained queries");
		CQCUtilities.removeContainedQueriesSyntacticSorter(resultlistfalse);
		// if (resultlist.size() < 300) {
		if ( != null) {
			.debug("Removing redundant queries by CQC. Using {} ABox dependencies.".getAssertions().size());
else {
			.debug("Removing redundatnt queries by CQC.");
		}
		resultlist = CQCUtilities.removeContainedQueriesSorted(resultlisttrue);
		// }
		DatalogProgram resultprogram = .getDatalogProgram();
		resultprogram.appendRule(resultlist);
		double endtime = System.currentTimeMillis();
		double milliseconds = (endtime - starttime) / 1000;
		QueryUtils.copyQueryModifiers(inputresultprogram);
		// if (showreformulation)
		// log.debug("Computed reformulation: \n{}", resultprogram);
		.debug("Reformulation size: {}, Time elapse: {}ms"resultlist.size(), milliseconds);
		// log.info("Time elapsed for reformulation: {}s", seconds);
		return resultprogram;
	}
	private boolean containsPredicate(CQIE qPredicate predicate) {
		for (Function atom : q.getBody()) {
			if (((Functionatom).getPredicate().equals(predicate))
				return true;
		}
		return q.getHead().getPredicate().equals(predicate);
	}

Some queries produced by the reformulator might be auxiliary. Queries that use auxiliary predicates only meant to encode exists.R.C given that we are not handling natively the qualified existential. In the future we will do it natively, in the meantime we just remove the aux queries.

Parameters:
originalQueries
Returns:
	private List<CQIEcleanAuxiliaryQueries(List<CQIEoriginalQueries) {
		List<CQIEnewQueries = new ArrayList<CQIE>((int) (originalQueries.size() * 1.5));
		for (CQIE query : originalQueries) {
			List<Functionbody = query.getBody();
			boolean auxiliary = false;
			for (Function atom : body) {
				String name = atom.getPredicate().getName().toString();
					continue;
					auxiliary = true;
					break;
				}
			}
			if (!auxiliary) {
				newQueries.add(query);
			}
		}
		return newQueries;
	}

Eliminates queries that must be empty becauase there are unsatisfiable atoms. At this moment, only queries containing atoms of the form "xsd:string(?x)" are empty queries.

Parameters:
originalQueries
Returns:
	private List<CQIEcleanEmptyQueries(List<CQIEoriginalQueries) {
		List<CQIEnewQueries = new ArrayList<CQIE>((int) (originalQueries.size() * 1.5));
		for (CQIE query : originalQueries) {
			List<Functionbody = query.getBody();
			boolean empty = false;
			for (Function atom : body) {
				Predicate predicate = atom.getPredicate();
					if (predicate == datatype) {
						empty = true;
						break;
					}
					if (empty)
						break;
				}
				if (empty)
					break;
			}
			if (!empty) {
				newQueries.add(query);
			}
		}
		return newQueries;
	}
	public void initialize() {
		// nothing to do here
	}
	public void setTBox(Ontology ontology) {
		this. = ontology.clone();
		/*
		 * Our strategy requires saturation to minimize the number of cycles
		 * that will be necessary to compute reformulation.
		 */
	}
	public void setCBox(Ontology sigma) {
		this. = (Ontologysigma;
		if (this. != null) {
			.debug("Using {} dependencies."sigma.getAssertions().size());
		}
	}
New to GrepCode? Check out our FAQ X