lucene-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From a.@apache.org
Subject [17/35] lucene-solr:jira/solr-11779: LUCENE-8144: Moved QueryCachingPolicy.ALWAYS_CACHE to the test framework.
Date Mon, 28 May 2018 15:40:00 GMT
LUCENE-8144: Moved QueryCachingPolicy.ALWAYS_CACHE to the test framework.


Project: http://git-wip-us.apache.org/repos/asf/lucene-solr/repo
Commit: http://git-wip-us.apache.org/repos/asf/lucene-solr/commit/24d79de7
Tree: http://git-wip-us.apache.org/repos/asf/lucene-solr/tree/24d79de7
Diff: http://git-wip-us.apache.org/repos/asf/lucene-solr/diff/24d79de7

Branch: refs/heads/jira/solr-11779
Commit: 24d79de796dcba20a43f7325f220513f7773f1fb
Parents: 0e4e009
Author: Adrien Grand <jpountz@gmail.com>
Authored: Fri May 25 08:47:00 2018 +0200
Committer: Adrien Grand <jpountz@gmail.com>
Committed: Fri May 25 09:30:10 2018 +0200

----------------------------------------------------------------------
 lucene/CHANGES.txt                              |  3 +
 lucene/MIGRATE.txt                              |  5 ++
 .../lucene/search/QueryCachingPolicy.java       | 13 -----
 .../apache/lucene/search/TestLRUQueryCache.java | 58 ++++++++++++--------
 4 files changed, 43 insertions(+), 36 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/24d79de7/lucene/CHANGES.txt
----------------------------------------------------------------------
diff --git a/lucene/CHANGES.txt b/lucene/CHANGES.txt
index 5d5b7f2..1b2ba84 100644
--- a/lucene/CHANGES.txt
+++ b/lucene/CHANGES.txt
@@ -44,6 +44,9 @@ API Changes
 * LUCENE-8267: Memory codecs removed from the codebase (MemoryPostings,
   MemoryDocValues). (Dawid Weiss)
 
+* LUCENE-8144: Moved QueryCachingPolicy.ALWAYS_CACHE to the test framework.
+  (Nhat Nguyen via Adrien Grand)
+
 Changes in Runtime Behavior
 
 * LUCENE-7837: Indices that were created before the previous major version

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/24d79de7/lucene/MIGRATE.txt
----------------------------------------------------------------------
diff --git a/lucene/MIGRATE.txt b/lucene/MIGRATE.txt
index 0f9fcf6..fb7ee08 100644
--- a/lucene/MIGRATE.txt
+++ b/lucene/MIGRATE.txt
@@ -47,3 +47,8 @@ a boost of 1f.
 ## Memory codecs removed (LUCENE-8267) ##
 
 Memory codecs have been removed from the codebase (MemoryPostings, MemoryDocValues).
