Elasticsearch源码分析十四--搜索类型

• 简介
• query_then_fetch
• query_and_fetch
• dfs_query_and_fetch
• dfs_query_then_fetch
• count
• scan

---

简介

Elasticsearch允许通过指定搜索类型来选择查询在内部如何处理。不同的搜索类型适合不同的情况；

可以只在乎性能，但有时查询的关联性可能是最重要的因素。使用search_type请求参数指定搜索类型，

其各种取值介绍参考下文，其中size参数指定一次查询中返回的最大文档数。默认值为0。在Elasticsearch代码中，会将上述几种搜索类型分隔成几个阶段phrases顺序执行,

前提是可以分成两个阶段。比如query_and_fetch不能分解成两个阶段，只需一步就能完成查询。

而dfs_query_then_fetch需要三个阶段。这几种搜索类型最终会调用具体的搜索类SearchService，

该类的介绍参考另一篇文章。

query_then_fetch

此搜索类型分两步，第一步：执行查询得到对文档进行排序和分级所需信息。这一步在所有的分片上执行。然后，只在相关分片上

查询文档的实际内容。不同于query_and_fetch，此查询类型返回结果的最大数量等于size参数的值。默认使用这个类型。

public class TransportSearchQueryThenFetchAction extends TransportSearchTypeAction {        '''执行请求'''        @Override    protected void doExecute(SearchRequest searchRequest, ActionListener<SearchResponse> listener) {        new AsyncAction(searchRequest, listener).start();    }    private class AsyncAction extends BaseAsyncAction<QuerySearchResult> {                '''第一阶段是queryphrase'''        @Override        protected String firstPhaseName() {            return "query";        }        @Override        protected void sendExecuteFirstPhase(DiscoveryNode node, ShardSearchRequest request, SearchServiceListener<QuerySearchResult> listener) {            '''调用SearchServiceTransportAction发送query请求'''            searchService.sendExecuteQuery(node, request, listener);        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段'''        @Override        protected void moveToSecondPhase()         { ... }    }}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

query_and_fetch

这通常是最快也最简单的搜索类型实现。查询在所有分片上并行执行（当然，任意一个主分片，只查询一个副本），所有分片

返回等于size值的结果数。返回文档的最大数量等于size的值乘以分片的数量。

public class TransportSearchQueryAndFetchAction extends TransportSearchTypeAction {        '''执行请求'''        @Override    protected void doExecute(SearchRequest searchRequest, ActionListener<SearchResponse> listener) {        new AsyncAction(searchRequest, listener).start();    }    private class AsyncAction extends BaseAsyncAction<QuerySearchResult> {                '''只有query_fetch'''        @Override        protected String firstPhaseName() {            return "query_fetch";        }        @Override        protected void sendExecuteFirstPhase(DiscoveryNode node, ShardSearchRequest request, SearchServiceListener<QueryFetchSearchResult> listener) {            '''调用SearchServiceTransportAction发送fetch请求'''            searchService.sendExecuteFetch(node, request, listener);        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段，对于该搜索类型，                     第二阶段无须再查询'''        @Override        protected void moveToSecondPhase() throws Exception {            try {                innerFinishHim();            } catch (Throwable e) {                ReduceSearchPhaseException failure = new ReduceSearchPhaseException("merge", "", e, buildShardFailures());                if (logger.isDebugEnabled()) {                    logger.debug("failed to reduce search", failure);                }                listener.onFailure(failure);            }        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段'''        @Override        protected void moveToSecondPhase()         { ... }    }}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

dfs_query_and_fetch

跟query_and_fetch类似，但相比query_and_fetch，它包含一个额外阶段，在初始查询中执行分布式词频的计算，

以得到返回文件的更精确的得分，从而让查询结果更相关。

public class TransportSearchDfsQueryAndFetchAction extends TransportSearchTypeAction {        '''执行请求'''        @Override    protected void doExecute(SearchRequest searchRequest, ActionListener<SearchResponse> listener) {        new AsyncAction(searchRequest, listener).start();    }    private class AsyncAction extends BaseAsyncAction<QuerySearchResult> {                '''第一阶段是dfs'''        @Override        protected String firstPhaseName() {            return "dfs";        }        @Override        protected void sendExecuteFirstPhase(DiscoveryNode node, ShardSearchRequest request, SearchServiceListener<DfsSearchResult> listener) {            '''调用SearchServiceTransportAction发送dfs请求'''            searchService.sendExecuteDfs(node, request, listener);        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段'''        protected void moveToSecondPhase() {            for (final AtomicArray.Entry<DfsSearchResult> entry : firstResults.asList()) {                DfsSearchResult dfsResult = entry.value;                DiscoveryNode node = nodes.get(dfsResult.shardTarget().nodeId());                if (node.id().equals(nodes.localNodeId())) {                    localOperations++;                } else {                    QuerySearchRequest querySearchRequest = new QuerySearchRequest(request, dfsResult.id(), dfs);                    '''执行第二阶段fetch'''                    executeSecondPhase(entry.index, dfsResult, counter, node, querySearchRequest);                }            }            ...        }    }}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

dfs_query_then_fetch

与前一个dfs_query_and_ fetch一样，dfs_query_then_fetch类似于相应的query_then_fetch，但比query_ then_fetch多了一个额外的阶段，就像dfs_query_and_fetch一样。

public class TransportSearchDfsQueryThenFetchAction extends TransportSearchTypeAction {        '''执行请求'''        @Override    protected void doExecute(SearchRequest searchRequest, ActionListener<SearchResponse> listener) {        new AsyncAction(searchRequest, listener).start();    }    private class AsyncAction extends BaseAsyncAction<QuerySearchResult> {                '''第一阶段是dfs'''        @Override        protected String firstPhaseName() {            return "dfs";        }        @Override        protected void sendExecuteFirstPhase(DiscoveryNode node, ShardSearchRequest request, SearchServiceListener<DfsSearchResult> listener) {            '''调用SearchServiceTransportAction发送dfs请求'''            searchService.sendExecuteDfs(node, request, listener);        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段'''                protected void moveToSecondPhase() {            final AggregatedDfs dfs = searchPhaseController.aggregateDfs(firstResults);            final AtomicInteger counter = new AtomicInteger(firstResults.asList().size());            int localOperations = 0;            for (final AtomicArray.Entry<DfsSearchResult> entry : firstResults.asList()) {                DfsSearchResult dfsResult = entry.value;                DiscoveryNode node = nodes.get(dfsResult.shardTarget().nodeId());                if (node.id().equals(nodes.localNodeId())) {                    localOperations++;                } else {                    QuerySearchRequest querySearchRequest = new QuerySearchRequest(request, dfsResult.id(), dfs);                    '''执行第二阶段query'''                    executeQuery(entry.index, dfsResult, counter, querySearchRequest, node);                }            }           ...        }        void executeQuery(final int shardIndex, final DfsSearchResult dfsResult, final AtomicInteger counter, final QuerySearchRequest querySearchRequest, DiscoveryNode node) {            searchService.sendExecuteQuery(node, querySearchRequest, new SearchServiceListener<QuerySearchResult>() {                @Override                public void onResult(QuerySearchResult result) {                    result.shardTarget(dfsResult.shardTarget());                    queryResults.set(shardIndex, result);                    if (counter.decrementAndGet() == 0) {                            '''执行第三个阶段fetch'''                        executeFetchPhase();                    }                }                 }          }}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

count

一个特殊的搜索，只返回匹配查询的文档数。如果你只需要结果数量，而不关心文档，

应该使用这个搜索类型。

public class TransportSearchCountAction extends TransportSearchTypeAction {        '''执行请求'''        @Override    protected void doExecute(SearchRequest searchRequest, ActionListener<SearchResponse> listener) {        new AsyncAction(searchRequest, listener).start();    }    private class AsyncAction extends BaseAsyncAction<QuerySearchResult> {                '''第一阶段是query'''        @Override        protected String firstPhaseName() {            return "query";        }        @Override        protected void sendExecuteFirstPhase(DiscoveryNode node, ShardSearchRequest request, SearchServiceListener<QuerySearchResult> listener) {            '''调用SearchServiceTransportAction发送query请求'''            searchService.sendExecuteQuery(node, request, listener);        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段，此搜索类型第二个阶段无需查询'''        protected void moveToSecondPhase() {                        protected void moveToSecondPhase() throws Exception {            // no need to sort, since we know we have no hits back            final InternalSearchResponse internalResponse = searchPhaseController.merge(SearchPhaseController.EMPTY_DOCS, firstResults, (AtomicArray<? extends FetchSearchResultProvider>) AtomicArray.empty());            String scrollId = null;            if (request.scroll() != null) {                scrollId = buildScrollId(request.searchType(), firstResults, null);            }            listener.onResponse(new SearchResponse(internalResponse, scrollId, expectedSuccessfulOps, successulOps.get(), buildTookInMillis(), buildShardFailures()));        }    }}  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

scan

另一个特殊的搜索类型，只有在要让查询返回大量结果时才用。它跟一般的查询有点不同，因为在发送第一个请

求之后， Elasticsearch响应一个滚动标识符，类似于关系型数据库中的游标。

所有查询需要在_search/scroll REST端点运行，并需要在请求主体中发送返回的滚动标识符。

public class TransportSearchScanAction extends TransportSearchTypeAction {        '''执行请求'''        @Override    protected void doExecute(SearchRequest searchRequest, ActionListener<SearchResponse> listener) {        new AsyncAction(searchRequest, listener).start();    }    private class AsyncAction extends BaseAsyncAction<QuerySearchResult> {                '''第一阶段是init_scan'''        @Override        protected String firstPhaseName() {            return "init_scan";        }        @Override        protected void sendExecuteFirstPhase(DiscoveryNode node, ShardSearchRequest request, SearchServiceListener<QuerySearchResult> listener) {            '''调用SearchServiceTransportAction发送scan请求'''            searchService.sendExecuteScan(node, request, listener);        }                '''在其父类TransportSearchTypeAction的onFirstPhaseResult函数中调用                     在收到第一阶段的处理结果后转移到第二阶段，此搜索类型第二个阶段无需查询'''        @Override        protected void moveToSecondPhase() throws Exception {            final InternalSearchResponse internalResponse = searchPhaseController.merge(SearchPhaseController.EMPTY_DOCS, firstResults, (AtomicArray<? extends FetchSearchResultProvider>) AtomicArray.empty());            String scrollId = null;            if (request.scroll() != null) {                scrollId = buildScrollId(request.searchType(), firstResults, ImmutableMap.of("total_hits", Long.toString(internalResponse.hits().totalHits())));            }            listener.onResponse(new SearchResponse(internalResponse, scrollId, expectedSuccessfulOps, successulOps.get(), buildTookInMillis(), buildShardFailures()));        }    }}