bundles/org.simantics.db.procore/src/fi/vtt/simantics/procore/internal/QuerySupportImpl.java

   1 package fi.vtt.simantics.procore.internal;\r
   2 \r
   3 import gnu.trove.set.hash.TIntHashSet;\r
   4 \r
   5 import java.io.ByteArrayInputStream;\r
   6 import java.io.InputStream;\r
   7 import java.util.Collection;\r
   8 \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
  38 \r
  39 public class QuerySupportImpl implements QuerySupport {\r
  40         \r
  41         final SessionImplSocket session;\r
  42         final State state;\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
  51         final int root;\r
  52 \r
  53     private boolean pendingPrimitives = false;\r
  54         \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
  77         }\r
  78 \r
  79         @Override\r
  80         public ResourceSupport getSupport() {\r
  81                 return resourceSupport;\r
  82         }\r
  83         \r
  84     @Override\r
  85     public Statement getStatement(int s, int p, int o) {\r
  86         return getStatement(null, s, p, o);\r
  87     }\r
  88 \r
  89     @Override\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
  95     }\r
  96 \r
  97         @Override\r
  98         public Session getSession() {\r
  99                 return session;\r
 100         }\r
 101 \r
 102     @Override\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
 107     }\r
 108     \r
 109     @Override\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
 118     }\r
 119 \r
 120     @Override\r
 121     public int getId(Resource resource) {\r
 122         if (resource instanceof ResourceImpl)\r
 123             return ((ResourceImpl)resource).id;\r
 124         return 0;\r
 125     }\r
 126 \r
 127         @Override\r
 128         public Resource getResource(int id) {\r
 129                 try {\r
 130                         return serializationSupport.getResource(id);\r
 131                 } catch (DatabaseException e) {\r
 132                         e.printStackTrace();\r
 133                 }\r
 134                 return null;\r
 135         }\r
 136 \r
 137         @Override\r
 138     public boolean resume(ReadGraphImpl graph) {\r
 139                 \r
 140                 return syncThreads.session.queryProvider2.resume(graph);\r
 141                 \r
 142     }\r
 143 \r
 144 //    @Override\r
 145 //    final public void sync(int resumeThread, final SessionRunnable runnable) {\r
 146 //      \r
 147 //      syncThreads.session.queryProvider2.schedule(Integer.MIN_VALUE, new SessionTask(resumeThread) {\r
 148 //\r
 149 //                      @Override\r
 150 //                      public void run(int thread) {\r
 151 //                              runnable.run(thread);\r
 152 //                      }\r
 153 //              \r
 154 //      });\r
 155 //      \r
 156 //    }\r
 157 \r
 158 //    @Override\r
 159 //    final public int nextSyncThread() {\r
 160 //      throw new Error();\r
 161 ////        return syncThreads.nextThread();\r
 162 //    }\r
 163 \r
 164         @Override\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
 170 \r
 171                 @Override\r
 172                 public void perform(WriteGraph graph) throws DatabaseException {\r
 173                     pendingPrimitives = false;\r
 174                 }\r
 175                 \r
 176             });\r
 177         }\r
 178     }\r
 179 \r
 180     @Override\r
 181     @Deprecated\r
 182     final public void aboutToRead() {\r
 183     }\r
 184 \r
 185 //    @Override\r
 186 //    public void increaseReferenceCount(int callerThread, int subject) {\r
 187 //        if (subject < 0)\r
 188 //            return;\r
 189 //        ClusterI proxy = clusterTable.getClusterByResourceKey(subject);\r
 190 //        if (null == proxy)\r
 191 //            return;\r
 192 //        proxy.increaseReferenceCount(callerThread, 1);\r
 193 //    }\r
 194 //\r
 195 //    @Override\r
 196 //    public void decreaseReferenceCount(int callerThread, int subject) {\r
 197 //        if (subject < 0)\r
 198 //            return;\r
 199 //        ClusterProxy proxy = clusterTable.getClusterByResourceKey(subject);\r
 200 //        if (null == proxy)\r
 201 //            return;\r
 202 //        proxy.decreaseReferenceCount(callerThread, 1);\r
 203 //    }\r
 204 \r
 205 //      @Override\r
 206         public void getObjects4(final ReadGraphImpl graph, final int subject, final ForEachObjectProcedure procedure) {\r
 207                 \r
 208                 if(subject < 0) {\r
 209                         \r
 210                         for(TransientGraph g : virtualGraphServerSupport.providers) {\r
 211                 for (final int id : g.getObjects(subject, procedure.predicateKey)) {\r
 212 \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
 216 //                    } else {\r
 217 //                      graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {\r
 218 //              \r
 219 //                              @Override\r
 220 //                              public void run(int thread) {\r
 221 //                              procedure.execute(graph.newAsync(thread), new ResourceImpl(resourceSupport, id));\r
 222 //                              }\r
 223 //              \r
 224 //                      });\r
 225 //                    }\r
 226                         \r
 227                 }\r
 228                         }\r
 229                         procedure.finished(graph);\r
 230 //              graph.dec();\r
 231                 return;\r
 232                 \r
 233                 } \r
 234                 \r
 235         final ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);\r
 236         if(!cluster.isLoaded()) {\r
 237                 cluster.load(session.clusterTranslator, new Runnable() {\r
 238 \r
 239                                 @Override\r
 240                                 public void run() {\r
 241                                         getObjects4(graph, subject, procedure);\r
 242                                 }\r
 243                         \r
 244                 });\r
 245                 return;\r
 246         }\r
 247                 \r
 248                 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {\r
 249                         \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
 255 //                    } else {\r
 256 //                      graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {\r
 257 //              \r
 258 //                              @Override\r
 259 //                              public void run(int thread) {\r
 260 //                              procedure.execute(graph.newAsync(thread), new ResourceImpl(resourceSupport, id));\r
 261 //                              }\r
 262 //              \r
 263 //                      });\r
 264 //                    }\r
 265                 }\r
 266                         }\r
 267                         \r
 268                         try {\r
 269                                 cluster.forObjects(graph, subject, procedure);\r
 270                         } catch (DatabaseException e) {\r
 271                                 e.printStackTrace();\r
 272                         }\r
 273                         \r
 274                 } else {\r
 275                         \r
 276                         try {\r
 277                                 cluster.forObjects(graph, subject, procedure);\r
 278                         } catch (DatabaseException e) {\r
 279                                 e.printStackTrace();\r
 280                         }\r
 281                         \r
 282                 }\r
 283                 \r
 284         }\r
 285 \r
 286         public <C> void getObjects4(final ReadGraphImpl graph, final int subject, final C context, final ForEachObjectContextProcedure<C> procedure) {\r
 287                 \r
 288                 if(subject < 0) {\r
 289                         \r
 290                         for(TransientGraph g : virtualGraphServerSupport.providers) {\r
 291                 for (final int id : g.getObjects(subject, procedure.predicateKey)) {\r
 292 \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
 296 //                    } else {\r
 297 //                      graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {\r
 298 //              \r
 299 //                              @Override\r
 300 //                              public void run(int thread) {\r
 301 //                              procedure.execute(graph.newAsync(thread), context, new ResourceImpl(resourceSupport, id));\r
 302 //                              }\r
 303 //              \r
 304 //                      });\r
 305 //                    }\r
 306                         \r
 307                 }\r
 308                         }\r
 309                         procedure.finished(graph);\r
 310 //              graph.dec();\r
 311                 return;\r
 312                 \r
 313                 } \r
 314                 \r
 315         final ClusterImpl cluster = (ClusterImpl)clusterTable.getClusterByResourceKey(subject);\r
 316         if(!cluster.isLoaded()) {\r
 317                 cluster.load(session.clusterTranslator, new Runnable() {\r
 318 \r
 319                                 @Override\r
 320                                 public void run() {\r
 321                                         getObjects4(graph, subject, context, procedure);\r
 322                                 }\r
 323                         \r
 324                 });\r
 325                 return;\r
 326         }\r
 327                 \r
 328                 if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {\r
 329                         \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
 335 //                    } else {\r
 336 //                      graph.processor.processor.schedule(graph.callerThread, new SessionTask(suggestSchedule) {\r
 337 //              \r
 338 //                              @Override\r
 339 //                              public void run(int thread) {\r
 340 //                              procedure.execute(graph.newAsync(thread), context, new ResourceImpl(resourceSupport, id));\r
 341 //                              }\r
 342 //              \r
 343 //                      });\r
 344 //                    }\r
 345                 }\r
 346                         }\r
 347                         \r
 348                         try {\r
 349                                 cluster.forObjects(graph, subject, context, procedure);\r
 350                         } catch (DatabaseException e) {\r
 351                                 e.printStackTrace();\r
 352                         }\r
 353                         \r
 354                 } else {\r
 355                         \r
 356                         try {\r
 357                                 cluster.forObjects(graph, subject, context, procedure);\r
 358                         } catch (DatabaseException e) {\r
 359                                 e.printStackTrace();\r
 360                         }\r
 361                         \r
 362                 }\r
 363                 \r
 364         }\r
 365         \r
 366         @Override\r
 367     public int getSingleInstance(final int subject) {\r
 368         \r
 369         // Do not process this information for virtual resources\r
 370         if(subject < 0) return 0;\r
 371         \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
 376 \r
 377         try {\r
 378         \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
 383                         return result;\r
 384                 } else {\r
 385                         return 0;\r
 386                 }\r
 387         \r
 388         } catch (DatabaseException e) {\r
 389                 \r
 390                 Logger.defaultLogError(e);\r
 391                 return 0;\r
 392                 \r
 393         }\r
 394         // This happens is the resource is bogus\r
 395         catch (Throwable t) {\r
 396                 \r
 397                 analyseProblem(cluster);\r
 398                 \r
 399                 Logger.defaultLogError(t);\r
 400                 \r
 401                 return 0;\r
 402                 \r
 403         }\r
 404         \r
 405     }\r
 406 \r
 407         @Override\r
 408     public int getSingleSuperrelation(final int subject) {\r
 409         \r
 410         // Do not process this information for virtual resources\r
 411         if(subject < 0) return 0;\r
 412 \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
 417 \r
 418         try {\r
 419         \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
 424                         return result;\r
 425                 } else {\r
 426                         return 0;\r
 427                 }\r
 428         \r
 429         } catch (DatabaseException e) {\r
 430                 \r
 431                 Logger.defaultLogError(e);\r
 432                 return 0;\r
 433                 \r
 434         }\r
 435         \r
 436     }\r
 437 \r
 438 //      @Override\r
 439 //    public void getSingleSuperrelation(ReadGraphImpl graph, final int subject, final AsyncProcedure<Resource> procedure) {\r
 440 //      \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
 445 //              return;\r
 446 //      }\r
 447 //\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
 451 //        \r
 452 //        assert (cluster != null);\r
 453 //\r
 454 //        if(!cluster.isLoaded()) {\r
 455 //            \r
 456 //              procedure.execute(graph, null);\r
 457 //                      graph.state.barrier.dec();\r
 458 //              return;\r
 459 //\r
 460 ////            queryProvider2.requestCluster(callerThread, cluster.getClusterId(), new Callback<Integer>() {\r
 461 ////    \r
 462 ////                            @Override\r
 463 ////                            public void run(Integer i) {\r
 464 ////    \r
 465 ////                                    queryProvider2.schedule(i, callerThread, new Runnable() {\r
 466 ////    \r
 467 ////                                            @Override\r
 468 ////                                            public void run() {\r
 469 ////                                                    \r
 470 ////                                                    try  {\r
 471 ////                                                    \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
 477 ////                                                } else {\r
 478 ////                                                    procedure.execute(graph, null);\r
 479 ////                                                }\r
 480 ////                                                            graph.state.barrier.dec();\r
 481 ////                                                            \r
 482 ////                                                    } catch (DatabaseException e) {\r
 483 ////                                                            e.printStackTrace();\r
 484 ////                                                    }\r
 485 ////                                                    \r
 486 ////                                            }\r
 487 ////    \r
 488 ////                                    });\r
 489 ////    \r
 490 ////                            }\r
 491 ////    \r
 492 ////                    });\r
 493 //                      \r
 494 //        } else {\r
 495 //\r
 496 //              try {\r
 497 //\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
 503 //                      } else {\r
 504 //                              procedure.execute(graph, null);\r
 505 //                      }\r
 506 //                      graph.state.barrier.dec();\r
 507 //\r
 508 //              } catch (DatabaseException e) {\r
 509 //                      e.printStackTrace();\r
 510 //              }\r
 511 //                      \r
 512 //        }\r
 513 //        \r
 514 //        \r
 515 //    }\r
 516 \r
 517 //      @Override\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
 520 //\r
 521 //                      @Override\r
 522 //                      public void run() {\r
 523 //                              safeGetObjects2(callerThread, subject, predicate, procedure);\r
 524 //                      }\r
 525 //                      \r
 526 //              });\r
 527 //      }\r
 528 \r
 529 //    public void safeGetObjects2(final ReadGraphImpl graph, final int subject, final int predicate, final IntProcedure procedure) {\r
 530 //\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
 536 //\r
 537 //            final TIntHashSet result = new TIntHashSet(16);\r
 538 //\r
 539 //            for (VirtualGraph provider : providers) {\r
 540 //\r
 541 //                for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {\r
 542 //\r
 543 //                    if (result.add(id)) {\r
 544 //                      procedure.execute(graph, id);\r
 545 //                    }\r
 546 //\r
 547 //                }\r
 548 //\r
 549 //            }\r
 550 //\r
 551 //            if (subject < 0)\r
 552 //                return;\r
 553 //\r
 554 //            final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
 555 //\r
 556 //            assert (testCluster(subject, cluster));\r
 557 //            \r
 558 //            // wheels within wheels\r
 559 //            final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {\r
 560 //\r
 561 //                @Override\r
 562 //                public boolean execute(int callerThread, Object context, int object) {\r
 563 //\r
 564 //                    if (result.add(object)) {\r
 565 //                      procedure.execute(graph.newAsync(callerThread), object);\r
 566 //                    }\r
 567 //\r
 568 //                    return false; // continue looping\r
 569 //\r
 570 //                }\r
 571 //                \r
 572 //                              @Override\r
 573 //                              public boolean found() {\r
 574 //                                      throw new UnsupportedOperationException();\r
 575 //                              }\r
 576 //                \r
 577 //            };\r
 578 //\r
 579 //            try {\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
 586 //            }\r
 587 //            return;\r
 588 //            \r
 589 //        }\r
 590 //        \r
 591 //        assert(subject > 0);\r
 592 //\r
 593 //        final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
 594 //\r
 595 //        assert (testCluster(subject, cluster));\r
 596 //        \r
 597 //        try {\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
 604 //        }\r
 605 //        \r
 606 //    }\r
 607 \r
 608         @Override\r
 609     public boolean getObjects(final ReadGraphImpl graph, final int subject, final int predicate, final IntProcedure procedure) {\r
 610                 \r
 611                 assert (subject != 0);\r
 612                 assert (predicate != 0);\r
 613 \r
 614                 if(subject < 0) {\r
 615 \r
 616                         boolean found = false;\r
 617                         \r
 618                         for(TransientGraph g : virtualGraphServerSupport.providers) {\r
 619                                 for (final int id : g.getObjects(subject, predicate)) {\r
 620                                         found = true;\r
 621                                         procedure.execute(graph, id);\r
 622                                 }\r
 623                         }\r
 624                         \r
 625                         return found;\r
 626 \r
 627                 }\r
 628 \r
 629                 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
 630                 assert(cluster.isLoaded());\r
 631         \r
 632         if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {\r
 633                 \r
 634                 final DataContainer<Boolean> found = new DataContainer<Boolean>(Boolean.FALSE);\r
 635                 final TIntHashSet result = new TIntHashSet(5);\r
 636                 \r
 637                         for(TransientGraph g : virtualGraphServerSupport.providers) {\r
 638                                 for (final int id : g.getObjects(subject, predicate)) {\r
 639 \r
 640                                         found.set(true);\r
 641                                         if (result.add(id)) {\r
 642                                                 procedure.execute(graph, id);\r
 643                                         }\r
 644 \r
 645                                 }\r
 646                         }\r
 647                         \r
 648                         // Virtual predicates are not found from persistent clusters\r
 649                         if(predicate < 0) return found.get();\r
 650 \r
 651                 // wheels within wheels\r
 652                 final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {\r
 653 \r
 654                         @Override\r
 655                         public boolean execute(Object context, int object) {\r
 656 \r
 657                                 found.set(true);\r
 658                                 if (result.add(object)) {\r
 659                                         procedure.execute(graph, object);\r
 660                                 }\r
 661 \r
 662                                 return false; // continue looping\r
 663 \r
 664                         }\r
 665 \r
 666                 };\r
 667                         \r
 668                         try {\r
 669                 cluster.forObjects(subject, predicate, proc, null, clusterSupport);\r
 670                         } catch (DatabaseException e) {\r
 671                                 e.printStackTrace();\r
 672                         }\r
 673                         \r
 674                         return found.get();\r
 675                         \r
 676                 } else {\r
 677                         \r
 678                         // Virtual predicates are not found from persistent clusters\r
 679                         if(predicate < 0) return false;\r
 680                         \r
 681                         class A implements ClusterI.ObjectProcedure<Object> {\r
 682 \r
 683                         boolean found = false;\r
 684 \r
 685                         @Override\r
 686                         public boolean execute(Object context, int object) {\r
 687 \r
 688                                 found = true;\r
 689                                 procedure.execute(graph, object);\r
 690 \r
 691                                 return false; // continue looping\r
 692 \r
 693                         }\r
 694 \r
 695                                 public boolean found() {\r
 696                                         return found;\r
 697                                 }\r
 698 \r
 699                         }\r
 700                         \r
 701                 // wheels within wheels\r
 702                 final A proc = new A();\r
 703                 \r
 704                         try {\r
 705                 cluster.forObjects(subject, predicate, proc, null, clusterSupport);\r
 706                         } catch (DatabaseException e) {\r
 707                                 e.printStackTrace();\r
 708                         } \r
 709                         // This happens if resource is bogus\r
 710                         catch (Throwable t) {\r
 711                                 \r
 712                         analyseProblem(cluster);\r
 713                         \r
 714                         Logger.defaultLogError(t);\r
 715                                 \r
 716                         }\r
 717                 \r
 718                 return proc.found();\r
 719                         \r
 720                 }\r
 721         \r
 722     }\r
 723 \r
 724 //      @Override\r
 725 //    public boolean getFunctionalObject(final ReadGraphImpl graph, final int subject, final int predicate,\r
 726 //            final IntProcedure procedure) {\r
 727 //\r
 728 //        assert (subject != 0);\r
 729 //        assert (predicate != 0);\r
 730 //\r
 731 //        if(subject < 0) {\r
 732 //\r
 733 //              boolean found = false;\r
 734 //\r
 735 //              Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);\r
 736 //              if (providers != null) {\r
 737 //\r
 738 //                      for (VirtualGraph provider : providers) {\r
 739 //\r
 740 //                              for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {\r
 741 //                                      found = true;\r
 742 //                      procedure.execute(graph, id);\r
 743 //                    }\r
 744 //\r
 745 //                }\r
 746 //\r
 747 //            }\r
 748 //              \r
 749 //              return found;\r
 750 //              \r
 751 //        }\r
 752 //        \r
 753 //        final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
 754 //        \r
 755 //        if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {\r
 756 //        \r
 757 //              final DataContainer<Boolean> found = new DataContainer<Boolean>(false);\r
 758 //              final TIntHashSet result = new TIntHashSet(5);\r
 759 //\r
 760 //              Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);\r
 761 //              if (providers != null) {\r
 762 //\r
 763 //                      for (VirtualGraph provider : providers) {\r
 764 //\r
 765 //                              for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {\r
 766 //                                      found.set(true);\r
 767 //                      procedure.execute(graph, id);\r
 768 //                    }\r
 769 //\r
 770 //                }\r
 771 //\r
 772 //            }\r
 773 //              \r
 774 //            // wheels within wheels\r
 775 //            final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {\r
 776 //\r
 777 //                @Override\r
 778 //                public boolean execute(int callerThread, Object context, int object) {\r
 779 //\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
 784 //                    }\r
 785 //\r
 786 //                    return false; // continue looping\r
 787 //\r
 788 //                }\r
 789 //                \r
 790 //                              @Override\r
 791 //                              public boolean found() {\r
 792 //                                      throw new UnsupportedOperationException();\r
 793 //                              }\r
 794 //                \r
 795 //            };\r
 796 //            \r
 797 //            try {\r
 798 //                cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);\r
 799 //            } catch (DatabaseException e) {\r
 800 //                Logger.defaultLogError(e);\r
 801 //                return false;\r
 802 //            } catch (Throwable t) {\r
 803 //                Logger.defaultLogError(t);\r
 804 //              t.printStackTrace();\r
 805 //            }\r
 806 //            \r
 807 //            return found.get();\r
 808 //            \r
 809 //        } else {\r
 810 //\r
 811 //              // wheels within wheels\r
 812 //              final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {\r
 813 //                  \r
 814 //                      boolean found = false;\r
 815 //                      \r
 816 //                  @Override\r
 817 //                  public boolean execute(int callerThread, Object context, int object) {\r
 818 //      \r
 819 //                      found = true;\r
 820 //                      procedure.execute(graph.newAsync(callerThread), object);\r
 821 //                      return false; // continue looping\r
 822 //                      \r
 823 //                  }\r
 824 //                  \r
 825 //                              @Override\r
 826 //                              public boolean found() {\r
 827 //                                      return found;\r
 828 //                              }\r
 829 //                  \r
 830 //                  @Override\r
 831 //                  public String toString() {\r
 832 //                      return "Wheels for " + procedure;\r
 833 //                  }\r
 834 //                  \r
 835 //              };\r
 836 //              \r
 837 //              try {\r
 838 //                  cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);\r
 839 //              } catch (DatabaseException e) {\r
 840 //                  Logger.defaultLogError(e);\r
 841 //                  return false;\r
 842 //              } catch (Throwable t) {\r
 843 //                      t.printStackTrace();\r
 844 //                  Logger.defaultLogError(t);\r
 845 //                  return false;\r
 846 //              }\r
 847 //              \r
 848 //              return proc.found();\r
 849 //        \r
 850 //        }\r
 851 //        \r
 852 //    }\r
 853         \r
 854         @Override\r
 855     public int getFunctionalObject(final int subject, final int predicate) {\r
 856 \r
 857         assert (subject != 0);\r
 858         assert (predicate != 0);\r
 859 \r
 860         if(subject < 0) {\r
 861 \r
 862                 int found = 0;\r
 863 \r
 864                 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);\r
 865                 if (providers != null) {\r
 866 \r
 867                         for (VirtualGraph provider : providers) {\r
 868 \r
 869                                 for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {\r
 870                                         if(found == 0) found = id;\r
 871                                         else found = -1;\r
 872                     }\r
 873 \r
 874                 }\r
 875 \r
 876             }\r
 877                 \r
 878                 return found;\r
 879 //              if(found == -1) return 0;\r
 880 //              else return found;\r
 881                 \r
 882         }\r
 883         \r
 884         final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
 885         \r
 886         if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject)) {\r
 887 \r
 888                 int result = 0;\r
 889                 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);\r
 890                 if (providers != null) {\r
 891 \r
 892                         for (VirtualGraph provider : providers) {\r
 893 \r
 894                                 for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {\r
 895                                         if(result == 0) result = id;\r
 896                                         else result = -1;\r
 897                     }\r
 898 \r
 899                 }\r
 900 \r
 901             }\r
 902                 \r
 903                 if(result != 0) return result; \r
 904             \r
 905                 try {\r
 906                                 return cluster.getSingleObject(subject, predicate, clusterSupport);\r
 907                         } catch (DatabaseException e) {\r
 908                                 return -1;\r
 909                         }\r
 910             \r
 911         } else {\r
 912 \r
 913                 try {\r
 914                                 return cluster.getSingleObject(subject, predicate, clusterSupport);\r
 915                         } catch (DatabaseException e) {\r
 916                                 return -1;\r
 917                         }\r
 918                 // This comes if the resource is bogus\r
 919                 catch (Throwable t) {\r
 920                         \r
 921                 analyseProblem(cluster);\r
 922                 \r
 923                 Logger.defaultLogError(t);\r
 924                         \r
 925                                 return -1;\r
 926                                 \r
 927                         }\r
 928         \r
 929         }\r
 930         \r
 931     }\r
 932 \r
 933 //      @Override\r
 934 //    public boolean getStatements(final ReadGraphImpl graph, final int subject, final int predicate,\r
 935 //            final TripleIntProcedure procedure, final Statements entry) {\r
 936 //\r
 937 //        assert (subject != 0);\r
 938 //        assert (predicate != 0);\r
 939 //\r
 940 //        final TIntHashSet result = new TIntHashSet(16);\r
 941 //        final DataContainer<Boolean> found = new DataContainer<Boolean>(false);\r
 942 //\r
 943 //        Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);\r
 944 //        \r
 945 //        if (providers != null) {\r
 946 //\r
 947 //            for (VirtualGraph provider : providers) {\r
 948 //\r
 949 //                for (int id : ((VirtualGraphImpl)provider).getObjects(subject, predicate)) {\r
 950 //\r
 951 //                    found.set(true);\r
 952 //\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
 958 //                        } else {\r
 959 //                            procedure.execute(graph, subject, predicate, id);\r
 960 //                        }\r
 961 //                    }\r
 962 //\r
 963 //                }\r
 964 //\r
 965 //            }\r
 966 //\r
 967 //        }\r
 968 //\r
 969 //        if (subject < 0)\r
 970 //            return found.get();\r
 971 //\r
 972 //        final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
 973 //        assert (cluster != null);\r
 974 //\r
 975 //        // wheels within wheels\r
 976 //        final ClusterI.ObjectProcedure<Object> proc = new ClusterI.ObjectProcedure<Object>() {\r
 977 //            @Override\r
 978 //            public boolean execute(int callerThread, Object context, int object) {\r
 979 //\r
 980 //                found.set(true);\r
 981 //\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
 987 //                    } else {\r
 988 //                        procedure.execute(graph.newAsync(callerThread), subject, predicate, object);\r
 989 //                    }\r
 990 //                }\r
 991 //\r
 992 //                return false; // continue looping\r
 993 //\r
 994 //            }\r
 995 //            \r
 996 //                      @Override\r
 997 //                      public boolean found() {\r
 998 //                              throw new UnsupportedOperationException();\r
 999 //                      }\r
