Disable caching when queries are profiled

server/src/main/java/org/elasticsearch/indices/IndicesService.java

@@ -1246,6 +1246,11 @@ public boolean canCache(ShardSearchRequest request, SearchContext context) {
             return false;
         }
 
+        // Profiled queries should not use the cache
+        if (request.source() != null && request.source().profile()) {
+            return false;
+        }
+
         IndexSettings settings = context.indexShard().indexSettings();
         // if not explicitly set in the request, use the index setting, if not, use the request
         if (request.requestCache() == null) {

server/src/main/java/org/elasticsearch/search/internal/ContextIndexSearcher.java

@@ -67,6 +67,19 @@ public class ContextIndexSearcher extends IndexSearcher {
      */
     private static int CHECK_CANCELLED_SCORER_INTERVAL = 1 << 11;
 
+    /**
+     * A policy to bypass the cache entirely
+     */
+    private static final QueryCachingPolicy NEVER_CACHE_POLICY = new QueryCachingPolicy() {
+        @Override
+        public void onUse(Query query) {}
+
+        @Override
+        public boolean shouldCache(Query query) {
+            return false;
+        }
+    };
+
     private AggregatedDfs aggregatedDfs;
     private QueryProfiler profiler;
     private Runnable checkCancelled;
@@ -79,6 +92,10 @@ public ContextIndexSearcher(IndexReader reader, Similarity similarity, QueryCach
     }
 
     public void setProfiler(QueryProfiler profiler) {
+        if (profiler != null) {
+            // disable query caching on profiled query
+            setQueryCachingPolicy(NEVER_CACHE_POLICY);
+        }
         this.profiler = profiler;
     }
 

server/src/main/java/org/elasticsearch/search/profile/query/ProfileWeight.java

@@ -120,7 +120,7 @@ public void extractTerms(Set<Term> set) {
 
     @Override
     public boolean isCacheable(LeafReaderContext ctx) {
-        return subQueryWeight.isCacheable(ctx);
+        return false;
     }
 
 }

server/src/test/java/org/elasticsearch/indices/IndicesRequestCacheIT.java

@@ -29,6 +29,7 @@
 import org.elasticsearch.common.time.DateFormatter;
 import org.elasticsearch.index.cache.request.RequestCacheStats;
 import org.elasticsearch.index.query.QueryBuilders;
+import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
 import org.elasticsearch.search.aggregations.bucket.histogram.Histogram;
 import org.elasticsearch.search.aggregations.bucket.histogram.Histogram.Bucket;
@@ -414,9 +415,49 @@ public void testCacheWithFilteredAlias() {
         assertCacheState(client, "index", 2, 2);
     }
 
+    public void testProfileDisableCache() throws Exception {
+        Client client = client();
+        assertAcked(
+            client.admin().indices().prepareCreate("index")
+                .addMapping("_doc", "k", "type=keyword")
+                .setSettings(
+                    Settings.builder()
+                        .put(IndicesRequestCache.INDEX_CACHE_REQUEST_ENABLED_SETTING.getKey(), true)
+                        .put(IndexMetaData.SETTING_NUMBER_OF_SHARDS, 1)
+                        .put(IndexMetaData.SETTING_NUMBER_OF_REPLICAS, 0)
+                )
+                .get()
+        );
+        indexRandom(true, client.prepareIndex("index", "_doc").setSource("k", "hello"));
+        ensureSearchable("index");
+
+        int expectedHits = 0;
+        int expectedMisses = 0;
+        for (int i = 0; i < 5; i++) {
+            boolean profile = i % 2 == 0;
+            SearchResponse resp = client.prepareSearch("index")
+                .setRequestCache(true)
+                .setProfile(profile)
+                .setQuery(QueryBuilders.termQuery("k", "hello"))
+                .get();
+            assertSearchResponse(resp);
+            ElasticsearchAssertions.assertAllSuccessful(resp);
+            assertThat(resp.getHits().getTotalHits().value, equalTo(1L));
+            if (profile == false) {
+                if (i == 1) {
+                    expectedMisses ++;
+                } else {
+                    expectedHits ++;
+                }
+            }
+            assertCacheState(client, "index", expectedHits, expectedMisses);
+        }
+    }
+
     private static void assertCacheState(Client client, String index, long expectedHits, long expectedMisses) {
-        RequestCacheStats requestCacheStats = client.admin().indices().prepareStats(index).setRequestCache(true).get().getTotal()
-                .getRequestCache();
+        RequestCacheStats requestCacheStats = client.admin().indices().prepareStats(index)
+            .setRequestCache(true)
+            .get().getTotal().getRequestCache();
         // Check the hit count and miss count together so if they are not
         // correct we can see both values
         assertEquals(Arrays.asList(expectedHits, expectedMisses, 0L),

server/src/test/java/org/elasticsearch/search/profile/query/QueryProfilerTests.java

@@ -30,6 +30,7 @@
 import org.apache.lucene.index.Term;
 import org.apache.lucene.search.Explanation;
 import org.apache.lucene.search.IndexSearcher;
+import org.apache.lucene.search.LRUQueryCache;
 import org.apache.lucene.search.LeafCollector;
 import org.apache.lucene.search.Query;
 import org.apache.lucene.search.QueryCachingPolicy;
@@ -47,6 +48,7 @@
 import org.elasticsearch.search.internal.ContextIndexSearcher;
 import org.elasticsearch.search.profile.ProfileResult;
 import org.elasticsearch.test.ESTestCase;
+import org.junit.After;
 import org.junit.AfterClass;
 import org.junit.BeforeClass;
 
@@ -81,7 +83,16 @@ public static void setup() throws IOException {
         reader = w.getReader();
         w.close();
         searcher = new ContextIndexSearcher(reader, IndexSearcher.getDefaultSimilarity(),
-            IndexSearcher.getDefaultQueryCache(), MAYBE_CACHE_POLICY);
+            IndexSearcher.getDefaultQueryCache(), ALWAYS_CACHE_POLICY);
+    }
+
+    @After
+    public void checkNoCache() {
+        LRUQueryCache cache = (LRUQueryCache) searcher.getQueryCache();
+        assertThat(cache.getHitCount(), equalTo(0L));
+        assertThat(cache.getCacheCount(), equalTo(0L));
+        assertThat(cache.getTotalCount(), equalTo(cache.getMissCount()));
+        assertThat(cache.getCacheSize(), equalTo(0L));
     }
 
     @AfterClass
@@ -158,10 +169,6 @@ public void testUseIndexStats() throws IOException {
 
     public void testApproximations() throws IOException {
         QueryProfiler profiler = new QueryProfiler();
-        // disable query caching since we want to test approximations, which won't
-        // be exposed on a cached entry
-        ContextIndexSearcher searcher = new ContextIndexSearcher(reader, IndexSearcher.getDefaultSimilarity(),
-            null, MAYBE_CACHE_POLICY);
         searcher.setProfiler(profiler);
         Query query = new RandomApproximationQuery(new TermQuery(new Term("foo", "bar")), random());
         searcher.count(query);
@@ -184,7 +191,6 @@ public void testApproximations() throws IOException {
 
         long rewriteTime = profiler.getRewriteTime();
         assertThat(rewriteTime, greaterThan(0L));
-
     }
 
     public void testCollector() throws IOException {
@@ -288,17 +294,4 @@ public boolean shouldCache(Query query) throws IOException {
         }
 
     };
-
-    private static final QueryCachingPolicy NEVER_CACHE_POLICY = new QueryCachingPolicy() {
-
-        @Override
-        public void onUse(Query query) {}
-
-        @Override
-        public boolean shouldCache(Query query) throws IOException {
-            return false;
-        }
-
-    };
-
 }