--- /dev/null
+package org.apache.lucene.search;
+
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import java.io.Serializable;
+import java.io.IOException;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+import org.apache.lucene.index.IndexReader;
+import org.apache.lucene.util.FixedBitSet;
+
+/**
+ * Wraps another filter's result and caches it. The purpose is to allow
+ * filters to simply filter, and then wrap with this class
+ * to add caching.
+ *
+ * <p><b>NOTE</b>: if you wrap this filter as a query (eg,
+ * using ConstantScoreQuery), you'll likely want to enforce
+ * deletions (using either {@link DeletesMode#RECACHE} or
+ * {@link DeletesMode#DYNAMIC}).
+ */
+public class CachingWrapperFilter extends Filter {
+ Filter filter;
+
+ /**
+ * Expert: Specifies how new deletions against a reopened
+ * reader should be handled.
+ *
+ * <p>The default is IGNORE, which means the cache entry
+ * will be re-used for a given segment, even when that
+ * segment has been reopened due to changes in deletions.
+ * This is a big performance gain, especially with
+ * near-real-timer readers, since you don't hit a cache
+ * miss on every reopened reader for prior segments.</p>
+ *
+ * <p>However, in some cases this can cause invalid query
+ * results, allowing deleted documents to be returned.
+ * This only happens if the main query does not rule out
+ * deleted documents on its own, such as a toplevel
+ * ConstantScoreQuery. To fix this, use RECACHE to
+ * re-create the cached filter (at a higher per-reopen
+ * cost, but at faster subsequent search performance), or
+ * use DYNAMIC to dynamically intersect deleted docs (fast
+ * reopen time but some hit to search performance).</p>
+ */
+ public static enum DeletesMode {IGNORE, RECACHE, DYNAMIC};
+
+ protected final FilterCache<DocIdSet> cache;
+
+ static abstract class FilterCache<T> implements Serializable {
+
+ /**
+ * A transient Filter cache (package private because of test)
+ */
+ // NOTE: not final so that we can dynamically re-init
+ // after de-serialize
+ transient Map<Object,T> cache;
+
+ private final DeletesMode deletesMode;
+
+ public FilterCache(DeletesMode deletesMode) {
+ this.deletesMode = deletesMode;
+ }
+
+ public synchronized T get(IndexReader reader, Object coreKey, Object delCoreKey) throws IOException {
+ T value;
+
+ if (cache == null) {
+ cache = new WeakHashMap<Object,T>();
+ }
+
+ if (deletesMode == DeletesMode.IGNORE) {
+ // key on core
+ value = cache.get(coreKey);
+ } else if (deletesMode == DeletesMode.RECACHE) {
+ // key on deletes, if any, else core
+ value = cache.get(delCoreKey);
+ } else {
+ assert deletesMode == DeletesMode.DYNAMIC;
+
+ // first try for exact match
+ value = cache.get(delCoreKey);
+
+ if (value == null) {
+ // now for core match, but dynamically AND NOT
+ // deletions
+ value = cache.get(coreKey);
+ if (value != null && reader.hasDeletions()) {
+ value = mergeDeletes(reader, value);
+ }
+ }
+ }
+
+ return value;
+ }
+
+ protected abstract T mergeDeletes(IndexReader reader, T value);
+
+ public synchronized void put(Object coreKey, Object delCoreKey, T value) {
+ if (deletesMode == DeletesMode.IGNORE) {
+ cache.put(coreKey, value);
+ } else if (deletesMode == DeletesMode.RECACHE) {
+ cache.put(delCoreKey, value);
+ } else {
+ cache.put(coreKey, value);
+ cache.put(delCoreKey, value);
+ }
+ }
+ }
+
+ /**
+ * New deletes are ignored by default, which gives higher
+ * cache hit rate on reopened readers. Most of the time
+ * this is safe, because the filter will be AND'd with a
+ * Query that fully enforces deletions. If instead you
+ * need this filter to always enforce deletions, pass
+ * either {@link DeletesMode#RECACHE} or {@link
+ * DeletesMode#DYNAMIC}.
+ * @param filter Filter to cache results of
+ */
+ public CachingWrapperFilter(Filter filter) {
+ this(filter, DeletesMode.IGNORE);
+ }
+
+ /**
+ * Expert: by default, the cached filter will be shared
+ * across reopened segments that only had changes to their
+ * deletions.
+ *
+ * @param filter Filter to cache results of
+ * @param deletesMode See {@link DeletesMode}
+ */
+ public CachingWrapperFilter(Filter filter, DeletesMode deletesMode) {
+ this.filter = filter;
+ cache = new FilterCache<DocIdSet>(deletesMode) {
+ @Override
+ public DocIdSet mergeDeletes(final IndexReader r, final DocIdSet docIdSet) {
+ return new FilteredDocIdSet(docIdSet) {
+ @Override
+ protected boolean match(int docID) {
+ return !r.isDeleted(docID);
+ }
+ };
+ }
+ };
+ }
+
+ /** Provide the DocIdSet to be cached, using the DocIdSet provided
+ * by the wrapped Filter.
+ * <p>This implementation returns the given {@link DocIdSet}, if {@link DocIdSet#isCacheable}
+ * returns <code>true</code>, else it copies the {@link DocIdSetIterator} into
+ * an {@link FixedBitSet}.
+ */
+ protected DocIdSet docIdSetToCache(DocIdSet docIdSet, IndexReader reader) throws IOException {
+ if (docIdSet == null) {
+ // this is better than returning null, as the nonnull result can be cached
+ return DocIdSet.EMPTY_DOCIDSET;
+ } else if (docIdSet.isCacheable()) {
+ return docIdSet;
+ } else {
+ final DocIdSetIterator it = docIdSet.iterator();
+ // null is allowed to be returned by iterator(),
+ // in this case we wrap with the empty set,
+ // which is cacheable.
+ if (it == null) {
+ return DocIdSet.EMPTY_DOCIDSET;
+ } else {
+ final FixedBitSet bits = new FixedBitSet(reader.maxDoc());
+ bits.or(it);
+ return bits;
+ }
+ }
+ }
+
+ // for testing
+ int hitCount, missCount;
+
+ @Override
+ public DocIdSet getDocIdSet(IndexReader reader) throws IOException {
+
+ final Object coreKey = reader.getCoreCacheKey();
+ final Object delCoreKey = reader.hasDeletions() ? reader.getDeletesCacheKey() : coreKey;
+
+ DocIdSet docIdSet = cache.get(reader, coreKey, delCoreKey);
+ if (docIdSet != null) {
+ hitCount++;
+ return docIdSet;
+ }
+
+ missCount++;
+
+ // cache miss
+ docIdSet = docIdSetToCache(filter.getDocIdSet(reader), reader);
+
+ if (docIdSet != null) {
+ cache.put(coreKey, delCoreKey, docIdSet);
+ }
+
+ return docIdSet;
+ }
+
+ @Override
+ public String toString() {
+ return "CachingWrapperFilter("+filter+")";
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (!(o instanceof CachingWrapperFilter)) return false;
+ return this.filter.equals(((CachingWrapperFilter)o).filter);
+ }
+
+ @Override
+ public int hashCode() {
+ return filter.hashCode() ^ 0x1117BF25;
+ }
+}
fnp / pylucene.git / blobdiff