X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.db.impl%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fimpl%2Fquery%2FQueryCache.java;fp=bundles%2Forg.simantics.db.impl%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fimpl%2Fquery%2FQueryCache.java;h=7b591abb7fd80e062308ce3df88c86e872cfe27e;hb=0d9b90834ce56b292c00b1a39850ed842c3e4d42;hp=0000000000000000000000000000000000000000;hpb=e5db6157fd8722c946613d4e46d7aaf6bfa92609;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java
new file mode 100644
index 000000000..7b591abb7
--- /dev/null
+++ b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCache.java
@@ -0,0 +1,1048 @@
+package org.simantics.db.impl.query;
+
+import org.simantics.db.ObjectResourceIdMap;
+import org.simantics.db.RelationInfo;
+import org.simantics.db.common.utils.Logger;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.impl.graph.ReadGraphImpl;
+import org.simantics.db.impl.procedure.InternalProcedure;
+import org.simantics.db.impl.query.QueryProcessor.SessionTask;
+import org.simantics.db.procedure.AsyncMultiProcedure;
+import org.simantics.db.procedure.AsyncProcedure;
+import org.simantics.db.procedure.ListenerBase;
+import org.simantics.db.procedure.SyncMultiProcedure;
+import org.simantics.db.request.AsyncMultiRead;
+import org.simantics.db.request.AsyncRead;
+import org.simantics.db.request.ExternalRead;
+import org.simantics.db.request.MultiRead;
+import org.simantics.db.request.Read;
+
+public class QueryCache extends QueryCacheBase {
+
+    public QueryCache(QuerySupport querySupport, int threads) {
+        super(querySupport, threads);
+    }
+
+    Objects getOrCreateObjects(QueryProcessor processor, int r1, int r2) throws DatabaseException {
+        Objects existing = null;
+        synchronized(objectsMap) {
+            existing = (Objects)objectsMap.get(r1,r2);
+            if(existing == null) {
+                existing = new Objects(r1,r2);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                objectsMap.put(keyR2(r1,r2), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(Objects entry) {
+        synchronized(objectsMap) {
+            objectsMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
+            Objects.computeForEach(graph, r1,r2, null, procedure);
+            return;
+        }
+        Objects entry = (Objects)cache.getOrCreateObjects(graph.processor, r1,r2);
+        IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureObjects;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            Objects.computeForEach(graph, r1,r2, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    Statements getOrCreateStatements(QueryProcessor processor, int r1, int r2) throws DatabaseException {
+        Statements existing = null;
+        synchronized(statementsMap) {
+            existing = (Statements)statementsMap.get(r1,r2);
+            if(existing == null) {
+                existing = new Statements(r1,r2);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                statementsMap.put(keyR2(r1,r2), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(Statements entry) {
+        synchronized(statementsMap) {
+            statementsMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
+            Statements.computeForEach(graph, r1,r2, null, procedure);
+            return;
+        }
+        Statements entry = (Statements)cache.getOrCreateStatements(graph.processor, r1,r2);
+        TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureStatements;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            Statements.computeForEach(graph, r1,r2, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    DirectObjects getOrCreateDirectObjects(QueryProcessor processor, int r1, int r2) throws DatabaseException {
+        DirectObjects existing = null;
+        synchronized(directObjectsMap) {
+            existing = (DirectObjects)directObjectsMap.get(r1,r2);
+            if(existing == null) {
+                existing = new DirectObjects(r1,r2);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                directObjectsMap.put(keyR2(r1,r2), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(DirectObjects entry) {
+        synchronized(directObjectsMap) {
+            directObjectsMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) {
+            DirectObjects.computeForEach(graph, r1,r2, null, procedure);
+            return;
+        }
+        DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(graph.processor, r1,r2);
+        IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectObjects;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            DirectObjects.computeForEach(graph, r1,r2, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    RelationInfoQuery getOrCreateRelationInfoQuery(QueryProcessor processor, int r) throws DatabaseException {
+        RelationInfoQuery existing = null;
+        synchronized(relationInfoQueryMap) {
+            existing = (RelationInfoQuery)relationInfoQueryMap.get(r);
+            if(existing == null) {
+                existing = new RelationInfoQuery(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                relationInfoQueryMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(RelationInfoQuery entry) {
+        synchronized(relationInfoQueryMap) {
+            relationInfoQueryMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<RelationInfo> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            RelationInfoQuery.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(graph.processor, r);
+        InternalProcedure<RelationInfo> procedure_ = procedure != null ? procedure : emptyProcedureRelationInfoQuery;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            RelationInfoQuery.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    URIToResource getOrCreateURIToResource(QueryProcessor processor, String id) throws DatabaseException {
+        URIToResource existing = null;
+        synchronized(uRIToResourceMap) {
+            existing = (URIToResource)uRIToResourceMap.get(id);
+            if(existing == null) {
+                existing = new URIToResource(id);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                uRIToResourceMap.put(keyID(id), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(URIToResource entry) {
+        synchronized(uRIToResourceMap) {
+            uRIToResourceMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, final InternalProcedure<Integer> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, id)) {
+            URIToResource.computeForEach(graph, id, null, procedure);
+            return;
+        }
+        URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(graph.processor, id);
+        InternalProcedure<Integer> procedure_ = procedure != null ? procedure : emptyProcedureURIToResource;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            URIToResource.computeForEach(graph, id, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    ValueQuery getOrCreateValueQuery(QueryProcessor processor, int r) throws DatabaseException {
+        ValueQuery existing = null;
+        synchronized(valueQueryMap) {
+            existing = (ValueQuery)valueQueryMap.get(r);
+            if(existing == null) {
+                existing = new ValueQuery(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                valueQueryMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(ValueQuery entry) {
+        synchronized(valueQueryMap) {
+            valueQueryMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<byte[]> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            ValueQuery.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(graph.processor, r);
+        InternalProcedure<byte[]> procedure_ = procedure != null ? procedure : emptyProcedureValueQuery;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            ValueQuery.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    OrderedSet getOrCreateOrderedSet(QueryProcessor processor, int r) throws DatabaseException {
+        OrderedSet existing = null;
+        synchronized(orderedSetMap) {
+            existing = (OrderedSet)orderedSetMap.get(r);
+            if(existing == null) {
+                existing = new OrderedSet(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                orderedSetMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(OrderedSet entry) {
+        synchronized(orderedSetMap) {
+            orderedSetMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            OrderedSet.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(graph.processor, r);
+        IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureOrderedSet;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            OrderedSet.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    PrincipalTypes getOrCreatePrincipalTypes(QueryProcessor processor, int r) throws DatabaseException {
+        PrincipalTypes existing = null;
+        synchronized(principalTypesMap) {
+            existing = (PrincipalTypes)principalTypesMap.get(r);
+            if(existing == null) {
+                existing = new PrincipalTypes(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                principalTypesMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(PrincipalTypes entry) {
+        synchronized(principalTypesMap) {
+            principalTypesMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            PrincipalTypes.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(graph.processor, r);
+        IntProcedure procedure_ = procedure != null ? procedure : emptyProcedurePrincipalTypes;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            PrincipalTypes.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    DirectPredicates getOrCreateDirectPredicates(QueryProcessor processor, int r) throws DatabaseException {
+        DirectPredicates existing = null;
+        synchronized(directPredicatesMap) {
+            existing = (DirectPredicates)directPredicatesMap.get(r);
+            if(existing == null) {
+                existing = new DirectPredicates(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                directPredicatesMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(DirectPredicates entry) {
+        synchronized(directPredicatesMap) {
+            directPredicatesMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            DirectPredicates.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(graph.processor, r);
+        InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureDirectPredicates;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            DirectPredicates.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    Predicates getOrCreatePredicates(QueryProcessor processor, int r) throws DatabaseException {
+        Predicates existing = null;
+        synchronized(predicatesMap) {
+            existing = (Predicates)predicatesMap.get(r);
+            if(existing == null) {
+                existing = new Predicates(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                predicatesMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(Predicates entry) {
+        synchronized(predicatesMap) {
+            predicatesMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            Predicates.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        Predicates entry = (Predicates)cache.getOrCreatePredicates(graph.processor, r);
+        InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedurePredicates;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            Predicates.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    ReadEntry getOrCreateReadEntry(QueryProcessor processor, Read<?> r, boolean isSync) throws DatabaseException {
+        ReadEntry existing = null;
+        synchronized(readEntryMap) {
+            existing = (ReadEntry)readEntryMap.get(r);
+            if(existing == null) {
+                existing = new ReadEntry(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                readEntryMap.put(id(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) {
+          if(isSync) waitPending(processor, existing);
+          else return null;
+        }
+        return existing;
+    }
+    
+    void remove(ReadEntry entry) {
+        synchronized(readEntryMap) {
+            readEntryMap.remove(entry.request);
+        }
+    }
+    
+    public static void runnerReadEntry(ReadGraphImpl graph, Read<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, boolean isSync) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            ReadEntry.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(graph.processor, r, isSync);
+        if(entry == null) {
+            graph.processor.schedule(new SessionTask(false) {
+                @Override
+                public void run(int thread) {
+                    try {
+                        assert(!isSync);
+                        runnerReadEntry(graph, r, parent, listener, procedure, isSync);
+                    } catch (DatabaseException e) {
+                        Logger.defaultLogError(e);
+                    }
+                }
+            });
+            return;
+        }
+        AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureReadEntry;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            ReadEntry.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    AsyncReadEntry getOrCreateAsyncReadEntry(QueryProcessor processor, AsyncRead<?> r, boolean isSync) throws DatabaseException {
+        AsyncReadEntry existing = null;
+        synchronized(asyncReadEntryMap) {
+            existing = (AsyncReadEntry)asyncReadEntryMap.get(r);
+            if(existing == null) {
+                existing = new AsyncReadEntry(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                asyncReadEntryMap.put(id(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) {
+          if(isSync) waitPending(processor, existing);
+          else return null;
+        }
+        return existing;
+    }
+    
+    void remove(AsyncReadEntry entry) {
+        synchronized(asyncReadEntryMap) {
+            asyncReadEntryMap.remove(entry.request);
+        }
+    }
+    
+    public static void runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure, boolean isSync) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            AsyncReadEntry.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(graph.processor, r, isSync);
+        if(entry == null) {
+            graph.processor.schedule(new SessionTask(false) {
+                @Override
+                public void run(int thread) {
+                    try {
+                        assert(!isSync);
+                        runnerAsyncReadEntry(graph, r, parent, listener, procedure, isSync);
+                    } catch (DatabaseException e) {
+                        Logger.defaultLogError(e);
+                    }
+                }
+            });
+            return;
+        }
+        AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncReadEntry;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            AsyncReadEntry.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    Types getOrCreateTypes(QueryProcessor processor, int r) throws DatabaseException {
+        Types existing = null;
+        synchronized(typesMap) {
+            existing = (Types)typesMap.get(r);
+            if(existing == null) {
+                existing = new Types(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                typesMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(Types entry) {
+        synchronized(typesMap) {
+            typesMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            Types.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        Types entry = (Types)cache.getOrCreateTypes(graph.processor, r);
+        InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypes;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            Types.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    ChildMap getOrCreateChildMap(QueryProcessor processor, int r) throws DatabaseException {
+        ChildMap existing = null;
+        synchronized(childMapMap) {
+            existing = (ChildMap)childMapMap.get(r);
+            if(existing == null) {
+                existing = new ChildMap(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                childMapMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(ChildMap entry) {
+        synchronized(childMapMap) {
+            childMapMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerChildMap(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<ObjectResourceIdMap<String>> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            ChildMap.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        ChildMap entry = (ChildMap)cache.getOrCreateChildMap(graph.processor, r);
+        InternalProcedure<ObjectResourceIdMap<String>> procedure_ = procedure != null ? procedure : emptyProcedureChildMap;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            ChildMap.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    TypeHierarchy getOrCreateTypeHierarchy(QueryProcessor processor, int r) throws DatabaseException {
+        TypeHierarchy existing = null;
+        synchronized(typeHierarchyMap) {
+            existing = (TypeHierarchy)typeHierarchyMap.get(r);
+            if(existing == null) {
+                existing = new TypeHierarchy(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                typeHierarchyMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(TypeHierarchy entry) {
+        synchronized(typeHierarchyMap) {
+            typeHierarchyMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerTypeHierarchy(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            TypeHierarchy.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        TypeHierarchy entry = (TypeHierarchy)cache.getOrCreateTypeHierarchy(graph.processor, r);
+        InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureTypeHierarchy;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            TypeHierarchy.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    SuperTypes getOrCreateSuperTypes(QueryProcessor processor, int r) throws DatabaseException {
+        SuperTypes existing = null;
+        synchronized(superTypesMap) {
+            existing = (SuperTypes)superTypesMap.get(r);
+            if(existing == null) {
+                existing = new SuperTypes(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                superTypesMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(SuperTypes entry) {
+        synchronized(superTypesMap) {
+            superTypesMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerSuperTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            SuperTypes.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        SuperTypes entry = (SuperTypes)cache.getOrCreateSuperTypes(graph.processor, r);
+        InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperTypes;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            SuperTypes.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    SuperRelations getOrCreateSuperRelations(QueryProcessor processor, int r) throws DatabaseException {
+        SuperRelations existing = null;
+        synchronized(superRelationsMap) {
+            existing = (SuperRelations)superRelationsMap.get(r);
+            if(existing == null) {
+                existing = new SuperRelations(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                superRelationsMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(SuperRelations entry) {
+        synchronized(superRelationsMap) {
+            superRelationsMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final InternalProcedure<IntSet> procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) {
+            SuperRelations.computeForEach(graph, r, null, procedure);
+            return;
+        }
+        SuperRelations entry = (SuperRelations)cache.getOrCreateSuperRelations(graph.processor, r);
+        InternalProcedure<IntSet> procedure_ = procedure != null ? procedure : emptyProcedureSuperRelations;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            SuperRelations.computeForEach(graph, r, entry, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    AssertedPredicates getOrCreateAssertedPredicates(QueryProcessor processor, int r) throws DatabaseException {
+        AssertedPredicates existing = null;
+        synchronized(assertedPredicatesMap) {
+            existing = (AssertedPredicates)assertedPredicatesMap.get(r);
+            if(existing == null) {
+                existing = new AssertedPredicates(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                assertedPredicatesMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(AssertedPredicates entry) {
+        synchronized(assertedPredicatesMap) {
+            assertedPredicatesMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerAssertedPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        AssertedPredicates entry = (AssertedPredicates)cache.getOrCreateAssertedPredicates(graph.processor, r);
+        IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedPredicates;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            entry.compute(graph, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    AssertedStatements getOrCreateAssertedStatements(QueryProcessor processor, int r1, int r2) throws DatabaseException {
+        AssertedStatements existing = null;
+        synchronized(assertedStatementsMap) {
+            existing = (AssertedStatements)assertedStatementsMap.get(r1,r2);
+            if(existing == null) {
+                existing = new AssertedStatements(r1,r2);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                assertedStatementsMap.put(keyR2(r1,r2), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(AssertedStatements entry) {
+        synchronized(assertedStatementsMap) {
+            assertedStatementsMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerAssertedStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, final TripleIntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        AssertedStatements entry = (AssertedStatements)cache.getOrCreateAssertedStatements(graph.processor, r1,r2);
+        TripleIntProcedure procedure_ = procedure != null ? procedure : emptyProcedureAssertedStatements;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            entry.compute(graph, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    DirectSuperRelations getOrCreateDirectSuperRelations(QueryProcessor processor, int r) throws DatabaseException {
+        DirectSuperRelations existing = null;
+        synchronized(directSuperRelationsMap) {
+            existing = (DirectSuperRelations)directSuperRelationsMap.get(r);
+            if(existing == null) {
+                existing = new DirectSuperRelations(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                directSuperRelationsMap.put(keyR(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(DirectSuperRelations entry) {
+        synchronized(directSuperRelationsMap) {
+            directSuperRelationsMap.remove(entry.id);
+        }
+    }
+    
+    public static void runnerDirectSuperRelations(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, final IntProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        DirectSuperRelations entry = (DirectSuperRelations)cache.getOrCreateDirectSuperRelations(graph.processor, r);
+        IntProcedure procedure_ = procedure != null ? procedure : emptyProcedureDirectSuperRelations;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            entry.compute(graph, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    MultiReadEntry getOrCreateMultiReadEntry(QueryProcessor processor, MultiRead<?> r) throws DatabaseException {
+        MultiReadEntry existing = null;
+        synchronized(multiReadEntryMap) {
+            existing = (MultiReadEntry)multiReadEntryMap.get(r);
+            if(existing == null) {
+                existing = new MultiReadEntry(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                multiReadEntryMap.put(id(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(MultiReadEntry entry) {
+        synchronized(multiReadEntryMap) {
+            multiReadEntryMap.remove(entry.request);
+        }
+    }
+    
+    public static void runnerMultiReadEntry(ReadGraphImpl graph, MultiRead<?> r, CacheEntry parent, ListenerBase listener, final SyncMultiProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        MultiReadEntry entry = (MultiReadEntry)cache.getOrCreateMultiReadEntry(graph.processor, r);
+        SyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureMultiReadEntry;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            entry.compute(graph, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    AsyncMultiReadEntry getOrCreateAsyncMultiReadEntry(QueryProcessor processor, AsyncMultiRead<?> r) throws DatabaseException {
+        AsyncMultiReadEntry existing = null;
+        synchronized(asyncMultiReadEntryMap) {
+            existing = (AsyncMultiReadEntry)asyncMultiReadEntryMap.get(r);
+            if(existing == null) {
+                existing = new AsyncMultiReadEntry(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                asyncMultiReadEntryMap.put(id(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(AsyncMultiReadEntry entry) {
+        synchronized(asyncMultiReadEntryMap) {
+            asyncMultiReadEntryMap.remove(entry.request);
+        }
+    }
+    
+    public static void runnerAsyncMultiReadEntry(ReadGraphImpl graph, AsyncMultiRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncMultiProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        AsyncMultiReadEntry entry = (AsyncMultiReadEntry)cache.getOrCreateAsyncMultiReadEntry(graph.processor, r);
+        AsyncMultiProcedure procedure_ = procedure != null ? procedure : emptyProcedureAsyncMultiReadEntry;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            entry.compute(graph, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+    ExternalReadEntry getOrCreateExternalReadEntry(QueryProcessor processor, ExternalRead<?> r) throws DatabaseException {
+        ExternalReadEntry existing = null;
+        synchronized(externalReadEntryMap) {
+            existing = (ExternalReadEntry)externalReadEntryMap.get(r);
+            if(existing == null) {
+                existing = new ExternalReadEntry(r);
+                existing.clearResult(querySupport);
+                existing.setPending();
+                externalReadEntryMap.put(id(r), existing);
+                size++;
+                return existing;
+            }
+            if(existing.requiresComputation()) {
+                existing.setPending();
+                return existing;
+            }
+        }
+        if(existing.isPending()) waitPending(processor, existing);
+        return existing;
+    }
+    
+    void remove(ExternalReadEntry entry) {
+        synchronized(externalReadEntryMap) {
+            externalReadEntryMap.remove(entry.request);
+        }
+    }
+    
+    public static void runnerExternalReadEntry(ReadGraphImpl graph, ExternalRead<?> r, CacheEntry parent, ListenerBase listener, final AsyncProcedure procedure) throws DatabaseException {
+        QueryCache cache  = graph.processor.cache;
+        ExternalReadEntry entry = (ExternalReadEntry)cache.getOrCreateExternalReadEntry(graph.processor, r);
+        AsyncProcedure procedure_ = procedure != null ? procedure : emptyProcedureExternalReadEntry;
+        ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure_, false);
+        if(entry.isReady()) entry.performFromCache(graph, procedure_);
+        else {
+          assert(entry.isPending());
+            entry.compute(graph, procedure_);
+            if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult());
+        }
+    }
+    
+}