Merge branch 'upstream' into Query-dependent-skolemisation

Conflicts:
	src/uk/ac/ox/cs/pagoda/approx/RLPlusOntology.java
	src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
	src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
	src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
	src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
	src/uk/ac/ox/cs/pagoda/reasoner/MyQueryReasoner.java
	src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java
	src/uk/ac/ox/cs/pagoda/tracking/TrackingRuleEncoderWithGap.java
	src/uk/ac/ox/cs/pagoda/util/Utility.java
	test/uk/ac/ox/cs/pagoda/junit/ClauseTester.java
	test/uk/ac/ox/cs/pagoda/junit/TestGapMappedToLower.java

1 files changed, 95 insertions, 86 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java b/src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java
index 9aa6235..79be8aa 100644
--- a/src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java
+++ b/src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java
@@ -1,36 +1,42 @@
 package uk.ac.ox.cs.pagoda.reasoner.light;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
 import org.semanticweb.HermiT.model.DLClause;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.store.DataStore;
-import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
-import uk.ac.ox.cs.JRDFox.store.Parameters;
-import uk.ac.ox.cs.JRDFox.store.TripleStatus;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+
 import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
 import uk.ac.ox.cs.pagoda.query.AnswerTuples;
 import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
 import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
 import uk.ac.ox.cs.pagoda.rules.Program;
-import uk.ac.ox.cs.pagoda.util.*;
+import uk.ac.ox.cs.pagoda.util.ConjunctiveQueryHelper;
+import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Timer;
-
-import java.util.*;
+import uk.ac.ox.cs.pagoda.util.UFS;
+import uk.ac.ox.cs.pagoda.util.Utility;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.JRDFox.store.Parameters;
+import uk.ac.ox.cs.JRDFox.store.TripleStatus;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
 
 public class BasicQueryEngine extends RDFoxQueryEngine {
 
-        protected DataStore store;
-        protected Parameters parameters = new Parameters();
-        Set<DLClause> materialisedRules = new HashSet<DLClause>();
-        private UFS<String> equalityGroups = null;
+        protected DataStore store; 
+        protected Parameters parameters = new Parameters(); 
         
         public BasicQueryEngine(String name) {
-                super(name);
+                super(name); 
                 store = RDFoxQueryEngine.createDataStore();
-                parameters.m_allAnswersInRoot = true;
-                parameters.m_useBushy = true;
+                parameters.m_allAnswersInRoot = true; 
+                parameters.m_useBushy = true; 
         }
-
+        
         public void materialiseFoldedly(DatalogProgram dProgram, GapByStore4ID gap) {
                 if (gap != null) {
                         materialise("lower program", dProgram.getLower().toString());
@@ -42,9 +48,10 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
                         } catch (JRDFStoreException e) {
                                 e.printStackTrace();
                         } finally {
-                                gap.clear();
+                                gap.clear(); 
                         }
-                } else
+                }
+                else 
                         materialise("upper program", dProgram.getUpper().toString());
         }
         
@@ -59,23 +66,20 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
                         } catch (JRDFStoreException e) {
                                 e.printStackTrace();
                         } finally {
-                                gap.clear();
+                                gap.clear(); 
                         }
-                } else
+                }
+                else 
                         materialise("upper program", dProgram.getUpper().toString());
-
-                return 1;
+                
+                return 1; 
         }
         
-        public int materialiseSkolemly(DatalogProgram dProgram, GapByStore4ID gap) {
-                throw new UnsupportedOperationException();
-        }
-
         @Override
         public AnswerTuples evaluate(String queryText) {
-                return evaluate(queryText, ConjunctiveQueryHelper.getAnswerVariables(queryText)[0]);
+                return evaluate(queryText, ConjunctiveQueryHelper.getAnswerVariables(queryText)[0]); 
         }
-
+        
         @Override
         public AnswerTuples evaluate(String queryText, String[] answerVars) {
                 TupleIterator tupleIterator;
@@ -83,9 +87,9 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
                         tupleIterator = store.compileQuery(queryText.replace("_:", "?"), prefixes, parameters);
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                        return null;
+                        return null; 
                 }
-                return new RDFoxAnswerTuples(answerVars, tupleIterator);
+                return new RDFoxAnswerTuples(answerVars, tupleIterator); 
         }
 
         @Override
