1 package org.simantics.db.impl.query;
3 import org.simantics.db.RelationInfo;
4 import org.simantics.db.exception.DatabaseException;
5 import org.simantics.db.impl.graph.ReadGraphImpl;
6 import org.simantics.db.impl.procedure.InternalProcedure;
7 import org.simantics.db.procedure.AsyncMultiProcedure;
8 import org.simantics.db.procedure.AsyncProcedure;
9 import org.simantics.db.procedure.ListenerBase;
10 import org.simantics.db.request.AsyncMultiRead;
11 import org.simantics.db.request.AsyncRead;
12 import org.simantics.db.request.ExternalRead;
13 import org.simantics.db.request.MultiRead;
14 import org.simantics.db.request.Read;
16 import gnu.trove.map.hash.TObjectIntHashMap;
18 public class QueryCache extends QueryCacheBase {
20 public QueryCache(QuerySupport querySupport, int threads) {
21 super(querySupport, threads);
24 Objects getOrCreateObjects(int r1, int r2) throws DatabaseException {
25 Objects existing = null;
26 synchronized(objectsMap) {
27 existing = (Objects)objectsMap.get(r1,r2);
28 if(existing == null) {
29 existing = new Objects(r1,r2);
30 existing.clearResult(querySupport);
31 existing.setPending();
32 objectsMap.put(keyR2(r1,r2), existing);
35 if(existing.requiresComputation()) {
36 existing.setPending();
40 if(existing.isPending()) waitPending(existing);
44 void remove(Objects entry) {
45 synchronized(objectsMap) {
46 objectsMap.remove(entry.id);
50 public static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
51 if(parent == null && listener == null) {
52 Objects.computeForEach(graph, r1,r2, null, procedure);
55 QueryCache cache = graph.processor.cache;
56 if(procedure == null) procedure = emptyProcedureObjects;
57 Objects entry = (Objects)cache.getOrCreateObjects(r1,r2);
58 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
59 if(entry.isReady()) entry.performFromCache(graph, procedure);
61 Objects.computeForEach(graph, r1,r2, entry, procedure);
62 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
66 Statements getOrCreateStatements(int r1, int r2) throws DatabaseException {
67 Statements existing = null;
68 synchronized(statementsMap) {
69 existing = (Statements)statementsMap.get(r1,r2);
70 if(existing == null) {
71 existing = new Statements(r1,r2);
72 existing.clearResult(querySupport);
73 existing.setPending();
74 statementsMap.put(keyR2(r1,r2), existing);
77 if(existing.requiresComputation()) {
78 existing.setPending();
82 if(existing.isPending()) waitPending(existing);
86 void remove(Statements entry) {
87 synchronized(statementsMap) {
88 statementsMap.remove(entry.id);
92 public static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, TripleIntProcedure procedure) throws DatabaseException {
93 if(parent == null && listener == null) {
94 Statements.computeForEach(graph, r1,r2, null, procedure);
97 QueryCache cache = graph.processor.cache;
98 if(procedure == null) procedure = emptyProcedureStatements;
99 Statements entry = (Statements)cache.getOrCreateStatements(r1,r2);
100 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
101 if(entry.isReady()) entry.performFromCache(graph, procedure);
103 Statements.computeForEach(graph, r1,r2, entry, procedure);
104 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
108 DirectObjects getOrCreateDirectObjects(int r1, int r2) throws DatabaseException {
109 DirectObjects existing = null;
110 synchronized(directObjectsMap) {
111 existing = (DirectObjects)directObjectsMap.get(r1,r2);
112 if(existing == null) {
113 existing = new DirectObjects(r1,r2);
114 existing.clearResult(querySupport);
115 existing.setPending();
116 directObjectsMap.put(keyR2(r1,r2), existing);
119 if(existing.requiresComputation()) {
120 existing.setPending();
124 if(existing.isPending()) waitPending(existing);
128 void remove(DirectObjects entry) {
129 synchronized(directObjectsMap) {
130 directObjectsMap.remove(entry.id);
134 public static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
135 if(parent == null && listener == null) {
136 DirectObjects.computeForEach(graph, r1,r2, null, procedure);
139 QueryCache cache = graph.processor.cache;
140 if(procedure == null) procedure = emptyProcedureDirectObjects;
141 DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(r1,r2);
142 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
143 if(entry.isReady()) entry.performFromCache(graph, procedure);
145 DirectObjects.computeForEach(graph, r1,r2, entry, procedure);
146 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
150 RelationInfoQuery getOrCreateRelationInfoQuery(int r) throws DatabaseException {
151 RelationInfoQuery existing = null;
152 synchronized(relationInfoQueryMap) {
153 existing = (RelationInfoQuery)relationInfoQueryMap.get(r);
154 if(existing == null) {
155 existing = new RelationInfoQuery(r);
156 existing.clearResult(querySupport);
157 existing.setPending();
158 relationInfoQueryMap.put(keyR(r), existing);
161 if(existing.requiresComputation()) {
162 existing.setPending();
166 if(existing.isPending()) waitPending(existing);
170 void remove(RelationInfoQuery entry) {
171 synchronized(relationInfoQueryMap) {
172 relationInfoQueryMap.remove(entry.id);
176 public static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<RelationInfo> procedure) throws DatabaseException {
177 if(parent == null && listener == null) {
178 RelationInfoQuery.computeForEach(graph, r, null, procedure);
181 QueryCache cache = graph.processor.cache;
182 if(procedure == null) procedure = emptyProcedureRelationInfoQuery;
183 RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(r);
184 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
185 if(entry.isReady()) entry.performFromCache(graph, procedure);
187 RelationInfoQuery.computeForEach(graph, r, entry, procedure);
188 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
192 URIToResource getOrCreateURIToResource(String id) throws DatabaseException {
193 URIToResource existing = null;
194 synchronized(uRIToResourceMap) {
195 existing = (URIToResource)uRIToResourceMap.get(id);
196 if(existing == null) {
197 existing = new URIToResource(id);
198 existing.clearResult(querySupport);
199 existing.setPending();
200 uRIToResourceMap.put(keyID(id), existing);
203 if(existing.requiresComputation()) {
204 existing.setPending();
208 if(existing.isPending()) waitPending(existing);
212 void remove(URIToResource entry) {
213 synchronized(uRIToResourceMap) {
214 uRIToResourceMap.remove(entry.id);
218 public static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure<Integer> procedure) throws DatabaseException {
219 if(parent == null && listener == null) {
220 URIToResource.computeForEach(graph, id, null, procedure);
223 QueryCache cache = graph.processor.cache;
224 if(procedure == null) procedure = emptyProcedureURIToResource;
225 URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(id);
226 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
227 if(entry.isReady()) entry.performFromCache(graph, procedure);
229 URIToResource.computeForEach(graph, id, entry, procedure);
230 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
234 ValueQuery getOrCreateValueQuery(int r) throws DatabaseException {
235 ValueQuery existing = null;
236 synchronized(valueQueryMap) {
237 existing = (ValueQuery)valueQueryMap.get(r);
238 if(existing == null) {
239 existing = new ValueQuery(r);
240 existing.clearResult(querySupport);
241 existing.setPending();
242 valueQueryMap.put(keyR(r), existing);
245 if(existing.requiresComputation()) {
246 existing.setPending();
250 if(existing.isPending()) waitPending(existing);
254 void remove(ValueQuery entry) {
255 synchronized(valueQueryMap) {
256 valueQueryMap.remove(entry.id);
260 public static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<byte[]> procedure) throws DatabaseException {
261 if(parent == null && listener == null) {
262 ValueQuery.computeForEach(graph, r, null, procedure);
265 QueryCache cache = graph.processor.cache;
266 if(procedure == null) procedure = emptyProcedureValueQuery;
267 ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(r);
268 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
269 if(entry.isReady()) entry.performFromCache(graph, procedure);
271 ValueQuery.computeForEach(graph, r, entry, procedure);
272 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
276 OrderedSet getOrCreateOrderedSet(int r) throws DatabaseException {
277 OrderedSet existing = null;
278 synchronized(orderedSetMap) {
279 existing = (OrderedSet)orderedSetMap.get(r);
280 if(existing == null) {
281 existing = new OrderedSet(r);
282 existing.clearResult(querySupport);
283 existing.setPending();
284 orderedSetMap.put(keyR(r), existing);
287 if(existing.requiresComputation()) {
288 existing.setPending();
292 if(existing.isPending()) waitPending(existing);
296 void remove(OrderedSet entry) {
297 synchronized(orderedSetMap) {
298 orderedSetMap.remove(entry.id);
302 public static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
303 if(parent == null && listener == null) {
304 OrderedSet.computeForEach(graph, r, null, procedure);
307 QueryCache cache = graph.processor.cache;
308 if(procedure == null) procedure = emptyProcedureOrderedSet;
309 OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(r);
310 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
311 if(entry.isReady()) entry.performFromCache(graph, procedure);
313 OrderedSet.computeForEach(graph, r, entry, procedure);
314 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
318 PrincipalTypes getOrCreatePrincipalTypes(int r) throws DatabaseException {
319 PrincipalTypes existing = null;
320 synchronized(principalTypesMap) {
321 existing = (PrincipalTypes)principalTypesMap.get(r);
322 if(existing == null) {
323 existing = new PrincipalTypes(r);
324 existing.clearResult(querySupport);
325 existing.setPending();
326 principalTypesMap.put(keyR(r), existing);
329 if(existing.requiresComputation()) {
330 existing.setPending();
334 if(existing.isPending()) waitPending(existing);
338 void remove(PrincipalTypes entry) {
339 synchronized(principalTypesMap) {
340 principalTypesMap.remove(entry.id);
344 public static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
345 if(parent == null && listener == null) {
346 PrincipalTypes.computeForEach(graph, r, null, procedure);
349 QueryCache cache = graph.processor.cache;
350 if(procedure == null) procedure = emptyProcedurePrincipalTypes;
351 PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(r);
352 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
353 if(entry.isReady()) entry.performFromCache(graph, procedure);
355 PrincipalTypes.computeForEach(graph, r, entry, procedure);
356 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
360 DirectPredicates getOrCreateDirectPredicates(int r) throws DatabaseException {
361 DirectPredicates existing = null;
362 synchronized(directPredicatesMap) {
363 existing = (DirectPredicates)directPredicatesMap.get(r);
364 if(existing == null) {
365 existing = new DirectPredicates(r);
366 existing.clearResult(querySupport);
367 existing.setPending();
368 directPredicatesMap.put(keyR(r), existing);
371 if(existing.requiresComputation()) {
372 existing.setPending();
376 if(existing.isPending()) waitPending(existing);
380 void remove(DirectPredicates entry) {
381 synchronized(directPredicatesMap) {
382 directPredicatesMap.remove(entry.id);
386 public static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
387 if(parent == null && listener == null) {
388 DirectPredicates.computeForEach(graph, r, null, procedure);
391 QueryCache cache = graph.processor.cache;
392 if(procedure == null) procedure = emptyProcedureDirectPredicates;
393 DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(r);
394 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
395 if(entry.isReady()) entry.performFromCache(graph, procedure);
397 DirectPredicates.computeForEach(graph, r, entry, procedure);
398 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
402 Predicates getOrCreatePredicates(int r) throws DatabaseException {
403 Predicates existing = null;
404 synchronized(predicatesMap) {
405 existing = (Predicates)predicatesMap.get(r);
406 if(existing == null) {
407 existing = new Predicates(r);
408 existing.clearResult(querySupport);
409 existing.setPending();
410 predicatesMap.put(keyR(r), existing);
413 if(existing.requiresComputation()) {
414 existing.setPending();
418 if(existing.isPending()) waitPending(existing);
422 void remove(Predicates entry) {
423 synchronized(predicatesMap) {
424 predicatesMap.remove(entry.id);
428 public static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
429 if(parent == null && listener == null) {
430 Predicates.computeForEach(graph, r, null, procedure);
433 QueryCache cache = graph.processor.cache;
434 if(procedure == null) procedure = emptyProcedurePredicates;
435 Predicates entry = (Predicates)cache.getOrCreatePredicates(r);
436 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
437 if(entry.isReady()) entry.performFromCache(graph, procedure);
439 Predicates.computeForEach(graph, r, entry, procedure);
440 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
444 ReadEntry getOrCreateReadEntry(Read<?> r) throws DatabaseException {
445 ReadEntry existing = null;
446 synchronized(readEntryMap) {
447 existing = (ReadEntry)readEntryMap.get(r);
448 if(existing == null) {
449 existing = new ReadEntry(r);
450 existing.clearResult(querySupport);
451 existing.setPending();
452 readEntryMap.put(id(r), existing);
455 if(existing.requiresComputation()) {
456 existing.setPending();
460 if(existing.isPending()) waitPending(existing);
464 void remove(ReadEntry entry) {
465 synchronized(readEntryMap) {
466 readEntryMap.remove(entry.request);
470 public static void runnerReadEntry(ReadGraphImpl graph, Read<?> r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException {
471 if(parent == null && listener == null) {
472 ReadEntry.computeForEach(graph, r, null, procedure);
475 QueryCache cache = graph.processor.cache;
476 if(procedure == null) procedure = emptyProcedureReadEntry;
477 ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(r);
478 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
479 if(entry.isReady()) entry.performFromCache(graph, procedure);
481 ReadEntry.computeForEach(graph, r, entry, procedure);
482 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
486 AsyncReadEntry getOrCreateAsyncReadEntry(AsyncRead<?> r) throws DatabaseException {
487 AsyncReadEntry existing = null;
488 synchronized(asyncReadEntryMap) {
489 existing = (AsyncReadEntry)asyncReadEntryMap.get(r);
490 if(existing == null) {
491 existing = new AsyncReadEntry(r);
492 existing.clearResult(querySupport);
493 existing.setPending();
494 asyncReadEntryMap.put(id(r), existing);
497 if(existing.requiresComputation()) {
498 existing.setPending();
502 if(existing.isPending()) waitPending(existing);
506 void remove(AsyncReadEntry entry) {
507 synchronized(asyncReadEntryMap) {
508 asyncReadEntryMap.remove(entry.request);
512 public static void runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead<?> r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException {
513 if(parent == null && listener == null) {
514 AsyncReadEntry.computeForEach(graph, r, null, procedure);
517 QueryCache cache = graph.processor.cache;
518 if(procedure == null) procedure = emptyProcedureAsyncReadEntry;
519 AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(r);
520 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
521 if(entry.isReady()) entry.performFromCache(graph, procedure);
523 AsyncReadEntry.computeForEach(graph, r, entry, procedure);
524 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
528 Types getOrCreateTypes(int r) throws DatabaseException {
529 Types existing = null;
530 synchronized(typesMap) {
531 existing = (Types)typesMap.get(r);
532 if(existing == null) {
533 existing = new Types(r);
534 existing.clearResult(querySupport);
535 existing.setPending();
536 typesMap.put(keyR(r), existing);
539 if(existing.requiresComputation()) {
540 existing.setPending();
544 if(existing.isPending()) waitPending(existing);
548 void remove(Types entry) {
549 synchronized(typesMap) {
550 typesMap.remove(entry.id);
554 public static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
555 if(parent == null && listener == null) {
556 Types.computeForEach(graph, r, null, procedure);
559 QueryCache cache = graph.processor.cache;
560 if(procedure == null) procedure = emptyProcedureTypes;
561 Types entry = (Types)cache.getOrCreateTypes(r);
562 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
563 if(entry.isReady()) entry.performFromCache(graph, procedure);
565 Types.computeForEach(graph, r, entry, procedure);
566 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
570 NamespaceIndex getOrCreateNamespaceIndex(String id) throws DatabaseException {
571 NamespaceIndex existing = null;
572 synchronized(namespaceIndexMap) {
573 existing = (NamespaceIndex)namespaceIndexMap.get(id);
574 if(existing == null) {
575 existing = new NamespaceIndex(id);
576 existing.clearResult(querySupport);
577 existing.setPending();
578 namespaceIndexMap.put(keyID(id), existing);
581 if(existing.requiresComputation()) {
582 existing.setPending();
586 if(existing.isPending()) waitPending(existing);
590 void remove(NamespaceIndex entry) {
591 synchronized(namespaceIndexMap) {
592 namespaceIndexMap.remove(entry.id);
596 public static void runnerNamespaceIndex(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure<TObjectIntHashMap<String>> procedure) throws DatabaseException {
597 if(parent == null && listener == null) {
598 NamespaceIndex.computeForEach(graph, id, null, procedure);
601 QueryCache cache = graph.processor.cache;
602 if(procedure == null) procedure = emptyProcedureNamespaceIndex;
603 NamespaceIndex entry = (NamespaceIndex)cache.getOrCreateNamespaceIndex(id);
604 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
605 if(entry.isReady()) entry.performFromCache(graph, procedure);
607 NamespaceIndex.computeForEach(graph, id, entry, procedure);
608 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
612 AssertedStatements getOrCreateAssertedStatements(int r1, int r2) throws DatabaseException {
613 AssertedStatements existing = null;
614 synchronized(assertedStatementsMap) {
615 existing = (AssertedStatements)assertedStatementsMap.get(r1,r2);
616 if(existing == null) {
617 existing = new AssertedStatements(r1,r2);
618 existing.clearResult(querySupport);
619 existing.setPending();
620 assertedStatementsMap.put(keyR2(r1,r2), existing);
623 if(existing.requiresComputation()) {
624 existing.setPending();
628 if(existing.isPending()) waitPending(existing);
632 void remove(AssertedStatements entry) {
633 synchronized(assertedStatementsMap) {
634 assertedStatementsMap.remove(entry.id);
638 public static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, TripleIntProcedure procedure) throws DatabaseException {
639 QueryCache cache = graph.processor.cache;
640 if(procedure == null) procedure = emptyProcedureAssertedStatements;
641 AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(r1,r2);
642 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
643 if(entry.isReady()) entry.performFromCache(graph, procedure);
645 entry.compute(graph, procedure);
646 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
650 AssertedPredicates getOrCreateAssertedPredicates(int r) throws DatabaseException {
651 AssertedPredicates existing = null;
652 synchronized(assertedPredicatesMap) {
653 existing = (AssertedPredicates)assertedPredicatesMap.get(r);
654 if(existing == null) {
655 existing = new AssertedPredicates(r);
656 existing.clearResult(querySupport);
657 existing.setPending();
658 assertedPredicatesMap.put(keyR(r), existing);
661 if(existing.requiresComputation()) {
662 existing.setPending();
666 if(existing.isPending()) waitPending(existing);
670 void remove(AssertedPredicates entry) {
671 synchronized(assertedPredicatesMap) {
672 assertedPredicatesMap.remove(entry.id);
676 public static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
677 QueryCache cache = graph.processor.cache;
678 if(procedure == null) procedure = emptyProcedureAssertedPredicates;
679 AssertedPredicates entry = (AssertedPredicates)cache.getOrCreateAssertedPredicates(r);
680 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
681 if(entry.isReady()) entry.performFromCache(graph, procedure);
683 entry.compute(graph, procedure);
684 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
688 DirectSuperRelations getOrCreateDirectSuperRelations(int r) throws DatabaseException {
689 DirectSuperRelations existing = null;
690 synchronized(directSuperRelationsMap) {
691 existing = (DirectSuperRelations)directSuperRelationsMap.get(r);
692 if(existing == null) {
693 existing = new DirectSuperRelations(r);
694 existing.clearResult(querySupport);
695 existing.setPending();
696 directSuperRelationsMap.put(keyR(r), existing);
699 if(existing.requiresComputation()) {
700 existing.setPending();
704 if(existing.isPending()) waitPending(existing);
708 void remove(DirectSuperRelations entry) {
709 synchronized(directSuperRelationsMap) {
710 directSuperRelationsMap.remove(entry.id);
714 public static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException {
715 QueryCache cache = graph.processor.cache;
716 if(procedure == null) procedure = emptyProcedureDirectSuperRelations;
717 DirectSuperRelations entry = (DirectSuperRelations)cache.getOrCreateDirectSuperRelations(r);
718 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
719 if(entry.isReady()) entry.performFromCache(graph, procedure);
721 entry.compute(graph, procedure);
722 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
726 SuperTypes getOrCreateSuperTypes(int r) throws DatabaseException {
727 SuperTypes existing = null;
728 synchronized(superTypesMap) {
729 existing = (SuperTypes)superTypesMap.get(r);
730 if(existing == null) {
731 existing = new SuperTypes(r);
732 existing.clearResult(querySupport);
733 existing.setPending();
734 superTypesMap.put(keyR(r), existing);
737 if(existing.requiresComputation()) {
738 existing.setPending();
742 if(existing.isPending()) waitPending(existing);
746 void remove(SuperTypes entry) {
747 synchronized(superTypesMap) {
748 superTypesMap.remove(entry.id);
752 public static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
753 QueryCache cache = graph.processor.cache;
754 if(procedure == null) procedure = emptyProcedureSuperTypes;
755 SuperTypes entry = (SuperTypes)cache.getOrCreateSuperTypes(r);
756 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
757 if(entry.isReady()) entry.performFromCache(graph, procedure);
759 entry.compute(graph, procedure);
760 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
764 TypeHierarchy getOrCreateTypeHierarchy(int r) throws DatabaseException {
765 TypeHierarchy existing = null;
766 synchronized(typeHierarchyMap) {
767 existing = (TypeHierarchy)typeHierarchyMap.get(r);
768 if(existing == null) {
769 existing = new TypeHierarchy(r);
770 existing.clearResult(querySupport);
771 existing.setPending();
772 typeHierarchyMap.put(keyR(r), existing);
775 if(existing.requiresComputation()) {
776 existing.setPending();
780 if(existing.isPending()) waitPending(existing);
784 void remove(TypeHierarchy entry) {
785 synchronized(typeHierarchyMap) {
786 typeHierarchyMap.remove(entry.id);
790 public static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
791 QueryCache cache = graph.processor.cache;
792 if(procedure == null) procedure = emptyProcedureTypeHierarchy;
793 TypeHierarchy entry = (TypeHierarchy)cache.getOrCreateTypeHierarchy(r);
794 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
795 if(entry.isReady()) entry.performFromCache(graph, procedure);
797 entry.compute(graph, procedure);
798 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
802 SuperRelations getOrCreateSuperRelations(int r) throws DatabaseException {
803 SuperRelations existing = null;
804 synchronized(superRelationsMap) {
805 existing = (SuperRelations)superRelationsMap.get(r);
806 if(existing == null) {
807 existing = new SuperRelations(r);
808 existing.clearResult(querySupport);
809 existing.setPending();
810 superRelationsMap.put(keyR(r), existing);
813 if(existing.requiresComputation()) {
814 existing.setPending();
818 if(existing.isPending()) waitPending(existing);
822 void remove(SuperRelations entry) {
823 synchronized(superRelationsMap) {
824 superRelationsMap.remove(entry.id);
828 public static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure<IntSet> procedure) throws DatabaseException {
829 QueryCache cache = graph.processor.cache;
830 if(procedure == null) procedure = emptyProcedureSuperRelations;
831 SuperRelations entry = (SuperRelations)cache.getOrCreateSuperRelations(r);
832 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
833 if(entry.isReady()) entry.performFromCache(graph, procedure);
835 entry.compute(graph, procedure);
836 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
840 MultiReadEntry getOrCreateMultiReadEntry(MultiRead<?> r) throws DatabaseException {
841 MultiReadEntry existing = null;
842 synchronized(multiReadEntryMap) {
843 existing = (MultiReadEntry)multiReadEntryMap.get(r);
844 if(existing == null) {
845 existing = new MultiReadEntry(r);
846 existing.clearResult(querySupport);
847 existing.setPending();
848 multiReadEntryMap.put(id(r), existing);
851 if(existing.requiresComputation()) {
852 existing.setPending();
856 if(existing.isPending()) waitPending(existing);
860 void remove(MultiReadEntry entry) {
861 synchronized(multiReadEntryMap) {
862 multiReadEntryMap.remove(entry.request);
866 public static void runnerMultiReadEntry(ReadGraphImpl graph, MultiRead<?> r, CacheEntry parent, ListenerBase listener, AsyncMultiProcedure procedure) throws DatabaseException {
867 QueryCache cache = graph.processor.cache;
868 if(procedure == null) procedure = emptyProcedureMultiReadEntry;
869 MultiReadEntry entry = (MultiReadEntry)cache.getOrCreateMultiReadEntry(r);
870 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
871 if(entry.isReady()) entry.performFromCache(graph, procedure);
873 entry.compute(graph, procedure);
874 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
878 AsyncMultiReadEntry getOrCreateAsyncMultiReadEntry(AsyncMultiRead<?> r) throws DatabaseException {
879 AsyncMultiReadEntry existing = null;
880 synchronized(asyncMultiReadEntryMap) {
881 existing = (AsyncMultiReadEntry)asyncMultiReadEntryMap.get(r);
882 if(existing == null) {
883 existing = new AsyncMultiReadEntry(r);
884 existing.clearResult(querySupport);
885 existing.setPending();
886 asyncMultiReadEntryMap.put(id(r), existing);
889 if(existing.requiresComputation()) {
890 existing.setPending();
894 if(existing.isPending()) waitPending(existing);
898 void remove(AsyncMultiReadEntry entry) {
899 synchronized(asyncMultiReadEntryMap) {
900 asyncMultiReadEntryMap.remove(entry.request);
904 public static void runnerAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead<?> r, CacheEntry parent, ListenerBase listener, AsyncMultiProcedure procedure) throws DatabaseException {
905 QueryCache cache = graph.processor.cache;
906 if(procedure == null) procedure = emptyProcedureAsyncMultiReadEntry;
907 AsyncMultiReadEntry entry = (AsyncMultiReadEntry)cache.getOrCreateAsyncMultiReadEntry(r);
908 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
909 if(entry.isReady()) entry.performFromCache(graph, procedure);
911 entry.compute(graph, procedure);
912 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
916 ExternalReadEntry getOrCreateExternalReadEntry(ExternalRead<?> r) throws DatabaseException {
917 ExternalReadEntry existing = null;
918 synchronized(externalReadEntryMap) {
919 existing = (ExternalReadEntry)externalReadEntryMap.get(r);
920 if(existing == null) {
921 existing = new ExternalReadEntry(r);
922 existing.clearResult(querySupport);
923 existing.setPending();
924 externalReadEntryMap.put(id(r), existing);
927 if(existing.requiresComputation()) {
928 existing.setPending();
932 if(existing.isPending()) waitPending(existing);
936 void remove(ExternalReadEntry entry) {
937 synchronized(externalReadEntryMap) {
938 externalReadEntryMap.remove(entry.request);
942 public static void runnerExternalReadEntry(ReadGraphImpl graph, ExternalRead<?> r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException {
943 QueryCache cache = graph.processor.cache;
944 if(procedure == null) procedure = emptyProcedureExternalReadEntry;
945 ExternalReadEntry entry = (ExternalReadEntry)cache.getOrCreateExternalReadEntry(r);
946 ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false);
947 if(entry.isReady()) entry.performFromCache(graph, procedure);
949 entry.compute(graph, procedure);
950 if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());