diff options
author | Brian S. O'Neill <bronee@gmail.com> | 2007-03-31 18:28:22 +0000 |
---|---|---|
committer | Brian S. O'Neill <bronee@gmail.com> | 2007-03-31 18:28:22 +0000 |
commit | 926dd4e7f74e482e046da5cc20991addb572e0ec (patch) | |
tree | 3ec20d7518154743b41366d22391b9dc664ff084 /src/main/java/com/amazon/carbonado/qe | |
parent | b529e7ff822cae02abfb5e5af7eb74cc2afdf78b (diff) |
Consider weak matches in filtering score.
Diffstat (limited to 'src/main/java/com/amazon/carbonado/qe')
-rw-r--r-- | src/main/java/com/amazon/carbonado/qe/FilteringScore.java | 83 |
1 files changed, 83 insertions, 0 deletions
diff --git a/src/main/java/com/amazon/carbonado/qe/FilteringScore.java b/src/main/java/com/amazon/carbonado/qe/FilteringScore.java index d3b3f35..ebbb189 100644 --- a/src/main/java/com/amazon/carbonado/qe/FilteringScore.java +++ b/src/main/java/com/amazon/carbonado/qe/FilteringScore.java @@ -206,6 +206,22 @@ public class FilteringScore<S extends Storable> { indexProperties[indexPropPos].getDirection() == Direction.DESCENDING;
}
+ List<PropertyFilter<S>> weakMatchFilters = null;
+ if (!filterList.isEmpty()) {
+ // Any remainder property which is provided by the index is a weak match.
+ for (PropertyFilter<S> subFilter : filterList) {
+ ChainedProperty<S> filterProp = subFilter.getChainedProperty();
+ for (OrderedProperty<S> indexProp : indexProperties) {
+ if (indexProp.getChainedProperty().equals(filterProp)) {
+ if (weakMatchFilters == null) {
+ weakMatchFilters = new ArrayList<PropertyFilter<S>>();
+ }
+ weakMatchFilters.add(subFilter);
+ }
+ }
+ }
+ }
+
return new FilteringScore<S>(clustered,
unique,
indexProperties.length,
@@ -215,6 +231,7 @@ public class FilteringScore<S extends Storable> { arrangementScore,
preferenceScore,
filterList,
+ weakMatchFilters,
shouldReverseRange);
}
@@ -275,11 +292,14 @@ public class FilteringScore<S extends Storable> { private final BigInteger mPreferenceScore;
private final List<PropertyFilter<S>> mRemainderFilters;
+ private final List<PropertyFilter<S>> mWeakMatchFilters;
private final boolean mShouldReverseRange;
private transient Filter<S> mIdentityFilter;
private transient Filter<S> mRemainderFilter;
+ private transient Filter<S> mWeakMatchFilter;
+ private transient Filter<S> mWeakMatchRemainderFilter;
private FilteringScore(boolean indexClustered,
boolean indexUnique,
@@ -290,6 +310,7 @@ public class FilteringScore<S extends Storable> { int arrangementScore,
BigInteger preferenceScore,
List<PropertyFilter<S>> remainderFilters,
+ List<PropertyFilter<S>> weakMatchFilters,
boolean shouldReverseRange)
{
mIndexClustered = indexClustered;
@@ -301,6 +322,7 @@ public class FilteringScore<S extends Storable> { mArrangementScore = arrangementScore;
mPreferenceScore = preferenceScore;
mRemainderFilters = prepareList(remainderFilters);
+ mWeakMatchFilters = prepareList(weakMatchFilters);
mShouldReverseRange = shouldReverseRange;
}
@@ -519,6 +541,59 @@ public class FilteringScore<S extends Storable> { }
/**
+ * Returns number of property filters which are weakly supported by the
+ * evaluated index. This count is no more than the remainder count.
+ */
+ public int getWeakMatchCount() {
+ return mWeakMatchFilters.size();
+ }
+
+ /**
+ * Returns the filters which are weakly supported by the evaluated index,
+ * which is a subset of the remainder filters.
+ */
+ public List<PropertyFilter<S>> getWeakMatchFilters() {
+ return mWeakMatchFilters;
+ }
+
+ /**
+ * Returns the composite weak match filter supported by the evaluated
+ * index, or null if no weak match.
+ */
+ public Filter<S> getWeakMatchFilter() {
+ if (mWeakMatchFilter == null) {
+ mWeakMatchFilter = buildCompositeFilter(getWeakMatchFilters());
+ }
+ return mWeakMatchFilter;
+ }
+
+ /**
+ * Returns the composite remainder filter without including the weak match
+ * filter. Returns null if no remainder.
+ */
+ public Filter<S> getWeakMatchRemainderFilter() {
+ if (mWeakMatchRemainderFilter == null) {
+ List<PropertyFilter<S>> remainderFilters = mRemainderFilters;
+ List<PropertyFilter<S>> weakMatchFilters = mWeakMatchFilters;
+ if (weakMatchFilters.size() < remainderFilters.size()) {
+ Filter<S> composite = null;
+ for (int i=0; i<remainderFilters.size(); i++) {
+ Filter<S> subFilter = remainderFilters.get(i);
+ if (!weakMatchFilters.contains(subFilter)) {
+ if (composite == null) {
+ composite = subFilter;
+ } else {
+ composite = composite.and(subFilter);
+ }
+ }
+ }
+ mWeakMatchRemainderFilter = composite;
+ }
+ }
+ return mWeakMatchRemainderFilter;
+ }
+
+ /**
* Returns true if evaluated index is unique and each of its properties has
* an identity match. When index and filter are used in a query, expect at
* most one result.
@@ -589,6 +664,7 @@ public class FilteringScore<S extends Storable> { ", hasRangeStart=" + hasRangeStart() +
", hasRangeEnd=" + hasRangeEnd() +
", remainderCount=" + getRemainderCount() +
+ ", weakMatchCount=" + getWeakMatchCount() +
'}';
}
@@ -712,6 +788,13 @@ public class FilteringScore<S extends Storable> { return 1;
}
+ // Favor index which contains more weak matches.
+ if (first.getWeakMatchCount() > second.getWeakMatchCount()) {
+ return -1;
+ } else if (first.getWeakMatchCount() < second.getWeakMatchCount()) {
+ return 1;
+ }
+
// Favor index with fewer properties, under the assumption that fewer
// properties means smaller sized records that need to be read in.
if (first.getIndexPropertyCount() < second.getIndexPropertyCount()) {
|