From 4f98cb7df7f2921808d825cdcd82f95a0899640e Mon Sep 17 00:00:00 2001 From: yujiao Date: Mon, 25 May 2015 22:07:14 -0700 Subject: fixed a bug in the process of generating gap tuples, see test in TestGapMappedToLower.java --- src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java | 31 +++-- src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java | 146 +++++++++++++++++++++ src/uk/ac/ox/cs/pagoda/query/GapByTriple.java | 5 - src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java | 4 +- 4 files changed, 162 insertions(+), 24 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..84929ad 100644 --- a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java +++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java @@ -8,6 +8,7 @@ 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; @@ -17,14 +18,14 @@ import uk.ac.ox.cs.JRDFox.store.TupleIterator; //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; public GapByStore4ID(BasicQueryEngine engine) { m_engine = engine; @@ -32,7 +33,7 @@ public class GapByStore4ID extends GapTupleIterator { tripleManager = new RDFoxTripleManager(m_store, false); } - long multi; + protected long multi; @Override public void compile(String program) throws JRDFStoreException { @@ -117,7 +118,7 @@ public class GapByStore4ID extends GapTupleIterator { return predicatesWithGap; } - private Integer getGapPredicateID(int originalID) { + protected Integer getGapPredicateID(int originalID) { Integer gapID; if ((gapID = original2gap.get(originalID)) != null) return gapID; @@ -136,11 +137,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 +154,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 +170,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 +184,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..f8e1709 --- /dev/null +++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java @@ -0,0 +1,146 @@ +package uk.ac.ox.cs.pagoda.query; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.Map; +import java.util.Set; + +import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine; +import uk.ac.ox.cs.pagoda.util.UFS; +import uk.ac.ox.cs.JRDFox.JRDFStoreException; +import uk.ac.ox.cs.JRDFox.store.TupleIterator; + +public class GapByStore4ID2 extends GapByStore4ID { + + private BasicQueryEngine m_baseEngine; + private UFS m_equality = null, m_baseEquality = null; + + 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] = (int) 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 LinkedList toAddedIndividuals = null; + private TupleIterator iter_individual = null; + private int currentID = -1; + + 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..d2e9b90 100644 --- a/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java +++ b/src/uk/ac/ox/cs/pagoda/query/GapByTriple.java @@ -163,11 +163,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..61b6364 100644 --- a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java +++ b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java @@ -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; @@ -26,5 +24,5 @@ public abstract class GapTupleIterator implements Iterator { public abstract void addTo(DataStore store) throws JRDFStoreException; public abstract void clear(); - + } -- cgit v1.2.3