[Mulgara-svn] r1558 - in branches/mgr-183-project/src/jar: resolver-store/java/org/mulgara/resolver/store resolver-store/java/org/mulgara/store/statement/xa tuples/java/org/mulgara/store/tuples

andrae at mulgara.org andrae at mulgara.org
Thu Feb 26 12:24:58 UTC 2009


Author: andrae
Date: 2009-02-26 04:24:55 -0800 (Thu, 26 Feb 2009)
New Revision: 1558

Modified:
   branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/resolver/store/StatementStoreResolution.java
   branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/store/statement/xa/XAStatementStoreImpl.java
   branches/mgr-183-project/src/jar/tuples/java/org/mulgara/store/tuples/ReorderAnnotation.java
Log:
refs #183

Refactored XAStatementStoreImpl to seperate the selection of the index from the selection of the find method
on the index.  This allows us to select the best valid index for a set of bound variables matching an ordering
preference for the unbound variables.  This is necessary if higher level code is to avoid a sort.



Modified: branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/resolver/store/StatementStoreResolution.java
===================================================================
--- branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/resolver/store/StatementStoreResolution.java	2009-02-25 19:20:31 UTC (rev 1557)
+++ branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/resolver/store/StatementStoreResolution.java	2009-02-26 12:24:55 UTC (rev 1558)
@@ -47,6 +47,7 @@
 import org.mulgara.store.tuples.Annotation;
 import org.mulgara.store.tuples.AbstractTuples;
 import org.mulgara.store.tuples.DefinablePrefixAnnotation;
+import org.mulgara.store.tuples.ReorderAnnotation;
 import org.mulgara.store.tuples.ReresolveAnnotation;
 import org.mulgara.store.tuples.StoreTuples;
 import org.mulgara.store.tuples.Tuples;
@@ -559,6 +560,27 @@
           defineIndex(bound);
         }
       };
