From 295c4484f89014235c35c7f432c5a778b703fa4f Mon Sep 17 00:00:00 2001
From: "Brian S. O'Neill" <bronee@gmail.com>
Date: Tue, 10 Oct 2006 05:43:48 +0000
Subject: Removed broken (and useless) delegate merging optimization.

---
 .../com/amazon/carbonado/qe/FilteringScore.java    | 28 ++++++++++++++++++++
 .../amazon/carbonado/qe/IndexedQueryAnalyzer.java  | 24 ++++++++++++++---
 .../amazon/carbonado/qe/UnionQueryAnalyzer.java    | 30 ++--------------------
 3 files changed, 50 insertions(+), 32 deletions(-)

diff --git a/src/main/java/com/amazon/carbonado/qe/FilteringScore.java b/src/main/java/com/amazon/carbonado/qe/FilteringScore.java
index d872ec6..22a8c86 100644
--- a/src/main/java/com/amazon/carbonado/qe/FilteringScore.java
+++ b/src/main/java/com/amazon/carbonado/qe/FilteringScore.java
@@ -429,6 +429,34 @@ public class FilteringScore<S extends Storable> {
         return reduce(getRangeEndFilters(), RelOp.LE);
     }
 
+    /**
+     * Returns the count of all handled property filters.
+     */
+    public int getHandledCount() {
+        return getIdentityCount() + mRangeStartFilters.size() + mRangeEndFilters.size();
+    }
+
+    /**
+     * Returns the composite handled filter, or null if no matches at all.
+     */
+    public Filter<S> getHandledFilter() {
+        Filter<S> identity = getIdentityFilter();
+        Filter<S> rangeStart = buildCompositeFilter(getRangeStartFilters());
+        Filter<S> rangeEnd = buildCompositeFilter(getRangeEndFilters());
+
+        return and(and(identity, rangeStart), rangeEnd);
+    }
+
+    private Filter<S> and(Filter<S> a, Filter<S> b) {
+        if (a == null) {
+            return b;
+        }
+        if (b == null) {
+            return a;
+        }
+        return a.and(b);
+    }
+
     /**
      * Returns true if there is both a range start and range end.
      */
diff --git a/src/main/java/com/amazon/carbonado/qe/IndexedQueryAnalyzer.java b/src/main/java/com/amazon/carbonado/qe/IndexedQueryAnalyzer.java
index 219400c..73837a0 100644
--- a/src/main/java/com/amazon/carbonado/qe/IndexedQueryAnalyzer.java
+++ b/src/main/java/com/amazon/carbonado/qe/IndexedQueryAnalyzer.java
@@ -428,13 +428,19 @@ public class IndexedQueryAnalyzer<S extends Storable> {
                 return this;
             }
 
+            // Assuming canMergeRemainder returned true, each handled filter
+            // and the combined filter are all identical. This is just a safeguard.
+            Filter<S> handledFilter =
+                orFilters(getCompositeScore().getFilteringScore().getHandledFilter(),
+                          other.getCompositeScore().getFilteringScore().getHandledFilter());
+
             Filter<S> remainderFilter =
-                mergeFilters(getRemainderFilter(), other.getRemainderFilter());
+                orFilters(getRemainderFilter(), other.getRemainderFilter());
 
             OrderingList<S> remainderOrdering =
                 getRemainderOrdering().concat(other.getRemainderOrdering()).reduce();
 
-            Filter<S> filter = mergeFilters(getFilter(), remainderFilter);
+            Filter<S> filter = andFilters(handledFilter, remainderFilter);
 
             return new Result
                 (filter, mScore, mLocalIndex, mForeignIndex, mForeignProperty,
@@ -447,10 +453,20 @@ public class IndexedQueryAnalyzer<S extends Storable> {
          * doesn't usually make sense to call this method.
          */
         public Result mergeRemainderFilter(Filter<S> filter) {
-            return setRemainderFilter(mergeFilters(getRemainderFilter(), filter));
+            return setRemainderFilter(orFilters(getRemainderFilter(), filter));
+        }
+
+        private Filter<S> andFilters(Filter<S> a, Filter<S> b) {
+            if (a == null) {
+                return b;
+            }
+            if (b == null) {
+                return a;
+            }
+            return a.and(b).reduce();
         }
 
-        private Filter<S> mergeFilters(Filter<S> a, Filter<S> b) {
+        private Filter<S> orFilters(Filter<S> a, Filter<S> b) {
             if (a == null) {
                 return b;
             }
diff --git a/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java b/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java
index b06edba..3e7a0a3 100644
--- a/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java
+++ b/src/main/java/com/amazon/carbonado/qe/UnionQueryAnalyzer.java
@@ -325,7 +325,7 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
     }
 
     private Direction findHandledDirection(IndexedQueryAnalyzer<S>.Result result,
-                                           OrderedProperty unspecified)
+                                           OrderedProperty<S> unspecified)
     {
         ChainedProperty<S> chained = unspecified.getChainedProperty();
         OrderingScore<S> score = result.getCompositeScore().getOrderingScore();
@@ -431,22 +431,6 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
         return mergedResults;
     }
 
-    Storage storageDelegate(IndexedQueryAnalyzer<S>.Result result)
-        throws SupportException, RepositoryException
-    {
-        StorableIndex<S> localIndex = result.getLocalIndex();
-        StorageAccess<S> localAccess = mRepoAccess.storageAccessFor(getStorableType());
-
-        if (localIndex != null) {
-            return localAccess.storageDelegate(localIndex);
-        }
-
-        StorableIndex foreignIndex = result.getForeignIndex();
-        StorageAccess foreignAccess = mRepoAccess.storageAccessFor(foreignIndex.getStorableType());
-
-        return foreignAccess.storageDelegate(foreignIndex);
-    }
-
     public class Result {
         private final List<IndexedQueryAnalyzer<S>.Result> mSubResults;
         private final OrderingList<S> mTotalOrdering;
@@ -646,8 +630,6 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
             IndexedQueryAnalyzer<S>.Result subResult =
                 mIndexAnalyzer.analyze(subFilter, mOrdering);
 
-            Storage subResultStorage = storageDelegate(subResult);
-
             // Rather than blindly add to mSubResults, try to merge with
             // another result. This in turn reduces the number of cursors
             // needed by the union.
@@ -655,15 +637,7 @@ public class UnionQueryAnalyzer<S extends Storable> implements QueryExecutorFact
             int size = mSubResults.size();
             for (int i=0; i<size; i++) {
                 IndexedQueryAnalyzer<S>.Result existing = mSubResults.get(i);
-                boolean canMerge = existing.canMergeRemainder(subResult);
-                if (!canMerge) {
-                    Storage existingStorage = storageDelegate(existing);
-                    if (existingStorage != null && existingStorage == subResultStorage) {
-                        // Merge common delegates together.
-                        canMerge = true;
-                    }
-                }
-                if (canMerge) {
+                if (existing.canMergeRemainder(subResult)) {
                     mSubResults.set(i, existing.mergeRemainder(subResult));
                     return;
                 }
-- 
cgit v1.2.3