4 files changed, 216 insertions, 91 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
index 1c0eb48..02db18d 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
@@ -1,103 +1,106 @@
 package uk.ac.ox.cs.pagoda.query;
 
-import java.util.HashMap;
-import java.util.LinkedList;
-import java.util.Map;
-
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
-//import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
+import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Timer;
 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.TupleIterator;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+//import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
 
 //public class GapByStore4ID extends GapTupleIterator<AnswerTupleID> {
 public class GapByStore4ID extends GapTupleIterator<int[]> {
 
-        private MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes; 
-        private TupleIterator iterator = null; 
+        protected MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes;
+        protected TupleIterator iterator = null; 
         
 //      AnswerTupleID tuple;
-        int[] tuple; 
-        private BasicQueryEngine m_engine; 
-        private DataStore m_store;
-        private RDFoxTripleManager tripleManager; 
+protected int[] tuple;
+        protected BasicQueryEngine m_engine;
+        protected DataStore m_store;
+        protected RDFoxTripleManager tripleManager;
+        protected long multi;
+        Map<Integer, Integer> original2gap = new HashMap<Integer, Integer>();
+        LinkedList<String> predicatesWithGap = new LinkedList<String>();
         
         public GapByStore4ID(BasicQueryEngine engine) {
-                m_engine = engine; 
-                m_store = engine.getDataStore(); 
-                tripleManager = new RDFoxTripleManager(m_store, false); 
+                m_engine = engine;
+                m_store = engine.getDataStore();
+                tripleManager = new RDFoxTripleManager(m_store, false);
         }
         
-        long multi; 
-        
         @Override
         public void compile(String program) throws JRDFStoreException {
-                clear(); 
+                clear();
 
-                boolean incrementally = true; 
+                boolean incrementally = true;
                 Timer t = new Timer();
                 long oldTripleCount = m_store.getTriplesCount();
-                
+
                 if (program != null) {
 //                      m_store.addRules(new String[] {program});
                         m_store.importRules(program);
-                        incrementally = false; 
+                        incrementally = false;
                 }
-                
+
                 m_store.applyReasoning(incrementally);
-                
+
                 long tripleCount = m_store.getTriplesCount();
-                        
-                Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)", 
+
+                Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)",
                                 "current store finished the materialisation of upper related rules in " + t.duration() + " seconds.");
-                
+
                 m_engine.setExpandEquality(false);
                 iterator = m_engine.internal_evaluateAgainstIDBs("select ?x ?y ?z where { ?x ?y ?z . }");
                 m_engine.setExpandEquality(true);
-                
+
                 multi = iterator.open();
-                Utility.logDebug("gap query evaluted ..."); 
+                Utility.logDebug("gap query evaluted ...");
         }
         
         @Override
         public boolean hasNext() {
-                if (iterator == null) return false; 
+                if(iterator == null) return false;
                 try {
 //                      tuple = new AnswerTupleID(3);
-                        tuple = new int[3]; 
-                        Integer predicate; 
+                        tuple = new int[3];
+                        Integer predicate;
                         for (; multi != 0; multi = iterator.getNext()) {
                                 for (int i = 0; i < 3; ++i)
 //                                      tuple.setTerm(i, (int) iterator.getResourceID(i));
-                                        tuple[i] = (int) iterator.getResourceID(i); 
-                                
+                                        tuple[i] = iterator.getResourceID(i);
+
                                 if (isRDF_TYPE()) {
 //                                      predicate = getGapPredicateID(tuple.getTerm(2));
-                                        predicate = getGapPredicateID(tuple[2]); 
-                                        if (predicate == null) continue; 
+                                        predicate = getGapPredicateID(tuple[2]);
+                                        if(predicate == null) continue;
 //                                      tuple.setTerm(2, predicate);
-                                        tuple[2] = predicate; 
+                                        tuple[2] = predicate;
                                 }
                                 else {
 //                                      predicate = getGapPredicateID(tuple.getTerm(1));
-                                        predicate = getGapPredicateID(tuple[1]); 
-                                        if (predicate == null) continue;  
+                                        predicate = getGapPredicateID(tuple[1]);
+                                        if(predicate == null) continue;
 //                                      tuple.setTerm(1, predicate);
-                                        tuple[1] = predicate; 
+                                        tuple[1] = predicate;
                                 }
-                                return true; 
+                                return true;
                         }
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                        return false; 
+                        return false;
                 }
-                return false; 
+                return false;
         }
-        
+
         @Override
 //      public AnswerTupleID next() {
         public int[] next() {
@@ -105,19 +108,16 @@ public class GapByStore4ID extends GapTupleIterator<int[]> {
                         multi = iterator.getNext();
                 } catch (JRDFStoreException e) {
                         e.printStackTrace();
-                } 
-                
-                return tuple; 
+                }
+
+                return tuple;
         }
         
-        Map<Integer, Integer> original2gap = new HashMap<Integer, Integer>();
-        LinkedList<String> predicatesWithGap = new LinkedList<String>();
-        
         public LinkedList<String> getPredicatesWithGap() {
                 return predicatesWithGap; 
         }
