X-Git-Url: https://gerrit.simantics.org/r/gitweb?p=simantics%2Fplatform.git;a=blobdiff_plain;f=bundles%2Forg.simantics.db.impl%2Fsrc%2Forg%2Fsimantics%2Fdb%2Fimpl%2Fquery%2FQueryCacheBase.java;h=b0bca135042fbe99a5f07ffc3f4cab28628a164b;hp=d7a235fc813d4f302e719bb66647cd2cef972d91;hb=e460fd6f0af60314e2ca28391ef7ff2043016d97;hpb=277b1c7fb3fdd8effb4bf2b447358d0e4ef0e302 diff --git a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCacheBase.java b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCacheBase.java index d7a235fc8..b0bca1350 100644 --- a/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCacheBase.java +++ b/bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryCacheBase.java @@ -3,21 +3,16 @@ package org.simantics.db.impl.query; import java.util.ArrayList; import java.util.Collection; import java.util.concurrent.Semaphore; -import java.util.concurrent.atomic.AtomicBoolean; import org.simantics.db.AsyncReadGraph; import org.simantics.db.ObjectResourceIdMap; import org.simantics.db.ReadGraph; import org.simantics.db.RelationInfo; -import org.simantics.db.common.utils.Logger; import org.simantics.db.exception.DatabaseException; -import org.simantics.db.impl.DebugPolicy; 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.Listener; import org.simantics.db.procedure.ListenerBase; import org.simantics.db.procedure.Procedure; import org.simantics.db.procedure.SyncMultiProcedure; @@ -71,8 +66,6 @@ public class QueryCacheBase { protected final StableHashMap asyncMultiReadEntryMap; protected final StableHashMap externalReadEntryMap; - final THashMap> listeners; - public final QuerySupport querySupport; public QueryCacheBase(QuerySupport querySupport, int threads) { @@ -105,159 +98,11 @@ public class QueryCacheBase { asyncMultiReadEntryMap = new StableHashMap(); multiReadEntryMap = new StableHashMap(); externalReadEntryMap = new StableHashMap(); - listeners = new THashMap>(10, 0.75f); - } - -// public Object performQuery(ReadGraphImpl parentGraph, final AsyncRead query, final CacheEntryBase entry_, AsyncProcedure procedure_) throws DatabaseException { -// -// AsyncReadEntry entry = (AsyncReadEntry)entry_; -// AsyncProcedure procedure = (AsyncProcedure)procedure_; -// -// ReadGraphImpl queryGraph = parentGraph.withParent(entry_); -// -// try { -// -// query.perform(queryGraph, new AsyncProcedure() { -// -// @Override -// public void execute(AsyncReadGraph returnGraph, T result) { -// ReadGraphImpl impl = (ReadGraphImpl)returnGraph; -// entry.addOrSet(parentGraph, result); -// try { -// procedure.execute(parentGraph, result); -// } catch (Throwable t) { -// t.printStackTrace(); -// } -//// parentBarrier.dec(query); -// } -// -// @Override -// public void exception(AsyncReadGraph returnGraph, Throwable t) { -// ReadGraphImpl impl = (ReadGraphImpl)returnGraph; -//// AsyncReadGraph resumeGraph = finalParentGraph.newAsync(); -// entry.except(parentGraph, t); -// try { -// procedure.exception(parentGraph, t); -// } catch (Throwable t2) { -// t2.printStackTrace(); -// } -//// parentBarrier.dec(query); -// } -// -// @Override -// public String toString() { -// return procedure.toString(); -// } -// -// }); -// -// } catch (Throwable t) { -// -// entry.except(t); -// try { -// procedure.exception(parentGraph, t); -// } catch (Throwable t2) { -// t2.printStackTrace(); -// } -//// parentBarrier.dec(query); -// -// } -// -// return null; -// -// } - -// public Object performQuery(ReadGraphImpl parentGraph, final Read query, final CacheEntryBase entry_, AsyncProcedure procedure_) throws DatabaseException { -// -// ReadGraphImpl queryGraph = parentGraph.withParent(entry_); -// -// ReadEntry entry = (ReadEntry)entry_; -// -// try { -// -// T result = (T)query.perform(queryGraph); -// entry.addOrSet(queryGraph, result); -// -// return (T)entry.get(parentGraph, procedure_); -// -// } catch (Throwable t) { -// -// entry.except(t); -// return (T)entry.get(parentGraph, procedure_); -// -// } -// -// } - - public Object performQuery(ReadGraphImpl parentGraph, final ExternalRead query, final CacheEntryBase entry_, AsyncProcedure procedure_) throws DatabaseException { - - ExternalReadEntry entry = (ExternalReadEntry)entry_; - AsyncProcedure procedure = (AsyncProcedure)procedure_; - - try { - - query.register(parentGraph, new Listener() { - - AtomicBoolean used = new AtomicBoolean(false); - - @Override - public void execute(T result) { - - // Just for safety - if(entry.isDiscarded()) return; - - if(used.compareAndSet(false, true)) { - //entry.setPending(); - entry.addOrSet(parentGraph.processor, result); - procedure.execute(parentGraph, result); - } else { - entry.queue(result); - parentGraph.processor.updatePrimitive(query); - } - - } - - @Override - public void exception(Throwable t) { - - entry.except(t); - - if(used.compareAndSet(false, true)) { - procedure.exception(parentGraph, t); - } else { -// entry.queue(result); - parentGraph.processor.updatePrimitive(query); - } - - } - - @Override - public String toString() { - return procedure.toString(); - } - - @Override - public boolean isDisposed() { - return entry.isDiscarded() || !parentGraph.processor.isBound(entry); - } - - }); - - return entry.getResult(); - - } catch (Throwable t) { - - entry.except(t); - procedure.exception(parentGraph, t); - return entry.getResult(); - - } - } public Object performQuery(ReadGraphImpl parentGraph, final AsyncMultiRead query, final CacheEntryBase entry_, Object procedure_) throws DatabaseException { - ReadGraphImpl queryGraph = parentGraph.withParent(entry_); + ReadGraphImpl queryGraph = parentGraph.withParent(entry_, null, false); AsyncMultiReadEntry entry = (AsyncMultiReadEntry)entry_; AsyncMultiProcedure procedure = (AsyncMultiProcedure)procedure_; @@ -320,7 +165,7 @@ public class QueryCacheBase { public Object performQuery(ReadGraphImpl parentGraph, final MultiRead query, final CacheEntryBase entry_, Object procedure_) throws DatabaseException { - ReadGraphImpl queryGraph = parentGraph.withParent(entry_); + ReadGraphImpl queryGraph = parentGraph.withParent(entry_, null, true); MultiReadEntry entry = (MultiReadEntry)entry_; SyncMultiProcedure procedure = (SyncMultiProcedure)procedure_; @@ -381,76 +226,6 @@ public class QueryCacheBase { } - public ListenerEntry registerDependencies(ReadGraphImpl graph, CacheEntry child, CacheEntry parent, ListenerBase listener, Object procedure, boolean inferred) { - - if (parent != null && !inferred) { - try { - if(!child.isImmutable(graph)) { - synchronized(child) { - child.addParent(parent); - } - } - } catch (DatabaseException e) { - Logger.defaultLogError(e); - } - if(DebugPolicy.DEPENDENCIES) System.out.println(child + " -> " + parent); - } - - if (listener != null) { - return registerListener(child, listener, procedure); - } else { - return null; - } - - } - - public synchronized ListenerEntry registerListener(final CacheEntry entry, final ListenerBase base, final Object procedure) { - - assert (entry != null); - - if (base.isDisposed()) - return null; - - return addListener(entry, base, procedure); - - } - - protected void primeListenerEntry(final ListenerEntry entry, final Object result) { - entry.setLastKnown(result); - } - - private ListenerEntry addListener(CacheEntry entry, ListenerBase base, Object procedure) { - - assert (entry != null); - assert (procedure != null); - - ArrayList list = listeners.get(entry); - if (list == null) { - list = new ArrayList(1); - listeners.put(entry, list); - } - - ListenerEntry result = new ListenerEntry(entry, base, procedure); - int currentIndex = list.indexOf(result); - // There was already a listener - if(currentIndex > -1) { - ListenerEntry current = list.get(currentIndex); - if(!current.base.isDisposed()) return null; - list.set(currentIndex, result); - } else { - list.add(result); - } - - if(DebugPolicy.LISTENER) { - new Exception().printStackTrace(); - System.out.println("addListener -> " + list.size() + " " + entry + " " + base + " " + procedure); - } - - return result; - - } - - public Collection getRootList() { ArrayList result = new ArrayList(); @@ -642,7 +417,7 @@ public class QueryCacheBase { int counter = 0; while(entry.isPending()) { try { - boolean performed = graph.performPending(); + boolean performed = false;//graph.performPending(); if(!performed) { Thread.sleep(1); counter++; @@ -1126,10 +901,6 @@ public class QueryCacheBase { return wrap.get(); } - public static T resultReadEntry(ReadGraphImpl graph, Read r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { - return (T)QueryCache.runnerReadEntry(graph, r, parent, listener, procedure, true); - } - public static T resultAsyncReadEntry(ReadGraphImpl graph, AsyncRead r, CacheEntry parent, ListenerBase listener, AsyncProcedure procedure) throws DatabaseException { return (T)QueryCache.runnerAsyncReadEntry(graph, r, parent, listener, procedure, true); } @@ -1205,5 +976,158 @@ public class QueryCacheBase { static boolean shouldCache(QueryProcessor processor, Object o) { return false; } + + AssertedPredicates getOrCreateAssertedPredicates(int r) { + AssertedPredicates entry = (AssertedPredicates)assertedPredicatesMap.get(r); + if(entry == null) { + entry = new AssertedPredicates(r); + assertedPredicatesMap.put(keyR(r), entry); + } + return entry; + } + AssertedStatements getOrCreateAssertedStatements(int r1, int r2) { + AssertedStatements entry = (AssertedStatements)assertedStatementsMap.get(r1, r2); + if(entry == null) { + entry = new AssertedStatements(r1, r2); + assertedStatementsMap.put(keyR2(r1, r2), entry); + } + return entry; + } + + ChildMap getOrCreateChildMap(int r) { + ChildMap entry = (ChildMap)childMapMap.get(r); + if(entry == null) { + entry = new ChildMap(r); + childMapMap.put(keyR(r), entry); + } + return entry; + } + + DirectObjects getOrCreateDirectObjects(int r1, int r2) { + DirectObjects entry = (DirectObjects)directObjectsMap.get(r1, r2); + if(entry == null) { + entry = new DirectObjects(r1, r2); + directObjectsMap.put(keyR2(r1, r2), entry); + } + return entry; + } + + DirectPredicates getOrCreateDirectPredicates(int r) { + DirectPredicates entry = (DirectPredicates)directPredicatesMap.get(r); + if(entry == null) { + entry = new DirectPredicates(r); + directPredicatesMap.put(keyR(r), entry); + } + return entry; + } + + Objects getOrCreateObjects(int r1, int r2) { + Objects entry = (Objects)objectsMap.get(r1, r2); + if(entry == null) { + entry = new Objects(r1, r2); + objectsMap.put(keyR2(r1, r2), entry); + } + return entry; + } + + OrderedSet getOrCreateOrderedSet(int r) { + OrderedSet entry = (OrderedSet)orderedSetMap.get(r); + if(entry == null) { + entry = new OrderedSet(r); + orderedSetMap.put(keyR(r), entry); + } + return entry; + } + + Predicates getOrCreatePredicates(int r) { + Predicates entry = (Predicates)predicatesMap.get(r); + if(entry == null) { + entry = new Predicates(r); + predicatesMap.put(keyR(r), entry); + } + return entry; + } + + PrincipalTypes getOrCreatePrincipalTypes(int r) { + PrincipalTypes entry = (PrincipalTypes)principalTypesMap.get(r); + if(entry == null) { + entry = new PrincipalTypes(r); + principalTypesMap.put(keyR(r), entry); + } + return entry; + } + + RelationInfoQuery getOrCreateRelationInfoQuery(int r) { + RelationInfoQuery entry = (RelationInfoQuery)relationInfoQueryMap.get(r); + if(entry == null) { + entry = new RelationInfoQuery(r); + relationInfoQueryMap.put(keyR(r), entry); + } + return entry; + } + + Statements getOrCreateStatements(int r1, int r2) { + Statements entry = (Statements)statementsMap.get(r1, r2); + if(entry == null) { + entry = new Statements(r1, r2); + statementsMap.put(keyR2(r1, r2), entry); + } + return entry; + } + + SuperRelations getOrCreateSuperRelations(int r) { + SuperRelations entry = (SuperRelations)superRelationsMap.get(r); + if(entry == null) { + entry = new SuperRelations(r); + superRelationsMap.put(keyR(r), entry); + } + return entry; + } + + SuperTypes getOrCreateSuperTypes(int r) { + SuperTypes entry = (SuperTypes)superTypesMap.get(r); + if(entry == null) { + entry = new SuperTypes(r); + superTypesMap.put(keyR(r), entry); + } + return entry; + } + + TypeHierarchy getOrCreateTypeHierarchy(int r) { + TypeHierarchy entry = (TypeHierarchy)typeHierarchyMap.get(r); + if(entry == null) { + entry = new TypeHierarchy(r); + typeHierarchyMap.put(keyR(r), entry); + } + return entry; + } + + Types getOrCreateTypes(int r) { + Types entry = (Types)typesMap.get(r); + if(entry == null) { + entry = new Types(r); + typesMap.put(keyR(r), entry); + } + return entry; + } + + URIToResource getOrCreateURIToResource(String s) { + URIToResource entry = (URIToResource)uRIToResourceMap.get(s); + if(entry == null) { + entry = new URIToResource(s); + uRIToResourceMap.put(keyID(s), entry); + } + return entry; + } + + ValueQuery getOrCreateValueQuery(int r) { + ValueQuery entry = (ValueQuery)valueQueryMap.get(r); + if(entry == null) { + entry = new ValueQuery(r); + valueQueryMap.put(keyR(r), entry); + } + return entry; + } + } \ No newline at end of file