Merge "Revert "First step to enable reading of cache when not writing""
authorTuukka Lehtonen <tuukka.lehtonen@semantum.fi>
Fri, 2 Aug 2019 19:24:10 +0000 (19:24 +0000)
committerGerrit Code Review <gerrit2@simantics>
Fri, 2 Aug 2019 19:24:10 +0000 (19:24 +0000)
bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/QueryProcessor.java

index 55855ee3e823bed936c00c558848ceaf05a04915..7743907202eb8fbf54fd584330e3dc84fcdfac16 100644 (file)
@@ -1452,17 +1452,17 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        return false;
                }
 
-//             if (entry.isRefuted()) {
-//                     if (Development.DEVELOPMENT) {
-//                             if(Development.<Boolean>getProperty(DevelopmentKeys.QUERYPROCESSOR_UPDATE, Bindings.BOOLEAN)) {
-//                                     System.err.print("R");
-//                                     for (int i = 0; i < e.indent; i++)
-//                                             System.err.print(" ");
-//                                     System.err.println(entry.getQuery());
-//                             }
-//                     }
-//                     return false;
-//             }
+               if (entry.isRefuted()) {
+                       if (Development.DEVELOPMENT) {
+                               if(Development.<Boolean>getProperty(DevelopmentKeys.QUERYPROCESSOR_UPDATE, Bindings.BOOLEAN)) {
+                                       System.err.print("R");
+                                       for (int i = 0; i < e.indent; i++)
+                                               System.err.print(" ");
+                                       System.err.println(entry.getQuery());
+                               }
+                       }
+                       return false;
+               }
 
                if (entry.isExcepted()) {
                        if (Development.DEVELOPMENT) {
@@ -1851,22 +1851,6 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
        private Object primitiveUpdateLock = new Object();
        private THashSet scheduledPrimitiveUpdates = new THashSet();
 
-       private ArrayList<CacheEntry> refutations = new ArrayList<>();
-       
-       private void markForUpdate(ReadGraphImpl graph, CacheEntry e) {
-               e.refute();
-               refutations.add(e);
-       }
-
-       private void updateRefutations(ReadGraphImpl graph) {
-               
-               for(CacheEntry e : refutations)
-                       update(graph, e);
-               
-               refutations.clear();
-               
-       }
-       
        public void performDirtyUpdates(final ReadGraphImpl graph) {
 
                cache.dirty = false;
@@ -1886,37 +1870,28 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        final int subject = (int)(arg0 >>> 32);
                        final int predicate = (int)(arg0 & 0xffffffff);
 
-                       for(Objects o : QueryCache.entriesObjects(QueryProcessor.this, subject)) markForUpdate(graph, o);
-                       for(DirectObjects o : QueryCache.entriesDirectObjects(QueryProcessor.this, subject)) markForUpdate(graph, o);
-                       for(Statements o : QueryCache.entriesStatements(QueryProcessor.this, subject)) markForUpdate(graph, o);
+                       for(Objects o : QueryCache.entriesObjects(QueryProcessor.this, subject)) update(graph, o);
+                       for(DirectObjects o : QueryCache.entriesDirectObjects(QueryProcessor.this, subject)) update(graph, o);
+                       for(Statements o : QueryCache.entriesStatements(QueryProcessor.this, subject)) update(graph, o);
 
                        if(predicate == instanceOf || predicate == inherits || predicate == subrelationOf) {
                                PrincipalTypes principalTypes = QueryCache.entryPrincipalTypes(QueryProcessor.this, subject);
-                               if(principalTypes != null) markForUpdate(graph, principalTypes);
+                               if(principalTypes != null) update(graph, principalTypes);
                                Types types = QueryCache.entryTypes(QueryProcessor.this, subject);
-                               if(types != null) markForUpdate(graph, types);
+                               if(types != null) update(graph, types);
                        }
 
                        if(predicate == subrelationOf) {
                                SuperRelations superRelations = SuperRelations.entry(QueryProcessor.this, subject);
-                               if(superRelations != null) markForUpdate(graph, superRelations);
+                               if(superRelations != null) update(graph, superRelations);
                        }
 
                        DirectPredicates dp = QueryCache.entryDirectPredicates(QueryProcessor.this, subject);
-                       if(dp != null) markForUpdate(graph, dp);
+                       if(dp != null) update(graph, dp);
                        OrderedSet os = QueryCache.entryOrderedSet(QueryProcessor.this, predicate);
-                       if(os != null) markForUpdate(graph, os);
+                       if(os != null) update(graph, os);
 
-                       updateRefutations(graph);
-                       
                        scheduledObjectUpdates.clear();
-
-                       if (Development.DEVELOPMENT) {
-                               if(Development.<Boolean>getProperty(DevelopmentKeys.QUERYPROCESSOR_UPDATE, Bindings.BOOLEAN)) {
-                                       System.err.println("== Query update ends ==");
-                               }
-                       }
-
                        return;
 
                }
@@ -1927,18 +1902,9 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        int arg0 = scheduledValueUpdates.getFirst();
 
                        ValueQuery valueQuery = QueryCache.entryValueQuery(QueryProcessor.this, arg0);
-                       if(valueQuery != null) markForUpdate(graph, valueQuery);
-
-                       updateRefutations(graph);
+                       if(valueQuery != null) update(graph, valueQuery);
 
                        scheduledValueUpdates.clear();
-
-                       if (Development.DEVELOPMENT) {
-                               if(Development.<Boolean>getProperty(DevelopmentKeys.QUERYPROCESSOR_UPDATE, Bindings.BOOLEAN)) {
-                                       System.err.println("== Query update ends ==");
-                               }
-                       }
-                       
                        return;
 
                }
@@ -1952,12 +1918,30 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        scheduledPrimitiveUpdates = new THashSet();
                }
 
