From 755d0fa1dfa42d8987dd9dc2439f8a1f9c058fe9 Mon Sep 17 00:00:00 2001
From: "Brian S. O'Neill" <bronee@gmail.com>
Date: Sun, 6 Apr 2008 20:13:22 +0000
Subject: Added support for internal query hints.

---
 .../amazon/carbonado/qe/UnionQueryAnalyzer.java    | 31 +++++++++++++---------
 1 file changed, 18 insertions(+), 13 deletions(-)

(limited to 'src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java')

diff --git a/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java b/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java
index 1771c71..67da7ee 100644
--- a/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java
+++ b/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java
@@ -80,8 +80,9 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
     /**
      * @param filter optional filter which must be {@link Filter#isBound bound}
      * @param ordering optional properties which define desired ordering
+     * @param hints optional query hints
      */
-    public Result analyze(Filter<S> filter, OrderingList<S> ordering)
+    public Result analyze(Filter<S> filter, OrderingList<S> ordering, QueryHints hints)
         throws SupportException, RepositoryException
     {
         if (filter != null && !filter.isBound()) {
@@ -92,7 +93,7 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
             ordering = OrderingList.emptyList();
         }
 
-        return buildResult(filter, ordering);
+        return buildResult(filter, ordering, hints);
     }
 
     /**
@@ -100,25 +101,27 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
      *
      * @param filter optional filter which must be {@link Filter#isBound bound}
      * @param ordering optional properties which define desired ordering
+     * @param hints optional query hints
      */
-    public QueryExecutor<S> executor(Filter<S> filter, OrderingList<S> ordering)
+    public QueryExecutor<S> executor(Filter<S> filter, OrderingList<S> ordering, QueryHints hints)
         throws RepositoryException
     {
-        return analyze(filter, ordering).createExecutor();
+        return analyze(filter, ordering, hints).createExecutor();
     }
 
     /**
      * Splits the filter into sub-results, merges sub-results, and possibly
      * imposes a total ordering.
      */
-    private Result buildResult(Filter<S> filter, OrderingList<S> ordering)
+    private Result buildResult(Filter<S> filter, OrderingList<S> ordering, QueryHints hints)
         throws SupportException, RepositoryException
     {
         List<IndexedQueryAnalyzer<S>.Result> subResults;
         if (filter == null) {
-            subResults = Collections.singletonList(mIndexAnalyzer.analyze(filter, ordering));
+            subResults = Collections
+                .singletonList(mIndexAnalyzer.analyze(filter, ordering, hints));
         } else {
-            subResults = splitIntoSubResults(filter, ordering);
+            subResults = splitIntoSubResults(filter, ordering, hints);
         }
 
         if (subResults.size() <= 1) {
@@ -145,7 +148,7 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
 
             // Re-calc with specified direction. Only do one property at a time
             // since one simple change might alter the query plan.
-            subResults = splitIntoSubResults(filter, ordering);
+            subResults = splitIntoSubResults(filter, ordering, hints);
 
             if (subResults.size() <= 1) {
                 // Total ordering no longer required.
@@ -225,7 +228,7 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
 
             // Now augment the orderings and create new sub-results.
             ordering = ordering.concat(OrderedProperty.get(bestProperty, best.getBestDirection()));
-            subResults = splitIntoSubResults(filter, ordering);
+            subResults = splitIntoSubResults(filter, ordering, hints);
 
             if (subResults.size() <= 1) {
                 // Total ordering no longer required.
@@ -342,13 +345,13 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
      * Splits the filter into sub-results and possibly merges them.
      */
     private List<IndexedQueryAnalyzer<S>.Result>
-        splitIntoSubResults(Filter<S> filter, OrderingList<S> ordering)
+        splitIntoSubResults(Filter<S> filter, OrderingList<S> ordering, QueryHints hints)
         throws SupportException, RepositoryException
     {
         // Required for split to work.
         Filter<S> dnfFilter = filter.disjunctiveNormalForm();
 
-        Splitter splitter = new Splitter(ordering);
+        Splitter splitter = new Splitter(ordering, hints);
         RepositoryException e = dnfFilter.accept(splitter, null);
         if (e != null) {
             throw e;
@@ -569,11 +572,13 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
      */
     private class Splitter extends Visitor<S, RepositoryException, Object> {
         private final OrderingList<S> mOrdering;
+        private final QueryHints mHints;
 
         final List<IndexedQueryAnalyzer<S>.Result> mSubResults;
 
-        Splitter(OrderingList<S> ordering) {
+        Splitter(OrderingList<S> ordering, QueryHints hints) {
             mOrdering = ordering;
+            mHints = hints;
             mSubResults = new ArrayList<IndexedQueryAnalyzer<S>.Result>();
         }
 
@@ -639,7 +644,7 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
 
         private void subAnalyze(Filter<S> subFilter) throws SupportException, RepositoryException {
             IndexedQueryAnalyzer<S>.Result subResult =
-                mIndexAnalyzer.analyze(subFilter, mOrdering);
+                mIndexAnalyzer.analyze(subFilter, mOrdering, mHints);
 
             // Rather than blindly add to mSubResults, try to merge with
             // another result. This in turn reduces the number of cursors
-- 
cgit v1.2.3