bundles/org.simantics.db.impl/src/org/simantics/db/impl/query/DirectStatements.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007, 2010 Association for Decentralized Information Management\r
   3  * in Industry THTH ry.\r
   4  * All rights reserved. This program and the accompanying materials\r
   5  * are made available under the terms of the Eclipse Public License v1.0\r
   6  * which accompanies this distribution, and is available at\r
   7  * http://www.eclipse.org/legal/epl-v10.html\r
   8  *\r
   9  * Contributors:\r
  10  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  11  *******************************************************************************/\r
  12 package org.simantics.db.impl.query;\r
  13 \r
  14 import org.simantics.db.impl.graph.ReadGraphImpl;\r
  15 import org.simantics.db.procedure.AsyncProcedure;\r
  16 import org.simantics.db.procedure.ListenerBase;\r
  17 import org.simantics.db.procedure.Procedure;\r
  18 \r
  19 \r
  20 final public class DirectStatements /*extends CollectionBinaryQuery<TripleIntProcedure>*/ {\r
  21 \r
  22         /*\r
  23         public DirectStatements(final int r1, final int r2) {\r
  24                 super(r1, r2);\r
  25         }\r
  26 \r
  27         public static DirectStatements newInstance(final int r1, final int r2) {\r
  28                 return new DirectStatements(r1, r2);\r
  29         }\r
  30 \r
  31         final static DirectStatements entry(final QueryProcessor provider, final int r1, final int r2) {\r
  32 \r
  33                 return (DirectStatements)provider.statementsMap[provider.resourceThread(r1)].get(id(r1,r2));\r
  34 \r
  35         }\r
  36 \r
  37         final static Collection<DirectStatements> entries(final QueryProcessor processor, final int r1) {\r
  38                 BinaryQueryHashMap<TripleIntProcedure> hash = processor.statementsMap[processor.resourceThread(r1)];\r
  39                 return hash.values(r1);\r
  40         }\r
  41         */\r
  42         \r
  43         final public static void queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final AsyncProcedure<org.simantics.db.DirectStatements> procedure, boolean ignoreVirtual) {\r
  44 \r
  45                 assert(r != 0);\r
  46 \r
  47                 org.simantics.db.DirectStatements result = provider.querySupport.getStatements(graph, r, provider, ignoreVirtual);\r
  48                 procedure.execute(graph, result);\r
  49 \r
  50         }\r
  51 \r
  52         final public static void queryEach(ReadGraphImpl graph, final int r, final QueryProcessor provider, final CacheEntry parent, final ListenerBase listener, final Procedure<org.simantics.db.DirectStatements> procedure) {\r
  53 \r
  54                 assert(r != 0);\r
  55 \r
  56                 try {\r
  57 \r
  58                         org.simantics.db.DirectStatements result = provider.querySupport.getStatements(graph, r, provider, true);\r
  59                         procedure.execute(result);\r
  60                         \r
  61 //                      provider.querySupport.getStatements(graph, r, procedure);\r
  62 \r
  63                 } catch (Throwable t) {\r
  64 \r
  65                         t.printStackTrace();\r
  66 \r
  67                 }\r
  68 \r
  69         }\r
  70 \r
  71         /*\r
  72         @Override\r
  73         public BinaryQuery<TripleIntProcedure> getEntry(int callerThread, QueryProcessor provider) {\r
  74                 return provider.statementsMap[callerThread].get(id);\r
  75         }\r
  76 \r
  77         @Override\r
  78         public void putEntry(int callerThread, QueryProcessor provider) {\r
  79                 provider.statementsMap[callerThread].put(id, this);\r
  80         }\r
  81 \r
  82         @Override\r
  83         final public void removeEntry(int callerThread, QueryProcessor provider) {\r
  84                 provider.statementsMap[callerThread].remove(id);\r
  85         }\r
  86 \r
  87         final private void forSingleAssertion(ReadGraphImpl graph, final QueryProcessor queryProvider, final TripleIntProcedure procedure) {\r
  88 \r
  89                 final AtomicInteger results = new AtomicInteger();\r
  90 \r
  91                 PrincipalTypes.queryEach(graph, r1(), queryProvider, this, null, new SyncIntProcedure() {\r
  92 \r
  93                         @Override\r
  94                         public void run(ReadGraphImpl graph) {\r
  95 \r
  96                                 int rc = results.get();\r
  97 \r
  98                                 if(isExcepted()) {\r
  99 \r
 100                                         procedure.exception(graph, (Throwable)getResult());\r
 101 \r
 102                                 } else {\r
 103 \r
 104                                         // No result or single result\r
 105                                         if(rc == 0 || rc == 1) {\r
 106 \r
 107                                                 finish(graph, queryProvider);\r
 108                                                 procedure.finished(graph);\r
 109 \r
 110                                         } else {\r
 111 \r
 112                                                 ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has more than one statement.", r1());\r
 113                                                 except(exception);\r
 114                                                 procedure.exception(graph, exception);\r
 115 \r
 116                                         }\r
 117 \r
 118                                 }\r
 119 \r
 120                         }\r
 121 \r
 122                         @Override\r
 123                         public void execute(ReadGraphImpl graph, int type) {\r
 124 \r
 125                                 inc();\r
 126 \r
 127                                 AssertedStatements.queryEach(graph, type, r2(), queryProvider, DirectStatements.this, null, new TripleIntProcedureAdapter() {\r
 128 \r
 129                                         @Override\r
 130                                         public void execute(ReadGraphImpl graph, int s, int p, int o) {\r
 131 \r
 132                                                 int event = results.getAndIncrement();\r
 133                                                 if(event == 0) {\r
 134 \r
 135                                                         addOrSet(s, p, o);\r
 136                                                         procedure.execute(graph, s, p, o);\r
 137 \r
 138                                                 }\r
 139 \r
 140                                         }\r
 141 \r
 142                                         @Override\r
 143                                         public void finished(ReadGraphImpl graph) {\r
 144 \r
 145                                                 dec(graph);\r
 146 \r
 147                                         }\r
 148 \r
 149                                         @Override\r
 150                                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 151 \r
 152                                                 except(t);\r
 153                                                 dec(graph);\r
 154 \r
 155                                         }\r
 156 \r
 157                                 });\r
 158 \r
 159                         }\r
 160 \r
 161                         @Override\r
 162                         public void finished(ReadGraphImpl graph) {\r
 163 \r
 164                                 dec(graph);\r
 165 \r
 166                         }\r
 167 \r
 168                 });\r
 169 \r
 170         }\r
 171 \r
 172         // Search for one statement\r
 173         final public void computeFunctionalIndex(ReadGraphImpl graph, final QueryProcessor provider, final RelationInfo ri, final TripleIntProcedure procedure, final boolean store) {\r
 174 \r
 175                 if(ri.isFinal) {\r
 176 \r
 177                         boolean found = provider.querySupport.getObjects(graph, r1(), r2(), new IntProcedure() {\r
 178 \r
 179                                 @Override\r
 180                                 public void execute(ReadGraphImpl graph, int i) {\r
 181                                         addOrSet(r1(), r2(), i);\r
 182                                 }\r
 183 \r
 184                                 @Override\r
 185                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 186                                         if(DebugException.DEBUG) new DebugException(t).printStackTrace();\r
 187                                 }\r
 188 \r
 189                                 @Override\r
 190                                 public void finished(ReadGraphImpl graph) {\r
 191                                 }\r
 192 \r
 193                         });\r
 194 \r
 195                         // If functional relation was found there is no need to check assertions\r
 196                         if(found) {\r
 197 \r
 198                                 final IntArray array = (IntArray)getResult();\r
 199                                 if(array.size() > 3) {\r
 200                                         Throwable exception = new ManyObjectsForFunctionalRelationException("Functional relation " + r2() + " has multiple objects " + Arrays.toString(array.toArray()) + " for subject " + r1());\r
 201                                         except(exception);\r
 202                                         procedure.exception(graph, exception);\r
 203                                         return;\r
 204                                 }\r
 205                                 procedure.execute(graph, array.data[0], array.data[1], array.data[2]);\r
 206                                 finish(graph, provider);\r
 207                                 procedure.finished(graph);\r
 208                                 return;\r
 209 \r
 210                         }\r
 211 \r
 212                         // Check for assertions\r
 213                         forSingleAssertion(graph, provider, procedure);\r
 214 \r
 215 \r
 216                 } else {\r
 217 \r
 218                         final AtomicBoolean found = new AtomicBoolean(false);\r
 219 \r
 220                         DirectPredicates.queryEach(graph, r1(), provider, DirectStatements.this, null, new SyncIntProcedure() {\r
 221 \r
 222                                 @Override\r
 223                                 public void run(ReadGraphImpl graph) {\r
 224 \r
 225                                         if(found.get()) return;\r
 226 \r
 227                                         // Check for assertions\r
 228                                         forSingleAssertion(graph, provider, procedure);\r
 229 \r
 230                                 }\r
 231 \r
 232                                 @Override\r
 233                                 public void execute(ReadGraphImpl graph, final int pred) {\r
 234 \r
 235                                         if(found.get()) return;\r
 236 \r
 237                                         if(pred == r2()) {\r
 238 \r
 239                                                 inc();\r
 240 \r
 241                                                 DirectObjects.queryEach(graph, r1(), pred, provider, DirectStatements.this, null, new IntProcedure() {\r
 242 \r
 243                                                         @Override\r
 244                                                         public void execute(ReadGraphImpl graph, int i) {\r
 245 \r
 246                                                                 if(found.compareAndSet(false, true)) {\r
 247 \r
 248                                                                         addOrSet(r1(), pred, i);\r
 249                                                                         finish(graph, provider);\r
 250                                                                         procedure.execute(graph, r1(), pred, i);\r
 251                                                                         procedure.finished(graph);\r
 252 \r
 253                                                                 } else {\r
 254 \r
 255                                                                         ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has more than one statement.", r1());\r
 256                                                                         except(exception);\r
 257                                                                         procedure.exception(graph, exception);\r
 258 \r
 259                                                                 }\r
 260 \r
 261                                                         }\r
 262 \r
 263                                                         @Override\r
 264                                                         public void finished(ReadGraphImpl graph) {\r
 265 \r
 266                                                                 dec(graph);\r
 267 \r
 268                                                         }\r
 269 \r
 270                                                         @Override\r
 271                                                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 272                                                                 procedure.exception(graph, t);\r
 273                                                         }\r
 274 \r
 275                                                 });\r
 276 \r
 277                                         } else {\r
 278 \r
 279                                                 inc();\r
 280 \r
 281                                                 SuperRelations.queryEach(graph, pred, provider, DirectStatements.this, null, new InternalProcedure<IntSet>() {\r
 282 \r
 283                                                         @Override\r
 284                                                         public void execute(ReadGraphImpl graph, IntSet result) {\r
 285 \r
 286                                                                 if(found.get()) {\r
 287                                                                         dec(graph);\r
 288                                                                         return;\r
 289                                                                 }\r
 290 \r
 291                                                                 if(result.contains(r2())) {\r
 292 \r
 293                                                                         inc();\r
 294 \r
 295                                                                         DirectObjects.queryEach(graph, r1(), pred, provider, DirectStatements.this, null, new IntProcedure() {\r
 296 \r
 297                                                                                 @Override\r
 298                                                                                 public void execute(ReadGraphImpl graph, int i) {\r
 299 \r
 300                                                                                         if(found.compareAndSet(false, true)) {\r
 301 \r
 302                                                                                                 addOrSet(r1(), pred, i);\r
 303                                                                                                 finish(graph, provider);\r
 304                                                                                                 procedure.execute(graph, r1(), pred, i);\r
 305                                                                                                 procedure.finished(graph);\r
 306 \r
 307                                                                                         } else {\r
 308 \r
 309                                                                                                 ManyObjectsForFunctionalRelationException exception = new ManyObjectsForFunctionalRelationException("Functional relation has more than one statement.", r1());\r
 310                                                                                                 except(exception);\r
 311                                                                                                 procedure.exception(graph, exception);\r
 312 \r
 313                                                                                         }\r
 314 \r
 315                                                                                 }\r
 316 \r
 317                                                                                 @Override\r
 318                                                                                 public void finished(ReadGraphImpl graph) {\r
 319 \r
 320                                                                                         dec(graph);\r
 321 \r
 322                                                                                 }\r
 323 \r
 324                                                                                 @Override\r
 325                                                                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 326                                                                                         procedure.exception(graph, t);\r
 327                                                                                 }\r
 328 \r
 329                                                                         });\r
 330 \r
 331                                                                 }\r
 332 \r
 333                                                                 dec(graph);\r
 334 \r
 335                                                         }\r
 336 \r
 337                                                         @Override\r
 338                                                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 339                                                                 procedure.exception(graph, t);\r
 340                                                         }\r
 341 \r
 342                                                 });\r
 343 \r
 344                                         }\r
 345 \r
 346                                 }\r
 347 \r
 348                                 @Override\r
 349                                 public void finished(ReadGraphImpl graph) {\r
 350 \r
 351                                         dec(graph);\r
 352 \r
 353                                 }\r
 354 \r
 355                         });\r
 356 \r
 357                 }\r
 358 \r
 359         }\r
 360 \r
 361         final private void forAssertions(ReadGraphImpl graph, final QueryProcessor queryProvider, final TripleIntProcedure procedure) {\r
 362 \r
 363                 PrincipalTypes.queryEach(graph, r1(), queryProvider, this, null, new SyncIntProcedure() {\r
 364 \r
 365                         @Override\r
 366                         public void run(ReadGraphImpl graph) {\r
 367 \r
 368                                 finish(graph, queryProvider);\r
 369                                 procedure.finished(graph);\r
 370 \r
 371                         }\r
 372 \r
 373                         TripleIntProcedure proc = new TripleIntProcedureAdapter() {\r
 374 \r
 375                                 @Override\r
 376                                 public void execute(ReadGraphImpl graph, int s, int p, int o) {\r
 377                                         addOrSet(s, p, o);\r
 378                                         procedure.execute(graph, s, p, o);\r
 379                                 }\r
 380 \r
 381                                 @Override\r
 382                                 public void finished(ReadGraphImpl graph) {\r
 383                                         dec(graph);\r
 384                                 }\r
 385 \r
 386                                 @Override\r
 387                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 388                                         procedure.exception(graph, t);\r
 389                                 }\r
 390 \r
 391                         }; \r
 392 \r
 393                         @Override\r
 394                         public void execute(ReadGraphImpl graph, int type) {\r
 395 \r
 396                                 inc();\r
 397 \r
 398                                 AssertedStatements.queryEach(graph, type, r2(), queryProvider, DirectStatements.this, null, proc);\r
 399 \r
 400                         }\r
 401 \r
 402                         @Override\r
 403                         public void finished(ReadGraphImpl graph) {\r
 404                                 dec(graph);       \r
 405                         }\r
 406 \r
 407                 });\r
 408 \r
 409 \r
 410         }\r
 411 \r
 412         final public void computeNotFunctionalIndex(ReadGraphImpl graph, final QueryProcessor provider, RelationInfo ri, final TripleIntProcedure procedure, final boolean store) {\r
 413 \r
 414                 if(ri.isFinal) {\r
 415 \r
 416                         provider.querySupport.getObjects(graph, r1(), r2(), new IntProcedure() {\r
 417 \r
 418                                 @Override\r
 419                                 public void execute(ReadGraphImpl graph, int i) {\r
 420                                         addOrSet(r1(), r2(), i);\r
 421                                 }\r
 422 \r
 423                                 @Override\r
 424                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 425                                         if(DebugException.DEBUG) new DebugException(t).printStackTrace();\r
 426                                         procedure.exception(graph, t);\r
 427                                 }\r
 428 \r
 429                                 @Override\r
 430                                 public void finished(ReadGraphImpl graph) {\r
 431                                 }\r
 432 \r
 433                         });\r
 434 \r
 435                         final IntArray value = (IntArray)getResult();\r
 436                         for(int i=0;i<value.size();i+=3) {\r
 437                                 procedure.execute(graph, value.data[i], value.data[i+1], value.data[i+2]);\r
 438                         }\r
 439 \r
 440                         forAssertions(graph, provider, procedure);\r
 441 \r
 442                 } else {\r
 443 \r
 444                         DirectPredicates.queryEach(graph, r1(), provider, DirectStatements.this, null, new SyncIntProcedure() {\r
 445 \r
 446                                 @Override\r
 447                                 public void run(ReadGraphImpl graph) {\r
 448 \r
 449                                         forAssertions(graph, provider, procedure);\r
 450 \r
 451                                 }\r
 452 \r
 453                                 @Override\r
 454                                 public void execute(ReadGraphImpl graph, final int pred) {\r
 455 \r
 456                                         //                      System.out.println("directpredicates execute " + pred);\r
 457 \r
 458                                         if(pred == r2()) {\r
 459 \r
 460                                                 inc();\r
 461 \r
 462                                                 DirectObjects.queryEach(graph, r1(), pred, provider, DirectStatements.this, null, new IntProcedure() {\r
 463 \r
 464                                                         @Override\r
 465                                                         public void execute(ReadGraphImpl graph, int i) {\r
 466                                                                 //                              System.out.println("pred=" + pred + " object=" + i);\r
 467                                                                 addOrSet(r1(), pred, i);\r
 468                                                                 procedure.execute(graph, r1(), pred, i);\r
 469                                                         }\r
 470 \r
 471                                                         @Override\r
 472                                                         public void finished(ReadGraphImpl graph) {\r
 473                                                                 dec(graph);\r
 474                                                         }\r
 475 \r
 476                                                         @Override\r
 477                                                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 478                                                                 procedure.exception(graph, t);\r
 479                                                         }\r
 480 \r
 481                                                 });\r
 482 \r
 483                                         } else {\r
 484 \r
 485                                                 inc();\r
 486 \r
 487                                                 SuperRelations.queryEach(graph, pred, provider, DirectStatements.this, null, new InternalProcedure<IntSet>() {\r
 488 \r
 489                                                         @Override\r
 490                                                         public void execute(ReadGraphImpl graph, IntSet result) {\r
 491 \r
 492                                                                 if(result.contains(r2())) {\r
 493 \r
 494                                                                         inc();\r
 495 \r
 496                                                                         DirectObjects.queryEach(graph, r1(), pred, provider, DirectStatements.this, null, new IntProcedure() {\r
 497 \r
 498                                                                                 @Override\r
 499                                                                                 public void execute(ReadGraphImpl graph, int i) {\r
 500 \r
 501                                                                                         //                                              if(pred == 65548)\r
 502                                                                                         //                                                      System.out.println("s=" + r1() + "p=" + pred + " o=" + i);\r
 503 \r
 504                                                                                         addOrSet(r1(), pred, i);\r
 505                                                                                         procedure.execute(graph, r1(), pred, i);\r
 506 \r
 507                                                                                 }\r
 508 \r
 509                                                                                 @Override\r
 510                                                                                 public void finished(ReadGraphImpl graph) {\r
 511                                                                                         dec(graph);\r
 512                                                                                 }\r
 513 \r
 514                                                                                 @Override\r
 515                                                                                 public void exception(ReadGraphImpl graph, Throwable t) {\r
 516                                                                                         procedure.exception(graph, t);\r
 517                                                                                 }\r
 518 \r
 519                                                                         });\r
 520 \r
 521                                                                 }\r
 522 \r
 523                                                                 dec(graph);\r
 524 \r
 525                                                         }\r
 526 \r
 527                                                         @Override\r
 528                                                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 529                                                                 procedure.exception(graph, t);\r
 530                                                         }\r
 531 \r
 532                                                 });\r
 533 \r
 534                                         }\r
 535 \r
 536                                 }\r
 537 \r
 538                                 @Override\r
 539                                 public void finished(ReadGraphImpl graph) {\r
 540                                         dec(graph);\r
 541                                 }\r
 542 \r
 543                         });\r
 544 \r
 545                 }\r
 546 \r
 547         }\r
 548 \r
 549 \r
 550         @Override\r
 551         public void computeForEach(ReadGraphImpl graph, final QueryProcessor provider, final TripleIntProcedure procedure, final boolean store) {\r
 552 \r
 553                 RelationInfoQuery.queryEach(graph, r2(), provider, this, null, new InternalProcedure<RelationInfo>() {\r
 554 \r
 555                         @Override\r
 556                         public void execute(ReadGraphImpl graph, final RelationInfo ri) {\r
 557 \r
 558                                 provider.querySupport.ensureLoaded(graph, r1(), r2());\r
 559                                 if(ri.isFunctional) {\r
 560                                         computeFunctionalIndex(graph, provider, ri, procedure, store);\r
 561                                 } else {\r
 562                                         computeNotFunctionalIndex(graph, provider, ri, procedure, store);\r
 563                                 }\r
 564                                 \r
 565                         }\r
 566 \r
 567                         @Override\r
 568                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 569                                 procedure.exception(graph, t);\r
 570                         }\r
 571 \r
 572                 });\r
 573 \r
 574         }\r
 575 \r
 576         @Override\r
 577         public String toString() {\r
 578                 return "Statements[" + r1() + " - " + r2() + "]";\r
 579         }\r
 580 \r
 581         final private void finish(ReadGraphImpl graph, QueryProcessor provider) {\r
 582 \r
 583                 assert(isPending());\r
 584 \r
 585                 synchronized(this) {\r
 586                         setReady();\r
 587                 }\r
 588 \r
 589         }\r
 590 \r
 591         synchronized public void addOrSet(int s, int p, int o) {\r
 592 \r
 593                 assert(isPending());\r
 594 \r
 595                 IntArray value = (IntArray)getResult();\r
 596                 value.add(s);\r
 597                 value.add(p);\r
 598                 value.add(o);\r
 599 \r
 600         }\r
 601 \r
 602         @Override\r
 603         public void performFromCache(ReadGraphImpl graph, QueryProcessor provider, final TripleIntProcedure procedure) {\r
 604 \r
 605                 assert(isReady());\r
 606 \r
 607         if(handleException(graph, procedure)) return;\r
 608                 \r
 609                 final IntArray value = (IntArray)getResult();\r
 610                 for(int i=0;i<value.size();i+=3) {\r
 611                         procedure.execute(graph, value.data[i], value.data[i+1], value.data[i+2]);\r
 612                 }\r
 613 \r
 614                 procedure.finished(graph);\r
 615 \r
 616         }\r
 617 \r
 618         @Override\r
 619         public void recompute(ReadGraphImpl graph, QueryProcessor provider) {\r
 620 \r
 621                 final Semaphore s = new Semaphore(0);\r
 622 \r
 623                 computeForEach(graph, provider, new TripleIntProcedureAdapter() {\r
 624 \r
 625                         @Override\r
 626                         public void finished(ReadGraphImpl graph) {\r
 627                                 s.release();\r
 628                         }\r
 629 \r
 630                         @Override\r
 631                         public void exception(ReadGraphImpl graph, Throwable t) {\r
 632                                 new Error("Error in recompute.", t).printStackTrace();\r
 633                                 s.release();\r
 634                         }\r
 635 \r
 636                 }, true);\r
 637 \r
 638         while(!s.tryAcquire()) {\r
 639                 provider.resume(graph);\r
 640         }\r
 641 \r
 642         }\r
 643 \r
 644         @Override\r
 645         public int type() {\r
 646                 return RequestFlags.IMMEDIATE_UPDATE;\r
 647         }\r
 648         */\r
 649 \r
 650 }\r