initial version

1 files changed, 192 insertions, 0 deletions

diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
new file mode 100644
index 0000000..1c0eb48
--- /dev/null
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
@@ -0,0 +1,192 @@
+package uk.ac.ox.cs.pagoda.query;
+
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+
+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.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;
+
+//public class GapByStore4ID extends GapTupleIterator<AnswerTupleID> {
+public class GapByStore4ID extends GapTupleIterator<int[]> {
+
+        private MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes; 
+        private TupleIterator iterator = null; 
+        
+//      AnswerTupleID tuple;
+        int[] tuple; 
+        private BasicQueryEngine m_engine; 
+        private DataStore m_store;
+        private RDFoxTripleManager tripleManager; 
+        
+        public GapByStore4ID(BasicQueryEngine engine) {
+                m_engine = engine; 
+                m_store = engine.getDataStore(); 
+                tripleManager = new RDFoxTripleManager(m_store, false); 
+        }
+        
+        long multi; 
+        
+        @Override
+        public void compile(String program) throws JRDFStoreException {
+                clear(); 
+
+                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; 
+                }
+                
+                m_store.applyReasoning(incrementally);
+                
+                long tripleCount = m_store.getTriplesCount();
+                        
+                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 ..."); 
+        }
+        
+        @Override
+        public boolean hasNext() {
+                if (iterator == null) return false; 
+                try {
+//                      tuple = new AnswerTupleID(3);
+                        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); 
+                                
+                                if (isRDF_TYPE()) {
+//                                      predicate = getGapPredicateID(tuple.getTerm(2));
+                                        predicate = getGapPredicateID(tuple[2]); 
+                                        if (predicate == null) continue; 
+//                                      tuple.setTerm(2, predicate);
+                                        tuple[2] = predicate; 
+                                }
+                                else {
+//                                      predicate = getGapPredicateID(tuple.getTerm(1));
+                                        predicate = getGapPredicateID(tuple[1]); 
+                                        if (predicate == null) continue;  
+//                                      tuple.setTerm(1, predicate);
+                                        tuple[1] = predicate; 
+                                }
+                                return true; 
+                        }
+                } catch (JRDFStoreException e) {
+                        e.printStackTrace();
+                        return false; 
+                }
+                return false; 
+        }
+        
+        @Override
+//      public AnswerTupleID next() {
+        public int[] next() {
+                try {
+                        multi = iterator.getNext();
+                } catch (JRDFStoreException e) {
+                        e.printStackTrace();
+                } 
+                
+                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) {
+                Integer gapID; 
+                if ((gapID = original2gap.get(originalID)) != null) 
+                        return gapID;
+                
+                String originalPredicate = tripleManager.getRawTerm(originalID);
+                if (isAuxPredicate(originalPredicate)) {
+//                      Utility.LOGS.info(originalPredicate); 
+                        return null; 
+                }
+
+                predicatesWithGap.add(originalPredicate);  
+                String gapPredicate = prefixes.expandIRI(getGapPredicate(originalPredicate));
+                gapID = tripleManager.getResourceID(gapPredicate);
+                original2gap.put(originalID, gapID); 
+                
+                return gapID;
+        }
+
+        private boolean isAuxPredicate(String originalPredicate) {
+                return originalPredicate.contains("_AUX");
+        }
+
+        private boolean isRDF_TYPE() {
+//              return tripleManager.isRdfTypeID(tuple.getTerm(1)); 
+                return tripleManager.isRdfTypeID(tuple[1]); 
+        }
+
+        @Override
+        public void remove() {
+                Utility.logError("Unsupported operation!"); 
+        }
+        
+        private boolean valid = false;
+
+        @Override
+        public void save(String file) {
+                Utility.logError("Unsupported Operation..."); 
+        }
+        
+        @Override
+        public void addBackTo() throws JRDFStoreException { 
+                int tupleCounter = 0;
+                Timer t = new Timer(); 
+                long oldTripleCounter; 
+                Utility.logDebug("current store before importing gap tuples: " + (oldTripleCounter = m_store.getTriplesCount())); 
+                while (hasNext()) {
+                        next(); 
+                        ++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.", 
+                                "current store after importing gap tuples: " + tripleCounter + " (" + (tripleCounter - oldTripleCounter) + ").", 
+                                "current store finished importing gap tuples: " + tripleCounter + " in " + t.duration() + "."); 
+        }
+        
+        public void clear() {
+                if (iterator != null) {
+                        iterator.dispose();
+                        iterator = null; 
+                }
+        }
+                
+        public boolean isValid() {return valid; }
+
+        @Override
+        public void addTo(DataStore store) throws JRDFStoreException {
+                Utility.logError("Unsupported Operation..."); 
+        }
+}