@@ -95,18 +99,17 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
 
         @Override
         public void dispose() {
-                store.dispose();
+                store.dispose();                
         }
 
         protected void outputClassAssertions(String filename) {
                 TupleIterator allTuples = null;
-                boolean redirect = false;
+                boolean redirect = false; 
                 try {
                         allTuples = getDataStore().compileQuery("SELECT ?X ?Z WHERE { ?X <" + Namespace.RDF_TYPE + "> ?Z }", prefixes, parameters);
                         redirect = Utility.redirectCurrentOut(filename);
-                        for(long multi = allTuples.open(); multi != 0; multi = allTuples.getNext())
-                                System.out.println(RDFoxTripleManager.getQuotedTerm(allTuples.getResource(0)) + " " + RDFoxTripleManager
-                                                .getQuotedTerm(allTuples.getResource(1)));
+                        for (long multi = allTuples.open(); multi != 0; multi = allTuples.getNext()) 
+                                System.out.println(RDFoxTripleManager.getQuotedTerm(allTuples.getResource(0)) + " " + RDFoxTripleManager.getQuotedTerm(allTuples.getResource(1))); 
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
                 } finally {
@@ -124,134 +127,138 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
         public void outputInstance4BinaryPredicate(String iri) {
                 outputAnswers("select ?x ?y where { ?x <" + iri + "> ?y . }");
         }
-
+        
         public void outputInstanceNumbers(String filename) {
                 TupleIterator predicateTuples = null;
-                TupleIterator instanceTuples;
-                Set<String> number = new HashSet<String>();
-                String predicate;
+                TupleIterator instanceTuples; 
+                Set<String> number = new HashSet<String>(); 
+                String predicate; 
                 try {
                         predicateTuples = getDataStore().compileQuery("SELECT DISTINCT ?Y WHERE { ?X <" + Namespace.RDF_TYPE + "> ?Y }", prefixes, parameters);
                         for (long multi = predicateTuples.open(); multi != 0; multi = predicateTuples.getNext()) {
                                 predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0));
-                                instanceTuples = null;
+                                instanceTuples = null; 
                                 try {
                                         instanceTuples = getDataStore().compileQuery("SELECT ?X WHERE { ?X <" + Namespace.RDF_TYPE + "> " + predicate + " }", prefixes, parameters);
-                                        long totalCount = 0;
+                                        long totalCount = 0; 
                                         for (long multi1 = instanceTuples.open(); multi1 != 0; multi1 = instanceTuples.getNext()) {
                                                 totalCount += instanceTuples.getMultiplicity();
                                         }
                                         number.add(predicate + " * " + totalCount);
                                 } finally {
-                                        if(instanceTuples != null) instanceTuples.dispose();
+                                        if (instanceTuples != null) instanceTuples.dispose(); 
                                 }
                         }
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                } finally {
+                } finally {                     
                         if (predicateTuples != null) predicateTuples.dispose();
-                        predicateTuples = null;
+                        predicateTuples = null; 
                 }
-
+                        
                 try {
                         predicateTuples = getDataStore().compileQuery("SELECT DISTINCT ?Y WHERE { ?X ?Y ?Z }", prefixes, parameters);
                         for (long multi = predicateTuples.open(); multi != 0; multi = predicateTuples.getNext()) {
-                                predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0));
-                                instanceTuples = null;
+                                predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0)); 
+                                instanceTuples = null; 
                                 try {
                                         instanceTuples = getDataStore().compileQuery("SELECT ?X ?Z WHERE { ?X " + predicate + " ?Z }", prefixes, parameters);
-                                        long totalCount = 0;
+                                        ;
+                                        long totalCount = 0; 
                                         for (long multi1 = instanceTuples.open(); multi1 != 0; multi1 = instanceTuples.getNext())
                                                 totalCount += instanceTuples.getMultiplicity();
-                                        number.add(predicate + " * " + totalCount);
+                                        number.add(predicate + " * " + totalCount); 
                                 } finally {
-                                        if(instanceTuples != null) instanceTuples.dispose();
+                                        if (instanceTuples != null) instanceTuples.dispose(); 
                                 }
                         }
-
+                        
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
                 } finally {
                         if (predicateTuples != null) predicateTuples.dispose();
                         predicateTuples = null;
                 }
-
+                
                 Utility.redirectCurrentOut(filename);
                 String[] ordered = number.toArray(new String[0]);
                 Arrays.sort(ordered, new DLPredicateComparator());
-                for(String line : ordered) System.out.println(line);
+                for (String line: ordered) System.out.println(line); 
                 Utility.closeCurrentOut();
-
+                
         }
         
         public TupleIterator internal_evaluateAgainstIDBs(String queryText) throws JRDFStoreException {
                 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters, TripleStatus.TUPLE_STATUS_IDB.union(TripleStatus.TUPLE_STATUS_EDB), TripleStatus.TUPLE_STATUS_IDB);
 //              iter.open();
-                return iter;
+                return iter; 
         }
 
         public TupleIterator internal_evaluate(String queryText) throws JRDFStoreException {
                 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters);