+
+## QueryCachingPolicy.ALWAYS_CACHE removed (LUCENE-8144) ##
+
+Caching everything is discouraged as it disables the ability to skip non-interesting documents.
+ALWAYS_CACHE can be replaced by a UsageTrackingQueryCachingPolicy with an appropriate config.

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/24d79de7/lucene/core/src/java/org/apache/lucene/search/QueryCachingPolicy.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/java/org/apache/lucene/search/QueryCachingPolicy.java b/lucene/core/src/java/org/apache/lucene/search/QueryCachingPolicy.java
index fabd971..e6364fa 100644
--- a/lucene/core/src/java/org/apache/lucene/search/QueryCachingPolicy.java
+++ b/lucene/core/src/java/org/apache/lucene/search/QueryCachingPolicy.java
@@ -31,19 +31,6 @@ import java.io.IOException;
 // TODO: add APIs for integration with IndexWriter.IndexReaderWarmer
 public interface QueryCachingPolicy {
 
-  /** A simple policy that caches all the provided filters on all segments. */
-  public static final QueryCachingPolicy ALWAYS_CACHE = new QueryCachingPolicy() {
-
-    @Override
-    public void onUse(Query query) {}
-
-    @Override
-    public boolean shouldCache(Query query) throws IOException {
-      return true;
-    }
-
-  };
-
   /** Callback that is called every time that a cached filter is used.
    *  This is typically useful if the policy wants to track usage statistics
    *  in order to make decisions. */

http://git-wip-us.apache.org/repos/asf/lucene-solr/blob/24d79de7/lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java
----------------------------------------------------------------------
diff --git a/lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java b/lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java
index d0eaa43..b3e1ed3 100644
--- a/lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java
+++ b/lucene/core/src/test/org/apache/lucene/search/TestLRUQueryCache.java
@@ -65,6 +65,18 @@ import org.apache.lucene.util.TestUtil;
 
 public class TestLRUQueryCache extends LuceneTestCase {
 
+  private static final QueryCachingPolicy ALWAYS_CACHE = new QueryCachingPolicy() {
+
+    @Override
+    public void onUse(Query query) {}
+
+    @Override
+    public boolean shouldCache(Query query) throws IOException {
+      return true;
+    }
+
+  };
+
   private static final QueryCachingPolicy NEVER_CACHE = new QueryCachingPolicy() {
 
     @Override
@@ -195,7 +207,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     searcher.search(new ConstantScoreQuery(green), 1);
     assertEquals(Collections.emptyList(), queryCache.cachedQueries());
 
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     searcher.search(new ConstantScoreQuery(red), 1);
     assertEquals(Collections.singletonList(red), queryCache.cachedQueries());
 
@@ -244,7 +256,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
 
     final LRUQueryCache queryCache = new LRUQueryCache(Integer.MAX_VALUE, Long.MAX_VALUE,
context -> true);
     searcher.setQueryCache(queryCache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     searcher.search(new BoostQuery(new ConstantScoreQuery(query1), random().nextFloat()),
1);
     assertEquals(1, queryCache.cachedQueries().size());
@@ -414,7 +426,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     final DirectoryReader reader = w.getReader();
     final IndexSearcher searcher = new IndexSearcher(reader);
     searcher.setQueryCache(queryCache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     final int numQueries = atLeast(1000);
     for (int i = 0; i < numQueries; ++i) {
@@ -532,7 +544,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     assertEquals(0, queryCache.getCacheSize());
 
     // second pass, lookups + caching, only the first one is a miss
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     for (int i = 0; i < 10; ++i) {
       searcher.search(new ConstantScoreQuery(query), 1);
     }
@@ -556,7 +568,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     assertEquals(1 * segmentCount, queryCache.getCacheSize());
 
     // fourth pass with a different filter which will trigger evictions since the size is
1
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     for (int i = 0; i < 10; ++i) {
       searcher.search(new ConstantScoreQuery(query2), 1);
     }
@@ -698,7 +710,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
 
     for (IndexSearcher searcher : Arrays.asList(searcher1, searcher2)) {
       searcher.setQueryCache(queryCache);
-      searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+      searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     }
 
     // search on searcher1
@@ -801,7 +813,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
 
     final LRUQueryCache queryCache = new LRUQueryCache(1000000, 10000000, context -> true);
     searcher.setQueryCache(queryCache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     BooleanQuery.Builder bq = new BooleanQuery.Builder();
     TermQuery should = new TermQuery(new Term("foo", "baz"));
@@ -920,7 +932,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
         uncachedSearcher.setQueryCache(null);
         cachedSearcher = newSearcher(reader);
         cachedSearcher.setQueryCache(queryCache);
-        cachedSearcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+        cachedSearcher.setQueryCachingPolicy(ALWAYS_CACHE);
       }
       final Query q = buildRandomQuery(0);
       assertEquals(uncachedSearcher.count(q), cachedSearcher.count(q));
@@ -983,7 +995,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     final LRUQueryCache queryCache = new LRUQueryCache(1, 10000, context -> true);
     final IndexSearcher searcher = newSearcher(reader);
     searcher.setQueryCache(queryCache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     BadQuery query = new BadQuery();
     searcher.count(query);
@@ -1017,7 +1029,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     final LRUQueryCache queryCache = new LRUQueryCache(1, 1, context -> random().nextBoolean());
     final IndexSearcher searcher = newSearcher(reader);
     searcher.setQueryCache(queryCache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     searcher.count(new MatchAllDocsQuery());
     assertEquals(0, queryCache.getCacheCount());
@@ -1152,7 +1164,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     bulkScorerCalled.set(false);
     weight = searcher.createWeight(new MatchAllDocsQuery(), ScoreMode.COMPLETE_NO_SCORES,
1);
     weight = new WeightWrapper(weight, scorerCalled, bulkScorerCalled);
-    weight = cache.doCache(weight, QueryCachingPolicy.ALWAYS_CACHE);
+    weight = cache.doCache(weight, ALWAYS_CACHE);
     weight.scorer(leaf);
     assertEquals(true, bulkScorerCalled.get());
     assertEquals(false, scorerCalled.get());
@@ -1177,7 +1189,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     };
 
     searcher.setQueryCache(queryCache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     Query query = new DummyQuery();
     searcher.count(query);
@@ -1196,7 +1208,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     w.addDocument(new Document());
     DirectoryReader reader = w.getReader();
     IndexSearcher searcher = newSearcher(reader);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     LRUQueryCache cache = new LRUQueryCache(2, 10000, new LRUQueryCache.MinSegmentSizePredicate(2,
0f));
     searcher.setQueryCache(cache);
@@ -1217,7 +1229,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     reader.close();
     reader = w.getReader();
     searcher = newSearcher(reader);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     cache = new LRUQueryCache(2, 10000, new LRUQueryCache.MinSegmentSizePredicate(0, .6f));
     searcher.setQueryCache(cache);
     searcher.count(new DummyQuery());
@@ -1267,7 +1279,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     w.addDocument(new Document());
     DirectoryReader reader = new DummyDirectoryReader(w.getReader());
     IndexSearcher searcher = newSearcher(reader);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     // don't cache if the reader does not expose a cache helper
     assertNull(reader.leaves().get(0).reader().getCoreCacheHelper());
@@ -1331,7 +1343,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     w.addDocument(new Document());
     DirectoryReader reader = w.getReader();
     IndexSearcher searcher = newSearcher(reader);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     LRUQueryCache cache = new LRUQueryCache(2, 10000, context -> true);
     searcher.setQueryCache(cache);
@@ -1491,7 +1503,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     // we need to be single threaded to ensure that LRUQueryCache doesn't skip the cache
     // due to thread contention
     IndexSearcher searcher = new AssertingIndexSearcher(random(), reader);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     LRUQueryCache cache = new LRUQueryCache(1, 10000, context -> true);
     searcher.setQueryCache(cache);
@@ -1509,7 +1521,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     reader.close();
     reader = DirectoryReader.open(w);
     searcher = new AssertingIndexSearcher(random(), reader); // no newSearcher(reader) -
see comment above
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     searcher.setQueryCache(cache);
 
     assertEquals(2, searcher.count(query));
@@ -1518,7 +1530,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     reader.close();
     reader = DirectoryReader.open(w);
     searcher = new AssertingIndexSearcher(random(), reader); // no newSearcher(reader) -
see comment above
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     searcher.setQueryCache(cache);
 
     assertEquals(2, searcher.count(query));
@@ -1529,7 +1541,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     reader.close();
     reader = DirectoryReader.open(w);
     searcher = new AssertingIndexSearcher(random(), reader); // no newSearcher(reader) -
see comment above
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
     searcher.setQueryCache(cache);
 
     assertEquals(2, searcher.count(query));
@@ -1550,7 +1562,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     IndexWriter w = new IndexWriter(dir, iwc);
     LRUQueryCache queryCache = new LRUQueryCache(10, 1000 * 1000, ctx -> true);
     IndexSearcher.setDefaultQueryCache(queryCache);
-    IndexSearcher.setDefaultQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    IndexSearcher.setDefaultQueryCachingPolicy(ALWAYS_CACHE);
 
     SearcherManager sm = new SearcherManager(w, new SearcherFactory());
 
@@ -1622,7 +1634,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
     LRUQueryCache cache = new LRUQueryCache(1, 100000, context -> true);
     IndexSearcher searcher = new AssertingIndexSearcher(random(), reader);
     searcher.setQueryCache(cache);
-    searcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    searcher.setQueryCachingPolicy(ALWAYS_CACHE);
 
     Query query = new ConstantScoreQuery(new BooleanQuery.Builder()
         .add(new BoostQuery(new TermQuery(new Term("field", "foo")), 3), Occur.SHOULD)
@@ -1634,7 +1646,7 @@ public class TestLRUQueryCache extends LuceneTestCase {
 
     IndexSearcher noCacheHelperSearcher = new AssertingIndexSearcher(random(), noCacheReader);
     noCacheHelperSearcher.setQueryCache(cache);
-    noCacheHelperSearcher.setQueryCachingPolicy(QueryCachingPolicy.ALWAYS_CACHE);
+    noCacheHelperSearcher.setQueryCachingPolicy(ALWAYS_CACHE);
     noCacheHelperSearcher.search(query, 1);
 
     Thread t = new Thread(() -> {


Mime
View raw message