-noise

Author: original-brownbear

server/src/main/java/org/elasticsearch/action/search/SearchQueryThenFetchAsyncAction.java

@@ -401,11 +401,13 @@ private static ShardSearchRequest tryRewriteWithUpdatedSortValue(
         // disable tracking total hits if we already reached the required estimation.
         if (trackTotalHitsUpTo != SearchContext.TRACK_TOTAL_HITS_ACCURATE && bottomSortCollector.getTotalHits() > trackTotalHitsUpTo) {
             request.source(request.source().shallowCopy().trackTotalHits(false));
+            request.setRunCanMatchInQueryPhase(true);
         }
 
         // set the current best bottom field doc
         if (bottomSortCollector.getBottomSortValues() != null) {
             request.setBottomSortValues(bottomSortCollector.getBottomSortValues());
+            request.setRunCanMatchInQueryPhase(true);
         }
         return request;
     }
@@ -467,30 +469,32 @@ protected void doRun(Map<SearchShardIterator, Integer> shardIndexMap) {
             transportService.getThreadPool().executor(ThreadPool.Names.SEARCH_COORDINATION).execute(new AbstractRunnable() {
                 @Override
                 protected void doRun() {
-                    if (hasPrimaryFieldSort(request.source())) {
+                    var shards = localNodeRequest.shards;
+                    if (shards.size() > 1 && hasPrimaryFieldSort(request.source())) {
                         @SuppressWarnings("rawtypes")
-                        final MinAndMax[] minAndMax = new MinAndMax[localNodeRequest.shards.size()];
+                        final MinAndMax[] minAndMax = new MinAndMax[shards.size()];
                         for (int i = 0; i < minAndMax.length; i++) {
-                            minAndMax[i] = searchService.canMatch(
-                                buildShardSearchRequestForLocal(localNodeRequest, localNodeRequest.shards.get(i))
-                            ).estimatedMinAndMax();
+                            // TODO: refactor to avoid building the search request twice, here and then when actually executing the query
+                            minAndMax[i] = searchService.canMatch(buildShardSearchRequestForLocal(localNodeRequest, shards.get(i)))
+                                .estimatedMinAndMax();
                         }
+
                         try {
-                            int[] indexes = CanMatchPreFilterSearchPhase.sortShards(
-                                localNodeRequest.shards,
+                            final int[] indexes = CanMatchPreFilterSearchPhase.sortShards(
+                                shards,
                                 minAndMax,
                                 FieldSortBuilder.getPrimaryFieldSortOrNull(request.source()).order()
                             );
+                            final ShardToQuery[] orig = shards.toArray(new ShardToQuery[0]);
                             for (int i = 0; i < indexes.length; i++) {
-                                ShardToQuery shardToQuery = localNodeRequest.shards.get(i);
-                                shardToQuery = localNodeRequest.shards.set(i, shardToQuery);
-                                localNodeRequest.shards.set(i, shardToQuery);
+                                shards.set(i, orig[indexes[i]]);
                             }
                         } catch (Exception e) {
                             // ignored, field type conflicts will be dealt with in upstream logic
                             // TODO: we should fail the query here, we're already seeing a field type conflict on the sort field,
                             // no need to actually execute the queries and go through a lot of work before we inevitably have to
                             // fail the search
+
                         }
                     }
                     executeWithoutBatching(localTarget, localNodeRequest);
@@ -650,14 +654,21 @@ static void registerNodeSearchAction(
                 final SearchRequest searchRequest = request.searchRequest;
                 final IntUnaryOperator shards;
                 final ShardSearchRequest[] shardSearchRequests;
-                if (hasPrimaryFieldSort(searchRequest.source())) {
-                    shardSearchRequests = new ShardSearchRequest[request.shards.size()];
+                final int shardCount = request.shards.size();
+                if (shardCount > 1 && hasPrimaryFieldSort(searchRequest.source())) {
+                    shardSearchRequests = new ShardSearchRequest[shardCount];
                     @SuppressWarnings("rawtypes")
-                    final MinAndMax[] minAndMax = new MinAndMax[request.shards.size()];
+                    final MinAndMax[] minAndMax = new MinAndMax[shardCount];
                     for (int i = 0; i < minAndMax.length; i++) {
                         ShardSearchRequest r = buildShardSearchRequestForLocal(request, request.shards.get(i));
                         shardSearchRequests[i] = r;
-                        minAndMax[i] = searchService.canMatch(r).estimatedMinAndMax();
+                        var canMatch = searchService.canMatch(r);
+                        if (canMatch.canMatch()) {
+                            r.setRunCanMatchInQueryPhase(false);
+                            minAndMax[i] = canMatch.estimatedMinAndMax();
+                        } else {
+                            assert false;
+                        }
                     }
                     int[] indexes = CanMatchPreFilterSearchPhase.sortShards(
                         request.shards,
@@ -670,11 +681,10 @@ static void registerNodeSearchAction(
                     shards = IntUnaryOperator.identity();
                 }
                 final CancellableTask cancellableTask = (CancellableTask) task;
-                final int shardCount = request.shards.size();
-                int workers = Math.min(request.searchRequest.getMaxConcurrentShardRequests(), Math.min(shardCount, searchPoolMax));
+                int workers = Math.min(searchRequest.getMaxConcurrentShardRequests(), Math.min(shardCount, searchPoolMax));
                 final var state = new QueryPerNodeState(
                     new QueryPhaseResultConsumer(
-                        request.searchRequest,
+                        searchRequest,
                         dependencies.executor,
                         searchService.getCircuitBreaker(),
                         searchPhaseController,

server/src/main/java/org/elasticsearch/search/SearchService.java

@@ -685,7 +685,7 @@ public void executeQueryPhase(ShardSearchRequest request, CancellableTask task,
                 threadPool
             ).delegateFailure((l, orig) -> {
                 // check if we can shortcut the query phase entirely.
-                if (orig.canReturnNullResponseIfMatchNoDocs()) {
+                if (orig.canReturnNullResponseIfMatchNoDocs() && orig.runCanMatchInQueryPhase()) {
                     assert orig.scroll() == null;
                     ShardSearchRequest clone = new ShardSearchRequest(orig);
                     CanMatchContext canMatchContext = new CanMatchContext(

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

@@ -101,6 +101,8 @@ public class ShardSearchRequest extends AbstractTransportRequest implements Indi
      */
     private final boolean forceSyntheticSource;
 
+    private transient boolean runCanMatchInQueryPhase = true;
+
     public ShardSearchRequest(
         OriginalIndices originalIndices,
         SearchRequest searchRequest,
@@ -349,6 +351,14 @@ public void writeTo(StreamOutput out) throws IOException {
         OriginalIndices.writeOriginalIndices(originalIndices, out);
     }
 
+    public void setRunCanMatchInQueryPhase(boolean runCanMatchInQueryPhase) {
+        this.runCanMatchInQueryPhase = runCanMatchInQueryPhase;
+    }
+
+    public boolean runCanMatchInQueryPhase() {
+        return runCanMatchInQueryPhase;
+    }
+
     protected final void innerWriteTo(StreamOutput out, boolean asKey) throws IOException {
         shardId.writeTo(out);
         out.writeByte(searchType.id());