1 package fi.vtt.simantics.procore.internal;
\r
3 import gnu.trove.set.hash.TIntHashSet;
\r
5 import java.io.ByteArrayInputStream;
\r
6 import java.io.InputStream;
\r
7 import java.util.Collection;
\r
9 import org.simantics.db.Resource;
\r
10 import org.simantics.db.Session;
\r
11 import org.simantics.db.Statement;
\r
12 import org.simantics.db.VirtualGraph;
\r
13 import org.simantics.db.WriteGraph;
\r
14 import org.simantics.db.common.StandardStatement;
\r
15 import org.simantics.db.common.request.WriteRequest;
\r
16 import org.simantics.db.common.utils.Logger;
\r
17 import org.simantics.db.exception.DatabaseException;
\r
18 import org.simantics.db.exception.InvalidResourceReferenceException;
\r
19 import org.simantics.db.exception.ResourceNotFoundException;
\r
20 import org.simantics.db.impl.ClusterI;
\r
21 import org.simantics.db.impl.ClusterSupport;
\r
22 import org.simantics.db.impl.ForEachObjectContextProcedure;
\r
23 import org.simantics.db.impl.ForEachObjectProcedure;
\r
24 import org.simantics.db.impl.ResourceImpl;
\r
25 import org.simantics.db.impl.TransientGraph;
\r
26 import org.simantics.db.impl.VirtualGraphImpl;
\r
27 import org.simantics.db.impl.graph.ReadGraphImpl;
\r
28 import org.simantics.db.impl.query.IntProcedure;
\r
29 import org.simantics.db.impl.query.QueryProcessor;
\r
30 import org.simantics.db.impl.query.QuerySupport;
\r
31 import org.simantics.db.impl.support.BuiltinSupport;
\r
32 import org.simantics.db.impl.support.ResourceSupport;
\r
33 import org.simantics.db.procore.cluster.ClusterImpl;
\r
34 import org.simantics.db.procore.cluster.ClusterSmall;
\r
35 import org.simantics.db.service.SerialisationSupport;
\r
36 import org.simantics.utils.DataContainer;
\r
37 import org.simantics.utils.datastructures.Callback;
\r
39 public class QuerySupportImpl implements QuerySupport {
\r
41 final SessionImplSocket session;
\r
43 final ClusterTable clusterTable;
\r
44 final BuiltinSupport builtinSupport;
\r
45 final ClusterSupport clusterSupport;
\r
46 final ResourceSupport resourceSupport;
\r
47 final SerialisationSupport serializationSupport;
\r
48 final VirtualGraphServerSupportImpl virtualGraphServerSupport;
\r
49 final GraphSession graphSession;
\r
50 final SessionRequestManager syncThreads;
\r
53 private boolean pendingPrimitives = false;
\r
55 QuerySupportImpl(SessionImplSocket session, ClusterSupport clusterSupport, SerialisationSupport serializationSupport, SessionRequestManager syncThreads) {
\r
56 this.session = session;
\r
57 this.state = session.state;
\r
58 this.clusterTable = session.clusterTable;
\r
59 this.resourceSupport = session.resourceSupport;
\r
60 this.virtualGraphServerSupport = session.virtualGraphServerSupport;
\r
61 this.graphSession = session.graphSession;
\r
62 this.builtinSupport = session.builtinSupport;
\r
63 this.clusterSupport = clusterSupport;
\r
64 this.serializationSupport = serializationSupport;
\r
65 this.syncThreads = syncThreads;
\r
66 this.root = getBuiltin("http:/");
\r
67 assert(this.session != null);
\r
68 assert(this.state != null);
\r
69 assert(this.clusterTable != null);
\r
70 assert(this.resourceSupport != null);
\r
71 assert(this.virtualGraphServerSupport != null);
\r
72 assert(this.graphSession != null);
\r
73 assert(this.builtinSupport != null);
\r
74 assert(this.clusterSupport != null);
\r
75 assert(this.serializationSupport != null);
\r
76 assert(this.syncThreads != null);
\r
80 public ResourceSupport getSupport() {
\r
81 return resourceSupport;
\r
85 public Statement getStatement(int s, int p, int o) {
\r
86 return getStatement(null, s, p, o);
\r
90 public Statement getStatement(ReadGraphImpl graph, int s, int p, int o) {
\r
91 Resource sr = getResource(s);
\r
92 Resource pr = getResource(p);
\r
93 Resource or = getResource(o);
\r
94 return new StandardStatement(sr, pr, or);
\r
98 public Session getSession() {
\r
103 public long getClusterId(int id) {
\r
104 ClusterI cluster = clusterTable.getClusterByResourceKey(id);
\r
105 if(cluster == null) return 0;
\r
106 return cluster.getClusterId();
\r
110 public boolean isImmutable(int id) {
\r
111 // Virtuals are mutable
\r
112 if(id < 0) return false;
\r
113 // Root library is mutable
\r
114 if(root == id) return false;
\r
115 // Anything goes in service mode
\r
116 if(session.serviceMode > 0) return false;
\r
117 return clusterTable.isImmutable(id);
\r
121 public int getId(Resource resource) {
\r
122 if (resource instanceof ResourceImpl)
\r
123 return ((ResourceImpl)resource).id;
\r
128 public Resource getResource(int id) {
\r
130 return serializationSupport.getResource(id);
\r
131 } catch (DatabaseException e) {
\r
132 e.printStackTrace();
\r
138 public boolean resume(ReadGraphImpl graph) {
\r
140 return syncThreads.session.queryProvider2.resume(graph);
\r
145 // final public void sync(int resumeThread, final SessionRunnable runnable) {
\r
147 // syncThreads.session.queryProvider2.schedule(Integer.MIN_VALUE, new SessionTask(resumeThread) {
\r
150 // public void run(int thread) {
\r
151 // runnable.run(thread);
\r
159 // final public int nextSyncThread() {
\r
160 // throw new Error();
\r
161 //// return syncThreads.nextThread();
\r
165 public void dirtyPrimitives() {
\r
166 session.dirtyPrimitives = true;
\r
167 if(state.getWriteCount() == 0 && !pendingPrimitives) {
\r
168 pendingPrimitives = true;
\r
169 session.asyncRequest(new WriteRequest() {
\r
172 public void perform(WriteGraph graph) throws DatabaseException {
\r
173 pendingPrimitives = false;
\r
182 final public void aboutToRead() {
\r
186 // public void increaseReferenceCount(int callerThread, int subject) {
\r
187 // if (subject < 0)
\r
189 // ClusterI proxy = clusterTable.getClusterByResourceKey(subject);
\r
190 // if (null == proxy)
\r
192 // proxy.increaseReferenceCount(callerThread, 1);
\r
196 // public void decreaseReferenceCount(int callerThread, int subject) {
\r
197 // if (subject < 0)
\r
199 // ClusterProxy proxy = clusterTable.getClusterByResourceKey(subject);
\r
200 // if (null == proxy)
\r
202 // proxy.decreaseReferenceCount(callerThread, 1);
\r
206 public void getObjects4(final ReadGraphImpl graph, final int subject, final ForEachObjectProcedure procedure) {
\r
210 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
211 for (final int id : g.getObjects(subject, procedure.predicateKey)) {
\r
213 // int suggestSchedule = graph.processor.processor.resourceThread(id);
\r
214 // if(graph.callerThread == suggestSchedule) {
\r
215 procedure.execute(graph, new ResourceImpl(resourceSupport, id));
\r
217 // graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {
\r
220 // public void run(int thread) {
\r
221 // procedure.execute(graph.newAsync(thread), new ResourceImpl(resourceSupport, id));
\r
229 procedure.finished(graph);
\r
235 final ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);
\r
236 if(!cluster.isLoaded()) {
\r
237 cluster.load(session.clusterTranslator, new Runnable() {
\r
240 public void run() {
\r
241 getObjects4(graph, subject, procedure);
\r
248 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {
\r
250 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
251 for (final int id : g.getObjects(subject, procedure.predicateKey)) {
\r
252 // int suggestSchedule = graph.processor.processor.resourceThread(id);
\r
253 // if(graph.callerThread == suggestSchedule) {
\r
254 procedure.execute(graph, new ResourceImpl(resourceSupport, id));
\r
256 // graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {
\r
259 // public void run(int thread) {
\r
260 // procedure.execute(graph.newAsync(thread), new ResourceImpl(resourceSupport, id));
\r
269 cluster.forObjects(graph, subject, procedure);
\r
270 } catch (DatabaseException e) {
\r
271 e.printStackTrace();
\r
277 cluster.forObjects(graph, subject, procedure);
\r
278 } catch (DatabaseException e) {
\r
279 e.printStackTrace();
\r
286 public <C> void getObjects4(final ReadGraphImpl graph, final int subject, final C context, final ForEachObjectContextProcedure<C> procedure) {
\r
290 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
291 for (final int id : g.getObjects(subject, procedure.predicateKey)) {
\r
293 // int suggestSchedule = graph.processor.processor.resourceThread(id);
\r
294 // if(graph.callerThread == suggestSchedule) {
\r
295 procedure.execute(graph, context, new ResourceImpl(resourceSupport, id));
\r
297 // graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {
\r
300 // public void run(int thread) {
\r
301 // procedure.execute(graph.newAsync(thread), context, new ResourceImpl(resourceSupport, id));
\r
309 procedure.finished(graph);
\r
315 final ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);
\r
316 if(!cluster.isLoaded()) {
\r
317 cluster.load(session.clusterTranslator, new Runnable() {
\r
320 public void run() {
\r
321 getObjects4(graph, subject, context, procedure);
\r
328 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {
\r
330 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
331 for (final int id : g.getObjects(subject, procedure.predicateKey)) {
\r
332 // int suggestSchedule = graph.processor.processor.resourceThread(id);
\r
333 // if(graph.callerThread == suggestSchedule) {
\r
334 procedure.execute(graph, context, new ResourceImpl(resourceSupport, id));
\r
336 // graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {
\r
339 // public void run(int thread) {
\r
340 // procedure.execute(graph.newAsync(thread), context, new ResourceImpl(resourceSupport, id));
\r
349 cluster.forObjects(graph, subject, context, procedure);
\r
350 } catch (DatabaseException e) {
\r
351 e.printStackTrace();
\r
357 cluster.forObjects(graph, subject, context, procedure);
\r
358 } catch (DatabaseException e) {
\r
359 e.printStackTrace();
\r
367 public int getSingleInstance(final int subject) {
\r
369 // Do not process this information for virtual resources
\r
370 if(subject < 0) return 0;
\r
372 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
373 if (cluster == null)
\r
374 System.out.println("null cluster: " + Integer.toString(subject, 16));
\r
375 assert (cluster != null);
\r
379 ClusterI.CompleteTypeEnum type = cluster.getCompleteType(subject, clusterSupport);
\r
380 if(ClusterI.CompleteTypeEnum.InstanceOf == type) {
\r
381 int result = cluster.getCompleteObjectKey(subject, clusterSupport);
\r
382 assert(result > 0);
\r
388 } catch (DatabaseException e) {
\r
390 Logger.defaultLogError(e);
\r
394 // This happens is the resource is bogus
\r
395 catch (Throwable t) {
\r
397 analyseProblem(cluster);
\r
399 Logger.defaultLogError(t);
\r
408 public int getSingleSuperrelation(final int subject) {
\r
410 // Do not process this information for virtual resources
\r
411 if(subject < 0) return 0;
\r
413 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
414 if (cluster == null)
\r
415 System.out.println("null cluster: " + Integer.toString(subject, 16));
\r
416 assert (cluster != null);
\r
420 ClusterI.CompleteTypeEnum type = cluster.getCompleteType(subject, clusterSupport);
\r
421 if(ClusterI.CompleteTypeEnum.SubrelationOf == type) {
\r
422 int result = cluster.getCompleteObjectKey(subject, clusterSupport);
\r
423 assert(result > 0);
\r
429 } catch (DatabaseException e) {
\r
431 Logger.defaultLogError(e);
\r
439 // public void getSingleSuperrelation(ReadGraphImpl graph, final int subject, final AsyncProcedure<Resource> procedure) {
\r
441 // // Do not process this information for virtual resources
\r
442 // if(subject < 0) {
\r
443 // procedure.execute(graph, null);
\r
444 // graph.state.barrier.dec();
\r
448 // final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
449 // if (cluster == null)
\r
450 // System.out.println("null cluster: " + Integer.toString(subject, 16));
\r
452 // assert (cluster != null);
\r
454 // if(!cluster.isLoaded()) {
\r
456 // procedure.execute(graph, null);
\r
457 // graph.state.barrier.dec();
\r
460 //// queryProvider2.requestCluster(callerThread, cluster.getClusterId(), new Callback<Integer>() {
\r
463 //// public void run(Integer i) {
\r
465 //// queryProvider2.schedule(i, callerThread, new Runnable() {
\r
468 //// public void run() {
\r
472 //// ClusterI.CompleteTypeEnum type = cluster.getCompleteType(callerThread, subject, SessionImplSocket.this);
\r
473 //// if(ClusterI.CompleteTypeEnum.SubrelationOf == type) {
\r
474 //// int result = cluster.getCompleteObjectKey(callerThread, subject, SessionImplSocket.this);
\r
475 //// assert(result > 0);
\r
476 //// procedure.execute(graph, getResourceByKey(result));
\r
478 //// procedure.execute(graph, null);
\r
480 //// graph.state.barrier.dec();
\r
482 //// } catch (DatabaseException e) {
\r
483 //// e.printStackTrace();
\r
498 // ClusterI.CompleteTypeEnum type = cluster.getCompleteType(graph.callerThread, subject, clusterSupport);
\r
499 // if(ClusterI.CompleteTypeEnum.SubrelationOf == type) {
\r
500 // int result = cluster.getCompleteObjectKey(graph.callerThread, subject, clusterSupport);
\r
501 // assert(result > 0);
\r
502 // procedure.execute(graph, new ResourceImpl(resourceSupport, result));
\r
504 // procedure.execute(graph, null);
\r
506 // graph.state.barrier.dec();
\r
508 // } catch (DatabaseException e) {
\r
509 // e.printStackTrace();
\r
518 // public void getObjects2(final int callerThread, final int subject, final int predicate, final IntProcedure procedure) {
\r
519 // ensureLoaded(callerThread, subject, predicate, new Runnable() {
\r
522 // public void run() {
\r
523 // safeGetObjects2(callerThread, subject, predicate, procedure);
\r
529 // public void safeGetObjects2(final ReadGraphImpl graph, final int subject, final int predicate, final IntProcedure procedure) {
\r
531 // assert (subject != 0);
\r
532 // assert (predicate != 0);
\r
533 //// System.out.println("getObjects2: s=" + subject + "p=" + predicate);
\r
534 // Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
535 // if (providers != null) {
\r
537 // final TIntHashSet result = new TIntHashSet(16);
\r
539 // for (VirtualGraph provider : providers) {
\r
541 // for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {
\r
543 // if (result.add(id)) {
\r
544 // procedure.execute(graph, id);
\r
551 // if (subject < 0)
\r
554 // final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
556 // assert (testCluster(subject, cluster));
\r
558 // // wheels within wheels
\r
559 // final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {
\r
562 // public boolean execute(int callerThread, Object context, int object) {
\r
564 // if (result.add(object)) {
\r
565 // procedure.execute(graph.newAsync(callerThread), object);
\r
568 // return false; // continue looping
\r
573 // public boolean found() {
\r
574 // throw new UnsupportedOperationException();
\r
580 // cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);
\r
581 // } catch (DatabaseException e) {
\r
582 // Logger.defaultLogError(e);
\r
583 // } catch (Throwable t) {
\r
584 // Logger.defaultLogError(t);
\r
585 // t.printStackTrace();
\r
591 // assert(subject > 0);
\r
593 // final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
595 // assert (testCluster(subject, cluster));
\r
598 // cluster.forObjects(graph.callerThread, subject, predicate, new Wheels(procedure), null, clusterSupport);
\r
599 // } catch (DatabaseException e) {
\r
600 // Logger.defaultLogError(e);
\r
601 // } catch (Throwable t) {
\r
602 // t.printStackTrace();
\r
603 // Logger.defaultLogError(t);
\r
609 public boolean getObjects(final ReadGraphImpl graph, final int subject, final int predicate, final IntProcedure procedure) {
\r
611 assert (subject != 0);
\r
612 assert (predicate != 0);
\r
616 boolean found = false;
\r
618 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
619 for (final int id : g.getObjects(subject, predicate)) {
\r
621 procedure.execute(graph, id);
\r
629 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
630 assert(cluster.isLoaded());
\r
632 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {
\r
634 final DataContainer<Boolean> found = new DataContainer<Boolean>(Boolean.FALSE);
\r
635 final TIntHashSet result = new TIntHashSet(5);
\r
637 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
638 for (final int id : g.getObjects(subject, predicate)) {
\r
641 if (result.add(id)) {
\r
642 procedure.execute(graph, id);
\r
648 // Virtual predicates are not found from persistent clusters
\r
649 if(predicate < 0) return found.get();
\r
651 // wheels within wheels
\r
652 final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {
\r
655 public boolean execute(Object context, int object) {
\r
658 if (result.add(object)) {
\r
659 procedure.execute(graph, object);
\r
662 return false; // continue looping
\r
669 cluster.forObjects(subject, predicate, proc, null, clusterSupport);
\r
670 } catch (DatabaseException e) {
\r
671 e.printStackTrace();
\r
674 return found.get();
\r
678 // Virtual predicates are not found from persistent clusters
\r
679 if(predicate < 0) return false;
\r
681 class A implements ClusterI.ObjectProcedure<Object> {
\r
683 boolean found = false;
\r
686 public boolean execute(Object context, int object) {
\r
689 procedure.execute(graph, object);
\r
691 return false; // continue looping
\r
695 public boolean found() {
\r
701 // wheels within wheels
\r
702 final A proc = new A();
\r
705 cluster.forObjects(subject, predicate, proc, null, clusterSupport);
\r
706 } catch (DatabaseException e) {
\r
707 e.printStackTrace();
\r
709 // This happens if resource is bogus
\r
710 catch (Throwable t) {
\r
712 analyseProblem(cluster);
\r
714 Logger.defaultLogError(t);
\r
718 return proc.found();
\r
725 // public boolean getFunctionalObject(final ReadGraphImpl graph, final int subject, final int predicate,
\r
726 // final IntProcedure procedure) {
\r
728 // assert (subject != 0);
\r
729 // assert (predicate != 0);
\r
731 // if(subject < 0) {
\r
733 // boolean found = false;
\r
735 // Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
736 // if (providers != null) {
\r
738 // for (VirtualGraph provider : providers) {
\r
740 // for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {
\r
742 // procedure.execute(graph, id);
\r
753 // final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
755 // if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {
\r
757 // final DataContainer<Boolean> found = new DataContainer<Boolean>(false);
\r
758 // final TIntHashSet result = new TIntHashSet(5);
\r
760 // Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
761 // if (providers != null) {
\r
763 // for (VirtualGraph provider : providers) {
\r
765 // for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {
\r
766 // found.set(true);
\r
767 // procedure.execute(graph, id);
\r
774 // // wheels within wheels
\r
775 // final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {
\r
778 // public boolean execute(int callerThread, Object context, int object) {
\r
780 // found.set(true);
\r
781 // System.out.println("-found object " + object);
\r
782 // if (result.add(object)) {
\r
783 // procedure.execute(graph.newAsync(callerThread), object);
\r
786 // return false; // continue looping
\r
791 // public boolean found() {
\r
792 // throw new UnsupportedOperationException();
\r
798 // cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);
\r
799 // } catch (DatabaseException e) {
\r
800 // Logger.defaultLogError(e);
\r
802 // } catch (Throwable t) {
\r
803 // Logger.defaultLogError(t);
\r
804 // t.printStackTrace();
\r
807 // return found.get();
\r
811 // // wheels within wheels
\r
812 // final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {
\r
814 // boolean found = false;
\r
817 // public boolean execute(int callerThread, Object context, int object) {
\r
820 // procedure.execute(graph.newAsync(callerThread), object);
\r
821 // return false; // continue looping
\r
826 // public boolean found() {
\r
831 // public String toString() {
\r
832 // return "Wheels for " + procedure;
\r
838 // cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);
\r
839 // } catch (DatabaseException e) {
\r
840 // Logger.defaultLogError(e);
\r
842 // } catch (Throwable t) {
\r
843 // t.printStackTrace();
\r
844 // Logger.defaultLogError(t);
\r
848 // return proc.found();
\r
855 public int getFunctionalObject(final int subject, final int predicate) {
\r
857 assert (subject != 0);
\r
858 assert (predicate != 0);
\r
864 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
865 if (providers != null) {
\r
867 for (VirtualGraph provider : providers) {
\r
869 for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {
\r
870 if(found == 0) found = id;
\r
879 // if(found == -1) return 0;
\r
880 // else return found;
\r
884 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
886 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {
\r
889 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
890 if (providers != null) {
\r
892 for (VirtualGraph provider : providers) {
\r
894 for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {
\r
895 if(result == 0) result = id;
\r
903 if(result != 0) return result;
\r
906 return cluster.getSingleObject(subject, predicate, clusterSupport);
\r
907 } catch (DatabaseException e) {
\r
914 return cluster.getSingleObject(subject, predicate, clusterSupport);
\r
915 } catch (DatabaseException e) {
\r
918 // This comes if the resource is bogus
\r
919 catch (Throwable t) {
\r
921 analyseProblem(cluster);
\r
923 Logger.defaultLogError(t);
\r
934 // public boolean getStatements(final ReadGraphImpl graph, final int subject, final int predicate,
\r
935 // final TripleIntProcedure procedure, final Statements entry) {
\r
937 // assert (subject != 0);
\r
938 // assert (predicate != 0);
\r
940 // final TIntHashSet result = new TIntHashSet(16);
\r
941 // final DataContainer<Boolean> found = new DataContainer<Boolean>(false);
\r
943 // Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
945 // if (providers != null) {
\r
947 // for (VirtualGraph provider : providers) {
\r
949 // for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {
\r
951 // found.set(true);
\r
953 // if (result.add(id)) {
\r
954 // if (null != entry) {
\r
955 // entry.addOrSet(subject, predicate, id);
\r
956 // procedure.execute(graph, subject, predicate, id);
\r
957 // return true; // break;
\r
959 // procedure.execute(graph, subject, predicate, id);
\r
969 // if (subject < 0)
\r
970 // return found.get();
\r
972 // final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
973 // assert (cluster != null);
\r
975 // // wheels within wheels
\r
976 // final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {
\r
978 // public boolean execute(int callerThread, Object context, int object) {
\r
980 // found.set(true);
\r
982 // if (result.add(object)) {
\r
983 // if (null != entry) {
\r
984 // entry.addOrSet(subject, predicate, object);
\r
985 // procedure.execute(graph.newAsync(callerThread), subject, predicate, object);
\r
986 // return true; // break;
\r
988 // procedure.execute(graph.newAsync(callerThread), subject, predicate, object);
\r
992 // return false; // continue looping
\r
997 // public boolean found() {
\r
998 // throw new UnsupportedOperationException();
\r
1004 // cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);
\r
1005 // } catch (DatabaseException e) {
\r
1006 // Logger.defaultLogError(e);
\r
1008 // return found.get();
\r
1013 public org.simantics.db.DirectStatements getStatements(final ReadGraphImpl graph, final int subject, final QueryProcessor processor, boolean ignoreVirtual) {
\r
1015 assert (subject != 0);
\r
1017 final DirectStatementsImpl result = new DirectStatementsImpl(resourceSupport, subject);
\r
1019 if (!ignoreVirtual) {
\r
1020 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
1021 if (providers != null) {
\r
1022 for (TransientGraph provider : providers) {
\r
1023 for (int p : provider.getPredicates(subject)) {
\r
1024 for (int o : provider.getObjects(subject, p)) {
\r
1025 result.addStatement(p, o);
\r
1032 if (subject < 0) {
\r
1035 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
1036 assert (cluster != null);
\r
1037 doGetStatements(graph, cluster, subject, result);
\r
1045 // public void getStatements(ReadGraphImpl graph, final int subject, final Procedure<DirectStatements> procedure) {
\r
1047 // procedure.exception(new DatabaseException("Not supported"));
\r
1052 public void getPredicates(final ReadGraphImpl graph, final int subject, final IntProcedure procedure) {
\r
1054 final TIntHashSet result = new TIntHashSet(16);
\r
1056 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);
\r
1058 if (providers != null) {
\r
1060 for (VirtualGraph provider : providers) {
\r
1062 for (int id : ((VirtualGraphImpl)provider).getPredicates(subject)) {
\r
1064 if (result.add(id)) {
\r
1065 procedure.execute(graph, id);
\r
1074 if (subject < 0) {
\r
1075 procedure.finished(graph);
\r
1079 ClusterI proxy = clusterTable.getClusterByResourceKey(subject);
\r
1080 // if(!proxy.isLoaded()) {
\r
1082 // proxy.load(callerThread, session, new Runnable() {
\r
1085 // public void run() {
\r
1086 // getPredicates(callerThread, subject, procedure);
\r
1093 assert (proxy != null);
\r
1095 final DataContainer<Integer> got = new DataContainer<Integer>(0);
\r
1096 ClusterI.PredicateProcedure<Object> proc = new ClusterI.PredicateProcedure<Object>() {
\r
1098 public boolean execute(Object context, int predicate, int oi) {
\r
1099 if (result.add(predicate)) {
\r
1100 procedure.execute(graph, predicate);
\r
1102 got.set(got.get() + 1);
\r
1103 return false; // continue looping
\r
1107 proxy.forPredicates(subject, proc, null, clusterSupport);
\r
1108 } catch (DatabaseException e) {
\r
1109 Logger.defaultLogError(e);
\r
1111 procedure.finished(graph);
\r
1118 // public void getValue(ReadGraphImpl graph, int resource, InternalProcedure<byte[]> procedure) {
\r
1120 // if(resource < 0) {
\r
1122 // Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);
\r
1124 // if (providers != null) {
\r
1126 // for (VirtualGraph provider : providers) {
\r
1128 // Object value = ((VirtualGraphImpl)provider).getValue(resource);
\r
1129 // if (value != null) {
\r
1130 // procedure.execute(graph, (byte[])value);
\r
1142 // ClusterI cluster = clusterTable.getClusterByResourceKey(resource);
\r
1143 // if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(resource)) {
\r
1145 // Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);
\r
1147 // if (providers != null) {
\r
1149 // for (VirtualGraph provider : providers) {
\r
1151 // Object value = ((VirtualGraphImpl)provider).getValue(resource);
\r
1152 // if (value != null) {
\r
1153 // procedure.execute(graph, (byte[])value);
\r
1163 // byte[] data = cluster.getValue(resource, clusterSupport);
\r
1164 // if (null == data || 0 == data.length) {
\r
1165 // procedure.execute(graph, null);
\r
1167 // procedure.execute(graph, data);
\r
1170 // } catch (DatabaseException e) {
\r
1171 // Logger.defaultLogError(e);
\r
1178 // byte[] data = cluster.getValue(resource, clusterSupport);
\r
1179 // if (null == data || 0 == data.length) {
\r
1180 // procedure.execute(graph, null);
\r
1182 // procedure.execute(graph, data);
\r
1185 // } catch (DatabaseException e) {
\r
1186 // Logger.defaultLogError(e);
\r
1195 public byte[] getValue(ReadGraphImpl graph, int resource) {
\r
1197 if(resource < 0) {
\r
1199 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);
\r
1201 if (providers != null) {
\r
1203 for (VirtualGraph provider : providers) {
\r
1205 Object value = ((VirtualGraphImpl)provider).getValue(resource);
\r
1206 if (value != null) {
\r
1207 return (byte[])value;
\r
1218 ClusterI cluster = clusterTable.getClusterByResourceKey(resource);
\r
1219 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(resource)) {
\r
1221 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);
\r
1223 if (providers != null) {
\r
1225 for (VirtualGraph provider : providers) {
\r
1227 Object value = ((VirtualGraphImpl)provider).getValue(resource);
\r
1228 if (value != null) {
\r
1229 return (byte[])value;
\r
1238 byte[] data = cluster.getValue(resource, clusterSupport);
\r
1239 if (null != data && 0 != data.length) {
\r
1243 } catch (DatabaseException e) {
\r
1244 Logger.defaultLogError(e);
\r
1253 byte[] data = cluster.getValue(resource, clusterSupport);
\r
1254 if (null != data && 0 != data.length) {
\r
1258 } catch (DatabaseException e) {
\r
1259 Logger.defaultLogError(e);
\r
1269 public InputStream getValueStream(ReadGraphImpl graph, int resource) {
\r
1271 if(resource < 0) {
\r
1273 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);
\r
1275 if (providers != null) {
\r
1277 for (VirtualGraph provider : providers) {
\r
1279 Object value = ((VirtualGraphImpl)provider).getValue(resource);
\r
1280 if (value != null) {
\r
1281 return new ByteArrayInputStream((byte[])value);
\r
1292 ClusterI cluster = clusterTable.getClusterByResourceKey(resource);
\r
1293 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(resource)) {
\r
1295 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);
\r
1297 if (providers != null) {
\r
1299 for (VirtualGraph provider : providers) {
\r
1301 Object value = ((VirtualGraphImpl)provider).getValue(resource);
\r
1302 if (value != null) {
\r
1303 return new ByteArrayInputStream((byte[])value);
\r
1312 return cluster.getValueStream(resource, clusterSupport);
\r
1314 } catch (DatabaseException e) {
\r
1315 Logger.defaultLogError(e);
\r
1324 return cluster.getValueStream(resource, clusterSupport);
\r
1326 } catch (DatabaseException e) {
\r
1327 Logger.defaultLogError(e);
\r
1337 public void requestCluster(ReadGraphImpl graph, final long clusterId, final Runnable r) {
\r
1339 class CallbackAdapter implements Callback<DatabaseException> {
\r
1341 CallbackAdapter(final Runnable r) {
\r
1345 public void run(DatabaseException e) {
\r
1347 e.printStackTrace();
\r
1354 double p = clusterTable.getLoadProbability();
\r
1355 // System.out.print("Load cluster " + clusterId + " with probability " + p +
\r
1357 final ClusterI proxy = clusterSupport.getClusterByClusterId(clusterId);
\r
1358 if (!proxy.isLoaded()) {
\r
1359 clusterTable.gc();
\r
1360 if (Math.random() < p) {
\r
1361 proxy.load(new CallbackAdapter(r));
\r
1372 public int getBuiltin(String uri) {
\r
1373 return builtinSupport.getBuiltin(uri);
\r
1377 public void checkTasks() {
\r
1378 System.out.println(syncThreads.toString());
\r
1382 // public void asyncWrite(Write request) {
\r
1384 //// if(plainWrite(writer) && sameProvider(request)) {
\r
1385 //// writer.writeSupport.pushRequest(request);
\r
1387 // asyncRequest(request);
\r
1398 private void doGetStatements(ReadGraphImpl graph, final ClusterI cluster, final int subject, final DirectStatementsImpl result) {
\r
1400 final class Proc implements ClusterI.PredicateProcedure<Object> {
\r
1403 public boolean execute(Object context, final int predicate, final int objectIndex) {
\r
1405 doExecute(null, predicate, objectIndex);
\r
1410 private void doExecute(Object context, final int predicate, final int objectIndex) {
\r
1413 cluster.forObjects(subject, predicate, new ClusterI.ObjectProcedure<Object>() {
\r
1416 public boolean execute(Object context, int object) {
\r
1417 result.addStatement(predicate, object);
\r
1421 }, null, clusterSupport);
\r
1422 } catch (DatabaseException e) {
\r
1423 e.printStackTrace();
\r
1431 cluster.forPredicates(subject, new Proc(), null, clusterSupport);
\r
1432 } catch (DatabaseException e) {
\r
1433 e.printStackTrace();
\r
1438 // private void getDirectObjects4(final int callerThread, final ClusterI cluster, final int subject, final int predicate, final QueryProcessor processor, final ReadGraphImpl graph, final ForEachObjectProcedure procedure) {
\r
1440 // if(!cluster.isLoaded()) {
\r
1442 // requestCluster(callerThread, cluster.getClusterId(), new Callback<Integer>() {
\r
1445 // public void run(Integer i) {
\r
1447 // processor.schedule(i, new SessionTask(callerThread) {
\r
1450 // public void run(int thread) {
\r
1452 // getDirectObjects4(thread, cluster, subject, predicate, processor, graph, procedure);
\r
1465 // cluster.forObjects(graph, subject, predicate, procedure);
\r
1466 // } catch (DatabaseException e) {
\r
1467 // e.printStackTrace();
\r
1470 //// procedure.finished(graph);
\r
1471 //// graph.state.barrier.dec();
\r
1473 //// System.err.println("ai2=" + ai2.decrementAndGet());
\r
1480 // AtomicInteger ai2 =new AtomicInteger(0);
\r
1482 // private boolean testCluster(int subject, ClusterI proxy) {
\r
1484 // if (proxy == null)
\r
1485 // System.out.println("null cluster: " + Integer.toString(subject, 16));
\r
1487 // return proxy != null;
\r
1491 long getCluster(int id) {
\r
1492 // Virtual resource
\r
1493 if(id < 0) return 0;
\r
1494 ClusterI proxy = clusterTable.getClusterByResourceKey(id);
\r
1495 if(proxy == null) return 0;
\r
1496 else return proxy.getClusterId();
\r
1500 public int getRandomAccessReference(String id) throws ResourceNotFoundException {
\r
1503 Resource res = serializationSupport.getResourceSerializer().getResource(id);
\r
1504 if(res == null) return 0;
\r
1505 else return ((ResourceImpl)res).id;
\r
1506 } catch (InvalidResourceReferenceException e) {
\r
1507 //e.printStackTrace();
\r
1514 public void ensureLoaded(final ReadGraphImpl graph, final int subject, final int predicate) {
\r
1518 SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, predicate, new Callback<ReadGraphImpl>() {
\r
1521 public void run(ReadGraphImpl parameter) {
\r
1528 final ClusterI cluster = clusterTable.checkedGetClusterByResourceKey(subject);
\r
1530 if(cluster.isLoaded()) {
\r
1532 if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject, predicate)) {
\r
1534 SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, predicate, new Callback<ReadGraphImpl>() {
\r
1537 public void run(ReadGraphImpl parameter) {
\r
1548 new Exception().printStackTrace();
\r
1550 cluster.load(session.clusterTranslator, new Runnable() {
\r
1553 public void run() {
\r
1555 if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject, predicate)) {
\r
1557 SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, predicate, new Callback<ReadGraphImpl>() {
\r
1560 public void run(ReadGraphImpl parameter) {
\r
1581 public void ensureLoaded(final ReadGraphImpl graph, final int subject) {
\r
1585 SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, new Callback<ReadGraphImpl>() {
\r
1588 public void run(ReadGraphImpl parameter) {
\r
1595 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
1597 if(cluster.isLoaded()) {
\r
1599 if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject)) {
\r
1601 SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, new Callback<ReadGraphImpl>() {
\r
1604 public void run(ReadGraphImpl parameter) {
\r
1615 // System.err.println("cluster not loaded " + subject);
\r
1616 new Exception().printStackTrace();
\r
1618 cluster.load(session.clusterTranslator, new Runnable() {
\r
1621 public void run() {
\r
1623 if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject)) {
\r
1625 SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, new Callback<ReadGraphImpl>() {
\r
1628 public void run(ReadGraphImpl parameter) {
\r
1649 public boolean isLoaded(int subject) {
\r
1650 ClusterI cluster = clusterTable.getClusterByResourceKey(subject);
\r
1651 return cluster.isLoaded();
\r
1655 public void ceased(int thread) {
\r
1657 session.ceased(thread);
\r
1662 public Object getLock() {
\r
1664 return session.requestManager;
\r
1669 public VirtualGraph getProvider(int subject, int predicate, int object) {
\r
1672 ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);
\r
1673 // This persistent resource does not have virtual statements => must deny in persistent graph
\r
1674 if(!cluster.hasVirtual() || !virtualGraphServerSupport.virtuals.contains(subject)) return null;
\r
1677 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
1678 for (final int id : g.getObjects(subject, predicate)) {
\r
1679 if(object == id) return g;
\r
1683 // Nothing found from virtual graphs
\r
1689 public VirtualGraph getProvider(int subject, int predicate) {
\r
1692 ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);
\r
1693 // This persistent resource does not have virtual statements => must deny in persistent graph
\r
1694 if(!cluster.hasVirtual() || !virtualGraphServerSupport.virtuals.contains(subject)) return null;
\r
1697 TransientGraph result = null;
\r
1698 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
1699 if(g.getObjects(subject, predicate).length > 0) {
\r
1700 // Found multiple, return null;
\r
1701 if(result != null) return null;
\r
1710 public VirtualGraph getValueProvider(int subject) {
\r
1713 ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);
\r
1714 // This persistent resource does not have virtual statements => must deny in persistent graph
\r
1715 if(!cluster.hasVirtual() || !virtualGraphServerSupport.virtuals.contains(subject)) return null;
\r
1718 TransientGraph result = null;
\r
1719 for(TransientGraph g : virtualGraphServerSupport.providers) {
\r
1720 if(g.getValue(subject) != null) {
\r
1721 if(result != null) return null;
\r
1730 public void exit(Throwable t) {
\r
1734 private void analyseProblem(ClusterI cluster) {
\r
1736 if(cluster instanceof ClusterSmall)
\r
1738 ((ClusterSmall)cluster).check();
\r
1739 } catch (DatabaseException e) {
\r
1740 e.printStackTrace();
\r