1 package org.simantics.db.impl.query;
3 import org.simantics.db.ObjectResourceIdMap;
4 import org.simantics.db.RelationInfo;
5 import org.simantics.db.common.utils.Logger;
6 import org.simantics.db.exception.DatabaseException;
7 import org.simantics.db.impl.graph.ReadGraphImpl;
8 import org.simantics.db.impl.procedure.InternalProcedure;
9 import org.simantics.db.impl.query.QueryProcessor.SessionTask;
10 import org.simantics.db.procedure.AsyncMultiProcedure;
11 import org.simantics.db.procedure.AsyncProcedure;
12 import org.simantics.db.procedure.ListenerBase;
13 import org.simantics.db.procedure.SyncMultiProcedure;
14 import org.simantics.db.request.AsyncMultiRead;
15 import org.simantics.db.request.AsyncRead;
16 import org.simantics.db.request.ExternalRead;
17 import org.simantics.db.request.MultiRead;
18 import org.simantics.db.request.Read;
20 public class QueryCache extends QueryCacheBase {
22 private static final boolean SINGLE = true;
23 public QueryCache(QuerySupport querySupport, int threads) {
24 super(querySupport, threads);
27 Objects getOrCreateObjects(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
28 Objects existing = null;
29 synchronized(objectsMap) {
30 existing = (Objects)objectsMap.get(r1,r2);
31 if(existing == null) {
32 existing = new Objects(r1,r2);
33 existing.clearResult(querySupport);
34 existing.setPending();
35 objectsMap.put(keyR2(r1,r2), existing);
39 if(existing.requiresComputation()) {
40 existing.setPending();
44 if(existing.isPending()) waitPending(graph, existing);
48 void remove(Objects entry) {
49 synchronized(objectsMap) {
50 objectsMap.remove(entry.id);
54 public static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
55 QueryCache cache = graph.processor.cache;
56 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
58 Objects e = cache.peekObjects(r1,r2);
59 if (e != null && e.isReady()) {
60 e.performFromCache(graph, procedure);
64 Objects.computeForEach(graph, r1,r2, null, procedure);
67 Objects entry = (Objects)cache.getOrCreateObjects(graph, r1,r2);
68 IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureObjects;
69 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
70 if(entry.isReady()) entry.performFromCache(graph, procedure_);
72 assert(entry.isPending());
73 Objects.computeForEach(graph, r1,r2, entry, procedure_);
74 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
78 private Objects peekObjects(int r1, int r2) {
79 synchronized(objectsMap) {
80 return (Objects) objectsMap.get(r1,r2);
84 Statements getOrCreateStatements(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
85 Statements existing = null;
86 synchronized(statementsMap) {
87 existing = (Statements)statementsMap.get(r1,r2);
88 if(existing == null) {
89 existing = new Statements(r1,r2);
90 existing.clearResult(querySupport);
91 existing.setPending();
92 statementsMap.put(keyR2(r1,r2), existing);
96 if(existing.requiresComputation()) {
97 existing.setPending();
101 if(existing.isPending()) waitPending(graph, existing);
105 void remove(Statements entry) {
106 synchronized(statementsMap) {
107 statementsMap.remove(entry.id);
111 public static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {
112 QueryCache cache = graph.processor.cache;
113 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
115 Statements e = cache.peekStatements(r1,r2);
116 if (e != null && e.isReady()) {
117 e.performFromCache(graph, procedure);
121 Statements.computeForEach(graph, r1,r2, null, procedure);
124 Statements entry = (Statements)cache.getOrCreateStatements(graph, r1,r2);
125 TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureStatements;
126 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
127 if(entry.isReady()) entry.performFromCache(graph, procedure_);
129 assert(entry.isPending());
130 Statements.computeForEach(graph, r1,r2, entry, procedure_);
131 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
135 private Statements peekStatements(int r1, int r2) {
136 synchronized(statementsMap) {
137 return (Statements) statementsMap.get(r1,r2);
141 DirectObjects getOrCreateDirectObjects(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
142 DirectObjects existing = null;
143 synchronized(directObjectsMap) {
144 existing = (DirectObjects)directObjectsMap.get(r1,r2);
145 if(existing == null) {
146 existing = new DirectObjects(r1,r2);
147 existing.clearResult(querySupport);
148 existing.setPending();
149 directObjectsMap.put(keyR2(r1,r2), existing);
153 if(existing.requiresComputation()) {
154 existing.setPending();
158 if(existing.isPending()) waitPending(graph, existing);
162 void remove(DirectObjects entry) {
163 synchronized(directObjectsMap) {
164 directObjectsMap.remove(entry.id);
168 public static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
169 QueryCache cache = graph.processor.cache;
170 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
172 DirectObjects e = cache.peekDirectObjects(r1,r2);
173 if (e != null && e.isReady()) {
174 e.performFromCache(graph, procedure);
178 DirectObjects.computeForEach(graph, r1,r2, null, procedure);
181 DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(graph, r1,r2);
182 IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectObjects;
183 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
184 if(entry.isReady()) entry.performFromCache(graph, procedure_);
186 assert(entry.isPending());
187 DirectObjects.computeForEach(graph, r1,r2, entry, procedure_);
188 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
192 private DirectObjects peekDirectObjects(int r1, int r2) {
193 synchronized(directObjectsMap) {
194 return (DirectObjects) directObjectsMap.get(r1,r2);
198 RelationInfoQuery getOrCreateRelationInfoQuery(ReadGraphImpl graph, int r) throws DatabaseException {
199 RelationInfoQuery existing = null;
200 synchronized(relationInfoQueryMap) {
201 existing = (RelationInfoQuery)relationInfoQueryMap.get(r);
202 if(existing == null) {
203 existing = new RelationInfoQuery(r);
204 existing.clearResult(querySupport);
205 existing.setPending();
206 relationInfoQueryMap.put(keyR(r), existing);
210 if(existing.requiresComputation()) {
211 existing.setPending();
215 if(existing.isPending()) waitPending(graph, existing);
219 void remove(RelationInfoQuery entry) {
220 synchronized(relationInfoQueryMap) {
221 relationInfoQueryMap.remove(entry.id);
225 public static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<RelationInfo> procedure) throws DatabaseException {
226 QueryCache cache = graph.processor.cache;
227 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
229 RelationInfoQuery e = cache.peekRelationInfoQuery(r);
230 if (e != null && e.isReady()) {
231 e.performFromCache(graph, procedure);
235 RelationInfoQuery.computeForEach(graph, r, null, procedure);
238 RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(graph, r);
239 InternalProcedure<RelationInfo> procedure_ = procedure != null ? procedure : emptyProcedureRelationInfoQuery;
240 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
241 if(entry.isReady()) entry.performFromCache(graph, procedure_);
243 assert(entry.isPending());
244 RelationInfoQuery.computeForEach(graph, r, entry, procedure_);
245 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
249 private RelationInfoQuery peekRelationInfoQuery(int r) {
250 synchronized(relationInfoQueryMap) {
251 return (RelationInfoQuery) relationInfoQueryMap.get(r);
255 URIToResource getOrCreateURIToResource(ReadGraphImpl graph, String id) throws DatabaseException {
256 URIToResource existing = null;
257 synchronized(uRIToResourceMap) {
258 existing = (URIToResource)uRIToResourceMap.get(id);
259 if(existing == null) {
260 existing = new URIToResource(id);
261 existing.clearResult(querySupport);
262 existing.setPending();
263 uRIToResourceMap.put(keyID(id), existing);
267 if(existing.requiresComputation()) {
268 existing.setPending();
272 if(existing.isPending()) waitPending(graph, existing);
276 void remove(URIToResource entry) {
277 synchronized(uRIToResourceMap) {
278 uRIToResourceMap.remove(entry.id);
282 public static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, final InternalProcedure<Integer> procedure) throws DatabaseException {
283 QueryCache cache = graph.processor.cache;
284 if(parent == null && listener == null && !cache.shouldCache(graph.processor, id)) {
286 URIToResource e = cache.peekURIToResource(id);
287 if (e != null && e.isReady()) {
288 e.performFromCache(graph, procedure);
292 URIToResource.computeForEach(graph, id, null, procedure);
295 URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(graph, id);
296 InternalProcedure<Integer> procedure_ = procedure != null ? procedure : emptyProcedureURIToResource;
297 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
298 if(entry.isReady()) entry.performFromCache(graph, procedure_);
300 assert(entry.isPending());
301 URIToResource.computeForEach(graph, id, entry, procedure_);
302 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
306 private URIToResource peekURIToResource(String id) {
307 synchronized(uRIToResourceMap) {
308 return (URIToResource) uRIToResourceMap.get(id);
312 ValueQuery getOrCreateValueQuery(ReadGraphImpl graph, int r) throws DatabaseException {
313 ValueQuery existing = null;
314 synchronized(valueQueryMap) {
315 existing = (ValueQuery)valueQueryMap.get(r);
316 if(existing == null) {
317 existing = new ValueQuery(r);
318 existing.clearResult(querySupport);
319 existing.setPending();
320 valueQueryMap.put(keyR(r), existing);
324 if(existing.requiresComputation()) {
325 existing.setPending();
329 if(existing.isPending()) waitPending(graph, existing);
333 void remove(ValueQuery entry) {
334 synchronized(valueQueryMap) {
335 valueQueryMap.remove(entry.id);
339 public static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<byte[]> procedure) throws DatabaseException {
340 QueryCache cache = graph.processor.cache;
341 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
343 ValueQuery e = cache.peekValueQuery(r);
344 if (e != null && e.isReady()) {
345 e.performFromCache(graph, procedure);
349 ValueQuery.computeForEach(graph, r, null, procedure);
352 ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(graph, r);
353 InternalProcedure<byte[]> procedure_ = procedure != null ? procedure : emptyProcedureValueQuery;
354 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
355 if(entry.isReady()) entry.performFromCache(graph, procedure_);
357 assert(entry.isPending());
358 ValueQuery.computeForEach(graph, r, entry, procedure_);
359 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
363 private ValueQuery peekValueQuery(int r) {
364 synchronized(valueQueryMap) {
365 return (ValueQuery) valueQueryMap.get(r);
369 OrderedSet getOrCreateOrderedSet(ReadGraphImpl graph, int r) throws DatabaseException {
370 OrderedSet existing = null;
371 synchronized(orderedSetMap) {
372 existing = (OrderedSet)orderedSetMap.get(r);
373 if(existing == null) {
374 existing = new OrderedSet(r);
375 existing.clearResult(querySupport);
376 existing.setPending();
377 orderedSetMap.put(keyR(r), existing);
381 if(existing.requiresComputation()) {
382 existing.setPending();
386 if(existing.isPending()) waitPending(graph, existing);
390 void remove(OrderedSet entry) {
391 synchronized(orderedSetMap) {
392 orderedSetMap.remove(entry.id);
396 public static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
397 QueryCache cache = graph.processor.cache;
398 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
400 OrderedSet e = cache.peekOrderedSet(r);
401 if (e != null && e.isReady()) {
402 e.performFromCache(graph, procedure);
406 OrderedSet.computeForEach(graph, r, null, procedure);
409 OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(graph, r);
410 IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureOrderedSet;
411 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
412 if(entry.isReady()) entry.performFromCache(graph, procedure_);
414 assert(entry.isPending());
415 OrderedSet.computeForEach(graph, r, entry, procedure_);
416 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
420 private OrderedSet peekOrderedSet(int r) {
421 synchronized(orderedSetMap) {
422 return (OrderedSet) orderedSetMap.get(r);
426 PrincipalTypes getOrCreatePrincipalTypes(ReadGraphImpl graph, int r) throws DatabaseException {
427 PrincipalTypes existing = null;
428 synchronized(principalTypesMap) {
429 existing = (PrincipalTypes)principalTypesMap.get(r);
430 if(existing == null) {
431 existing = new PrincipalTypes(r);
432 existing.clearResult(querySupport);
433 existing.setPending();
434 principalTypesMap.put(keyR(r), existing);
438 if(existing.requiresComputation()) {
439 existing.setPending();
443 if(existing.isPending()) waitPending(graph, existing);
447 void remove(PrincipalTypes entry) {
448 synchronized(principalTypesMap) {
449 principalTypesMap.remove(entry.id);
453 public static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
454 QueryCache cache = graph.processor.cache;
455 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
457 PrincipalTypes e = cache.peekPrincipalTypes(r);
458 if (e != null && e.isReady()) {
459 e.performFromCache(graph, procedure);
463 PrincipalTypes.computeForEach(graph, r, null, procedure);
466 PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(graph, r);
467 IntProcedure procedure_ = procedure != null ? procedure : emptyProcedurePrincipalTypes;
468 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
469 if(entry.isReady()) entry.performFromCache(graph, procedure_);
471 assert(entry.isPending());
472 PrincipalTypes.computeForEach(graph, r, entry, procedure_);
473 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
477 private PrincipalTypes peekPrincipalTypes(int r) {
478 synchronized(principalTypesMap) {
479 return (PrincipalTypes) principalTypesMap.get(r);
483 DirectPredicates getOrCreateDirectPredicates(ReadGraphImpl graph, int r) throws DatabaseException {
484 DirectPredicates existing = null;
485 synchronized(directPredicatesMap) {
486 existing = (DirectPredicates)directPredicatesMap.get(r);
487 if(existing == null) {
488 existing = new DirectPredicates(r);
489 existing.clearResult(querySupport);
490 existing.setPending();
491 directPredicatesMap.put(keyR(r), existing);
495 if(existing.requiresComputation()) {
496 existing.setPending();
500 if(existing.isPending()) waitPending(graph, existing);
504 void remove(DirectPredicates entry) {
505 synchronized(directPredicatesMap) {
506 directPredicatesMap.remove(entry.id);
510 public static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
511 QueryCache cache = graph.processor.cache;
512 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
514 DirectPredicates e = cache.peekDirectPredicates(r);
515 if (e != null && e.isReady()) {
516 e.performFromCache(graph, procedure);
520 DirectPredicates.computeForEach(graph, r, null, procedure);
523 DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(graph, r);
524 InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureDirectPredicates;
525 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
526 if(entry.isReady()) entry.performFromCache(graph, procedure_);
528 assert(entry.isPending());
529 DirectPredicates.computeForEach(graph, r, entry, procedure_);
530 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
534 private DirectPredicates peekDirectPredicates(int r) {
535 synchronized(directPredicatesMap) {
536 return (DirectPredicates) directPredicatesMap.get(r);
540 Predicates getOrCreatePredicates(ReadGraphImpl graph, int r) throws DatabaseException {
541 Predicates existing = null;
542 synchronized(predicatesMap) {
543 existing = (Predicates)predicatesMap.get(r);
544 if(existing == null) {
545 existing = new Predicates(r);
546 existing.clearResult(querySupport);
547 existing.setPending();
548 predicatesMap.put(keyR(r), existing);
552 if(existing.requiresComputation()) {
553 existing.setPending();
557 if(existing.isPending()) waitPending(graph, existing);
561 void remove(Predicates entry) {
562 synchronized(predicatesMap) {
563 predicatesMap.remove(entry.id);
567 public static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
568 QueryCache cache = graph.processor.cache;
569 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
571 Predicates e = cache.peekPredicates(r);
572 if (e != null && e.isReady()) {
573 e.performFromCache(graph, procedure);
577 Predicates.computeForEach(graph, r, null, procedure);
580 Predicates entry = (Predicates)cache.getOrCreatePredicates(graph, r);
581 InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedurePredicates;
582 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
583 if(entry.isReady()) entry.performFromCache(graph, procedure_);
585 assert(entry.isPending());
586 Predicates.computeForEach(graph, r, entry, procedure_);
587 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
591 private Predicates peekPredicates(int r) {
592 synchronized(predicatesMap) {
593 return (Predicates) predicatesMap.get(r);
597 ReadEntry getOrCreateReadEntry(ReadGraphImpl graph, Read<?> r, boolean needsToBlock) throws DatabaseException {
598 ReadEntry existing = null;
599 synchronized(readEntryMap) {
600 existing = (ReadEntry)readEntryMap.get(r);
601 if(existing == null) {
602 existing = new ReadEntry(r);
603 existing.clearResult(querySupport);
604 existing.setPending();
605 readEntryMap.put(id(r), existing);
609 if(existing.requiresComputation()) {
610 existing.setPending();
614 if(existing.isPending()) {
615 if(needsToBlock) waitPending(graph, existing);
622 void remove(ReadEntry entry) {
623 synchronized(readEntryMap) {
624 readEntryMap.remove(entry.request);
628 public static Object runnerReadEntry(ReadGraphImpl graph, Read<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, final boolean needsToBlock) throws DatabaseException {
629 QueryCache cache = graph.processor.cache;
630 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
632 ReadEntry e = cache.peekReadEntry(r);
633 if (e != null && e.isReady()) {
634 return e.performFromCache(graph, procedure);
637 return ReadEntry.computeForEach(graph, r, null, procedure);
639 ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(graph, r, needsToBlock);
641 graph.processor.schedule(new SessionTask(graph) {
643 public void run0(int thread) {
645 runnerReadEntry(graph, r, parent, listener, procedure, needsToBlock);
646 } catch (DatabaseException e) {
647 Logger.defaultLogError(e);
653 AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureReadEntry;
654 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
655 if(entry.isReady()) return entry.performFromCache(graph, procedure_);
657 assert(entry.isPending());
658 Object result = ReadEntry.computeForEach(graph, r, entry, procedure_);
659 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
665 private ReadEntry peekReadEntry(Read<?> r) {
666 synchronized(readEntryMap) {
667 return (ReadEntry) readEntryMap.get(r);
671 AsyncReadEntry getOrCreateAsyncReadEntry(ReadGraphImpl graph, AsyncRead<?> r, boolean needsToBlock) throws DatabaseException {
672 AsyncReadEntry existing = null;
673 synchronized(asyncReadEntryMap) {
674 existing = (AsyncReadEntry)asyncReadEntryMap.get(r);
675 if(existing == null) {
676 existing = new AsyncReadEntry(r);
677 existing.clearResult(querySupport);
678 existing.setPending();
679 asyncReadEntryMap.put(id(r), existing);
683 if(existing.requiresComputation()) {
684 existing.setPending();
688 if(existing.isPending()) {
689 if(needsToBlock) waitPending(graph, existing);
696 void remove(AsyncReadEntry entry) {
697 synchronized(asyncReadEntryMap) {
698 asyncReadEntryMap.remove(entry.request);
702 public static Object runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, final boolean needsToBlock) throws DatabaseException {
703 QueryCache cache = graph.processor.cache;
704 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
706 AsyncReadEntry e = cache.peekAsyncReadEntry(r);
707 if (e != null && e.isReady()) {
708 return e.performFromCache(graph, procedure);
711 return AsyncReadEntry.computeForEach(graph, r, null, procedure, needsToBlock);
713 AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(graph, r, needsToBlock);
715 graph.processor.schedule(new SessionTask(graph) {
717 public void run0(int thread) {
719 runnerAsyncReadEntry(graph, r, parent, listener, procedure, needsToBlock);
720 } catch (DatabaseException e) {
721 Logger.defaultLogError(e);
727 AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncReadEntry;
728 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
729 if(entry.isReady()) return entry.performFromCache(graph, procedure_);
731 assert(entry.isPending());
732 Object result = AsyncReadEntry.computeForEach(graph, r, entry, procedure_, needsToBlock);
733 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
739 private AsyncReadEntry peekAsyncReadEntry(AsyncRead<?> r) {
740 synchronized(asyncReadEntryMap) {
741 return (AsyncReadEntry) asyncReadEntryMap.get(r);
745 Types getOrCreateTypes(ReadGraphImpl graph, int r) throws DatabaseException {
746 Types existing = null;
747 synchronized(typesMap) {
748 existing = (Types)typesMap.get(r);
749 if(existing == null) {
750 existing = new Types(r);
751 existing.clearResult(querySupport);
752 existing.setPending();
753 typesMap.put(keyR(r), existing);
757 if(existing.requiresComputation()) {
758 existing.setPending();
762 if(existing.isPending()) waitPending(graph, existing);
766 void remove(Types entry) {
767 synchronized(typesMap) {
768 typesMap.remove(entry.id);
772 public static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
773 QueryCache cache = graph.processor.cache;
774 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
776 Types e = cache.peekTypes(r);
777 if (e != null && e.isReady()) {
778 e.performFromCache(graph, procedure);
782 Types.computeForEach(graph, r, null, procedure);
785 Types entry = (Types)cache.getOrCreateTypes(graph, r);
786 InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypes;
787 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
788 if(entry.isReady()) entry.performFromCache(graph, procedure_);
790 assert(entry.isPending());
791 Types.computeForEach(graph, r, entry, procedure_);
792 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
796 private Types peekTypes(int r) {
797 synchronized(typesMap) {
798 return (Types) typesMap.get(r);
802 ChildMap getOrCreateChildMap(ReadGraphImpl graph, int r) throws DatabaseException {
803 ChildMap existing = null;
804 synchronized(childMapMap) {
805 existing = (ChildMap)childMapMap.get(r);
806 if(existing == null) {
807 existing = new ChildMap(r);
808 existing.clearResult(querySupport);
809 existing.setPending();
810 childMapMap.put(keyR(r), existing);
814 if(existing.requiresComputation()) {
815 existing.setPending();
819 if(existing.isPending()) waitPending(graph, existing);
823 void remove(ChildMap entry) {
824 synchronized(childMapMap) {
825 childMapMap.remove(entry.id);
829 public static void runnerChildMap(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<ObjectResourceIdMap<String>> procedure) throws DatabaseException {
830 QueryCache cache = graph.processor.cache;
831 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
833 ChildMap e = cache.peekChildMap(r);
834 if (e != null && e.isReady()) {
835 e.performFromCache(graph, procedure);
839 ChildMap.computeForEach(graph, r, null, procedure);
842 ChildMap entry = (ChildMap)cache.getOrCreateChildMap(graph, r);
843 InternalProcedure<ObjectResourceIdMap<String>> procedure_ = procedure != null ? procedure : emptyProcedureChildMap;
844 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
845 if(entry.isReady()) entry.performFromCache(graph, procedure_);
847 assert(entry.isPending());
848 ChildMap.computeForEach(graph, r, entry, procedure_);
849 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
853 private ChildMap peekChildMap(int r) {
854 synchronized(childMapMap) {
855 return (ChildMap) childMapMap.get(r);
859 TypeHierarchy getOrCreateTypeHierarchy(ReadGraphImpl graph, int r) throws DatabaseException {
860 TypeHierarchy existing = null;
861 synchronized(typeHierarchyMap) {
862 existing = (TypeHierarchy)typeHierarchyMap.get(r);
863 if(existing == null) {
864 existing = new TypeHierarchy(r);
865 existing.clearResult(querySupport);
866 existing.setPending();
867 typeHierarchyMap.put(keyR(r), existing);
871 if(existing.requiresComputation()) {
872 existing.setPending();
876 if(existing.isPending()) waitPending(graph, existing);
880 void remove(TypeHierarchy entry) {
881 synchronized(typeHierarchyMap) {
882 typeHierarchyMap.remove(entry.id);
886 public static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
887 QueryCache cache = graph.processor.cache;
888 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
890 TypeHierarchy e = cache.peekTypeHierarchy(r);
891 if (e != null && e.isReady()) {
892 e.performFromCache(graph, procedure);
896 TypeHierarchy.computeForEach(graph, r, null, procedure);
899 TypeHierarchy entry = (TypeHierarchy)cache.getOrCreateTypeHierarchy(graph, r);
900 InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypeHierarchy;
901 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
902 if(entry.isReady()) entry.performFromCache(graph, procedure_);
904 assert(entry.isPending());
905 TypeHierarchy.computeForEach(graph, r, entry, procedure_);
906 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
910 private TypeHierarchy peekTypeHierarchy(int r) {
911 synchronized(typeHierarchyMap) {
912 return (TypeHierarchy) typeHierarchyMap.get(r);
916 SuperTypes getOrCreateSuperTypes(ReadGraphImpl graph, int r) throws DatabaseException {
917 SuperTypes existing = null;
918 synchronized(superTypesMap) {
919 existing = (SuperTypes)superTypesMap.get(r);
920 if(existing == null) {
921 existing = new SuperTypes(r);
922 existing.clearResult(querySupport);
923 existing.setPending();
924 superTypesMap.put(keyR(r), existing);
928 if(existing.requiresComputation()) {
929 existing.setPending();
933 if(existing.isPending()) waitPending(graph, existing);
937 void remove(SuperTypes entry) {
938 synchronized(superTypesMap) {
939 superTypesMap.remove(entry.id);
943 public static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
944 QueryCache cache = graph.processor.cache;
945 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
947 SuperTypes e = cache.peekSuperTypes(r);
948 if (e != null && e.isReady()) {
949 e.performFromCache(graph, procedure);
953 SuperTypes.computeForEach(graph, r, null, procedure);
956 SuperTypes entry = (SuperTypes)cache.getOrCreateSuperTypes(graph, r);
957 InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperTypes;
958 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
959 if(entry.isReady()) entry.performFromCache(graph, procedure_);
961 assert(entry.isPending());
962 SuperTypes.computeForEach(graph, r, entry, procedure_);
963 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
967 private SuperTypes peekSuperTypes(int r) {
968 synchronized(superTypesMap) {
969 return (SuperTypes) superTypesMap.get(r);
973 SuperRelations getOrCreateSuperRelations(ReadGraphImpl graph, int r) throws DatabaseException {
974 SuperRelations existing = null;
975 synchronized(superRelationsMap) {
976 existing = (SuperRelations)superRelationsMap.get(r);
977 if(existing == null) {
978 existing = new SuperRelations(r);
979 existing.clearResult(querySupport);
980 existing.setPending();
981 superRelationsMap.put(keyR(r), existing);
985 if(existing.requiresComputation()) {
986 existing.setPending();
990 if(existing.isPending()) waitPending(graph, existing);
994 void remove(SuperRelations entry) {
995 synchronized(superRelationsMap) {
996 superRelationsMap.remove(entry.id);
1000 public static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
1001 QueryCache cache = graph.processor.cache;
1002 if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
1004 SuperRelations e = cache.peekSuperRelations(r);
1005 if (e != null && e.isReady()) {
1006 e.performFromCache(graph, procedure);
1010 SuperRelations.computeForEach(graph, r, null, procedure);
1013 SuperRelations entry = (SuperRelations)cache.getOrCreateSuperRelations(graph, r);
1014 InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperRelations;
1015 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1016 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1018 assert(entry.isPending());
1019 SuperRelations.computeForEach(graph, r, entry, procedure_);
1020 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1024 private SuperRelations peekSuperRelations(int r) {
1025 synchronized(superRelationsMap) {
1026 return (SuperRelations) superRelationsMap.get(r);
1030 AssertedPredicates getOrCreateAssertedPredicates(ReadGraphImpl graph, int r) throws DatabaseException {
1031 AssertedPredicates existing = null;
1032 synchronized(assertedPredicatesMap) {
1033 existing = (AssertedPredicates)assertedPredicatesMap.get(r);
1034 if(existing == null) {
1035 existing = new AssertedPredicates(r);
1036 existing.clearResult(querySupport);
1037 existing.setPending();
1038 assertedPredicatesMap.put(keyR(r), existing);
1042 if(existing.requiresComputation()) {
1043 existing.setPending();
1047 if(existing.isPending()) waitPending(graph, existing);
1051 void remove(AssertedPredicates entry) {
1052 synchronized(assertedPredicatesMap) {
1053 assertedPredicatesMap.remove(entry.id);
1057 public static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
1058 QueryCache cache = graph.processor.cache;
1059 AssertedPredicates entry = (AssertedPredicates)cache.getOrCreateAssertedPredicates(graph, r);
1060 IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedPredicates;
1061 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1062 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1064 assert(entry.isPending());
1065 entry.compute(graph, procedure_);
1066 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1070 private AssertedPredicates peekAssertedPredicates(int r) {
1071 synchronized(assertedPredicatesMap) {
1072 return (AssertedPredicates) assertedPredicatesMap.get(r);
1076 AssertedStatements getOrCreateAssertedStatements(ReadGraphImpl graph, int r1, int r2) throws DatabaseException {
1077 AssertedStatements existing = null;
1078 synchronized(assertedStatementsMap) {
1079 existing = (AssertedStatements)assertedStatementsMap.get(r1,r2);
1080 if(existing == null) {
1081 existing = new AssertedStatements(r1,r2);
1082 existing.clearResult(querySupport);
1083 existing.setPending();
1084 assertedStatementsMap.put(keyR2(r1,r2), existing);
1088 if(existing.requiresComputation()) {
1089 existing.setPending();
1093 if(existing.isPending()) waitPending(graph, existing);
1097 void remove(AssertedStatements entry) {
1098 synchronized(assertedStatementsMap) {
1099 assertedStatementsMap.remove(entry.id);
1103 public static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {
1104 QueryCache cache = graph.processor.cache;
1105 AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(graph, r1,r2);
1106 TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedStatements;
1107 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1108 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1110 assert(entry.isPending());
1111 entry.compute(graph, procedure_);
1112 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1116 private AssertedStatements peekAssertedStatements(int r1, int r2) {
1117 synchronized(assertedStatementsMap) {
1118 return (AssertedStatements) assertedStatementsMap.get(r1,r2);
1122 DirectSuperRelations getOrCreateDirectSuperRelations(ReadGraphImpl graph, int r) throws DatabaseException {
1123 DirectSuperRelations existing = null;
1124 synchronized(directSuperRelationsMap) {
1125 existing = (DirectSuperRelations)directSuperRelationsMap.get(r);
1126 if(existing == null) {
1127 existing = new DirectSuperRelations(r);
1128 existing.clearResult(querySupport);
1129 existing.setPending();
1130 directSuperRelationsMap.put(keyR(r), existing);
1134 if(existing.requiresComputation()) {
1135 existing.setPending();
1139 if(existing.isPending()) waitPending(graph, existing);
1143 void remove(DirectSuperRelations entry) {
1144 synchronized(directSuperRelationsMap) {
1145 directSuperRelationsMap.remove(entry.id);
1149 public static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
1150 QueryCache cache = graph.processor.cache;
1151 DirectSuperRelations entry = (DirectSuperRelations)cache.getOrCreateDirectSuperRelations(graph, r);
1152 IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectSuperRelations;
1153 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1154 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1156 assert(entry.isPending());
1157 entry.compute(graph, procedure_);
1158 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1162 private DirectSuperRelations peekDirectSuperRelations(int r) {
1163 synchronized(directSuperRelationsMap) {
1164 return (DirectSuperRelations) directSuperRelationsMap.get(r);
1168 MultiReadEntry getOrCreateMultiReadEntry(ReadGraphImpl graph, MultiRead<?> r) throws DatabaseException {
1169 MultiReadEntry existing = null;
1170 synchronized(multiReadEntryMap) {
1171 existing = (MultiReadEntry)multiReadEntryMap.get(r);
1172 if(existing == null) {
1173 existing = new MultiReadEntry(r);
1174 existing.clearResult(querySupport);
1175 existing.setPending();
1176 multiReadEntryMap.put(id(r), existing);
1180 if(existing.requiresComputation()) {
1181 existing.setPending();
1185 if(existing.isPending()) waitPending(graph, existing);
1189 void remove(MultiReadEntry entry) {
1190 synchronized(multiReadEntryMap) {
1191 multiReadEntryMap.remove(entry.request);
1195 public static void runnerMultiReadEntry(ReadGraphImpl graph, MultiRead<?> r, CacheEntry parent, ListenerBase listener, final SyncMultiProcedure procedure) throws DatabaseException {
1196 QueryCache cache = graph.processor.cache;
1197 MultiReadEntry entry = (MultiReadEntry)cache.getOrCreateMultiReadEntry(graph, r);
1198 SyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureMultiReadEntry;
1199 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1200 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1202 assert(entry.isPending());
1203 entry.compute(graph, procedure_);
1204 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1208 private MultiReadEntry peekMultiReadEntry(MultiRead<?> r) {
1209 synchronized(multiReadEntryMap) {
1210 return (MultiReadEntry) multiReadEntryMap.get(r);
1214 AsyncMultiReadEntry getOrCreateAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead<?> r) throws DatabaseException {
1215 AsyncMultiReadEntry existing = null;
1216 synchronized(asyncMultiReadEntryMap) {
1217 existing = (AsyncMultiReadEntry)asyncMultiReadEntryMap.get(r);
1218 if(existing == null) {
1219 existing = new AsyncMultiReadEntry(r);
1220 existing.clearResult(querySupport);
1221 existing.setPending();
1222 asyncMultiReadEntryMap.put(id(r), existing);
1226 if(existing.requiresComputation()) {
1227 existing.setPending();
1231 if(existing.isPending()) waitPending(graph, existing);
1235 void remove(AsyncMultiReadEntry entry) {
1236 synchronized(asyncMultiReadEntryMap) {
1237 asyncMultiReadEntryMap.remove(entry.request);
1241 public static void runnerAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncMultiProcedure procedure) throws DatabaseException {
1242 QueryCache cache = graph.processor.cache;
1243 AsyncMultiReadEntry entry = (AsyncMultiReadEntry)cache.getOrCreateAsyncMultiReadEntry(graph, r);
1244 AsyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncMultiReadEntry;
1245 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1246 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1248 assert(entry.isPending());
1249 entry.compute(graph, procedure_);
1250 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1254 private AsyncMultiReadEntry peekAsyncMultiReadEntry(AsyncMultiRead<?> r) {
1255 synchronized(asyncMultiReadEntryMap) {
1256 return (AsyncMultiReadEntry) asyncMultiReadEntryMap.get(r);
1260 ExternalReadEntry getOrCreateExternalReadEntry(ReadGraphImpl graph, ExternalRead<?> r) throws DatabaseException {
1261 ExternalReadEntry existing = null;
1262 synchronized(externalReadEntryMap) {
1263 existing = (ExternalReadEntry)externalReadEntryMap.get(r);
1264 if(existing == null) {
1265 existing = new ExternalReadEntry(r, graph);
1266 existing.clearResult(querySupport);
1267 existing.setPending();
1268 externalReadEntryMap.put(id(r), existing);
1272 if(existing.requiresComputation()) {
1273 existing.setPending();
1277 if(existing.isPending()) waitPending(graph, existing);
1282 void remove(ExternalReadEntry entry) {
1283 synchronized(externalReadEntryMap) {
1284 externalReadEntryMap.remove(entry.request);
1288 public static void runnerExternalReadEntry(ReadGraphImpl graph, ExternalRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure) throws DatabaseException {
1289 QueryCache cache = graph.processor.cache;
1290 ExternalReadEntry entry = (ExternalReadEntry)cache.getOrCreateExternalReadEntry(graph, r);
1291 AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureExternalReadEntry;
1292 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
1293 if(entry.isReady()) entry.performFromCache(graph, procedure_);
1295 assert(entry.isPending());
1296 entry.compute(graph, procedure_);
1297 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
1301 private ExternalReadEntry peekExternalReadEntry(ExternalRead<?> r) {
1302 synchronized(externalReadEntryMap) {
1303 return (ExternalReadEntry) externalReadEntryMap.get(r);