Index query fixes after commit 5e340942
[simantics/platform.git] / bundles / org.simantics.db.indexing / src / org / simantics / db / indexing / IndexUtils.java
1 package org.simantics.db.indexing;
2
3 import java.util.ArrayList;
4 import java.util.Collection;
5 import java.util.HashSet;
6 import java.util.List;
7 import java.util.Map;
8
9 import org.apache.lucene.index.Term;
10 import org.apache.lucene.util.BytesRef;
11 import org.apache.lucene.util.NumericUtils;
12 import org.eclipse.core.runtime.IProgressMonitor;
13 import org.eclipse.core.runtime.NullProgressMonitor;
14 import org.eclipse.core.runtime.SubMonitor;
15 import org.simantics.databoard.Bindings;
16 import org.simantics.db.ReadGraph;
17 import org.simantics.db.Resource;
18 import org.simantics.db.Session;
19 import org.simantics.db.common.procedure.adapter.TransientCacheListener;
20 import org.simantics.db.common.request.ObjectsWithType;
21 import org.simantics.db.exception.DatabaseException;
22 import org.simantics.db.indexing.exception.IndexCorruptedException;
23 import org.simantics.db.layer0.genericrelation.Dependencies;
24 import org.simantics.db.layer0.genericrelation.IndexQueries;
25 import org.simantics.db.layer0.genericrelation.IndexedRelations;
26 import org.simantics.db.layer0.util.Layer0Utils;
27 import org.simantics.db.service.CollectionSupport;
28 import org.simantics.layer0.Layer0;
29 import org.simantics.operation.Layer0X;
30 import org.slf4j.Logger;
31 import org.slf4j.LoggerFactory;
32
33 public class IndexUtils {
34
35     private static final Logger LOGGER = LoggerFactory.getLogger(IndexUtils.class);
36
37     public static Collection<Map<String, Object>> find(ReadGraph graph, Resource index, String filter) throws DatabaseException {
38         
39         Collection<Map<String, Object>> indexResult = graph.syncRequest(new QueryIndex(index, filter), TransientCacheListener.<Collection<Map<String, Object>>>instance());
40
41         Layer0 L0 = Layer0.getInstance(graph);
42         Collection<Resource> linkedRoots = graph.syncRequest(new ObjectsWithType(index, L0.IsLinkedTo, L0.IndexRoot));
43         if (linkedRoots.isEmpty())
44             return indexResult;
45
46         Collection<Map<String, Object>> result = indexResult;
47         for (Resource dep : linkedRoots) {
48             Collection<Map<String, Object>> linkedIndexResults = find(graph, dep, filter);
49             if (linkedIndexResults.isEmpty())
50                 continue;
51             if (result == indexResult) {
52                 result = new ArrayList<Map<String, Object>>(indexResult.size() + linkedIndexResults.size());
53                 result.addAll(indexResult);
54             } else {
55             }
56             result.addAll(linkedIndexResults);
57         }
58         
59         return result;
60         
61     }
62
63     public static List<Resource> findResources(ReadGraph graph, Resource index, String filter) throws DatabaseException {
64         
65         List<Resource> indexResult = graph.syncRequest(new QueryIndexResources(index, filter), TransientCacheListener.<List<Resource>>instance());
66
67         Layer0 L0 = Layer0.getInstance(graph);
68         CollectionSupport coll = graph.getService(CollectionSupport.class);
69         
70         Collection<Resource> linkedRoots = graph.syncRequest(new ObjectsWithType(index, L0.IsLinkedTo, L0.IndexRoot));
71         if (linkedRoots.isEmpty())
72             return indexResult;
73
74         List<Resource> result = indexResult;
75         for (Resource dep : linkedRoots) {
76             Collection<Resource> linkedIndexResults = findResources(graph, dep, filter);
77             if (linkedIndexResults.isEmpty())
78                 continue;
79             if (result == indexResult) {
80                 result = coll.createList();
81                 result.addAll(indexResult);
82             }
83             result.addAll(linkedIndexResults);
84         }
85         
86         Layer0Utils.sort(graph, result);
87         return result;
88         
89     }
90     
91     public static Collection<Resource> findByName(ReadGraph graph, Resource model, String name) throws DatabaseException {
92         Layer0 L0 = Layer0.getInstance(graph);
93         HashSet<Resource> results = new HashSet<Resource>();
94         
95         String search = IndexQueries.quoteTerm(Dependencies.FIELD_NAME, name);
96
97         for(Resource resource : findResources(graph, model, search)) {
98             if(name.equals(graph.getPossibleRelatedValue(resource, L0.HasName, Bindings.STRING))) results.add(resource);
99         }
100         return results;
101     }
102
103     public static Collection<Resource> findByType(ReadGraph graph, Resource model, Resource type) throws DatabaseException {
104         
105         HashSet<Resource> results = new HashSet<Resource>();
106         Layer0 L0 = Layer0.getInstance(graph);
107         String typeName = graph.getRelatedValue(type, L0.HasName, Bindings.STRING);
108         String search = IndexQueries.quoteTerm(Dependencies.FIELD_TYPES, typeName);
109
110         for(Resource resource : findResources(graph, model, search)) {
111                 if(graph.isInstanceOf(resource, type)) results.add(resource);
112         }
113         return results;
114     }
115
116     public static Collection<Resource> findByTypeAndName(ReadGraph graph, Resource model, Resource type, String name) throws DatabaseException {
117         
118         Layer0 L0 = Layer0.getInstance(graph);
119         
120         HashSet<Resource> results = new HashSet<Resource>();
121         String typeName = graph.getRelatedValue(type, L0.HasName, Bindings.STRING);
122         
123         String search = IndexQueries.and(IndexQueries.quoteTerm(Dependencies.FIELD_TYPES, typeName), IndexQueries.quoteTerm(Dependencies.FIELD_NAME, name));
124
125         for(Resource resource : findResources(graph, model, search)) {
126                 if(graph.isInstanceOf(resource, type)) results.add(resource);
127         }
128         return results;
129     }
130     
131     public static void flushIndexCaches(IProgressMonitor progress, Session session) throws Exception {
132
133         MemoryIndexing mem = MemoryIndexing.getInstance(session);
134         mem.flush(progress);
135         
136     }
137     
138     public static List<Object> list(IProgressMonitor progress, Session session, Resource indexRoot) throws Exception {
139         
140         if(progress == null) progress = new NullProgressMonitor();
141
142         MemoryIndexing mem = MemoryIndexing.getInstance(session);
143         Layer0X L0X = Layer0X.getInstance(session);
144
145         mem.flush(progress);
146                 
147         IndexedRelationsSearcher searcher = mem.get(session, L0X.DependenciesRelation, indexRoot);
148         List<Object> results;
149         try {
150             results = searcher.doList(progress, session);
151         } catch (IndexCorruptedException e) {
152             LOGGER.error("Index is corrupted for indexRoot {}", indexRoot, e);
153             rebuild(session, progress);
154             // if this fails then no can do
155             searcher = mem.get(session, L0X.DependenciesRelation, indexRoot);
156             results = searcher.doList(progress, session);
157         }
158         return results;
159     }
160     
161     private static void rebuild(Session session, IProgressMonitor monitor) throws Exception {
162         LOGGER.error("Trying to rebuild index");
163         DatabaseIndexing.deleteAllIndexes();
164         session.getService(IndexedRelations.class).fullRebuild(SubMonitor.convert(monitor, 100), session);
165     }
166
167     public static Term longTerm(String key, Long value) {
168         BytesRef ref = new BytesRef();    
169         NumericUtils.longToPrefixCoded( value, 0, ref );
170         return new Term(key, ref);
171     }
172
173 }