From de3749532d060f26c966a81c03f9a5d846c33d06 Mon Sep 17 00:00:00 2001 From: RncLsn Date: Thu, 28 May 2015 17:11:35 +0100 Subject: Merged updates from upstream. --- src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java | 120 +++++++++--------- src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java | 141 +++++++++++++++++++++ src/uk/ac/ox/cs/pagoda/query/GapByTriple.java | 40 ++---- src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java | 6 +- 4 files changed, 216 insertions(+), 91 deletions(-) create mode 100644 src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java (limited to 'src/uk/ac/ox/cs/pagoda/query') 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 { public class GapByStore4ID extends GapTupleIterator { - 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 original2gap = new HashMap(); + LinkedList predicatesWithGap = new LinkedList(); 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 { multi = iterator.getNext(); } catch (JRDFStoreException e) { e.printStackTrace(); - } - - return tuple; + } + + return tuple; } - Map original2gap = new HashMap(); - LinkedList predicatesWithGap = new LinkedList(); - public LinkedList 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 { 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 { 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 { ++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 { } } - 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 m_equality = null, m_baseEquality = null; + private LinkedList 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(); + Map rep2cnt = new HashMap(); + Map rep2cnt_base = new HashMap(); + count(m_engine, m_equality, rep2cnt); + count(m_baseEngine, m_baseEquality, rep2cnt_base); + Set visitedrep = new HashSet(); + 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 equality, Map 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 { - 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; @@ -163,11 +156,6 @@ public class GapByTriple extends GapTupleIterator { addTo(upperStore); } - @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 implements Iterator { public static final String gapPredicateSuffix = "_AUXg"; @@ -17,8 +17,6 @@ public abstract class GapTupleIterator implements Iterator { public void compile(String programText) throws JRDFStoreException {} - public abstract boolean isValid(); - public abstract void save(String file); public abstract void addBackTo() throws JRDFStoreException; -- cgit v1.2.3