-        
-        private Integer getGapPredicateID(int originalID) {
+
+        protected Integer getGapPredicateID(int originalID) {
                 Integer gapID; 
                 if ((gapID = original2gap.get(originalID)) != null) 
                         return gapID;
@@ -136,11 +136,14 @@ public class GapByStore4ID extends GapTupleIterator<int[]> {
                 return gapID;
         }
 
-        private boolean isAuxPredicate(String originalPredicate) {
-                return originalPredicate.contains("_AUX");
+        protected boolean isAuxPredicate(String originalPredicate) {
+                if(originalPredicate.equals(Namespace.EQUALITY_QUOTED)) return false;
+                return originalPredicate.contains("_AUX") ||
+                                originalPredicate.startsWith("<" + Namespace.OWL_NS) ||
+                                originalPredicate.startsWith("<" + Namespace.PAGODA_ORIGINAL);
         }
 
-        private boolean isRDF_TYPE() {
+        protected boolean isRDF_TYPE() {
 //              return tripleManager.isRdfTypeID(tuple.getTerm(1)); 
                 return tripleManager.isRdfTypeID(tuple[1]); 
         }
@@ -150,8 +153,6 @@ public class GapByStore4ID extends GapTupleIterator<int[]> {
                 Utility.logError("Unsupported operation!"); 
         }
         
-        private boolean valid = false;
-
         @Override
         public void save(String file) {
                 Utility.logError("Unsupported Operation..."); 
@@ -168,7 +169,6 @@ public class GapByStore4ID extends GapTupleIterator<int[]> {
                         ++tupleCounter;
                         tripleManager.addTripleByID(tuple);
                 }
-                valid = true; 
 
                 long tripleCounter = m_store.getTriplesCount(); 
                 Utility.logDebug("There are " + tupleCounter + " tuples in the gap between lower and upper bound materialisation.", 
@@ -183,8 +183,6 @@ public class GapByStore4ID extends GapTupleIterator<int[]> {
                 }
         }
                 
-        public boolean isValid() {return valid; }
-
         @Override
         public void addTo(DataStore store) throws JRDFStoreException {
                 Utility.logError("Unsupported Operation..."); 
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
new file mode 100644
index 0000000..19efc58
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
@@ -0,0 +1,141 @@
+package uk.ac.ox.cs.pagoda.query;
+
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
+import uk.ac.ox.cs.pagoda.util.UFS;
+
+import java.util.*;
+
+public class GapByStore4ID2 extends GapByStore4ID {
+
+    private BasicQueryEngine m_baseEngine;
+    private UFS<String> m_equality = null, m_baseEquality = null;
+    private LinkedList<String> toAddedIndividuals = null;
+    private TupleIterator iter_individual = null;
+    private int currentID = -1;
+
+    public GapByStore4ID2(BasicQueryEngine engine, BasicQueryEngine baseEngine) {
+        super(engine);
+        m_baseEngine = baseEngine;
+    }
+
+    @Override
+    public boolean hasNext() {
+        if(getNewGapTuple(iterator, -1)) return true;
+        if(iterator != null) {
+            iterator.dispose();
+            iterator = null;
+        }
+        return getNextGapFactAboutEquality();
+    }
+
+    private boolean getNewGapTuple(TupleIterator it, int firstElement) {
+        if(it == null) return false;
+        int firstIndex = 0;
+        tuple = new int[3];
+        if(firstElement > 0) {
+            tuple[0] = firstElement;
+            firstIndex = 1;
+        }
+        Integer predicate;
+        try {
+            for(; multi != 0; multi = it.getNext()) {
+                for(int i = firstIndex; i < 3; ++i)
+                    tuple[i] = it.getResourceID(i - firstIndex);
+
+                if(isRDF_TYPE()) {
+                    predicate = getGapPredicateID(tuple[2]);
+                    if(predicate == null) continue;
+                    tuple[2] = predicate;
+                } else {
+                    predicate = getGapPredicateID(tuple[1]);
+                    if(predicate == null) continue;
+                    tuple[1] = predicate;
+                }
+                return true;
+            }
+        } catch(JRDFStoreException e) {
+            e.printStackTrace();
+            return false;
+        }
+        return false;
+    }
+
+    private boolean getNextGapFactAboutEquality() {
+        if(toAddedIndividuals == null) {
+            m_equality = m_engine.getEqualityGroups(false);
+            m_baseEquality = m_baseEngine.getEqualityGroups(false);
+            toAddedIndividuals = new LinkedList<String>();
+            Map<String, Integer> rep2cnt = new HashMap<String, Integer>();
+            Map<String, Integer> rep2cnt_base = new HashMap<String, Integer>();
+            count(m_engine, m_equality, rep2cnt);
+            count(m_baseEngine, m_baseEquality, rep2cnt_base);
+            Set<String> visitedrep = new HashSet<String>();
+            for(String individual : m_equality.keySet()) {
+                String rep = m_equality.find(individual);
+                if(visitedrep.contains(rep)) continue;
+                visitedrep.add(rep);
+                String rep_base = m_baseEquality.find(individual);
+                if(!rep2cnt.get(rep).equals(rep2cnt_base.get(rep_base))) {
+                    toAddedIndividuals.add(rep);
+                }
+            }
+
+        }
+        while(true) {
+            if(getNewGapTuple(iter_individual, currentID)) return true;
+            if(iter_individual != null) {
+                iter_individual.dispose();
+                iter_individual = null;
+            }
+            if(toAddedIndividuals.isEmpty()) {
+                currentID = -1;
+                return false;
+            }
+            String individual = toAddedIndividuals.remove();
+            currentID = tripleManager.getResourceID(individual);
+            try {
+                iter_individual =
+                        m_engine.internal_evaluateNotExpanded(String.format("select distinct ?y ?z where { <%s> ?y ?z }", individual));
+                multi = iter_individual.open();
+            } catch(JRDFStoreException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void count(BasicQueryEngine engine, UFS<String> equality, Map<String, Integer> map) {
+        for(String ind : equality.keySet()) {
+            Integer exist = map.get(ind);
+            if(exist == null)
+                map.put(equality.find(ind), 1);
+            else
+                map.put(equality.find(ind), ++exist);
+        }
+    }
+
+    @Override
+    public int[] next() {
+        try {
+            if(iterator != null)
+                multi = iterator.getNext();
+            else if(iter_individual != null)
+                multi = iter_individual.getNext();
+            else
+                multi = 0;
+        } catch(JRDFStoreException e) {
+            e.printStackTrace();
+        }
+        return tuple;
+    }
+
+    public void clear() {
+        super.clear();
+        if(iter_individual != null) {
+            iter_individual.dispose();
+            iter_individual = null;
+        }
+    }
+
+}
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java b/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java
index a1c1b0e..eaa629b 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java
@@ -1,36 +1,29 @@
 package uk.ac.ox.cs.pagoda.query;
 
-import java.io.BufferedWriter;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.util.Collection;
-
-import org.semanticweb.HermiT.model.Atom;
-import org.semanticweb.HermiT.model.AtomicConcept;
-import org.semanticweb.HermiT.model.AtomicRole;
-import org.semanticweb.HermiT.model.DLClause;
-import org.semanticweb.HermiT.model.Individual;
-
+import org.semanticweb.HermiT.model.*;
+import uk.ac.ox.cs.JRDFox.JRDFStoreException;
+import uk.ac.ox.cs.JRDFox.Prefixes;
+import uk.ac.ox.cs.JRDFox.store.DataStore;
+import uk.ac.ox.cs.JRDFox.store.Parameters;
+import uk.ac.ox.cs.JRDFox.store.TupleIterator;
 import uk.ac.ox.cs.pagoda.MyPrefixes;
 import uk.ac.ox.cs.pagoda.owl.OWLHelper;
 import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
 import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
 import uk.ac.ox.cs.pagoda.util.Namespace;
 import uk.ac.ox.cs.pagoda.util.Utility;
-import uk.ac.ox.cs.JRDFox.JRDFStoreException;
-import uk.ac.ox.cs.JRDFox.Prefixes;
-import uk.ac.ox.cs.JRDFox.store.DataStore;
-import uk.ac.ox.cs.JRDFox.store.Parameters;
-import uk.ac.ox.cs.JRDFox.store.TupleIterator;
+
+import java.io.BufferedWriter;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.util.Collection;
 
 public class GapByTriple extends GapTupleIterator<String> {
         
-        private static final String RDF_TYPE = Namespace.RDF_NS + "type"; 
-        private static final String BRIEF_RDF_TYPE = "rdf:type"; 
-        
         static final String allTripleQuery = "SELECT ?X ?Y ?Z WHERE { ?X ?Y ?Z }";
-        
+        private static final String RDF_TYPE = Namespace.RDF_NS + "type";
+        private static final String BRIEF_RDF_TYPE = "rdf:type";
         DataStore lowerStore, upperStore;
         long multi; 
         TupleIterator iterator;
@@ -164,11 +157,6 @@ public class GapByTriple extends GapTupleIterator<String> {
         }
         
         @Override
-        public boolean isValid() {
-                return true;
-        }
-
-        @Override
         public void clear() {
                 iterator.dispose();             
         }
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
index 58303bb..2983b2e 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
@@ -1,10 +1,10 @@
 package uk.ac.ox.cs.pagoda.query;
 
-import java.util.Iterator;
-
 import uk.ac.ox.cs.JRDFox.JRDFStoreException;
 import uk.ac.ox.cs.JRDFox.store.DataStore;
 
+import java.util.Iterator;
+
 public abstract class GapTupleIterator<T> implements Iterator<T> {
         
         public static final String gapPredicateSuffix = "_AUXg"; 
@@ -17,8 +17,6 @@ public abstract class GapTupleIterator<T> implements Iterator<T> {
         
         public void compile(String programText) throws JRDFStoreException {}
         
-        public abstract boolean isValid();
-        
         public abstract void save(String file); 
         
         public abstract void addBackTo() throws JRDFStoreException;