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;h=49e02dece32049884f7a3907e85f960f2bf27f64;hb=ded784594eb0e1fb318fbb931135288152691cf2;hp=dbd0068c3f66100404eda02d5fbba9d70fdc8308;hpb=1fb7e00de0895266e08097371c6f84e4322d6530;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 index dbd0068c3..49e02dece 100644 --- 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 @@ -1,5 +1,6 @@ package org.simantics.db.impl.query; +import org.simantics.db.ObjectResourceIdMap; import org.simantics.db.RelationInfo; import org.simantics.db.exception.DatabaseException; import org.simantics.db.impl.graph.ReadGraphImpl; @@ -30,6 +31,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); objectsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -48,11 +50,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) { Objects.computeForEach(graph, r1,r2, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureObjects; Objects entry = (Objects)cache.getOrCreateObjects(r1,r2); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -72,6 +74,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); statementsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -90,11 +93,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerStatements(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, TripleIntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) { Statements.computeForEach(graph, r1,r2, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureStatements; Statements entry = (Statements)cache.getOrCreateStatements(r1,r2); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -114,6 +117,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); directObjectsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -132,11 +136,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerDirectObjects(ReadGraphImpl graph, int r1, int r2, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r1,r2)) { DirectObjects.computeForEach(graph, r1,r2, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureDirectObjects; DirectObjects entry = (DirectObjects)cache.getOrCreateDirectObjects(r1,r2); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -156,6 +160,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); relationInfoQueryMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -174,11 +179,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerRelationInfoQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { RelationInfoQuery.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureRelationInfoQuery; RelationInfoQuery entry = (RelationInfoQuery)cache.getOrCreateRelationInfoQuery(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -198,6 +203,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); uRIToResourceMap.put(keyID(id), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -216,11 +222,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerURIToResource(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, id)) { URIToResource.computeForEach(graph, id, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureURIToResource; URIToResource entry = (URIToResource)cache.getOrCreateURIToResource(id); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -240,6 +246,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); valueQueryMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -258,11 +265,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerValueQuery(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { ValueQuery.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureValueQuery; ValueQuery entry = (ValueQuery)cache.getOrCreateValueQuery(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -282,6 +289,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); orderedSetMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -300,11 +308,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerOrderedSet(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { OrderedSet.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureOrderedSet; OrderedSet entry = (OrderedSet)cache.getOrCreateOrderedSet(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -324,6 +332,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); principalTypesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -342,11 +351,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerPrincipalTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, IntProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { PrincipalTypes.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedurePrincipalTypes; PrincipalTypes entry = (PrincipalTypes)cache.getOrCreatePrincipalTypes(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -366,6 +375,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); directPredicatesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -384,11 +394,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerDirectPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { DirectPredicates.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureDirectPredicates; DirectPredicates entry = (DirectPredicates)cache.getOrCreateDirectPredicates(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -408,6 +418,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); predicatesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -426,11 +437,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerPredicates(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { Predicates.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedurePredicates; Predicates entry = (Predicates)cache.getOrCreatePredicates(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -450,6 +461,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); readEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -468,11 +480,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerReadEntry(ReadGraphImpl graph, Read r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { ReadEntry.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureReadEntry; ReadEntry entry = (ReadEntry)cache.getOrCreateReadEntry(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -492,6 +504,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); asyncReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -510,11 +523,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerAsyncReadEntry(ReadGraphImpl graph, AsyncRead r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { AsyncReadEntry.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureAsyncReadEntry; AsyncReadEntry entry = (AsyncReadEntry)cache.getOrCreateAsyncReadEntry(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -534,6 +547,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); typesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -552,11 +566,11 @@ public class QueryCache extends QueryCacheBase { } public static void runnerTypes(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure procedure) throws DatabaseException { - if(parent == null && listener == null) { + QueryCache cache = graph.processor.cache; + if(parent == null && listener == null && !cache.shouldCache(graph.processor, r)) { Types.computeForEach(graph, r, null, procedure); return; } - QueryCache cache = graph.processor.cache; if(procedure == null) procedure = emptyProcedureTypes; Types entry = (Types)cache.getOrCreateTypes(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); @@ -567,15 +581,16 @@ public class QueryCache extends QueryCacheBase { } } - NamespaceIndex getOrCreateNamespaceIndex(String id) throws DatabaseException { - NamespaceIndex existing = null; - synchronized(namespaceIndexMap) { - existing = (NamespaceIndex)namespaceIndexMap.get(id); + ChildMap getOrCreateChildMap(int r) throws DatabaseException { + ChildMap existing = null; + synchronized(childMapMap) { + existing = (ChildMap)childMapMap.get(r); if(existing == null) { - existing = new NamespaceIndex(id); + existing = new ChildMap(r); existing.clearResult(querySupport); existing.setPending(); - namespaceIndexMap.put(keyID(id), existing); + childMapMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -587,24 +602,24 @@ public class QueryCache extends QueryCacheBase { return existing; } - void remove(NamespaceIndex entry) { - synchronized(namespaceIndexMap) { - namespaceIndexMap.remove(entry.id); + void remove(ChildMap entry) { + synchronized(childMapMap) { + childMapMap.remove(entry.id); } } - public static void runnerNamespaceIndex(ReadGraphImpl graph, String id, CacheEntry parent, ListenerBase listener, InternalProcedure> procedure) throws DatabaseException { - if(parent == null && listener == null) { - NamespaceIndex.computeForEach(graph, id, null, procedure); + public static void runnerChildMap(ReadGraphImpl graph, int r, CacheEntry parent, ListenerBase listener, InternalProcedure> 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; } - QueryCache cache = graph.processor.cache; - if(procedure == null) procedure = emptyProcedureNamespaceIndex; - NamespaceIndex entry = (NamespaceIndex)cache.getOrCreateNamespaceIndex(id); + if(procedure == null) procedure = emptyProcedureChildMap; + ChildMap entry = (ChildMap)cache.getOrCreateChildMap(r); ListenerEntry listenerEntry = cache.registerDependencies(graph, entry, parent, listener, procedure, false); if(entry.isReady()) entry.performFromCache(graph, procedure); else { - NamespaceIndex.computeForEach(graph, id, entry, procedure); + ChildMap.computeForEach(graph, r, entry, procedure); if(listenerEntry != null) cache.primeListenerEntry(listenerEntry, entry.getResult()); } } @@ -618,6 +633,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); assertedStatementsMap.put(keyR2(r1,r2), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -656,6 +672,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); assertedPredicatesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -694,6 +711,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); directSuperRelationsMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -732,6 +750,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); superTypesMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -770,6 +789,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); typeHierarchyMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -808,6 +828,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); superRelationsMap.put(keyR(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -846,6 +867,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); multiReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -884,6 +906,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); asyncMultiReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) { @@ -922,6 +945,7 @@ public class QueryCache extends QueryCacheBase { existing.clearResult(querySupport); existing.setPending(); externalReadEntryMap.put(id(r), existing); + size++; return existing; } if(existing.requiresComputation()) {