1000 //            \r
1001 //        };\r
1002 //\r
1003 //        try {\r
1004 //            cluster.forObjects(graph.callerThread, subject, predicate, proc, null, clusterSupport);\r
1005 //        } catch (DatabaseException e) {\r
1006 //            Logger.defaultLogError(e);\r
1007 //        }\r
1008 //        return found.get();\r
1009 //\r
1010 //    }\r
1011 \r
1012         @Override\r
1013     public org.simantics.db.DirectStatements getStatements(final ReadGraphImpl graph, final int subject, final QueryProcessor processor, boolean ignoreVirtual) {\r
1014 \r
1015         assert (subject != 0);\r
1016 \r
1017         final DirectStatementsImpl result = new DirectStatementsImpl(resourceSupport, subject);\r
1018 \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
1026                         }\r
1027                     }\r
1028                 }\r
1029             }\r
1030         }\r
1031 \r
1032         if (subject < 0) {\r
1033                 return result;\r
1034         } else {\r
1035             final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
1036             assert (cluster != null);\r
1037             doGetStatements(graph, cluster, subject, result);\r
1038         }\r
1039         \r
1040         return result;\r
1041 \r
1042     }\r
1043 \r
1044 //    @Override\r
1045 //    public void getStatements(ReadGraphImpl graph, final int subject, final Procedure<DirectStatements> procedure) {\r
1046 //      \r
1047 //              procedure.exception(new DatabaseException("Not supported"));\r
1048 //              \r
1049 //    }\r
1050 \r
1051     @Override\r
1052     public void getPredicates(final ReadGraphImpl graph, final int subject, final IntProcedure procedure) {\r
1053 \r
1054         final TIntHashSet result = new TIntHashSet(16);\r
1055 \r
1056         Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(subject);\r
1057         \r
1058         if (providers != null) {\r
1059 \r
1060             for (VirtualGraph provider : providers) {\r
1061 \r
1062                 for (int id : ((VirtualGraphImpl)provider).getPredicates(subject)) {\r
1063 \r
1064                     if (result.add(id)) {\r
1065                         procedure.execute(graph, id);\r
1066                     }\r
1067 \r
1068                 }\r
1069 \r
1070             }\r
1071 \r
1072         }\r
1073 \r
1074         if (subject < 0) {\r
1075             procedure.finished(graph);\r
1076             return;\r
1077         }\r
1078 \r
1079         ClusterI proxy = clusterTable.getClusterByResourceKey(subject);\r
1080 //        if(!proxy.isLoaded()) {\r
1081 //              \r
1082 //              proxy.load(callerThread, session, new Runnable() {\r
1083 //\r
1084 //                              @Override\r
1085 //                              public void run() {\r
1086 //                                      getPredicates(callerThread, subject, procedure);\r
1087 //                              }\r
1088 //                      \r
1089 //              });\r
1090 //              return;\r
1091 //              \r
1092 //        }\r
1093         assert (proxy != null);\r
1094 \r
1095         final DataContainer<Integer> got = new DataContainer<Integer>(0);\r
1096         ClusterI.PredicateProcedure<Object> proc = new ClusterI.PredicateProcedure<Object>() {\r
1097             @Override\r
1098             public boolean execute(Object context, int predicate, int oi) {\r
1099                 if (result.add(predicate)) {\r
1100                     procedure.execute(graph, predicate);\r
1101                 }\r
1102                 got.set(got.get() + 1);\r
1103                 return false; // continue looping\r
1104             }\r
1105         };\r
1106         try {\r
1107             proxy.forPredicates(subject, proc, null, clusterSupport);\r
1108         } catch (DatabaseException e) {\r
1109             Logger.defaultLogError(e);\r
1110         }\r
1111         procedure.finished(graph);\r
1112 \r
1113     }\r
1114     \r
1115     \r
1116 \r
1117 //    @Override\r
1118 //    public void getValue(ReadGraphImpl graph, int resource, InternalProcedure<byte[]> procedure) {\r
1119 //\r
1120 //      if(resource < 0) {\r
1121 //      \r
1122 //              Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);\r
1123 //              \r
1124 //              if (providers != null) {\r
1125 //      \r
1126 //                  for (VirtualGraph provider : providers) {\r
1127 //      \r
1128 //                      Object value = ((VirtualGraphImpl)provider).getValue(resource);\r
1129 //                      if (value != null) {\r
1130 //                          procedure.execute(graph, (byte[])value);\r
1131 //                          return;\r
1132 //                      }\r
1133 //      \r
1134 //                  }\r
1135 //      \r
1136 //              }\r
1137 //              \r
1138 //              return;\r
1139 //        \r
1140 //      }\r
1141 //      \r
1142 //      ClusterI cluster = clusterTable.getClusterByResourceKey(resource);\r
1143 //        if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(resource)) {\r
1144 //              \r
1145 //              Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);\r
1146 //              \r
1147 //              if (providers != null) {\r
1148 //      \r
1149 //                  for (VirtualGraph provider : providers) {\r
1150 //      \r
1151 //                      Object value = ((VirtualGraphImpl)provider).getValue(resource);\r
1152 //                      if (value != null) {\r
1153 //                          procedure.execute(graph, (byte[])value);\r
1154 //                          return;\r
1155 //                      }\r
1156 //      \r
1157 //                  }\r
1158 //      \r
1159 //              }\r
1160 //              \r
1161 //              try {\r
1162 //                      \r
1163 //                      byte[] data = cluster.getValue(resource, clusterSupport);\r
1164 //                      if (null == data || 0 == data.length) {\r
1165 //                          procedure.execute(graph, null);\r
1166 //                      } else {\r
1167 //                          procedure.execute(graph, data);\r
1168 //                      }\r
1169 //                      \r
1170 //              } catch (DatabaseException e) {\r
1171 //                  Logger.defaultLogError(e);\r
1172 //              }\r
1173 //              \r
1174 //        } else {\r
1175 //\r
1176 //              try {\r
1177 //                      \r
1178 //                      byte[] data = cluster.getValue(resource, clusterSupport);\r
1179 //                      if (null == data || 0 == data.length) {\r
1180 //                          procedure.execute(graph, null);\r
1181 //                      } else {\r
1182 //                          procedure.execute(graph, data);\r
1183 //                      }\r
1184 //                      \r
1185 //              } catch (DatabaseException e) {\r
1186 //                  Logger.defaultLogError(e);\r
1187 //              }\r
1188 //\r
1189 //        }\r
1190 //\r
1191 //    }\r
1192 \r
1193 \r
1194     @Override\r
1195     public byte[] getValue(ReadGraphImpl graph, int resource) {\r
1196 \r
1197         if(resource < 0) {\r
1198         \r
1199                 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);\r
1200                 \r
1201                 if (providers != null) {\r
1202         \r
1203                     for (VirtualGraph provider : providers) {\r
1204         \r
1205                         Object value = ((VirtualGraphImpl)provider).getValue(resource);\r
1206                         if (value != null) {\r
1207                                 return (byte[])value;\r
1208                         }\r
1209         \r
1210                     }\r
1211         \r
1212                 }\r
1213                 \r
1214                 return null;\r
1215         \r
1216         }\r
1217         \r
1218         ClusterI cluster = clusterTable.getClusterByResourceKey(resource);\r
1219         if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(resource)) {\r
1220                 \r
1221                 Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);\r
1222                 \r
1223                 if (providers != null) {\r
1224         \r
1225                     for (VirtualGraph provider : providers) {\r
1226         \r
1227                         Object value = ((VirtualGraphImpl)provider).getValue(resource);\r
1228                         if (value != null) {\r
1229                                 return (byte[])value;\r
1230                         }\r
1231         \r
1232                     }\r
1233         \r
1234                 }\r
1235                 \r
1236                 try {\r
1237                         \r
1238                         byte[] data = cluster.getValue(resource, clusterSupport);\r
1239                         if (null != data && 0 != data.length) {\r
1240                                 return data;\r
1241                         }\r
1242                         \r
1243                 } catch (DatabaseException e) {\r
1244                     Logger.defaultLogError(e);\r
1245                 }\r
1246                 \r
1247                 return null;\r
1248                 \r
1249         } else {\r
1250 \r
1251                 try {\r
1252                         \r
1253                         byte[] data = cluster.getValue(resource, clusterSupport);\r
1254                         if (null != data && 0 != data.length) {\r
1255                                 return data;\r
1256                         }\r
1257                         \r
1258                 } catch (DatabaseException e) {\r
1259                     Logger.defaultLogError(e);\r
1260                 }\r
1261                 \r
1262                 return null;\r
1263 \r
1264         }\r
1265 \r
1266     }\r
1267 \r
1268     @Override\r
1269     public InputStream getValueStream(ReadGraphImpl graph, int resource) {\r
1270 \r
1271         if(resource < 0) {\r
1272         \r
1273             Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);\r
1274             \r
1275             if (providers != null) {\r
1276     \r
1277                 for (VirtualGraph provider : providers) {\r
1278     \r
1279                     Object value = ((VirtualGraphImpl)provider).getValue(resource);\r
1280                     if (value != null) {\r
1281                         return new ByteArrayInputStream((byte[])value);\r
1282                     }\r
1283     \r
1284                 }\r
1285     \r
1286             }\r
1287             \r
1288             return null;\r
1289         \r
1290         }\r
1291         \r
1292         ClusterI cluster = clusterTable.getClusterByResourceKey(resource);\r
1293         if (cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(resource)) {\r
1294             \r
1295             Collection<TransientGraph> providers = virtualGraphServerSupport.getVirtualGraphs(resource);\r
1296             \r
1297             if (providers != null) {\r
1298     \r
1299                 for (VirtualGraph provider : providers) {\r
1300     \r
1301                     Object value = ((VirtualGraphImpl)provider).getValue(resource);\r
1302                     if (value != null) {\r
1303                         return new ByteArrayInputStream((byte[])value);\r
1304                     }\r
1305     \r
1306                 }\r
1307     \r
1308             }\r
1309             \r
1310             try {\r
1311                 \r
1312                 return cluster.getValueStream(resource, clusterSupport);\r
1313                 \r
1314             } catch (DatabaseException e) {\r
1315                 Logger.defaultLogError(e);\r
1316             }\r
1317             \r
1318             return null;\r
1319             \r
1320         } else {\r
1321 \r
1322             try {\r
1323                 \r
1324                 return cluster.getValueStream(resource, clusterSupport);\r
1325                 \r
1326             } catch (DatabaseException e) {\r
1327                 Logger.defaultLogError(e);\r
1328             }\r
1329             \r
1330             return null;\r
1331 \r
1332         }\r
1333 \r
1334     }\r
1335     \r
1336     @Override\r
1337     public void requestCluster(ReadGraphImpl graph, final long clusterId, final Runnable r) {\r
1338 \r
1339         class CallbackAdapter implements Callback<DatabaseException> {\r
1340                 final Runnable r;\r
1341                 CallbackAdapter(final Runnable r) {\r
1342                         this.r = r;\r
1343                 }\r
1344                 @Override\r
1345                 public void run(DatabaseException e) {\r
1346                         if (null != e)\r
1347                                 e.printStackTrace();\r
1348                         else\r
1349                                 r.run();\r
1350                 }\r
1351                 \r
1352         }\r
1353         \r
1354         double p = clusterTable.getLoadProbability();\r
1355 // System.out.print("Load cluster " + clusterId + " with probability " + p +\r
1356         // " -> ");\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
1362             } else {\r
1363                 r.run();\r
1364             }\r
1365         } else {\r
1366             r.run();\r
1367         }\r
1368 \r
1369     }\r
1370 \r
1371     @Override\r
1372     public int getBuiltin(String uri) {\r
1373         return builtinSupport.getBuiltin(uri);\r
1374     }\r
1375 \r
1376     @Override\r
1377     public void checkTasks() {\r
1378         System.out.println(syncThreads.toString());\r
1379     }\r
1380 \r
1381 //    @Override\r
1382 //    public void asyncWrite(Write request) {\r
1383 //        \r
1384 ////            if(plainWrite(writer) && sameProvider(request)) {\r
1385 ////                    writer.writeSupport.pushRequest(request);\r
1386 ////            } else {\r
1387 //              asyncRequest(request);\r
1388 ////            }\r
1389 //        \r
1390 //    }\r
1391 \r
1392     /*\r
1393      * Helpers\r
1394      * \r
1395      * \r
1396      */\r
1397     \r
1398     private void doGetStatements(ReadGraphImpl graph, final ClusterI cluster, final int subject, final DirectStatementsImpl result) {\r
1399 \r
1400         final class Proc implements ClusterI.PredicateProcedure<Object> {\r
1401 \r
1402                         @Override\r
1403                         public boolean execute(Object context, final int predicate, final int objectIndex) {\r
1404                                 \r
1405                                 doExecute(null, predicate, objectIndex);\r
1406                                 return false;\r
1407                                 \r
1408                         }\r
1409 \r
1410                         private void doExecute(Object context, final int predicate, final int objectIndex) {\r
1411 \r
1412                                 try {\r
1413                                         cluster.forObjects(subject, predicate, new ClusterI.ObjectProcedure<Object>() {\r
1414 \r
1415                                                 @Override\r
1416                                                 public boolean execute(Object context, int object) {\r
1417                                                         result.addStatement(predicate, object);\r
1418                                                         return false;\r
1419                                                 }\r
1420 \r
1421                                         }, null, clusterSupport);\r
1422                                 } catch (DatabaseException e) {\r
1423                                         e.printStackTrace();\r
1424                                 }\r
1425                                 \r
1426                         }\r
1427                 \r
1428         }\r
1429 \r
1430         try {\r
1431                         cluster.forPredicates(subject, new Proc(), null, clusterSupport);\r
1432                 } catch (DatabaseException e) {\r
1433                         e.printStackTrace();\r
1434                 }\r
1435         \r
1436     }\r
1437     \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
1439 //\r
1440 //        if(!cluster.isLoaded()) {\r
1441 //\r
1442 //                      requestCluster(callerThread, cluster.getClusterId(), new Callback<Integer>() {\r
1443 //      \r
1444 //                              @Override\r
1445 //                              public void run(Integer i) {\r
1446 //      \r
1447 //                                      processor.schedule(i, new SessionTask(callerThread) {\r
1448 //      \r
1449 //                                              @Override\r
1450 //                                              public void run(int thread) {\r
1451 //                                                      \r
1452 //                                                      getDirectObjects4(thread, cluster, subject, predicate, processor, graph, procedure);\r
1453 //                                                      \r
1454 //                                              }\r
1455 //      \r
1456 //                                      });\r
1457 //      \r
1458 //                              }\r
1459 //      \r
1460 //                      });\r
1461 //                      \r
1462 //        } else {\r
1463 //\r
1464 //              try {\r
1465 //                      cluster.forObjects(graph, subject, predicate, procedure);\r
1466 //              } catch (DatabaseException e) {\r
1467 //                      e.printStackTrace();\r
1468 //              }\r
1469 //              \r
1470 ////                    procedure.finished(graph);\r
1471 ////                    graph.state.barrier.dec();\r
1472 ////                    \r
1473 ////            System.err.println("ai2=" + ai2.decrementAndGet());\r
1474 //              \r
1475 //        }\r
1476 //              \r
1477 //              \r
1478 //      }\r
1479 \r
1480 //      AtomicInteger ai2  =new AtomicInteger(0);\r
1481         \r
1482 //    private boolean testCluster(int subject, ClusterI proxy) {\r
1483 //      \r
1484 //        if (proxy == null)\r
1485 //            System.out.println("null cluster: " + Integer.toString(subject, 16));\r
1486 //        \r
1487 //        return proxy != null;\r
1488 //      \r
1489 //    }\r
1490 \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
1497     }\r
1498 \r
1499         @Override\r
1500         public int getRandomAccessReference(String id) throws ResourceNotFoundException {\r
1501                 \r
1502                 try {\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
1508                 }\r
1509                 return 0;\r
1510                 \r
1511         }\r
1512         \r
1513         @Override\r
1514         public void ensureLoaded(final ReadGraphImpl graph, final int subject, final int predicate) {\r
1515                 \r
1516                 if(subject < 0) {\r
1517                         \r
1518                         SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, predicate, new Callback<ReadGraphImpl>() {\r
1519 \r
1520                                 @Override\r
1521                                 public void run(ReadGraphImpl parameter) {\r
1522                                 }\r
1523                                 \r
1524                         });\r
1525                         \r
1526                 } else {\r
1527                         \r
1528                 final ClusterI cluster = clusterTable.checkedGetClusterByResourceKey(subject);\r
1529 \r
1530                 if(cluster.isLoaded()) {\r
1531                         \r
1532                         if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject, predicate)) {\r
1533 \r
1534                                         SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, predicate, new Callback<ReadGraphImpl>() {\r
1535 \r
1536                                                 @Override\r
1537                                                 public void run(ReadGraphImpl parameter) {\r
1538                                                 }\r
1539                                                 \r
1540                                         });\r
1541                                 \r
1542                                 } else {\r
1543                                         \r
1544                                 }\r
1545                         \r
1546                 } else {\r
1547                         \r
1548                                 new Exception().printStackTrace();\r
1549                         \r
1550                         cluster.load(session.clusterTranslator, new Runnable() {\r
1551 \r
1552                                         @Override\r
1553                                         public void run() {\r
1554                                                 \r
1555                                         if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject, predicate)) {\r
1556 \r
1557                                                         SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, predicate, new Callback<ReadGraphImpl>() {\r
1558 \r
1559                                                                 @Override\r
1560                                                                 public void run(ReadGraphImpl parameter) {\r
1561                                                                 }\r
1562                                                                 \r
1563                                                         });\r
1564                                                 \r
1565                                                 } else {\r
1566                                                         \r
1567                                                 }\r
1568                                                 \r
1569                                         }\r
1570                                 \r
1571                         });\r
1572                         \r
1573                 }\r
1574                 \r
1575                 \r
1576                 }\r
1577                 \r
1578         }\r
1579         \r
1580         @Override\r
1581         public void ensureLoaded(final ReadGraphImpl graph, final int subject) {\r
1582                 \r
1583                 if(subject < 0) {\r
1584                         \r
1585                         SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, new Callback<ReadGraphImpl>() {\r
1586 \r
1587                                 @Override\r
1588                                 public void run(ReadGraphImpl parameter) {\r
1589                                 }\r
1590                                 \r
1591                         });\r
1592                         \r
1593                 } else {\r
1594                         \r
1595                 final ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
1596 \r
1597                 if(cluster.isLoaded()) {\r
1598                         \r
1599                         if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject)) {\r
1600 \r
1601                                         SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, new Callback<ReadGraphImpl>() {\r
1602 \r
1603                                                 @Override\r
1604                                                 public void run(ReadGraphImpl parameter) {\r
1605                                                 }\r
1606                                                 \r
1607                                         });\r
1608                                 \r
1609                                 } else {\r
1610                                         \r
1611                                 }\r
1612                         \r
1613                 } else {\r
1614                         \r
1615 //                      System.err.println("cluster not loaded " + subject);\r
1616                                 new Exception().printStackTrace();\r
1617                         \r
1618                         cluster.load(session.clusterTranslator, new Runnable() {\r
1619 \r
1620                                         @Override\r
1621                                         public void run() {\r
1622                                                 \r
1623                                         if(cluster.hasVirtual() && virtualGraphServerSupport.virtuals.contains(subject) && !SessionImplSocket.areVirtualStatementsLoaded(virtualGraphServerSupport, subject)) {\r
1624 \r
1625                                                         SessionImplSocket.loadVirtualStatements(virtualGraphServerSupport, graph, subject, new Callback<ReadGraphImpl>() {\r
1626 \r
1627                                                                 @Override\r
1628                                                                 public void run(ReadGraphImpl parameter) {\r
1629                                                                 }\r
1630                                                                 \r
1631                                                         });\r
1632                                                 \r
1633                                                 } else {\r
1634                                                         \r
1635                                                 }\r
1636                                                 \r
1637                                         }\r
1638                                 \r
1639                         });\r
1640                         \r
1641                 }\r
1642                 \r
1643                 \r
1644                 }\r
1645                 \r
1646         }\r
1647 \r
1648         @Override\r
1649         public boolean isLoaded(int subject) {\r
1650         ClusterI cluster = clusterTable.getClusterByResourceKey(subject);\r
1651         return cluster.isLoaded();\r
1652         }\r
1653         \r
1654         @Override\r
1655         public void ceased(int thread) {\r
1656                 \r
1657                 session.ceased(thread);\r
1658                 \r
1659         }\r
1660 \r
1661     @Override\r
1662     public Object getLock() {\r
1663         \r
1664         return session.requestManager;\r
1665         \r
1666     }\r
1667 \r
1668     @Override\r
1669     public VirtualGraph getProvider(int subject, int predicate, int object) {\r
1670 \r
1671         if(subject > 0) {\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
1675         }\r
1676         \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
1680                 }\r
1681         }\r
1682         \r
1683         // Nothing found from virtual graphs\r
1684         return null;\r
1685                 \r
1686     }\r
1687 \r
1688     @Override\r
1689     public VirtualGraph getProvider(int subject, int predicate) {\r
1690 \r
1691         if(subject > 0) {\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
1695         }\r
1696 \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
1702                         else result = g;\r
1703                 }\r
1704         }\r
1705         return result;\r
1706                 \r
1707     }\r
1708 \r
1709     @Override\r
1710     public VirtualGraph getValueProvider(int subject) {\r
1711 \r
1712         if(subject > 0) {\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
1716         }\r
1717 \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
1722                         else result = g;\r
1723                 }\r
1724         }\r
1725         return result;\r
1726                 \r
1727     }\r
1728     \r
1729     @Override\r
1730     public void exit(Throwable t) {\r
1731         state.close();\r
1732     }\r
1733     \r
1734     private void analyseProblem(ClusterI cluster) {\r
1735         \r
1736         if(cluster instanceof ClusterSmall)\r
1737                         try {\r
1738                                 ((ClusterSmall)cluster).check();\r
1739                         } catch (DatabaseException e) {\r
1740                                 e.printStackTrace();\r
1741                         }\r
1742         \r
1743     }\r
1744     \r
1745 }\r