aboutsummaryrefslogtreecommitdiff
path: root/src/uk/ac/ox/cs
diff options
context:
space:
mode:
authorRncLsn <rnc.lsn@gmail.com>2015-05-28 17:24:00 +0100
committerRncLsn <rnc.lsn@gmail.com>2015-05-28 17:24:00 +0100
commit1055e67727b1aca80ae7ffaceabce3aacb00b6d2 (patch)
tree71632dfc0fdf596d0286a4912245cacedfd2b534 /src/uk/ac/ox/cs
parentde3749532d060f26c966a81c03f9a5d846c33d06 (diff)
parent4f98cb7df7f2921808d825cdcd82f95a0899640e (diff)
downloadACQuA-1055e67727b1aca80ae7ffaceabce3aacb00b6d2.tar.gz
ACQuA-1055e67727b1aca80ae7ffaceabce3aacb00b6d2.zip
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
Diffstat (limited to 'src/uk/ac/ox/cs')
-rw-r--r--src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java85
-rw-r--r--src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java67
-rw-r--r--src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java105
-rw-r--r--src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java265
-rw-r--r--src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java2
-rw-r--r--src/uk/ac/ox/cs/pagoda/reasoner/light/BasicQueryEngine.java181
6 files changed, 366 insertions, 339 deletions
diff --git a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
index 862fdc8..4e2fc5f 100644
--- a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
+++ b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndMultiThreadPlan.java
@@ -1,81 +1,88 @@
1package uk.ac.ox.cs.pagoda.endomorph.plan; 1package uk.ac.ox.cs.pagoda.endomorph.plan;
2 2
3import uk.ac.ox.cs.pagoda.endomorph.Clique; 3import java.util.Collection;
4import java.util.Collections;
5import java.util.LinkedList;
6import java.util.Map;
7import java.util.Set;
8import java.util.concurrent.ConcurrentHashMap;
9import java.util.concurrent.ConcurrentLinkedDeque;
10import java.util.concurrent.atomic.AtomicInteger;
11
4import uk.ac.ox.cs.pagoda.endomorph.DependencyGraph; 12import uk.ac.ox.cs.pagoda.endomorph.DependencyGraph;
13import uk.ac.ox.cs.pagoda.endomorph.Clique;
5import uk.ac.ox.cs.pagoda.query.AnswerTuple; 14import uk.ac.ox.cs.pagoda.query.AnswerTuple;
6import uk.ac.ox.cs.pagoda.reasoner.full.Checker; 15import uk.ac.ox.cs.pagoda.reasoner.full.Checker;
7import uk.ac.ox.cs.pagoda.reasoner.full.HermitChecker; 16import uk.ac.ox.cs.pagoda.reasoner.full.HermitChecker;
8import uk.ac.ox.cs.pagoda.util.Utility; 17import uk.ac.ox.cs.pagoda.util.Utility;
9 18
10import java.util.*;
11import java.util.concurrent.ConcurrentHashMap;
12import java.util.concurrent.ConcurrentLinkedDeque;
13import java.util.concurrent.atomic.AtomicInteger;
14
15public class OpenEndMultiThreadPlan implements CheckPlan { 19public class OpenEndMultiThreadPlan implements CheckPlan {
16 20
17 Checker checker; 21 Checker checker;
18 DependencyGraph dGraph; 22 DependencyGraph dGraph;
19 // Clique[] topo; 23
20// AtomicInteger open, end;
21 ConcurrentLinkedDeque<Clique> topo;
22 Set<Clique> validated, falsified;
23 AtomicInteger counter = new AtomicInteger();
24
25 public OpenEndMultiThreadPlan(Checker checker, DependencyGraph dGraph) { 24 public OpenEndMultiThreadPlan(Checker checker, DependencyGraph dGraph) {
26 this.checker = checker; 25 this.checker = checker;
27 this.dGraph = dGraph; 26 this.dGraph = dGraph;
28 } 27 }
29 28
29// Clique[] topo;
30// AtomicInteger open, end;
31 ConcurrentLinkedDeque<Clique> topo;
32
33 Set<Clique> validated, falsified;
34
30 @Override 35 @Override
31 public int check() { 36 public int check() {
32 Collection<Clique> cliques = dGraph.getTopologicalOrder(); 37 Collection<Clique> cliques = dGraph.getTopologicalOrder();
33// topo = new LinkedBlockingDeque<Clique>(cliques); 38// topo = new LinkedBlockingDeque<Clique>(cliques);
34 topo = new ConcurrentLinkedDeque<Clique>(cliques); 39 topo = new ConcurrentLinkedDeque<Clique>(cliques);
35 40
36// topo = new Clique[cliques.size()]; 41// topo = new Clique[cliques.size()];
37// int index = 0; 42// int index = 0;
38// for (Clique clique: cliques) topo[index++] = clique; 43// for (Clique clique: cliques) topo[index++] = clique;
39// open = new AtomicInteger(); 44// open = new AtomicInteger();
40// end = new AtomicInteger(cliques.size() - 1); 45// end = new AtomicInteger(cliques.size() - 1);
41 46
42// validated = Collections.synchronizedSet(new HashSet<Clique>()); 47// validated = Collections.synchronizedSet(new HashSet<Clique>());
43// falsified = Collections.synchronizedSet(new HashSet<Clique>()); 48// falsified = Collections.synchronizedSet(new HashSet<Clique>());
44 validated = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>()); 49 validated = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>());
45 falsified = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>()); 50 falsified = Collections.newSetFromMap(new ConcurrentHashMap<Clique, Boolean>());
46 51
47 int numOfThreads = 10; 52 int numOfThreads = 10;
48 Collection<Thread> threads = new LinkedList<Thread>(); 53 Collection<Thread> threads = new LinkedList<Thread>();
49 for(int i = 0; i < numOfThreads; ++i) 54 for (int i = 0; i < numOfThreads; ++i)
50 threads.add(new Thread(new SubThread(new HermitChecker(checker), i))); 55 threads.add(new Thread(new SubThread(new HermitChecker(checker), i)));
51 56
52 for (Thread thread: threads) thread.start(); 57 for (Thread thread: threads) thread.start();
53 58
54 for (Thread thread: threads) { 59 for (Thread thread: threads) {
55 try { 60 try {
56 thread.join(); 61 thread.join();
57 } catch (InterruptedException e) { 62 } catch (InterruptedException e) {
58 e.printStackTrace(); 63 e.printStackTrace();
59 } 64 }
60 } 65 }
61 66
62 Utility.logDebug("HermiT was called " + counter.get() + " times."); 67 Utility.logDebug("HermiT was called " + counter.get() + " times.");
63 68
64 int count = 0; 69 int count = 0;
65 for (Clique c: dGraph.getTopologicalOrder()) { 70 for (Clique c: dGraph.getTopologicalOrder()) {
66 if (validated.contains(c)) 71 if (validated.contains(c))
67 count += c.getNodeTuples().size(); 72 count += c.getNodeTuples().size();
68 } 73 }
69 return count; 74 return count;
70 } 75 }
71 76
72 private void setMarkCascadely(Clique clique, Set<Clique> marked, Map<Clique, Collection<Clique>> edges) { 77 private void setMarkCascadely(Clique clique, Set<Clique> marked, Map<Clique, Collection<Clique>> edges) {
73 marked.add(clique); 78 marked.add(clique);
74 if (edges.containsKey(clique)) 79 if (edges.containsKey(clique))
75 for (Clique c: edges.get(clique)) 80 for (Clique c: edges.get(clique))
76 if(!marked.contains(c)) 81 if (!marked.contains(c))
77 setMarkCascadely(c, marked, edges); 82 setMarkCascadely(c, marked, edges);
78 } 83 }
84
85 AtomicInteger counter = new AtomicInteger();
79 86
80 class SubThread implements Runnable { 87 class SubThread implements Runnable {
81 88
diff --git a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
index 3294c31..a740833 100644
--- a/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
+++ b/src/uk/ac/ox/cs/pagoda/endomorph/plan/OpenEndPlan.java
@@ -1,7 +1,12 @@
1package uk.ac.ox.cs.pagoda.endomorph.plan; 1package uk.ac.ox.cs.pagoda.endomorph.plan;
2 2
3import uk.ac.ox.cs.pagoda.endomorph.Clique; 3import java.util.Collection;
4import uk.ac.ox.cs.pagoda.endomorph.DependencyGraph; 4import java.util.HashSet;
5import java.util.LinkedList;
6import java.util.Map;
7import java.util.Set;
8
9import uk.ac.ox.cs.pagoda.endomorph.*;
5import uk.ac.ox.cs.pagoda.query.AnswerTuple; 10import uk.ac.ox.cs.pagoda.query.AnswerTuple;
6import uk.ac.ox.cs.pagoda.query.QueryRecord; 11import uk.ac.ox.cs.pagoda.query.QueryRecord;
7import uk.ac.ox.cs.pagoda.query.QueryRecord.Step; 12import uk.ac.ox.cs.pagoda.query.QueryRecord.Step;
@@ -10,40 +15,40 @@ import uk.ac.ox.cs.pagoda.summary.NodeTuple;
10import uk.ac.ox.cs.pagoda.util.Timer; 15import uk.ac.ox.cs.pagoda.util.Timer;
11import uk.ac.ox.cs.pagoda.util.Utility; 16import uk.ac.ox.cs.pagoda.util.Utility;
12 17
13import java.util.*;
14
15public class OpenEndPlan implements CheckPlan { 18public class OpenEndPlan implements CheckPlan {
16 19
17 public static final int TIME_OUT_MIN = 1; 20 public static final int TIME_OUT_MIN = 1;
18 21
19 Checker checker; 22 Checker checker;
20 DependencyGraph dGraph; 23 DependencyGraph dGraph;
21 QueryRecord m_record; 24 QueryRecord m_record;
22 int m_answerArity; 25 int m_answerArity;
23 Set<Clique> validated = new HashSet<Clique>(); 26
24 Set<Clique> falsified = new HashSet<Clique>();
25 Set<AnswerTuple> passedAnswers = new HashSet<AnswerTuple>();
26 public OpenEndPlan(Checker checker, DependencyGraph dGraph, QueryRecord record) { 27 public OpenEndPlan(Checker checker, DependencyGraph dGraph, QueryRecord record) {
27 this.checker = checker; 28 this.checker = checker;
28 this.dGraph = dGraph; 29 this.dGraph = dGraph;
29 m_record = record; 30 m_record = record;
30 m_answerArity = record.getAnswerVariables().length; 31 m_answerArity = record.getAnswerVariables().length;
31 } 32 }
32 33
34 Set<Clique> validated = new HashSet<Clique>();
35 Set<Clique> falsified = new HashSet<Clique>();
36 Set<AnswerTuple> passedAnswers = new HashSet<AnswerTuple>();
37
33 @Override 38 @Override
34 public int check() { 39 public int check() {
35 LinkedList<Clique> topo = new LinkedList<Clique>(dGraph.getTopologicalOrder()); 40 LinkedList<Clique> topo = new LinkedList<Clique>(dGraph.getTopologicalOrder());
36 Utility.logInfo("Entrances: " + dGraph.getEntrances().size() + " Exists: " + dGraph.getExits().size()); 41 Utility.logInfo("Entrances: " + dGraph.getEntrances().size() + " Exists: " + dGraph.getExits().size());
37 42
38 boolean flag = true; 43 boolean flag = true;
39 Clique clique; 44 Clique clique;
40 Timer t = new Timer(); 45 Timer t = new Timer();
41 46
42 AnswerTuple answerTuple; 47 AnswerTuple answerTuple;
43 while (!topo.isEmpty()) { 48 while (!topo.isEmpty()) {
44 if (flag) { 49 if (flag) {
45 clique = topo.removeFirst(); 50 clique = topo.removeFirst();
46 if(redundant(clique)) continue; 51 if (redundant(clique)) continue;
47 if (validated.contains(clique)) continue; 52 if (validated.contains(clique)) continue;
48 if (falsified.contains(clique)) { flag = false; continue; } 53 if (falsified.contains(clique)) { flag = false; continue; }
49 Utility.logDebug("start checking front ... " + (answerTuple = clique.getRepresentative().getAnswerTuple())); 54 Utility.logDebug("start checking front ... " + (answerTuple = clique.getRepresentative().getAnswerTuple()));
@@ -60,8 +65,8 @@ public class OpenEndPlan implements CheckPlan {
60 clique = topo.removeLast(); 65 clique = topo.removeLast();
61 if (falsified.contains(clique)) continue; 66 if (falsified.contains(clique)) continue;
62 if (validated.contains(clique)) { flag = true; continue; } 67 if (validated.contains(clique)) { flag = true; continue; }
63 Utility.logDebug("start checking back ... " + (answerTuple = clique.getRepresentative().getAnswerTuple())); 68 Utility.logDebug("start checking back ... " + (answerTuple = clique.getRepresentative().getAnswerTuple()));
64 if(!checker.check(answerTuple)) 69 if (!checker.check(answerTuple))
65 setMarkCascadelyFasified(clique); 70 setMarkCascadelyFasified(clique);
66 else { 71 else {
67 Utility.logDebug(answerTuple.toString() + " is verified."); 72 Utility.logDebug(answerTuple.toString() + " is verified.");
@@ -88,38 +93,38 @@ public class OpenEndPlan implements CheckPlan {
88 } 93 }
89 94
90 m_record.addLowerBoundAnswers(validAnswers); 95 m_record.addLowerBoundAnswers(validAnswers);
91 m_record.addProcessingTime(Step.FULL_REASONING, t.duration()); 96 m_record.addProcessingTime(Step.FullReasoning, t.duration());
92 return count; 97 return count;
93 } 98 }
94 99
95 private boolean redundant(Clique clique) { 100 private boolean redundant(Clique clique) {
96 for(NodeTuple nodeTuple : clique.getNodeTuples()) 101 for (NodeTuple nodeTuple: clique.getNodeTuples())
97 if(!passedAnswers.contains(AnswerTuple.getInstance(nodeTuple.getAnswerTuple(), m_answerArity))) 102 if (!passedAnswers.contains(AnswerTuple.create(nodeTuple.getAnswerTuple(), m_answerArity)))
98 return false; 103 return false;
99 return true; 104 return true;
100 } 105 }
101 106
102 private void addProjections(Clique clique) { 107 private void addProjections(Clique clique) {
103 for(NodeTuple nodeTuple : clique.getNodeTuples()) 108 for (NodeTuple nodeTuple: clique.getNodeTuples())
104 passedAnswers.add(AnswerTuple.getInstance(nodeTuple.getAnswerTuple(), m_answerArity)); 109 passedAnswers.add(AnswerTuple.create(nodeTuple.getAnswerTuple(), m_answerArity));
105 } 110 }
106 111
107 private void setMarkCascadelyValidated(Clique clique) { 112 private void setMarkCascadelyValidated(Clique clique) {
108 validated.add(clique); 113 validated.add(clique);
109 addProjections(clique); 114 addProjections(clique);
110 Map<Clique, Collection<Clique>> edges = dGraph.getOutGoingEdges(); 115 Map<Clique, Collection<Clique>> edges = dGraph.getOutGoingEdges();
111 if (edges.containsKey(clique)) 116 if (edges.containsKey(clique))
112 for (Clique c: edges.get(clique)) 117 for (Clique c: edges.get(clique))
113 if(!validated.contains(c)) 118 if (!validated.contains(c))
114 setMarkCascadelyValidated(c); 119 setMarkCascadelyValidated(c);
115 } 120 }
116 121
117 private void setMarkCascadelyFasified(Clique clique) { 122 private void setMarkCascadelyFasified(Clique clique) {
118 falsified.add(clique); 123 falsified.add(clique);
119 Map<Clique, Collection<Clique>> edges = dGraph.getInComingEdges(); 124 Map<Clique, Collection<Clique>> edges = dGraph.getInComingEdges();
120 if(edges.containsKey(clique)) 125 if (edges.containsKey(clique))
121 for(Clique c : edges.get(clique)) 126 for (Clique c: edges.get(clique))
122 if(!falsified.contains(c)) 127 if (!falsified.contains(c))
123 setMarkCascadelyFasified(c); 128 setMarkCascadelyFasified(c);
124 } 129 }
125 130
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
index 02db18d..84929ad 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID.java
@@ -1,106 +1,104 @@
1package uk.ac.ox.cs.pagoda.query; 1package uk.ac.ox.cs.pagoda.query;
2 2
3import uk.ac.ox.cs.JRDFox.JRDFStoreException; 3import java.util.HashMap;
4import uk.ac.ox.cs.JRDFox.store.DataStore; 4import java.util.LinkedList;
5import uk.ac.ox.cs.JRDFox.store.TupleIterator; 5import java.util.Map;
6
6import uk.ac.ox.cs.pagoda.MyPrefixes; 7import uk.ac.ox.cs.pagoda.MyPrefixes;
8//import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
7import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine; 9import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
8import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager; 10import uk.ac.ox.cs.pagoda.reasoner.light.RDFoxTripleManager;
9import uk.ac.ox.cs.pagoda.util.Namespace; 11import uk.ac.ox.cs.pagoda.util.Namespace;
10import uk.ac.ox.cs.pagoda.util.Timer; 12import uk.ac.ox.cs.pagoda.util.Timer;
11import uk.ac.ox.cs.pagoda.util.Utility; 13import uk.ac.ox.cs.pagoda.util.Utility;
12 14import uk.ac.ox.cs.JRDFox.JRDFStoreException;
13import java.util.HashMap; 15import uk.ac.ox.cs.JRDFox.store.DataStore;
14import java.util.LinkedList; 16import uk.ac.ox.cs.JRDFox.store.TupleIterator;
15import java.util.Map;
16
17//import uk.ac.ox.cs.pagoda.multistage.AnswerTupleID;
18 17
19//public class GapByStore4ID extends GapTupleIterator<AnswerTupleID> { 18//public class GapByStore4ID extends GapTupleIterator<AnswerTupleID> {
20public class GapByStore4ID extends GapTupleIterator<int[]> { 19public class GapByStore4ID extends GapTupleIterator<int[]> {
21 20
22 protected MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes; 21 protected MyPrefixes prefixes = MyPrefixes.PAGOdAPrefixes;
23 protected TupleIterator iterator = null; 22 protected TupleIterator iterator = null;
24 23
25// AnswerTupleID tuple; 24// AnswerTupleID tuple;
26protected int[] tuple; 25 protected int[] tuple;
27 protected BasicQueryEngine m_engine; 26 protected BasicQueryEngine m_engine;
28 protected DataStore m_store; 27 protected DataStore m_store;
29 protected RDFoxTripleManager tripleManager; 28 protected RDFoxTripleManager tripleManager;
30 protected long multi;
31 Map<Integer, Integer> original2gap = new HashMap<Integer, Integer>();
32 LinkedList<String> predicatesWithGap = new LinkedList<String>();
33 29
34 public GapByStore4ID(BasicQueryEngine engine) { 30 public GapByStore4ID(BasicQueryEngine engine) {
35 m_engine = engine; 31 m_engine = engine;
36 m_store = engine.getDataStore(); 32 m_store = engine.getDataStore();
37 tripleManager = new RDFoxTripleManager(m_store, false); 33 tripleManager = new RDFoxTripleManager(m_store, false);
38 } 34 }
39 35
36 protected long multi;
37
40 @Override 38 @Override
41 public void compile(String program) throws JRDFStoreException { 39 public void compile(String program) throws JRDFStoreException {
42 clear(); 40 clear();
43 41
44 boolean incrementally = true; 42 boolean incrementally = true;
45 Timer t = new Timer(); 43 Timer t = new Timer();
46 long oldTripleCount = m_store.getTriplesCount(); 44 long oldTripleCount = m_store.getTriplesCount();
47 45
48 if (program != null) { 46 if (program != null) {
49// m_store.addRules(new String[] {program}); 47// m_store.addRules(new String[] {program});
50 m_store.importRules(program); 48 m_store.importRules(program);
51 incrementally = false; 49 incrementally = false;
52 } 50 }
53 51
54 m_store.applyReasoning(incrementally); 52 m_store.applyReasoning(incrementally);
55 53
56 long tripleCount = m_store.getTriplesCount(); 54 long tripleCount = m_store.getTriplesCount();
57 55
58 Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)", 56 Utility.logDebug("current store after materialising upper related rules: " + tripleCount + " (" + (tripleCount - oldTripleCount) + " new)",
59 "current store finished the materialisation of upper related rules in " + t.duration() + " seconds."); 57 "current store finished the materialisation of upper related rules in " + t.duration() + " seconds.");
60 58
61 m_engine.setExpandEquality(false); 59 m_engine.setExpandEquality(false);
62 iterator = m_engine.internal_evaluateAgainstIDBs("select ?x ?y ?z where { ?x ?y ?z . }"); 60 iterator = m_engine.internal_evaluateAgainstIDBs("select ?x ?y ?z where { ?x ?y ?z . }");
63 m_engine.setExpandEquality(true); 61 m_engine.setExpandEquality(true);
64 62
65 multi = iterator.open(); 63 multi = iterator.open();
66 Utility.logDebug("gap query evaluted ..."); 64 Utility.logDebug("gap query evaluted ...");
67 } 65 }
68 66
69 @Override 67 @Override
70 public boolean hasNext() { 68 public boolean hasNext() {
71 if(iterator == null) return false; 69 if (iterator == null) return false;
72 try { 70 try {
73// tuple = new AnswerTupleID(3); 71// tuple = new AnswerTupleID(3);
74 tuple = new int[3]; 72 tuple = new int[3];
75 Integer predicate; 73 Integer predicate;
76 for (; multi != 0; multi = iterator.getNext()) { 74 for (; multi != 0; multi = iterator.getNext()) {
77 for (int i = 0; i < 3; ++i) 75 for (int i = 0; i < 3; ++i)
78// tuple.setTerm(i, (int) iterator.getResourceID(i)); 76// tuple.setTerm(i, (int) iterator.getResourceID(i));
79 tuple[i] = iterator.getResourceID(i); 77 tuple[i] = (int) iterator.getResourceID(i);
80 78
81 if (isRDF_TYPE()) { 79 if (isRDF_TYPE()) {
82// predicate = getGapPredicateID(tuple.getTerm(2)); 80// predicate = getGapPredicateID(tuple.getTerm(2));
83 predicate = getGapPredicateID(tuple[2]); 81 predicate = getGapPredicateID(tuple[2]);
84 if(predicate == null) continue; 82 if (predicate == null) continue;
85// tuple.setTerm(2, predicate); 83// tuple.setTerm(2, predicate);
86 tuple[2] = predicate; 84 tuple[2] = predicate;
87 } 85 }
88 else { 86 else {
89// predicate = getGapPredicateID(tuple.getTerm(1)); 87// predicate = getGapPredicateID(tuple.getTerm(1));
90 predicate = getGapPredicateID(tuple[1]); 88 predicate = getGapPredicateID(tuple[1]);
91 if(predicate == null) continue; 89 if (predicate == null) continue;
92// tuple.setTerm(1, predicate); 90// tuple.setTerm(1, predicate);
93 tuple[1] = predicate; 91 tuple[1] = predicate;
94 } 92 }
95 return true; 93 return true;
96 } 94 }
97 } catch (JRDFStoreException e) { 95 } catch (JRDFStoreException e) {
98 e.printStackTrace(); 96 e.printStackTrace();
99 return false; 97 return false;
100 } 98 }
101 return false; 99 return false;
102 } 100 }
103 101
104 @Override 102 @Override
105// public AnswerTupleID next() { 103// public AnswerTupleID next() {
106 public int[] next() { 104 public int[] next() {
@@ -108,15 +106,18 @@ protected int[] tuple;
108 multi = iterator.getNext(); 106 multi = iterator.getNext();
109 } catch (JRDFStoreException e) { 107 } catch (JRDFStoreException e) {
110 e.printStackTrace(); 108 e.printStackTrace();
111 } 109 }
112 110
113 return tuple; 111 return tuple;
114 } 112 }
115 113
114 Map<Integer, Integer> original2gap = new HashMap<Integer, Integer>();
115 LinkedList<String> predicatesWithGap = new LinkedList<String>();
116
116 public LinkedList<String> getPredicatesWithGap() { 117 public LinkedList<String> getPredicatesWithGap() {
117 return predicatesWithGap; 118 return predicatesWithGap;
118 } 119 }
119 120
120 protected Integer getGapPredicateID(int originalID) { 121 protected Integer getGapPredicateID(int originalID) {
121 Integer gapID; 122 Integer gapID;
122 if ((gapID = original2gap.get(originalID)) != null) 123 if ((gapID = original2gap.get(originalID)) != null)
@@ -137,9 +138,9 @@ protected int[] tuple;
137 } 138 }
138 139
139 protected boolean isAuxPredicate(String originalPredicate) { 140 protected boolean isAuxPredicate(String originalPredicate) {
140 if(originalPredicate.equals(Namespace.EQUALITY_QUOTED)) return false; 141 if (originalPredicate.equals(Namespace.EQUALITY_QUOTED)) return false;
141 return originalPredicate.contains("_AUX") || 142 return originalPredicate.contains("_AUX") ||
142 originalPredicate.startsWith("<" + Namespace.OWL_NS) || 143 originalPredicate.startsWith("<" + Namespace.OWL_NS) ||
143 originalPredicate.startsWith("<" + Namespace.PAGODA_ORIGINAL); 144 originalPredicate.startsWith("<" + Namespace.PAGODA_ORIGINAL);
144 } 145 }
145 146
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
index 19efc58..f8e1709 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapByStore4ID2.java
@@ -1,141 +1,146 @@
1package uk.ac.ox.cs.pagoda.query; 1package uk.ac.ox.cs.pagoda.query;
2 2
3import uk.ac.ox.cs.JRDFox.JRDFStoreException; 3import java.util.HashMap;
4import uk.ac.ox.cs.JRDFox.store.TupleIterator; 4import java.util.HashSet;
5import java.util.LinkedList;
6import java.util.Map;
7import java.util.Set;
8
5import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine; 9import uk.ac.ox.cs.pagoda.reasoner.light.BasicQueryEngine;
6import uk.ac.ox.cs.pagoda.util.UFS; 10import uk.ac.ox.cs.pagoda.util.UFS;
7 11import uk.ac.ox.cs.JRDFox.JRDFStoreException;
8import java.util.*; 12import uk.ac.ox.cs.JRDFox.store.TupleIterator;
9 13
10public class GapByStore4ID2 extends GapByStore4ID { 14public class GapByStore4ID2 extends GapByStore4ID {
15
16 private BasicQueryEngine m_baseEngine;
17 private UFS<String> m_equality = null, m_baseEquality = null;
18
19 public GapByStore4ID2(BasicQueryEngine engine, BasicQueryEngine baseEngine) {
20 super(engine);
21 m_baseEngine = baseEngine;
22 }
23
24 @Override
25 public boolean hasNext() {
26 if (getNewGapTuple(iterator, -1)) return true;
27 if (iterator != null) {
28 iterator.dispose();
29 iterator = null;
30 }
31 return getNextGapFactAboutEquality();
32 }
33
34 private boolean getNewGapTuple(TupleIterator it, int firstElement) {
35 if (it == null) return false;
36 int firstIndex = 0;
37 tuple = new int[3];
38 if (firstElement > 0) {
39 tuple[0] = firstElement;
40 firstIndex = 1;
41 }
42 Integer predicate;
43 try {
44 for (; multi != 0; multi = it.getNext()) {
45 for (int i = firstIndex; i < 3; ++i)
46 tuple[i] = (int) it.getResourceID(i - firstIndex);
47
48 if (isRDF_TYPE()) {
49 predicate = getGapPredicateID(tuple[2]);
50 if (predicate == null) continue;
51 tuple[2] = predicate;
52 }
53 else {
54 predicate = getGapPredicateID(tuple[1]);
55 if (predicate == null) continue;
56 tuple[1] = predicate;
57 }
58 return true;
59 }
60 } catch (JRDFStoreException e) {
61 e.printStackTrace();
62 return false;
63 }
64 return false;
65 }
11 66
12 private BasicQueryEngine m_baseEngine; 67 private LinkedList<String> toAddedIndividuals = null;
13 private UFS<String> m_equality = null, m_baseEquality = null; 68 private TupleIterator iter_individual = null;
14 private LinkedList<String> toAddedIndividuals = null; 69 private int currentID = -1;
15 private TupleIterator iter_individual = null; 70
16 private int currentID = -1; 71 private boolean getNextGapFactAboutEquality() {
17 72 if (toAddedIndividuals == null) {
18 public GapByStore4ID2(BasicQueryEngine engine, BasicQueryEngine baseEngine) { 73 m_equality = m_engine.getEqualityGroups(false);
19 super(engine); 74 m_baseEquality = m_baseEngine.getEqualityGroups(false);
20 m_baseEngine = baseEngine; 75 toAddedIndividuals = new LinkedList<String>();
21 } 76 Map<String, Integer> rep2cnt = new HashMap<String, Integer>();
22 77 Map<String, Integer> rep2cnt_base = new HashMap<String, Integer>();
23 @Override 78 count(m_engine, m_equality, rep2cnt);
24 public boolean hasNext() { 79 count(m_baseEngine, m_baseEquality, rep2cnt_base);
25 if(getNewGapTuple(iterator, -1)) return true; 80 Set<String> visitedrep = new HashSet<String>();
26 if(iterator != null) { 81 for (String individual : m_equality.keySet()) {
27 iterator.dispose(); 82 String rep = m_equality.find(individual);
28 iterator = null; 83 if (visitedrep.contains(rep)) continue;
29 } 84 visitedrep.add(rep);
30 return getNextGapFactAboutEquality(); 85 String rep_base = m_baseEquality.find(individual);
31 } 86 if (!rep2cnt.get(rep).equals(rep2cnt_base.get(rep_base))) {
32 87 toAddedIndividuals.add(rep);
33 private boolean getNewGapTuple(TupleIterator it, int firstElement) { 88 }
34 if(it == null) return false; 89 }
35 int firstIndex = 0;
36 tuple = new int[3];
37 if(firstElement > 0) {
38 tuple[0] = firstElement;
39 firstIndex = 1;
40 }
41 Integer predicate;
42 try {
43 for(; multi != 0; multi = it.getNext()) {
44 for(int i = firstIndex; i < 3; ++i)
45 tuple[i] = it.getResourceID(i - firstIndex);
46
47 if(isRDF_TYPE()) {
48 predicate = getGapPredicateID(tuple[2]);
49 if(predicate == null) continue;
50 tuple[2] = predicate;
51 } else {
52 predicate = getGapPredicateID(tuple[1]);
53 if(predicate == null) continue;
54 tuple[1] = predicate;
55 }
56 return true;
57 }
58 } catch(JRDFStoreException e) {
59 e.printStackTrace();
60 return false;
61 }
62 return false;
63 }
64
65 private boolean getNextGapFactAboutEquality() {
66 if(toAddedIndividuals == null) {
67 m_equality = m_engine.getEqualityGroups(false);
68 m_baseEquality = m_baseEngine.getEqualityGroups(false);
69 toAddedIndividuals = new LinkedList<String>();
70 Map<String, Integer> rep2cnt = new HashMap<String, Integer>();
71 Map<String, Integer> rep2cnt_base = new HashMap<String, Integer>();
72 count(m_engine, m_equality, rep2cnt);
73 count(m_baseEngine, m_baseEquality, rep2cnt_base);
74 Set<String> visitedrep = new HashSet<String>();
75 for(String individual : m_equality.keySet()) {
76 String rep = m_equality.find(individual);
77 if(visitedrep.contains(rep)) continue;
78 visitedrep.add(rep);
79 String rep_base = m_baseEquality.find(individual);
80 if(!rep2cnt.get(rep).equals(rep2cnt_base.get(rep_base))) {
81 toAddedIndividuals.add(rep);
82 }
83 }
84
85 }
86 while(true) {
87 if(getNewGapTuple(iter_individual, currentID)) return true;
88 if(iter_individual != null) {
89 iter_individual.dispose();
90 iter_individual = null;
91 }
92 if(toAddedIndividuals.isEmpty()) {
93 currentID = -1;
94 return false;
95 }
96 String individual = toAddedIndividuals.remove();
97 currentID = tripleManager.getResourceID(individual);
98 try {
99 iter_individual =
100 m_engine.internal_evaluateNotExpanded(String.format("select distinct ?y ?z where { <%s> ?y ?z }", individual));
101 multi = iter_individual.open();
102 } catch(JRDFStoreException e) {
103 e.printStackTrace();
104 }
105 }
106 }
107
108 private void count(BasicQueryEngine engine, UFS<String> equality, Map<String, Integer> map) {
109 for(String ind : equality.keySet()) {
110 Integer exist = map.get(ind);
111 if(exist == null)
112 map.put(equality.find(ind), 1);
113 else
114 map.put(equality.find(ind), ++exist);
115 }
116 }
117 90
118 @Override 91 }
119 public int[] next() { 92 while (true) {
120 try { 93 if (getNewGapTuple(iter_individual, currentID)) return true;
121 if(iterator != null) 94 if (iter_individual != null) {
122 multi = iterator.getNext(); 95 iter_individual.dispose();
123 else if(iter_individual != null) 96 iter_individual = null;
124 multi = iter_individual.getNext(); 97 }
125 else 98 if (toAddedIndividuals.isEmpty()) {
126 multi = 0; 99 currentID = -1;
127 } catch(JRDFStoreException e) { 100 return false;
128 e.printStackTrace(); 101 }
129 } 102 String individual = toAddedIndividuals.remove();
130 return tuple; 103 currentID = tripleManager.getResourceID(individual);
131 } 104 try {
105 iter_individual = m_engine.internal_evaluateNotExpanded(String.format("select distinct ?y ?z where { <%s> ?y ?z }", individual));
106 multi = iter_individual.open();
107 } catch (JRDFStoreException e) {
108 e.printStackTrace();
109 }
110 }
111 }
132 112
133 public void clear() { 113 private void count(BasicQueryEngine engine, UFS<String> equality, Map<String, Integer> map) {
134 super.clear(); 114 for (String ind : equality.keySet()) {
135 if(iter_individual != null) { 115 Integer exist = map.get(ind);
136 iter_individual.dispose(); 116 if (exist == null)
137 iter_individual = null; 117 map.put(equality.find(ind), 1);
138 } 118 else
139 } 119 map.put(equality.find(ind), ++exist);
120 }
121 }
140 122
123 @Override
124 public int[] next() {
125 try {
126 if (iterator != null)
127 multi = iterator.getNext();
128 else if (iter_individual != null)
129 multi = iter_individual.getNext();
130 else
131 multi = 0;
132 } catch (JRDFStoreException e) {
133 e.printStackTrace();
134 }
135 return tuple;
136 }
137
138 public void clear() {
139 super.clear();
140 if (iter_individual != null) {
141 iter_individual.dispose();
142 iter_individual = null;
143 }
144 }
145
141} 146}
diff --git a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
index 2983b2e..bf11168 100644
--- a/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
+++ b/src/uk/ac/ox/cs/pagoda/query/GapTupleIterator.java
@@ -24,5 +24,5 @@ public abstract class GapTupleIterator<T> implements Iterator<T> {
24 public abstract void addTo(DataStore store) throws JRDFStoreException; 24 public abstract void addTo(DataStore store) throws JRDFStoreException;
25 25
26 public abstract void clear(); 26 public abstract void clear();
27 27
28} 28}
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 @@
1package uk.ac.ox.cs.pagoda.reasoner.light; 1package uk.ac.ox.cs.pagoda.reasoner.light;
2 2
3import java.util.Arrays;
4import java.util.Collection;
5import java.util.HashSet;
6import java.util.Iterator;
7import java.util.Set;
8
3import org.semanticweb.HermiT.model.DLClause; 9import org.semanticweb.HermiT.model.DLClause;
4import uk.ac.ox.cs.JRDFox.JRDFStoreException; 10
5import uk.ac.ox.cs.JRDFox.store.DataStore;
6import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
7import uk.ac.ox.cs.JRDFox.store.Parameters;
8import uk.ac.ox.cs.JRDFox.store.TripleStatus;
9import uk.ac.ox.cs.JRDFox.store.TupleIterator;
10import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper; 11import uk.ac.ox.cs.pagoda.hermit.DLClauseHelper;
11import uk.ac.ox.cs.pagoda.query.AnswerTuples; 12import uk.ac.ox.cs.pagoda.query.AnswerTuples;
12import uk.ac.ox.cs.pagoda.query.GapByStore4ID; 13import uk.ac.ox.cs.pagoda.query.GapByStore4ID;
13import uk.ac.ox.cs.pagoda.rules.DatalogProgram; 14import uk.ac.ox.cs.pagoda.rules.DatalogProgram;
14import uk.ac.ox.cs.pagoda.rules.Program; 15import uk.ac.ox.cs.pagoda.rules.Program;
15import uk.ac.ox.cs.pagoda.util.*; 16import uk.ac.ox.cs.pagoda.util.ConjunctiveQueryHelper;
17import uk.ac.ox.cs.pagoda.util.Namespace;
16import uk.ac.ox.cs.pagoda.util.Timer; 18import uk.ac.ox.cs.pagoda.util.Timer;
17 19import uk.ac.ox.cs.pagoda.util.UFS;
18import java.util.*; 20import uk.ac.ox.cs.pagoda.util.Utility;
21import uk.ac.ox.cs.JRDFox.JRDFStoreException;
22import uk.ac.ox.cs.JRDFox.store.DataStore;
23import uk.ac.ox.cs.JRDFox.store.Parameters;
24import uk.ac.ox.cs.JRDFox.store.TripleStatus;
25import uk.ac.ox.cs.JRDFox.store.TupleIterator;
26import uk.ac.ox.cs.JRDFox.store.DataStore.UpdateType;
19 27
20public class BasicQueryEngine extends RDFoxQueryEngine { 28public class BasicQueryEngine extends RDFoxQueryEngine {
21 29
22 protected DataStore store; 30 protected DataStore store;
23 protected Parameters parameters = new Parameters(); 31 protected Parameters parameters = new Parameters();
24 Set<DLClause> materialisedRules = new HashSet<DLClause>();
25 private UFS<String> equalityGroups = null;
26 32
27 public BasicQueryEngine(String name) { 33 public BasicQueryEngine(String name) {
28 super(name); 34 super(name);
29 store = RDFoxQueryEngine.createDataStore(); 35 store = RDFoxQueryEngine.createDataStore();
30 parameters.m_allAnswersInRoot = true; 36 parameters.m_allAnswersInRoot = true;
31 parameters.m_useBushy = true; 37 parameters.m_useBushy = true;
32 } 38 }
33 39
34 public void materialiseFoldedly(DatalogProgram dProgram, GapByStore4ID gap) { 40 public void materialiseFoldedly(DatalogProgram dProgram, GapByStore4ID gap) {
35 if (gap != null) { 41 if (gap != null) {
36 materialise("lower program", dProgram.getLower().toString()); 42 materialise("lower program", dProgram.getLower().toString());
@@ -42,9 +48,10 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
42 } catch (JRDFStoreException e) { 48 } catch (JRDFStoreException e) {
43 e.printStackTrace(); 49 e.printStackTrace();
44 } finally { 50 } finally {
45 gap.clear(); 51 gap.clear();
46 } 52 }
47 } else 53 }
54 else
48 materialise("upper program", dProgram.getUpper().toString()); 55 materialise("upper program", dProgram.getUpper().toString());
49 } 56 }
50 57
@@ -59,23 +66,20 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
59 } catch (JRDFStoreException e) { 66 } catch (JRDFStoreException e) {
60 e.printStackTrace(); 67 e.printStackTrace();
61 } finally { 68 } finally {
62 gap.clear(); 69 gap.clear();
63 } 70 }
64 } else 71 }
72 else
65 materialise("upper program", dProgram.getUpper().toString()); 73 materialise("upper program", dProgram.getUpper().toString());
66 74
67 return 1; 75 return 1;
68 } 76 }
69 77
70 public int materialiseSkolemly(DatalogProgram dProgram, GapByStore4ID gap) {
71 throw new UnsupportedOperationException();
72 }
73
74 @Override 78 @Override
75 public AnswerTuples evaluate(String queryText) { 79 public AnswerTuples evaluate(String queryText) {
76 return evaluate(queryText, ConjunctiveQueryHelper.getAnswerVariables(queryText)[0]); 80 return evaluate(queryText, ConjunctiveQueryHelper.getAnswerVariables(queryText)[0]);
77 } 81 }
78 82
79 @Override 83 @Override
80 public AnswerTuples evaluate(String queryText, String[] answerVars) { 84 public AnswerTuples evaluate(String queryText, String[] answerVars) {
81 TupleIterator tupleIterator; 85 TupleIterator tupleIterator;
@@ -83,9 +87,9 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
83 tupleIterator = store.compileQuery(queryText.replace("_:", "?"), prefixes, parameters); 87 tupleIterator = store.compileQuery(queryText.replace("_:", "?"), prefixes, parameters);
84 } catch (JRDFStoreException e) { 88 } catch (JRDFStoreException e) {
85 e.printStackTrace(); 89 e.printStackTrace();
86 return null; 90 return null;
87 } 91 }
88 return new RDFoxAnswerTuples(answerVars, tupleIterator); 92 return new RDFoxAnswerTuples(answerVars, tupleIterator);
89 } 93 }
90 94
91 @Override 95 @Override
@@ -95,18 +99,17 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
95 99
96 @Override 100 @Override
97 public void dispose() { 101 public void dispose() {
98 store.dispose(); 102 store.dispose();
99 } 103 }
100 104
101 protected void outputClassAssertions(String filename) { 105 protected void outputClassAssertions(String filename) {
102 TupleIterator allTuples = null; 106 TupleIterator allTuples = null;
103 boolean redirect = false; 107 boolean redirect = false;
104 try { 108 try {
105 allTuples = getDataStore().compileQuery("SELECT ?X ?Z WHERE { ?X <" + Namespace.RDF_TYPE + "> ?Z }", prefixes, parameters); 109 allTuples = getDataStore().compileQuery("SELECT ?X ?Z WHERE { ?X <" + Namespace.RDF_TYPE + "> ?Z }", prefixes, parameters);
106 redirect = Utility.redirectCurrentOut(filename); 110 redirect = Utility.redirectCurrentOut(filename);
107 for(long multi = allTuples.open(); multi != 0; multi = allTuples.getNext()) 111 for (long multi = allTuples.open(); multi != 0; multi = allTuples.getNext())
108 System.out.println(RDFoxTripleManager.getQuotedTerm(allTuples.getResource(0)) + " " + RDFoxTripleManager 112 System.out.println(RDFoxTripleManager.getQuotedTerm(allTuples.getResource(0)) + " " + RDFoxTripleManager.getQuotedTerm(allTuples.getResource(1)));
109 .getQuotedTerm(allTuples.getResource(1)));
110 } catch (JRDFStoreException e) { 113 } catch (JRDFStoreException e) {
111 e.printStackTrace(); 114 e.printStackTrace();
112 } finally { 115 } finally {
@@ -124,134 +127,138 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
124 public void outputInstance4BinaryPredicate(String iri) { 127 public void outputInstance4BinaryPredicate(String iri) {
125 outputAnswers("select ?x ?y where { ?x <" + iri + "> ?y . }"); 128 outputAnswers("select ?x ?y where { ?x <" + iri + "> ?y . }");
126 } 129 }
127 130
128 public void outputInstanceNumbers(String filename) { 131 public void outputInstanceNumbers(String filename) {
129 TupleIterator predicateTuples = null; 132 TupleIterator predicateTuples = null;
130 TupleIterator instanceTuples; 133 TupleIterator instanceTuples;
131 Set<String> number = new HashSet<String>(); 134 Set<String> number = new HashSet<String>();
132 String predicate; 135 String predicate;
133 try { 136 try {
134 predicateTuples = getDataStore().compileQuery("SELECT DISTINCT ?Y WHERE { ?X <" + Namespace.RDF_TYPE + "> ?Y }", prefixes, parameters); 137 predicateTuples = getDataStore().compileQuery("SELECT DISTINCT ?Y WHERE { ?X <" + Namespace.RDF_TYPE + "> ?Y }", prefixes, parameters);
135 for (long multi = predicateTuples.open(); multi != 0; multi = predicateTuples.getNext()) { 138 for (long multi = predicateTuples.open(); multi != 0; multi = predicateTuples.getNext()) {
136 predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0)); 139 predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0));
137 instanceTuples = null; 140 instanceTuples = null;
138 try { 141 try {
139 instanceTuples = getDataStore().compileQuery("SELECT ?X WHERE { ?X <" + Namespace.RDF_TYPE + "> " + predicate + " }", prefixes, parameters); 142 instanceTuples = getDataStore().compileQuery("SELECT ?X WHERE { ?X <" + Namespace.RDF_TYPE + "> " + predicate + " }", prefixes, parameters);
140 long totalCount = 0; 143 long totalCount = 0;
141 for (long multi1 = instanceTuples.open(); multi1 != 0; multi1 = instanceTuples.getNext()) { 144 for (long multi1 = instanceTuples.open(); multi1 != 0; multi1 = instanceTuples.getNext()) {
142 totalCount += instanceTuples.getMultiplicity(); 145 totalCount += instanceTuples.getMultiplicity();
143 } 146 }
144 number.add(predicate + " * " + totalCount); 147 number.add(predicate + " * " + totalCount);
145 } finally { 148 } finally {
146 if(instanceTuples != null) instanceTuples.dispose(); 149 if (instanceTuples != null) instanceTuples.dispose();
147 } 150 }
148 } 151 }
149 } catch (JRDFStoreException e) { 152 } catch (JRDFStoreException e) {
150 e.printStackTrace(); 153 e.printStackTrace();
151 } finally { 154 } finally {
152 if (predicateTuples != null) predicateTuples.dispose(); 155 if (predicateTuples != null) predicateTuples.dispose();
153 predicateTuples = null; 156 predicateTuples = null;
154 } 157 }
155 158
156 try { 159 try {
157 predicateTuples = getDataStore().compileQuery("SELECT DISTINCT ?Y WHERE { ?X ?Y ?Z }", prefixes, parameters); 160 predicateTuples = getDataStore().compileQuery("SELECT DISTINCT ?Y WHERE { ?X ?Y ?Z }", prefixes, parameters);
158 for (long multi = predicateTuples.open(); multi != 0; multi = predicateTuples.getNext()) { 161 for (long multi = predicateTuples.open(); multi != 0; multi = predicateTuples.getNext()) {
159 predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0)); 162 predicate = RDFoxTripleManager.getQuotedTerm(predicateTuples.getResource(0));
160 instanceTuples = null; 163 instanceTuples = null;
161 try { 164 try {
162 instanceTuples = getDataStore().compileQuery("SELECT ?X ?Z WHERE { ?X " + predicate + " ?Z }", prefixes, parameters); 165 instanceTuples = getDataStore().compileQuery("SELECT ?X ?Z WHERE { ?X " + predicate + " ?Z }", prefixes, parameters);
163 long totalCount = 0; 166 ;
167 long totalCount = 0;
164 for (long multi1 = instanceTuples.open(); multi1 != 0; multi1 = instanceTuples.getNext()) 168 for (long multi1 = instanceTuples.open(); multi1 != 0; multi1 = instanceTuples.getNext())
165 totalCount += instanceTuples.getMultiplicity(); 169 totalCount += instanceTuples.getMultiplicity();
166 number.add(predicate + " * " + totalCount); 170 number.add(predicate + " * " + totalCount);
167 } finally { 171 } finally {
168 if(instanceTuples != null) instanceTuples.dispose(); 172 if (instanceTuples != null) instanceTuples.dispose();
169 } 173 }
170 } 174 }
171 175
172 } catch (JRDFStoreException e) { 176 } catch (JRDFStoreException e) {
173 e.printStackTrace(); 177 e.printStackTrace();
174 } finally { 178 } finally {
175 if (predicateTuples != null) predicateTuples.dispose(); 179 if (predicateTuples != null) predicateTuples.dispose();
176 predicateTuples = null; 180 predicateTuples = null;
177 } 181 }
178 182
179 Utility.redirectCurrentOut(filename); 183 Utility.redirectCurrentOut(filename);
180 String[] ordered = number.toArray(new String[0]); 184 String[] ordered = number.toArray(new String[0]);
181 Arrays.sort(ordered, new DLPredicateComparator()); 185 Arrays.sort(ordered, new DLPredicateComparator());
182 for(String line : ordered) System.out.println(line); 186 for (String line: ordered) System.out.println(line);
183 Utility.closeCurrentOut(); 187 Utility.closeCurrentOut();
184 188
185 } 189 }
186 190
187 public TupleIterator internal_evaluateAgainstIDBs(String queryText) throws JRDFStoreException { 191 public TupleIterator internal_evaluateAgainstIDBs(String queryText) throws JRDFStoreException {
188 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters, TripleStatus.TUPLE_STATUS_IDB.union(TripleStatus.TUPLE_STATUS_EDB), TripleStatus.TUPLE_STATUS_IDB); 192 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters, TripleStatus.TUPLE_STATUS_IDB.union(TripleStatus.TUPLE_STATUS_EDB), TripleStatus.TUPLE_STATUS_IDB);
189// iter.open(); 193// iter.open();
190 return iter; 194 return iter;
191 } 195 }
192 196
193 public TupleIterator internal_evaluate(String queryText) throws JRDFStoreException { 197 public TupleIterator internal_evaluate(String queryText) throws JRDFStoreException {
194 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters); 198 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters);
195// iter.open(); 199// iter.open();
196 return iter; 200 return iter;
197 } 201 }
198 202
199 public void setExpandEquality(boolean flag) { 203 public void setExpandEquality(boolean flag) {
200 parameters.m_expandEquality = flag; 204 parameters.m_expandEquality = flag;
201 } 205 }
202 206
203 public TupleIterator internal_evaluateNotExpanded(String queryText) throws JRDFStoreException { 207 public TupleIterator internal_evaluateNotExpanded(String queryText) throws JRDFStoreException {
204 parameters.m_expandEquality = false; 208 parameters.m_expandEquality = false;
205 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters); 209 TupleIterator iter = store.compileQuery(queryText, prefixes, parameters);
206// iter.open(); 210// iter.open();
207 parameters.m_expandEquality = true; 211 parameters.m_expandEquality = true;
208 return iter; 212 return iter;
209 } 213 }
214
210 215
211 public TupleIterator internal_evaluate(String queryText, boolean incrementally) throws JRDFStoreException { 216 public TupleIterator internal_evaluate(String queryText, boolean incrementally) throws JRDFStoreException {
212 return incrementally ? internal_evaluateAgainstIDBs(queryText) : internal_evaluate(queryText); 217 return incrementally ? internal_evaluateAgainstIDBs(queryText) : internal_evaluate(queryText);
213 } 218 }
214 219
220 Set<DLClause> materialisedRules = new HashSet<DLClause>();
221
215 public String getUnusedRules(Collection<DLClause> clauses, boolean toUpdate) { 222 public String getUnusedRules(Collection<DLClause> clauses, boolean toUpdate) {
216 DLClause clause; 223 DLClause clause;
217 for (Iterator<DLClause> iter = clauses.iterator(); iter.hasNext(); ) { 224 for (Iterator<DLClause> iter = clauses.iterator(); iter.hasNext(); ) {
218 if (materialisedRules.contains(clause = iter.next())) 225 if (materialisedRules.contains(clause = iter.next()))
219 iter.remove(); 226 iter.remove();
220 else if(toUpdate) materialisedRules.add(clause); 227 else if (toUpdate) materialisedRules.add(clause);
221 } 228 }
222 229
223 if (clauses.isEmpty()) return null; 230 if (clauses.isEmpty()) return null;
224 231
225 return Program.toString(clauses); 232 return Program.toString(clauses);
226 } 233 }
227 234
228 public void outputMaterialisedRules() { 235 public void outputMaterialisedRules() {
229 System.out.println(DLClauseHelper.toString(materialisedRules)); 236 System.out.println(DLClauseHelper.toString(materialisedRules));
230 } 237 }
231 238
232 public void outputAnswers(String query) { 239 public void outputAnswers(String query) {
233 TupleIterator iter = null; 240 TupleIterator iter = null;
234 try { 241 try {
235 iter = internal_evaluate(query); 242 iter = internal_evaluate(query);
236 System.out.println(query); 243 System.out.println(query);
237 int arity = iter.getArity(); 244 int arity = iter.getArity();
238 for (long multi = iter.open(); multi != 0; multi = iter.getNext()) { 245 for (long multi = iter.open(); multi != 0; multi = iter.getNext()) {
239 for (int i = 0; i < arity; ++i) 246 for (int i = 0; i < arity; ++i)
240 System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t"); 247 System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t");
241 System.out.println(); 248 System.out.println();
242 } 249 }
243 } catch (JRDFStoreException e) { 250 } catch (JRDFStoreException e) {
244 e.printStackTrace(); 251 e.printStackTrace();
245 } finally { 252 } finally {
246 if(iter != null) iter.dispose(); 253 if (iter != null) iter.dispose();
247 } 254 }
248 } 255 }
249 256
250 public void outputInstance4UnaryPredicate(String iri) { 257 public void outputInstance4UnaryPredicate(String iri) {
251 outputAnswers("select ?x where { ?x " 258 outputAnswers("select ?x where { ?x "
252 + "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <" 259 + "<http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <"
253 + iri 260 + iri
254 + "> .}"); 261 + "> .}");
255 } 262 }
256 263
257 public void outputSubjects(String p, String o) { 264 public void outputSubjects(String p, String o) {
@@ -263,13 +270,13 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
263 } 270 }
264 271
265 public void outputIDBFacts() { 272 public void outputIDBFacts() {
266 TupleIterator iter = null; 273 TupleIterator iter = null;
267 try { 274 try {
268 iter = internal_evaluateAgainstIDBs("select distict ?x ?y ?z where { ?x ?y ?z }"); 275 iter = internal_evaluateAgainstIDBs("select distict ?x ?y ?z where { ?x ?y ?z }");
269 for (long multi = iter.open(); multi != 0; multi = iter.getNext()) { 276 for (long multi = iter.open(); multi != 0; multi = iter.getNext()) {
270 for (int i = 0; i < 3; ++i) 277 for (int i = 0; i < 3; ++i)
271 System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t"); 278 System.out.print(RDFoxTripleManager.getQuotedTerm(iter.getResource(i)) + "\t");
272 System.out.println(); 279 System.out.println();
273 } 280 }
274 } catch (JRDFStoreException e) { 281 } catch (JRDFStoreException e) {
275 // TODO Auto-generated catch block 282 // TODO Auto-generated catch block
@@ -277,7 +284,7 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
277 } finally { 284 } finally {
278 if (iter != null) iter.dispose(); 285 if (iter != null) iter.dispose();
279 } 286 }
280 287
281 } 288 }
282 289
283 public void outputType4Individual(String iri) { 290 public void outputType4Individual(String iri) {
@@ -285,23 +292,25 @@ public class BasicQueryEngine extends RDFoxQueryEngine {
285 } 292 }
286 293
287 public int getSameAsNumber() { 294 public int getSameAsNumber() {
288 TupleIterator iter = null; 295 TupleIterator iter = null;
289 int counter = 0; 296 int counter = 0;
290 try { 297 try {
291 iter = internal_evaluate("select ?x ?y where {?x " + Namespace.EQUALITY_QUOTED + " ?y . }"); 298 iter = internal_evaluate("select ?x ?y where {?x " + Namespace.EQUALITY_QUOTED + " ?y . }");
292 for(long multi = iter.open(); multi != 0; multi = iter.getNext()) 299 for (long multi = iter.open(); multi != 0; multi = iter.getNext())
293 if (iter.getResourceID(0) != iter.getResourceID(1)) 300 if (iter.getResourceID(0) != iter.getResourceID(1))
294 ++counter; 301 ++counter;
295 } catch (JRDFStoreException e) { 302 } catch (JRDFStoreException e) {
296 e.printStackTrace(); 303 e.printStackTrace();
297 } finally { 304 } finally {
298 if (iter != null) iter.dispose(); 305 if (iter != null) iter.dispose();
299 } 306 }
300 return counter; 307 return counter;
301 } 308 }
302 309
310 private UFS<String> equalityGroups = null;
311
303 public UFS<String> getEqualityGroups(boolean reuse) { 312 public UFS<String> getEqualityGroups(boolean reuse) {
304 if(reuse && equalityGroups != null) return equalityGroups; 313 if (reuse && equalityGroups != null) return equalityGroups;
305 314
306 equalityGroups = new UFS<String>(); 315 equalityGroups = new UFS<String>();
307 316
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-05 17:33:20 +0000