-//              iter.open();
-                return iter;
+//              iter.open(); 
+                return iter; 
         }
-
+        
         public void setExpandEquality(boolean flag) {
-                parameters.m_expandEquality = flag;
+                parameters.m_expandEquality = flag; 
         }
-
+        
         public TupleIterator internal_evaluateNotExpanded(String queryText) throws JRDFStoreException {
-                parameters.m_expandEquality = false;
-                TupleIterator iter = store.compileQuery(queryText, prefixes, parameters);
-//              iter.open();
-                parameters.m_expandEquality = true;
+                parameters.m_expandEquality = false; 
+                TupleIterator iter = store.compileQuery(queryText, prefixes, parameters); 
+//              iter.open(); 
+                parameters.m_expandEquality = true; 
                 return iter;
         }
+
         
         public TupleIterator internal_evaluate(String queryText, boolean incrementally) throws JRDFStoreException {
                 return incrementally ? internal_evaluateAgainstIDBs(queryText) : internal_evaluate(queryText);
         }
 
+        Set<DLClause> materialisedRules = new HashSet<DLClause>(); 
+        
         public String getUnusedRules(Collection<DLClause> clauses, boolean toUpdate) {
                 DLClause clause;
                 for (Iterator<DLClause> iter = clauses.iterator(); iter.hasNext(); ) {
                         if (materialisedRules.contains(clause = iter.next()))
                                 iter.remove();
-                        else if(toUpdate) materialisedRules.add(clause);
+                        else if (toUpdate) materialisedRules.add(clause); 
                 }
-
+                
                 if (clauses.isEmpty()) return null;
-
+                
                 return Program.toString(clauses);
         }
 
         public void outputMaterialisedRules() {
-                System.out.println(DLClauseHelper.toString(materialisedRules));
+                System.out.println(DLClauseHelper.toString(materialisedRules));         
         }
 
         public void outputAnswers(String query) {
                 TupleIterator iter = null;
                 try {
                         iter = internal_evaluate(query);
-                        System.out.println(query);
-                        int arity = iter.getArity();
+                        System.out.println(query); 
+                        int arity = iter.getArity(); 
                         for (long multi = iter.open(); multi != 0; multi = iter.getNext())  {
                                 for (int i = 0; i < arity; ++i)
                                         System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t");
-                                System.out.println();
+                                System.out.println(); 
                         }
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
                 } finally {
-                        if(iter != null) iter.dispose();
+                        if (iter != null) iter.dispose(); 
                 }
         }
 
         public void outputInstance4UnaryPredicate(String iri) {
                 outputAnswers("select ?x where { ?x "
                                         + "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <"
-                                                          + iri
-                                                          + "> .}");
+                                        + iri 
+                                        + "> .}"); 
         }
 
         public void outputSubjects(String p, String o) {
@@ -263,13 +270,13 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
         }
 
         public void outputIDBFacts() {
-                TupleIterator iter = null;
+                TupleIterator iter = null; 
                 try {
                         iter = internal_evaluateAgainstIDBs("select distict ?x ?y ?z where { ?x ?y ?z }");
                         for (long multi = iter.open(); multi != 0; multi = iter.getNext()) {
                                 for (int i = 0; i < 3; ++i)
-                                        System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t");
-                                System.out.println();
+                                        System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t"); 
+                                System.out.println(); 
                         }
                 } catch (JRDFStoreException e) {
                         // TODO Auto-generated catch block
@@ -277,7 +284,7 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
                 } finally {
                         if (iter != null) iter.dispose();
                 }
-
+                
         }
         
         public void outputType4Individual(String iri) {
@@ -285,23 +292,25 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
         }
         
         public int getSameAsNumber() {
-                TupleIterator iter = null;
-                int counter = 0;
+                TupleIterator iter = null; 
+                int counter = 0; 
                 try {
                         iter = internal_evaluate("select ?x ?y where {?x " + Namespace.EQUALITY_QUOTED + " ?y . }");
-                        for(long multi = iter.open(); multi != 0; multi = iter.getNext())
+                        for (long multi = iter.open(); multi != 0; multi = iter.getNext()) 
                                 if (iter.getResourceID(0) != iter.getResourceID(1))
                                         ++counter;
                 } catch (JRDFStoreException e) {
-                        e.printStackTrace();
+                        e.printStackTrace(); 
                 } finally {
                         if (iter != null) iter.dispose();
                 }
-                return counter;
+                return counter; 
         }
-
+        
+        private UFS<String> equalityGroups = null; 
+        
         public UFS<String> getEqualityGroups(boolean reuse) {
-                if(reuse && equalityGroups != null) return equalityGroups;
+                if (reuse && equalityGroups != null) return equalityGroups; 
 
                 equalityGroups = new UFS<String>();