+    } else if (annotation.equals(ReorderAnnotation.class)) {
+      return null;
+      // Note: This isn't going to work, as the defineIndex() calls commits us to binding the
+      //       variable, when we just want to order on it.  It is however a starting point.
+//      return new ReorderAnnotation() {
+//        public Tuples reorder(List<Set<Variable>> partialOrder) throws TuplesException {
+//          if (partialOrder.size() == 0) {
+//            throw new TuplesException("Empty partial-order passed to reorder");
+//          } else if (partialOrder.size() == 1) {
+//            return this.clone();
+//          } else if (partialOrder.size() == 2) {
+//            Set<Variable> prefixSet = partialOrder.get(0);
+//            Tuples reordered = this.clone();
+//            reordered.getAnnotation(DefinablePrefixAnnotation.class).defineIndex(prefixSet);
+//
+//            return reordered;
+//          } else {
+//            throw new TuplesException("Unable to satisfy partial-order - greater than 2 equivalence sets unsupported");
+//          }
+//        }
+//      };
     } else if (annotation.equals(ReresolveAnnotation.class)) {
       return new ReresolveAnnotation() {
         public Tuples reresolve(final Map<? extends ConstraintElement, Long> bindings) throws TuplesException {

Modified: branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/store/statement/xa/XAStatementStoreImpl.java
===================================================================
--- branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/store/statement/xa/XAStatementStoreImpl.java	2009-02-25 19:20:31 UTC (rev 1557)
+++ branches/mgr-183-project/src/jar/resolver-store/java/org/mulgara/store/statement/xa/XAStatementStoreImpl.java	2009-02-26 12:24:55 UTC (rev 1558)
@@ -129,30 +129,29 @@
       {3, 2, 0, 1}
   };
 
-  private final static int[] selectIndex = {
-    /* XXXX */ TI_0123,
-    /* XXX0 */ TI_0123,
-    /* XX1X */ TI_1203,
-    /* XX10 */ TI_0123,
-    /* X2XX */ TI_2013,
-    /* X2X0 */ TI_2013,
-    /* X21X */ TI_1203,
-    /* X210 */ TI_0123,
-    /* 3XXX */ TI_3012,
-    /* 3XX0 */ TI_3012,
-    /* 3X1X */ TI_3120,
-    /* 3X10 */ TI_3012,
-    /* 32XX */ TI_3201,
-    /* 32X0 */ TI_3201,
-    /* 321X */ TI_3120,
-    /* 3210 */ TI_0123
-  };
-
   /*
    * Primary index = Mask of bound or committed vars.
    * Secondary index = Mask of preferred vars.
    * -1 indicates that the preferred vars cannot be satisfied.
-   * Query should then use selectIndex[] and perform a sort to obtain preferred vars.
+   * Query should then use selectIndexSet[mask][0] and perform a sort to obtain preferred vars.
+   *
+   * Default indexes for each variableMask:
+   * XXXX = TI_0123
+   * XXX0 = TI_0123
+   * XX1X = TI_1203
+   * XX10 = TI_0123
+   * X2XX = TI_2013
+   * X2X0 = TI_2013
+   * X21X = TI_1203
+   * X210 = TI_0123
+   * 3XXX = TI_3012
+   * 3XX0 = TI_3012
+   * 3X1X = TI_3120
+   * 3X10 = TI_3012
+   * 32XX = TI_3201
+   * 32X0 = TI_3201
+   * 321X = TI_3120
+   * 3210 = TI_0123
    */
   private final static int[][] selectIndexSet = {
     /* XXXX */ {
@@ -2023,105 +2022,75 @@
      * @return A StoreTuples containing all the triples which match the search.
      * @throws StatementStoreException EXCEPTION TO DO
      */
-    StoreTuples findTuples(int variableMask, long node0, long node1, long node2, long node3) throws StatementStoreException {
-      if (
-          node0 < NodePool.NONE ||
+    StoreTuples findTuples(int preference, long node0, long node1, long node2, long node3) throws StatementStoreException {
+      if (preference < 0 || preference > 15) {
+        throw new StatementStoreException("Invalid variable preference: " + preference);
+      }
+      if (node0 < NodePool.NONE ||
           node1 < NodePool.NONE ||
           node2 < NodePool.NONE ||
-          node3 < NodePool.NONE
-      ) {
+          node3 < NodePool.NONE) {
         // There is at least one query node.  Return an empty StoreTuples.
         return TuplesOperations.empty();
       }
 
-      if (0 == (variableMask & MASK3)) throw new StatementStoreException("This version of find is for re-ordering graphs, base on a given mask.");
-      try {
-        switch (variableMask) {
-          case MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3);
-          case MASK0 | MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3);
-          case MASK1 | MASK3:
-            return tripleAVLFilePhases[TI_3120].findTuples(node3);
-          case MASK0 | MASK1 | MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3);
-          case MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3201].findTuples(node3);
-          case MASK0 | MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3201].findTuples(node3);
-          case MASK1 | MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3120].findTuples(node3);
-          case MASK0 | MASK1 | MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3);
-          default:
-            throw new AssertionError();
-        }
-      } catch (IOException ex) {
-        throw new StatementStoreException("I/O error", ex);
+      int boundMask = 0;
+      boundMask += node0 != NodePool.NONE ? 1 : 0;
+      boundMask += node1 != NodePool.NONE ? 2 : 0;
+      boundMask += node2 != NodePool.NONE ? 4 : 0;
+      boundMask += node3 != NodePool.NONE ? 8 : 0;
+
+      if (selectIndexSet[boundMask][preference] < 0) {
+        return findTuplesFromPhase(tripleAVLFilePhases[selectIndexSet[boundMask][preference]],
+            node0, node1, node2, node3);
+      } else {
+        return null;
       }
     }
 