+               primitiveUpdates.forEach(new TObjectProcedure() {
+
+                       @Override
+                       public boolean execute(Object arg0) {
+
+                               ExternalReadEntry query = (ExternalReadEntry)cache.externalReadEntryMap.get(arg0);
+                               if (query != null) {
+                                       boolean listening = update(graph, query);
+                                       if (!listening && !query.hasParents()) {
+                                               cache.externalReadEntryMap.remove(arg0);
+                                               query.discard();
+                                       }
+                               }
+                               return true;
+                       }
+
+               });
+
                scheduledValueUpdates.forEach(new TIntProcedure() {
 
                        @Override
                        public boolean execute(int arg0) {
                                ValueQuery valueQuery = QueryCache.entryValueQuery(QueryProcessor.this, arg0);
-                               if(valueQuery != null) markForUpdate(graph, valueQuery);
+                               if(valueQuery != null) update(graph, valueQuery);
                                return true;
                        }
 
@@ -1969,15 +1953,15 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        public boolean execute(int resource) {
                                
                                ValueQuery valueQuery = QueryCache.entryValueQuery(QueryProcessor.this, resource);
-                               if(valueQuery != null) markForUpdate(graph, valueQuery);
+                               if(valueQuery != null) update(graph, valueQuery);
                                
                                PrincipalTypes principalTypes = QueryCache.entryPrincipalTypes(QueryProcessor.this, resource);
-                               if(principalTypes != null) markForUpdate(graph, principalTypes);
+                               if(principalTypes != null) update(graph, principalTypes);
                                Types types = QueryCache.entryTypes(QueryProcessor.this, resource);
-                               if(types != null) markForUpdate(graph, types);
+                               if(types != null) update(graph, types);
 
                                SuperRelations superRelations = SuperRelations.entry(QueryProcessor.this, resource);
-                               if(superRelations != null) markForUpdate(graph, superRelations);
+                               if(superRelations != null) update(graph, superRelations);
 
                                predicates.add(resource);
                                
@@ -1996,14 +1980,14 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
 
                                if(predicate == instanceOf || predicate == inherits || predicate == subrelationOf) {
                                        PrincipalTypes principalTypes = QueryCache.entryPrincipalTypes(QueryProcessor.this, subject);
-                                       if(principalTypes != null) markForUpdate(graph, principalTypes);
+                                       if(principalTypes != null) update(graph, principalTypes);
                                        Types types = QueryCache.entryTypes(QueryProcessor.this, subject);
-                                       if(types != null) markForUpdate(graph, types);
+                                       if(types != null) update(graph, types);
                                }
 
                                if(predicate == subrelationOf) {
                                        SuperRelations superRelations = SuperRelations.entry(QueryProcessor.this, subject);
-                                       if(superRelations != null) markForUpdate(graph, superRelations);
+                                       if(superRelations != null) update(graph, superRelations);
                                }
 
                                predicates.add(subject);
@@ -2020,12 +2004,12 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        @Override
                        public boolean execute(final int subject) {
 
-                               for(Objects o : QueryCache.entriesObjects(QueryProcessor.this, subject)) markForUpdate(graph, o);
-                               for(DirectObjects o : QueryCache.entriesDirectObjects(QueryProcessor.this, subject)) markForUpdate(graph, o);
-                               for(Statements o : QueryCache.entriesStatements(QueryProcessor.this, subject)) markForUpdate(graph, o);
+                               for(Objects o : QueryCache.entriesObjects(QueryProcessor.this, subject)) update(graph, o);
+                               for(DirectObjects o : QueryCache.entriesDirectObjects(QueryProcessor.this, subject)) update(graph, o);
+                               for(Statements o : QueryCache.entriesStatements(QueryProcessor.this, subject)) update(graph, o);
 
                                DirectPredicates entry = QueryCache.entryDirectPredicates(QueryProcessor.this, subject);
-                               if(entry != null) markForUpdate(graph, entry);
+                               if(entry != null) update(graph, entry);
 
                                return true;
 
@@ -2039,7 +2023,7 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
                        public boolean execute(int orderedSet) {
 
                                OrderedSet entry = QueryCache.entryOrderedSet(QueryProcessor.this, orderedSet);
-                               if(entry != null) markForUpdate(graph, entry);
+                               if(entry != null) update(graph, entry);
 
                                return true;
 
@@ -2047,36 +2031,22 @@ final public class QueryProcessor extends AbstractDisposable implements ReadGrap
 
                });
 
-               updateRefutations(graph);
-
-               primitiveUpdates.forEach(new TObjectProcedure() {
+               //              for (Integer subject : predicates) {
+               //                      DirectPredicates entry = DirectPredicates.entry(QueryProcessor.this, subject);
+               //                      if(entry != null) update(graph, entry);
+               //              }
 
-                       @Override
-                       public boolean execute(Object arg0) {
 
-                               ExternalReadEntry query = (ExternalReadEntry)cache.externalReadEntryMap.get(arg0);
-                               if (query != null) {
-                                       boolean listening = update(graph, query);
-                                       if (!listening && !query.hasParents()) {
-                                               cache.externalReadEntryMap.remove(arg0);
-                                               query.discard();
-                                       }
-                               }
-                               return true;
-                       }
-
-               });
-               
-               scheduledValueUpdates.clear();
-               scheduledObjectUpdates.clear();
-               scheduledInvalidates.clear();
-               
                if (Development.DEVELOPMENT) {
                        if(Development.<Boolean>getProperty(DevelopmentKeys.QUERYPROCESSOR_UPDATE, Bindings.BOOLEAN)) {
                                System.err.println("== Query update ends ==");
                        }
                }
 
+               scheduledValueUpdates.clear();
+               scheduledObjectUpdates.clear();
+               scheduledInvalidates.clear();
+
        }
 
        public void updateValue(final int resource) {