-    /**
-     * Finds triples matching the given specification.
-     *
-     * @param node0 The 0 node of the triple to find.
-     * @param node1 The 1 node of the triple to find.
-     * @param node2 The 2 node of the triple to find.
-     * @param node3 The 3 node of the triple to find.
-     * @return A StoreTuples containing all the triples which match the search.
-     * @throws StatementStoreException EXCEPTION TO DO
-     */
-    StoreTuples findTuples(long node0, long node1, long node2, long node3) throws StatementStoreException {
-      if (
-          node0 < NodePool.NONE ||
-          node1 < NodePool.NONE ||
-          node2 < NodePool.NONE ||
-          node3 < NodePool.NONE
-      ) {
-        // There is at least one query node.  Return an empty StoreTuples.
-        return TuplesOperations.empty();
-      }
+    StoreTuples findTuplesFromPhase(TripleAVLFile.Phase phase, long node0, long node1, long node2, long node3)
+        throws StatementStoreException {
 
       int variableMask =
         (node0 != NONE ? MASK0 : 0) |
         (node1 != NONE ? MASK1 : 0) |
         (node2 != NONE ? MASK2 : 0) |
         (node3 != NONE ? MASK3 : 0);
-
+     
       try {
         switch (variableMask) {
           case 0:
-            return tripleAVLFilePhases[TI_0123].allTuples();
+            return phase.allTuples();
           case MASK0:
-            return tripleAVLFilePhases[TI_0123].findTuples(node0);
+            return phase.findTuples(node0);
           case MASK1:
-            return tripleAVLFilePhases[TI_1203].findTuples(node1);
+            return phase.findTuples(node1);
           case MASK0 | MASK1:
-            return tripleAVLFilePhases[TI_0123].findTuples(node0, node1);
+            return phase.findTuples(node0, node1);
           case MASK2:
-            return tripleAVLFilePhases[TI_2013].findTuples(node2);
+            return phase.findTuples(node2);
           case MASK0 | MASK2:
-            return tripleAVLFilePhases[TI_2013].findTuples(node2, node0);
+            return phase.findTuples(node2, node0);
           case MASK1 | MASK2:
-            return tripleAVLFilePhases[TI_1203].findTuples(node1, node2);
+            return phase.findTuples(node1, node2);
           case MASK0 | MASK1 | MASK2:
-            return tripleAVLFilePhases[TI_0123].findTuples(node0, node1, node2);
+            return phase.findTuples(node0, node1, node2);
           case MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3);
+            return phase.findTuples(node3);
           case MASK0 | MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3, node0);
+            return phase.findTuples(node3, node0);
           case MASK1 | MASK3:
-            return tripleAVLFilePhases[TI_3120].findTuples(node3, node1);
+            return phase.findTuples(node3, node1);
           case MASK0 | MASK1 | MASK3:
-            return tripleAVLFilePhases[TI_3012].findTuples(node3, node0, node1);
+            return phase.findTuples(node3, node0, node1);
           case MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3201].findTuples(node3, node2);
+            return phase.findTuples(node3, node2);
           case MASK0 | MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3201].findTuples(node3, node2, node0);
+            return phase.findTuples(node3, node2, node0);
           case MASK1 | MASK2 | MASK3:
-            return tripleAVLFilePhases[TI_3120].findTuples(node3, node1, node2);
+            return phase.findTuples(node3, node1, node2);
           case MASK0 | MASK1 | MASK2 | MASK3:
-            if (tripleAVLFilePhases[TI_0123].existsTriple(node0, node1, node2, node3)) {
+            if (phase.existsTriple(node0, node1, node2, node3)) {
               return TuplesOperations.unconstrained();
             }
             return TuplesOperations.empty();
@@ -2133,7 +2102,23 @@
       }
     }
 
+    /**
+     * Finds triples matching the given specification.
+     *
+     * @param node0 The 0 node of the triple to find.
+     * @param node1 The 1 node of the triple to find.
+     * @param node2 The 2 node of the triple to find.
+     * @param node3 The 3 node of the triple to find.
+     * @return A StoreTuples containing all the triples which match the search.
+     * @throws StatementStoreException EXCEPTION TO DO
+     */
+    StoreTuples findTuples(long node0, long node1, long node2, long node3) throws StatementStoreException {
+      StoreTuples result = findTuples(0, node0, node1, node2, node3);
+      assert result != null;
+      return result;
+    }
 
+
     StoreTuples findTuples(boolean node0Bound, boolean node1Bound, boolean node2Bound, boolean node3Bound)
         throws StatementStoreException {
       int variableMask =
@@ -2142,7 +2127,7 @@
           (node2Bound ? MASK2 : 0) |
           (node3Bound ? MASK3 : 0);
 
-      return tripleAVLFilePhases[selectIndex[variableMask]].allTuples();
+      return tripleAVLFilePhases[selectIndexSet[variableMask][0]].allTuples();
     }
 
 

Modified: branches/mgr-183-project/src/jar/tuples/java/org/mulgara/store/tuples/ReorderAnnotation.java
===================================================================
--- branches/mgr-183-project/src/jar/tuples/java/org/mulgara/store/tuples/ReorderAnnotation.java	2009-02-25 19:20:31 UTC (rev 1557)
+++ branches/mgr-183-project/src/jar/tuples/java/org/mulgara/store/tuples/ReorderAnnotation.java	2009-02-26 12:24:55 UTC (rev 1558)
@@ -21,8 +21,7 @@
  */
 
 public class ReorderAnnotation implements Annotation {
-  public ReorderAnnotation() {
-  }
+  public ReorderAnnotation() { }
 
   /**
    * Returns a new tuples identical to this tuples, but with variables




More information about the Mulgara-svn mailing list