Docs Menu
Docs Home
/ /

쿼리 계획 및 실행 통계 검색 방법

MongoDB 검색 쿼리는 explain 메서드가 활성화된 상태에서 쿼리가 실행될 때 $search 쿼리 계획 및 실행 통계에 대한 정보를 반환합니다. explain으로 쿼리를 실행하면 MongoDB Search는 Lucene에서 쿼리가 내부적으로 어떻게 실행되었는지를 설명하는 통계 및 메타데이터가 포함된 BSON 문서를 반환합니다.

explain 명령

db.<myCollection>.explain("<verbosity>").aggregate([
{
$search: {
"<operator>": {
"<operator-options>"
}
}
}
])

상세 모드 explain 의 동작과 반환되는 정보의 양을 제어합니다. 값은 상세도가 낮은 순서대로 다음 중 하나일 수 있습니다.

쿼리에 대한 실행 쿼리 가 포함된 stats 필드를 포함한 쿼리 계획 에 대한 정보입니다. 계획 선택 중에 캡처한 부분 실행 데이터를 포함합니다.

쿼리에 대한 실행 통계가 포함된 stats 필드를 포함한 쿼리 계획에 대한 정보입니다.

queryPlanner(기본값)

쿼리 계획에 대한 정보입니다. 쿼리에 대한 실행 통계를 포함하는 stats 필드는 포함되지 않습니다.

explain 메서드를 사용한 쿼리는 stages.$_internalSearchMongotRemote 객체에서 다음 필드를 반환합니다.

옵션
유형
목적

mongotQuery

문서

실행한 쿼리를 포함하고 있습니다.

explain

문서

explain 결과를 포함하고 있습니다. 자세한 내용을 학습하려면 결과 설명을 참조하세요.

internalMongotBatchSizeHistory

정수 배열

각 배치의 문서 크기를 포함하여 mongotmongod에 반환한 내용입니다.

explain 메서드는 explain 문서에 다음 필드가 포함된 BSON 문서를 반환합니다.

옵션
유형
필요성
목적

collectors

문서

옵션

수집기의 실행 통계를 설명합니다. indexPartitionExplain이 존재하는 경우 이는 최상위 레벨이 아닌 각 indexPartitionExplain 내에 중첩됩니다.

highlight

문서

옵션

쿼리의 하이라이트 실행에 대한 세부 정보입니다. 쿼리에서 하이라이트를 지정한 경우에만 반환됩니다.

indexPartitionExplain

문서 배열

옵션

인덱스 파티션별 세부 정보를 포함합니다. 두 개 이상의 인덱스 파티션을 구성한 경우에만 반환됩니다.

metadata

문서

옵션

유용한 메타데이터를 포함합니다.

query

문서

옵션

쿼리의 실행 통계를 설명합니다. 이것은 반환되지 않습니다. indexPartitionExplain 이 존재하는 경우 이는 최상위 레벨이 아닌 각 indexPartitionExplain 내에 중첩됩니다.

resultMaterialization

문서

옵션

쿼리 실행 후 Lucene에서 문서별 데이터를 검색하는 것과 관련된 세부 정보입니다. queryPlanner 상세 수준 모드에서는 반환되지 않습니다.

resourceUsage

문서

옵션

쿼리가 실행되었을 때 쿼리의 리소스 사용량 세부 정보를 제공합니다. queryPlanner 상세 수준 모드에서는 반환되지 않습니다.

collectors BSON 문서는 다음 필드를 포함합니다.

필드
유형
필요성
목적

allCollectorStats

문서

필수 사항

쿼리 의 모든 수집기 통계입니다. 보고된 통계는 쿼리 에 사용된 모든 수집기의 최대값 또는 모든 하위 수집기의 통계 합계를 나타냅니다. 타이밍 통계는 전체 쿼리 에 대해 모든 수집기에서 소요된 총 시간을 반영하기 위해 합산됩니다. 자세한 학습 은 allCollectorStats를 참조하세요.

facet

문서

옵션

패싯을 지정하는 쿼리의 세부 분석입니다. 자세한 내용은 facet을 참조하세요.

sort

문서

옵션

정렬을 지정하는 쿼리의 세부 분석입니다. 자세한 내용은 sort를 참조하세요.

allCollectorStats BSON 문서는 facetsort를 포함한 쿼리에서 지정된 모든 수집기에 대한 통계를 설명합니다. 다음 키를 포함합니다.

필드
설명

collect

수집기가 수집한 결과의 지속 시간과 수량을 추적합니다.

competitiveIterator

수집기에서 competitiveIterator가 요청된 총 지속 시간과 횟수를 추적하는 통계입니다.

setScorer

수집기에 설정된 점수 계산기의 총 지속 시간과 횟수를 추적하는 통계입니다.

facet은 쿼리에서 패싯을 지정할 때 쿼리 및 실행 통계를 상세히 설명하는 BSON 문서입니다. 다음 필드를 포함합니다.

옵션
유형
필요성
목적

collectorStats

문서

옵션

facet 수집기에 대한 통계만 표시합니다. 여기의 키는 allCollectorStats와 동일합니다. 쿼리에서 sort를 사용한 경우 이를 통해 allCollectorStats와의 차이를 평가하여 sort 수집기의 실행 통계를 결정할 수 있습니다.

createCountsStats

문서

옵션

모든 패싯 그룹을 보유하는 내부 Lucene 객체 생성과 관련된 통계를 표시합니다. generateFacetCounts 필드를 포함하며 이는 mongot가 모든 패싯과 그 수를 보유하는 Lucene 객체를 생성하는 총 지속 시간과 횟수를 추적하는 통계를 반환합니다.

stringFacetFieldCardinalities

문서

필수 사항

쿼리와 일치하는 문서 및 전체 Lucene 인덱스에 대해 패싯 처리된 필드를 해당 카디널리티에 매핑합니다. 각 필드에 대해 다음과 같은 카디널리티 정보를 제공합니다.

  • queried - 쿼리된 모든 문서에서 필드의 패싯 카디널리티를 나타냅니다.

  • total - 인덱스의 모든 문서에서 필드의 패싯 카디널리티를 나타냅니다.

sort는 쿼리에서 정렬을 지정할 때 쿼리 및 실행 통계를 상세히 설명하는 BSON 문서입니다. 다음 필드를 포함합니다.

옵션
유형
필요성
목적

stats

문서

옵션

모든 정렬 필드에서 sort 실행과 관련된 통계를 추적합니다. 다음 필드를 포함합니다.

  • comparator - Lucene이 결과를 정렬하는 방식에 대한 통계 및 메타데이터를 보여줍니다.

    • setBottom - 현재 경쟁률이 가장 낮은 정렬 값이 더 새롭고 더 경쟁적인 값으로 업데이트되는 빈도를 반환합니다. MongoDB Search는 정렬 시 최하위 값을 추적 하며, 새 값이 관련성 또는 경쟁력 면에서 현재 최하위 값을 초과하면 이 메트릭이 증가합니다.

    • compareBottom - 현재 bottom 값과 후보 bottom 값을 비교하는 것과 관련된 타이밍 및 호출 통계를 반환합니다.

    • compareTop - 현재 top 값과 후보 top 값을 비교하는 것과 관련된 타이밍 및 호출 통계를 반환합니다.

    • setHitsThresholdReached - 최대 결과 수(limit)에 도달했을 때와 관련된 타이밍 및 호출 통계를 반환합니다.

    • competitiveIterator - 정렬된 결과에서 상위 위치를 차지하기 위해 경쟁할 가능성이 있는 문서에 대해서만 반복하는 것과 관련된 타이밍 및 호출 통계를 반환합니다.

    • setScorer - 문서의 점수 및 관련성 계산과 관련된 타이밍 및 호출 통계를 반환합니다.

  • prunedResultIterator - Lucene의 competitiveIterator에서 nextDocadvance 메서드 호출의 호출 및 타이밍 통계를 보여줍니다.

    혼합 데이터 유형 정렬을 수행하는 경우 이는 출력에 나타나지 않습니다.

    nextDoc 필드만 포함합니다.

fieldInfos

문서

필수 사항

정렬되는 필드를 해당 필드의 인덱스에 존재하는 데이터 유형 목록에 매핑합니다.

highlight는 쿼리에 강조 표시를 지정할 때 쿼리 및 실행 통계를 자세히 설명하는 BSON 문서입니다. 다음 필드를 포함합니다.

옵션
유형
필요성
목적

resolvedHighlightPaths

List<String>

필수 사항

강조 표시된 모든 필드의 목록입니다. 쿼리의 highlight 섹션에 와일드카드 경로를 지정한 경우 완전히 해결된 문서 경로 목록을 포함합니다.

stats

QueryExecutionArea

옵션

강조 표시 설정 및 실행과 관련된 호출 및 타이밍 통계입니다. 다음 필드를 포함합니다.

  • setupHighlight - executeHighlight 단계에서 사용된 내부 Lucene 객체를 설정하는 데 소요된 시간입니다.

  • executeHighlight - 일치하는 문서에 강조 표시를 실행하는 데 걸린 시간입니다.

indexPartitionExplain에는 각 인덱스 파티션에 대한 Explain 결과를 포함합니다. 최상위 collectorsquery는 각 인덱스 파티션의 explain 정보 내에 있으며 최상위 레벨에는 없습니다.

metadata는 다음과 같은 유용한 메타데이터를 포함합니다.

필드
유형
필요성
목적

mongotVersion

문자열

옵션

mongot의 현재 버전입니다.

mongotHostName

문자열

옵션

mongot 호스트를 식별하는 사람이 읽을 수 있는 레이블입니다.

indexName

문자열

옵션

쿼리 에 사용된 MongoDB Search 인덱스 .

cursorOptions

문서

옵션

mongot에 커서 옵션이 제공됩니다.

totalLuceneDocs

Integer

옵션

삭제된 문서를 포함한 인덱스 내 전체 객체 수입니다.

query BSON 문서는 쿼리 실행 통계를 설명합니다. 다음 필드를 포함합니다.

필드
유형
필요성
목적

path

문자열

옵션

연산자의 경로(루트가 아닌 경우에만).

type

문자열

필수 사항

MongoDB Search 연산자 생성한 루센 쿼리의 이름입니다. 자세한 내용은 query 를 참조하세요.

analyzer

문자열

옵션

쿼리 와 함께 사용되는 MongoDB Search 분석기 .

args

문서

필수 사항

Lucene 쿼리 정보입니다. 자세한 내용은 query를 참조하세요.

stats

문서

옵션

explainexecutionStats 또는 allPlansExecution 상세 수준으로 실행된 경우 쿼리에 대한 stats입니다.

검색 명령의 설명 응답 에는 해당 명령으로 실행된 쿼리에 대한 정보가 포함되어 있습니다. args 필드 의 응답에는 $search 쿼리 충족하기 위해 MongoDB Search가 실행한 루센 쿼리에 대한 구조화된 세부 정보가 포함되어 있습니다.

이 섹션에는 다음이 포함됩니다.

  • MongoDB Search 연산자가 생성하는 일부 루센 쿼리

  • 구조화된 요약에 포함된 루센 쿼리 옵션

  • 각 루센 쿼리 유형에 대한 루센 쿼리 구조화된 요약 예시

참고

예시 정보

이 섹션의 예시는 queryPlanner 상세 수준 모드를 사용하여 샘플 데이터세트에 실행된 쿼리를 기반으로 합니다. 예시 응답에서는 다음과 같습니다.

  • mongotQuery 필드 MongoDB Search 연산자 와 실행 된 쿼리 표시됩니다.

  • explain.type 필드에는 연산자가 만든 루센 쿼리가 표시됩니다.

전체 예시를 보려면 예시를 참조하세요.

BooleanQuery

루센 BooleanQuery의 경우 구조화된 요약에 다음 옵션에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

must

옵션

일치해야 하는 절입니다.

mustNot

옵션

일치해서는 안 되는 절.

should

옵션

일치해야 하는 절입니다.

filter

옵션

모두 일치해야 하는 절.

minimumShouldMatch

Integer

옵션

일치해야 하는 should 절의 최소 수.

ConstantScoreQuery

상수 점수 쿼리의 경우 구조화된 요약에는 다음 옵션에 대한 세 부정보가 포함됩니다.

필드
유형
필요성
설명

query

필수 사항

ConstantScoreQuery의 자식.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "equals" : {
7 "path" : "host.host_identity_verified",
8 "value" : true
9 }
10 },
11 "explain" : {
12 "type" : "ConstantScoreQuery",
13 "args" : {
14 "query" : {
15 "type" : "TermQuery",
16 "args" : {
17 "path" : "host.host_identity_verified",
18 "value" : "T"
19 }
20 }
21 }
22 }
23 }
24 },
25 {
26 "$_internalSearchIdLookup" : { }
27 }
28 ],
29 ...
30}
FunctionScoreQuery

루센 FunctionScoreQuery 쿼리의 경우 구조화된 요약에 다음 옵션에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

scoreFunction

문자열

필수 사항

쿼리에 사용된 점수 표현식입니다.

query

필수 사항

쿼리.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "near" : {
7 "path" : "accomodates",
8 "origin" : 8,
9 "pivot" : 2
10 }
11 },
12 "explain" : {
13 "type" : "BooleanQuery",
14 "args" : {
15 "must" : [ ],
16 "mustNot" : [ ],
17 "should" : [
18 {
19 "type" : "BooleanQuery",
20 "args" : {
21 "must" : [ ],
22 "mustNot" : [ ],
23 "should" : [
24 {
25 "type" : "FunctionScoreQuery",
26 "args" : {
27 "scoreFunction" : "expr(pivot / (pivot + abs(origin - value)))",
28 "query" : {
29 "type" : "LongDistanceFeatureQuery",
30 "args" : { },
31 "stats" : { }
32 }
33 }
34 }
35 ],
36 "filter" : [
37 {
38 "type" : "PointRangeQuery",
39 "args" : {
40 "path" : "accomodates",
41 "representation" : "double",
42 "gte" : 8.000000000000002,
43 "lte" : NaN
44 }
45 }
46 ],
47 "minimumShouldMatch" : 0
48 }
49 },
50 {
51 "type" : "LongDistanceFeatureQuery",
52 "args" : { },
53 "stats" : { }
54 }
55 ],
56 "filter" : [ ],
57 "minimumShouldMatch" : 0
58 }
59 }
60 },
61 ...
62 },
63 ...
64 ],
65 ...
66}
LatLonPointDistanceQuery

Lucene LatLonPointDistanceQuery 쿼리의 경우 응답에는 stats만 포함됩니다.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "geoWithin" : {
7 "path" : "address.location",
8 "circle" : {
9 "radius" : 4800,
10 "center" : {
11 "type" : "Point",
12 "coordinates" : [
13 -122.419472,
14 37.765302
15 ]
16 }
17 }
18 }
19 },
20 "explain" : {
21 "type" : "LatLonPointDistanceQuery",
22 "args" : { }
23 }
24 }
25 },
26 ...
27 ],
28 ...
29}
LatLonShapeQuery

Lucene LatLonShapeQuery 쿼리의 경우 응답에는 stats만 포함됩니다.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "geoShape" : {
7 "path" : "address.location",
8 "relation" : "within",
9 "geometry" : {
10 "type" : "Polygon",
11 "coordinates" : [
12 [
13 [ -74.3994140625, 40.5305017757 ],
14 [ -74.7290039063, 40.5805846641 ],
15 [ -74.7729492188, 40.9467136651 ],
16 [ -74.0698242188, 41.1290213475 ],
17 [ -73.65234375, 40.9964840144 ],
18 [ -72.6416015625, 40.9467136651 ],
19 [ -72.3559570313, 40.7971774152 ],
20 [ -74.3994140625, 40.5305017757 ]
21 ]
22 ]
23 }
24 }
25 },
26 "explain" : {
27 "type" : "LatLonShapeQuery",
28 "args" : { }
29 }
30 },
31 ...
32 },
33 ...
34 ],
35 ...
36}
LongDistanceFeatureQuery

Lucene LongDistanceFeatureQuery의 경우 응답에는 stats만 포함됩니다.

다음 예제에서는 sample_mflix.movies 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "near" : {
7 "path" : "released",
8 "origin" : ISODate("1915-09-13T00:00:00Z"),
9 "pivot" : 7776000000
10 }
11 },
12 "explain" : {
13 "type" : "LongDistanceFeatureQuery",
14 "args" : { }
15 }
16 },
17 ...
18 },
19 ...
20 ],
21 ...
22}
MultiTermQueryConstantScoreWrapper

루센 MultiTermQueryConstantScoreWrapper 쿼리의 경우 구조화된 요약에는 다음 인수에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

queries

필수 사항

쿼리 목록.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "regex" : {
7 "path" : "access",
8 "query" : "full(.{0,5})",
9 "allowAnalyzedField" : true
10 }
11 },
12 "explain" : {
13 "type" : "MultiTermQueryConstantScoreWrapper",
14 "args" : {
15 "queries" : [
16 {
17 "type" : "DefaultQuery",
18 "args" : {
19 "queryType" : "RegexpQuery"
20 }
21 }
22 ]
23 }
24 }
25 },
26 ...
27 },
28 ...
29 ],
30 ...
31}
PhraseQuery

루센 PhraseQuery 쿼리의 경우 구조화된 요약에는 다음 인수에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

path

문자열

필수 사항

검색할 인덱싱된 필드입니다.

query

문자열

필수 사항

검색할 문자열 또는 문자열을 입력합니다.

slop

번호

필수 사항

query 구문에서 단어 간 허용 거리입니다.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "phrase" : {
7 "path" : "description",
8 "query" : "comfortable apartment",
9 "slop" : 2
10 }
11 },
12 "explain" : {
13 "type" : "PhraseQuery",
14 "args" : {
15 "path" : "description",
16 "query" : "[comfortable, apartment]",
17 "slop" : 2
18 }
19 }
20 },
21 ...
22 },
23 ...
24 ],
25 ...
26}
PointRangeQuery

루센 PointRangeQuery 쿼리의 경우 구조화된 요약에는 다음 인수에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

path

문자열

필수 사항

검색할 인덱싱된 필드입니다.

representation

문자열

옵션

숫자 표현. 날짜로 입력된 데이터에 대한 쿼리에는 숫자 표현이 포함되지 않음.

gte

번호

옵션

쿼리의 하한값.

lte

번호

옵션

쿼리의 상한.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "range" : {
7 "path" : "number_of_reviews",
8 "gt" : 5
9 }
10 },
11 "explain" : {
12 "type" : "BooleanQuery",
13 "args" : {
14 "must" : [ ],
15 "mustNot" : [ ],
16 "should" : [
17 {
18 "type" : "PointRangeQuery",
19 "args" : {
20 "path" : "number_of_reviews",
21 "representation" : "double",
22 "gte" : 5.000000000000001
23 }
24 },
25 {
26 "type" : "PointRangeQuery",
27 "args" : {
28 "path" : "number_of_reviews",
29 "representation" : "int64",
30 "gte" : NumberLong(6)
31 }
32 }
33 ],
34 "filter" : [ ],
35 "minimumShouldMatch" : 0
36 }
37 }
38 },
39 ...
40 },
41 ...
42 ],
43 ...
44}
TermQuery

용어 쿼리의 경우 구조화된 요약에는 다음 인수에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

path

문자열

필수 사항

검색할 인덱싱된 필드입니다.

value

문자열

필수 사항

검색할 문자열입니다.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "queryString" : {
7 "defaultPath" : "summary",
8 "query" : "quiet"
9 }
10 },
11 "explain" : {
12 "type" : "TermQuery",
13 "args" : {
14 "path" : "summary",
15 "value" : "quiet"
16 }
17 }
18 },
19 ...
20 },
21 ...
22 ],
23 ...
24}
Default

다른 루센 쿼리에서 명시적으로 정의되지 않은 루센 쿼리는 기본 쿼리를 사용하여 직렬화됩니다. 구조화된 요약에는 다음 옵션에 대한 세부 정보가 포함되어 있습니다.

필드
유형
필요성
설명

queryType

문자열

필수 사항입니다.

루씬 쿼리 유형.

다음 예제에서는 sample_airbnb.listingsAndReviews 컬렉션에 대해 실행되는 쿼리에 대한 explain 응답을 보여줍니다.

1{
2 "stages" : [
3 {
4 "$_internalSearchMongotRemote" : {
5 "mongotQuery" : {
6 "near" : {
7 "origin" : {
8 "type" : "Point",
9 "coordinates" : [
10 -8.61308,
11 41.1413
12 ]
13 },
14 "pivot" : 1000,
15 "path" : "address.location"
16 }
17 },
18 "explain" : {
19 "type" : "DefaultQuery",
20 "args" : {
21 "queryType" : "LatLonPointDistanceFeatureQuery"
22 }
23 }
24 },
25 ...
26 },
27 ...
28 ],
29 ...
30}

executionStatsallPlansExecution 상세도 모드에 대한 explain 응답에는 stats 쿼리가 쿼리 실행의 다양한 단계 에서 소비하는 시간 에 대한 정보가 포함된 필드가 포함되어 있습니다.

타이밍 분석은 쿼리 실행 영역 과 관련된 실행 통계를 설명합니다. 다음 필드에는 타이밍 분석이 표시됩니다.

필드
유형
설명

millisElapsed

Long

쿼리 의 하위 항목이 이 영역에서 보낸 시간을 포함하여 이 영역에서 작업을 수행하는 데 경과된 대략적인 벽시계 시간입니다. 값은 이 영역에서 작업을 수행하는 동안 경과된 대략적인 시간(밀리초)입니다.

invocationCounts

문서

이 영역에 포함된 작업 호출의 횟수입니다. 값은 작업 이름과 해당 호출 횟수의 맵입니다.

다음 쿼리 영역에 대한 통계를 사용할 수 있습니다.

옵션
설명

context

Lucene 쿼리 실행과 관련된 통계입니다. 이 영역에서 호출 횟수가 열거되는 두 가지 작업이 있습니다.

createScorer

점수 산정기는 문서를 반복하고 각 문서에 대한 점수를 생성합니다. createScorer 호출은 점수 산정을 담당하는 객체를 생성합니다. 이 작업과 관련된 시간은 실제로 문서에 점수를 매기는 데 소요된 시간이 아닙니다. 개수에는 scorerSupplier 호출 수가 포함됩니다.

createWeight

가중치는 쿼리 및 IndexSearcher 과 관련된 상태를 저장합니다. 개수에는 createWeight 호출 수가 포함됩니다.

이 영역에서 소요된 시간은 쿼리 구조와 관련이 있으며, 반복되고 점수가 매겨지는 결과 수에 기반하지 않습니다.

예를 들면 다음과 같습니다.

"context" : {
"millisElapsed" : NumberDouble(4.934751),
"invocationCounts" : {
"createWeight" : NumberLong(1),
"createScorer" : NumberLong(10)
}
}

match

결과 문서를 반복하고 일치시키는 것과 관련된 통계입니다. 이 통계는 어떤 문서가 다음 일치 항목인지 결정하는 데 걸리는 시간을 보여줍니다. 결과 일치에 소요되는 시간은 쿼리의 특성에 따라 크게 달라질 수 있습니다. 이 영역에서 호출 횟수가 열거되는 두 가지 작업이 있습니다.

nextDoc

결과 집합의 다음 문서로 이동하도록 요청합니다. 여기에는 과거의 건너뛰기 또는 다음 일치 항목을 찾는 데 필요한 기타 작업을 식별하고 이동하는 등이 포함됩니다. 개수에는 nextDocadvance 호출 수가 포함됩니다.

refineRoughMatch

보다 철저한 일치를 수행합니다. 일부 쿼리는 문서가 먼저 '대략' 일치하는 2단계 프로세스로 실행되고, 첫 번째 대략적인 일치를 충족한 후에만 두 번째, 보다 철저한 단계에서 확인됩니다. refineRoughMatch 작업은 2단계 프로세스 중 두 번째 단계입니다. 개수에는 refineRoughMatch 호출 수가 포함됩니다.

예를 들면 다음과 같습니다.

"match" : {
"millisElapsed" : NumberDouble(4.901597),
"invocationCounts" : {
"nextDoc" : NumberLong(541),
"refineRoughMatch" : NumberLong(0)
}
}

score

결과 세트의 문서 점수 산정과 관련된 통계입니다. 이 영역에서 호출 횟수가 열거되는 두 가지 작업이 있습니다.

score

결과 세트의 각 문서에 점수를 매깁니다. 개수에는 score 호출 수가 포함됩니다.

setMinCompetitiveScore

점수가 지정된 값보다 낮은 문서를 무시합니다. 점수가 경쟁적이지 않은 일부 임계값보다 낮은 문서를 무시하여 쿼리가 수행되는 점수 산정 작업 수를 줄일 수 있었음을 나타냅니다. 개수에는 setMinCompetitiveScore 호출 수가 포함됩니다.

예를 들면 다음과 같습니다.

"score" : {
"millisElapsed" : NumberDouble(3.931312),
"invocationCounts" : {
"score" : NumberLong(536),
"setMinCompetitiveScore" : NumberLong(0)
}
}

resultMaterialization 문서는 mongot가 다음 작업을 수행하는 데 걸리는 시간을 보여줍니다.

  1. Lucene에 저장된 결과 데이터를 _id 또는 storedSource 형태로 검색합니다.

  2. mongod로 데이터를 보내기 전에 BSON 형식으로 직렬화합니다.

자세히 알아보려면 stats를 참조하세요.

resourceUsage 문서는 쿼리 실행에 사용된 리소스를 보여줍니다. 다음 필드를 포함합니다.

필드
유형
필요성
목적

majorFaults

Long

필수 사항

쿼리 실행 중 시스템이 메모리에서 필요한 데이터를 찾지 못해 디스크와 같은 백업 저장소에서 읽게 될 때 발생하는 주요 페이지 폴트 수입니다.

minorFaults

Long

필수 사항

데이터가 페이지 캐시에 있지만 아직 프로세스의 페이지 테이블에 매핑되지 않은 경우 발생하는 경미한 페이지 폴트의 수입니다.

userTimeMs

Long

필수 사항

사용자 공간에서 소요된 CPU 시간(밀리초)입니다.

systemTimeMs

Long

필수 사항

시스템 공간에서 소요된 CPU 시간(단위: 밀리초)입니다.

maxReportingThreads

Integer

필수 사항

모든 배치에서 쿼리 실행 중 mongot가 사용한 최대 스레드 수입니다. 동시 실행되지 않는 설명 쿼리의 경우 값은 1입니다.

numBatches

Integer

필수 사항

쿼리 처리 시 요청된 mongot의 총 배치 수입니다.

다음 예시에서는 sample_mflix 데이터베이스의 movies 컬렉션을 사용합니다.

샘플 데이터 세트를 이미 로드한 경우,MongoDB Search 빠른 시작 튜토리얼을 참조하여 인덱스 정의를 생성하고 MongoDB Search 쿼리를 실행 .

다음 예시에서는 다양한 연산자를 사용하여 allPlansExecution 상세 수준 모드로 title 필드를 쿼리합니다.

db.movies.explain("allPlansExecution").aggregate([
{
$search: {
"text": {
"path": "title",
"query": "yark",
"fuzzy": {
"maxEdits": 1,
"maxExpansions": 100,
}
}
}
}
])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$_internalSearchMongotRemote': {
6 mongotQuery: {
7 text: {
8 path: 'title',
9 query: 'yark',
10 fuzzy: { maxEdits: 1, maxExpansions: 100 }
11 }
12 },
13 explain: {
14 query: {
15 type: 'BooleanQuery',
16 args: {
17 must: [],
18 mustNot: [],
19 should: [
20 {
21 type: 'BoostQuery',
22 args: {
23 query: {
24 type: 'TermQuery',
25 args: { path: 'title', value: 'mark' },
26 stats: {
27 context: { millisElapsed: 0 },
28 match: { millisElapsed: 0 },
29 score: { millisElapsed: 0 }
30 }
31 },
32 boost: 0.75
33 },
34 stats: {
35 context: {
36 millisElapsed: 0.209279,
37 invocationCounts: {
38 createWeight: Long('2'),
39 createScorer: Long('18')
40 }
41 },
42 match: {
43 millisElapsed: 0.028079,
44 invocationCounts: { nextDoc: Long('22') }
45 },
46 score: {
47 millisElapsed: 0.01706,
48 invocationCounts: { score: Long('16') }
49 }
50 }
51 },
52 {
53 type: 'BoostQuery',
54 args: {
55 query: {
56 type: 'TermQuery',
57 args: { path: 'title', value: 'yard' },
58 stats: {
59 context: { millisElapsed: 0 },
60 match: { millisElapsed: 0 },
61 score: { millisElapsed: 0 }
62 }
63 },
64 boost: 0.75
65 },
66 stats: {
67 context: {
68 millisElapsed: 0.136254,
69 invocationCounts: {
70 createWeight: Long('2'),
71 createScorer: Long('14')
72 }
73 },
74 match: {
75 millisElapsed: 0.008556,
76 invocationCounts: { nextDoc: Long('10') }
77 },
78 score: {
79 millisElapsed: 0.006096,
80 invocationCounts: { score: Long('6') }
81 }
82 }
83 },
84 {
85 type: 'BoostQuery',
86 args: {
87 query: {
88 type: 'TermQuery',
89 args: { path: 'title', value: 'york' },
90 stats: {
91 context: { millisElapsed: 0 },
92 match: { millisElapsed: 0 },
93 score: { millisElapsed: 0 }
94 }
95 },
96 boost: 0.75
97 },
98 stats: {
99 context: {
100 millisElapsed: 0.303568,
101 invocationCounts: {
102 createWeight: Long('2'),
103 createScorer: Long('18')
104 }
105 },
106 match: {
107 millisElapsed: 0.374856,
108 invocationCounts: { nextDoc: Long('62') }
109 },
110 score: {
111 millisElapsed: 0.892383,
112 invocationCounts: { score: Long('56') }
113 }
114 }
115 },
116 {
117 type: 'BoostQuery',
118 args: {
119 query: {
120 type: 'TermQuery',
121 args: { path: 'title', value: 'ark' },
122 stats: {
123 context: { millisElapsed: 0 },
124 match: { millisElapsed: 0 },
125 score: { millisElapsed: 0 }
126 }
127 },
128 boost: 0.6666666269302368
129 },
130 stats: {
131 context: {
132 millisElapsed: 8.379562,
133 invocationCounts: {
134 createWeight: Long('2'),
135 createScorer: Long('10')
136 }
137 },
138 match: {
139 millisElapsed: 2.073272,
140 invocationCounts: { nextDoc: Long('6') }
141 },
142 score: {
143 millisElapsed: 0.004063,
144 invocationCounts: { score: Long('4') }
145 }
146 }
147 },
148 {
149 type: 'BoostQuery',
150 args: {
151 query: {
152 type: 'TermQuery',
153 args: { path: 'title', value: 'dark' },
154 stats: {
155 context: { millisElapsed: 0 },
156 match: { millisElapsed: 0 },
157 score: { millisElapsed: 0 }
158 }
159 },
160 boost: 0.75
161 },
162 stats: {
163 context: {
164 millisElapsed: 0.679029,
165 invocationCounts: {
166 createWeight: Long('2'),
167 createScorer: Long('18')
168 }
169 },
170 match: {
171 millisElapsed: 5.500198,
172 invocationCounts: { nextDoc: Long('172') }
173 },
174 score: {
175 millisElapsed: 2.465502,
176 invocationCounts: { score: Long('166') }
177 }
178 }
179 },
180 {
181 type: 'BoostQuery',
182 args: {
183 query: {
184 type: 'TermQuery',
185 args: { path: 'title', value: 'park' },
186 stats: {
187 context: { millisElapsed: 0 },
188 match: { millisElapsed: 0 },
189 score: { millisElapsed: 0 }
190 }
191 },
192 boost: 0.75
193 },
194 stats: {
195 context: {
196 millisElapsed: 0.221919,
197 invocationCounts: {
198 createWeight: Long('2'),
199 createScorer: Long('18')
200 }
201 },
202 match: {
203 millisElapsed: 0.116139,
204 invocationCounts: { nextDoc: Long('60') }
205 },
206 score: {
207 millisElapsed: 0.056817,
208 invocationCounts: { score: Long('54') }
209 }
210 }
211 }
212 ],
213 filter: [],
214 minimumShouldMatch: 0
215 },
216 stats: {
217 context: {
218 millisElapsed: 25.303419,
219 invocationCounts: { createWeight: Long('2'), createScorer: Long('12') }
220 },
221 match: {
222 millisElapsed: 10.533183,
223 invocationCounts: { nextDoc: Long('308') }
224 },
225 score: {
226 millisElapsed: 5.501189,
227 invocationCounts: { score: Long('302') }
228 }
229 }
230 },
231 collectStats: {
232 allCollectorStats: {
233 millisElapsed: 6.735626,
234 invocationCounts: {
235 collect: Long('302'),
236 competitiveIterator: Long('6'),
237 setScorer: Long('6')
238 }
239 },
240 facet: { collectorStats: { millisElapsed: 0 } }
241 },
242 resultMaterialization: {
243 stats: {
244 millisElapsed: 176.613905,
245 invocationCounts: { retrieveAndSerialize: Long('2') }
246 }
247 },
248 metadata: {
249 <hostname>.mongodb.netmongotVersion: '1.42.0',
250 mongotHostName: '<hostname>.mongodb.net',
251 indexName: 'default',
252 cursorOptions: { batchSize: 108, requiresSearchSequenceToken: false },
253 totalLuceneDocs: 21349
254 },
255 resourceUsage: {
256 majorFaults: Long('99'),
257 minorFaults: Long('192'),
258 userTimeMs: Long('80'),
259 systemTimeMs: Long('10'),
260 maxReportingThreads: 1,
261 numBatches: 2
262 }
263 },
264 requiresSearchMetaCursor: false,
265 internalMongotBatchSizeHistory: [ Long('108'), Long('162') ]
266 },
267 nReturned: Long('151'),
268 executionTimeMillisEstimate: Long('83')
269 },
270 {
271 '$_internalSearchIdLookup': {
272 subPipeline: [
273 { '$match': { _id: { '$eq': '_id placeholder' } } }
274 ],
275 totalDocsExamined: Long('151'),
276 totalKeysExamined: Long('151'),
277 numDocsFilteredByIdLookup: Long('0')
278 },
279 nReturned: Long('151'),
280 executionTimeMillisEstimate: Long('88')
281 }
282 ],
283 queryShapeHash: '6FD3791F785FA329D4ECD1171E0E5AF6772C18F5F0A7A50FC416D080A93C8CB7',
284 serverInfo: {
285 host: '<hostname>.mongodb.net',
286 port: 27017,
287 version: '8.2.0',
288 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
289 },
290 serverParameters: {
291 ...
292 },
293 command: {
294 aggregate: 'movies',
295 pipeline: [
296 {
297 '$search': {
298 text: {
299 path: 'title',
300 query: 'yark',
301 fuzzy: { maxEdits: 1, maxExpansions: 100 }
302 }
303 }
304 }
305 ],
306 cursor: {},
307 '$db': 'sample_mflix'
308 },
309 ok: 1,
310 '$clusterTime': {
311 clusterTime: Timestamp({ t: 1758295936, i: 19 }),
312 signature: {
313 hash: Binary.createFromBase64('+CanjrL9jdXPTLa2sUaNPtImkBc=', 0),
314 keyId: Long('7551379485140975621')
315 }
316 },
317 operationTime: Timestamp({ t: 1758295936, i: 19 })
318}
db.movies.explain("allPlansExecution").aggregate([ {
$search: {
"text": {
"path": "title",
"query": "prince"
},
"highlight": {
"path": "title",
"maxNumPassages": 1,
"maxCharsToExamine": 40
}
}
},
{
$project: {
"description": 1,
"_id": 0,
"highlights": { "$meta": "searchHighlights" }
}
} ])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$_internalSearchMongotRemote': {
6 mongotQuery: {
7 text: { path: 'title', query: 'prince' },
8 highlight: { path: 'title', maxNumPassages: 1, maxCharsToExamine: 40 }
9 },
10 explain: {
11 query: {
12 type: 'TermQuery',
13 args: { path: 'title', value: 'prince' },
14 stats: {
15 context: {
16 millisElapsed: 9.880819,
17 invocationCounts: { createWeight: Long('1'), createScorer: Long('6') }
18 },
19 match: {
20 millisElapsed: 3.566358,
21 invocationCounts: { nextDoc: Long('28') }
22 },
23 score: {
24 millisElapsed: 2.762687,
25 invocationCounts: { score: Long('25') }
26 }
27 }
28 },
29 collectStats: {
30 allCollectorStats: {
31 millisElapsed: 3.238152,
32 invocationCounts: {
33 collect: Long('25'),
34 competitiveIterator: Long('3'),
35 setScorer: Long('3')
36 }
37 },
38 facet: { collectorStats: { millisElapsed: 0 } }
39 },
40 highlight: {
41 resolvedHighlightPaths: [ '$type:string/title' ],
42 stats: {
43 millisElapsed: 157.543967,
44 invocationCounts: {
45 executeHighlight: Long('1'),
46 setupHighlight: Long('1')
47 }
48 }
49 },
50 resultMaterialization: {
51 stats: {
52 millisElapsed: 3.781115,
53 invocationCounts: { retrieveAndSerialize: Long('1') }
54 }
55 },
56 metadata: {
57 <hostname>.mongodb.netmongotVersion: '1.42.0',
58 mongotHostName: '<hostname>.mongodb.net',
59 indexName: 'default',
60 cursorOptions: { batchSize: 108, requiresSearchSequenceToken: false },
61 totalLuceneDocs: 21349
62 },
63 resourceUsage: {
64 majorFaults: Long('42'),
65 minorFaults: Long('167'),
66 userTimeMs: Long('50'),
67 systemTimeMs: Long('0'),
68 maxReportingThreads: 1,
69 numBatches: 1
70 }
71 },
72 requiresSearchMetaCursor: false,
73 internalMongotBatchSizeHistory: [ Long('108') ]
74 },
75 nReturned: Long('25'),
76 executionTimeMillisEstimate: Long('0')
77 },
78 {
79 '$_internalSearchIdLookup': {
80 subPipeline: [
81 { '$match': { _id: { '$eq': '_id placeholder' } } }
82 ],
83 totalDocsExamined: Long('25'),
84 totalKeysExamined: Long('25'),
85 numDocsFilteredByIdLookup: Long('0')
86 },
87 nReturned: Long('25'),
88 executionTimeMillisEstimate: Long('1')
89 },
90 {
91 '$project': {
92 description: true,
93 highlights: { '$meta': 'searchHighlights' },
94 _id: false
95 },
96 nReturned: Long('25'),
97 executionTimeMillisEstimate: Long('1')
98 }
99 ],
100 queryShapeHash: 'D08444272924C1E04A6E99D0CD4BF82FD929893862B3356F79EC18BBD1F0EF0C',
101 serverInfo: {
102 host: '<hostname>.mongodb.net',
103 port: 27017,
104 version: '8.2.0',
105 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
106 },
107 serverParameters: {
108 internalQueryFacetBufferSizeBytes: 104857600,
109 internalQueryFacetMaxOutputDocSizeBytes: 104857600,
110 internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
111 internalDocumentSourceGroupMaxMemoryBytes: 104857600,
112 internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
113 internalQueryProhibitBlockingMergeOnMongoS: 0,
114 internalQueryMaxAddToSetBytes: 104857600,
115 internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
116 internalQueryFrameworkControl: 'trySbeRestricted',
117 internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
118 },
119 command: {
120 aggregate: 'movies',
121 pipeline: [
122 {
123 '$search': {
124 text: { path: 'title', query: 'prince' },
125 highlight: { path: 'title', maxNumPassages: 1, maxCharsToExamine: 40 }
126 }
127 },
128 {
129 '$project': {
130 description: 1,
131 _id: 0,
132 highlights: { '$meta': 'searchHighlights' }
133 }
134 }
135 ],
136 cursor: {},
137 '$db': 'sample_mflix'
138 },
139 ok: 1,
140 '$clusterTime': {
141 clusterTime: Timestamp({ t: 1758302099, i: 1 }),
142 signature: {
143 hash: Binary.createFromBase64('pUGxwCVnDOBIObmhURJQ1a1UwC8=', 0),
144 keyId: Long('7551379485140975621')
145 }
146 },
147 operationTime: Timestamp({ t: 1758302099, i: 1 })
148}
db.movies.explain("allPlansExecution").aggregate([
{
"$searchMeta": {
"facet": {
"operator": {
"near": {
"path": "released",
"origin": ISODate("1921-11-01T00:00:00.000+00:00"),
"pivot": 7776000000
}
},
"facets": {
"genresFacet": {
"type": "string",
"path": "genres"
},
"yearFacet" : {
"type" : "number",
"path" : "year",
"boundaries" : [1910,1920,1930,1940]
}
}
}
}
}
])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$searchMeta': {
6 mongotQuery: {
7 facet: {
8 operator: {
9 near: {
10 path: 'released',
11 origin: ISODate('1921-11-01T00:00:00.000Z'),
12 pivot: 7776000000
13 }
14 },
15 facets: {
16 genresFacet: { type: 'string', path: 'genres' },
17 yearFacet: {
18 type: 'number',
19 path: 'year',
20 boundaries: [ 1910, 1920, 1930, 1940 ]
21 }
22 }
23 }
24 },
25 explain: {
26 query: {
27 type: 'LongDistanceFeatureQuery',
28 args: {},
29 stats: {
30 context: {
31 millisElapsed: 4.141763,
32 invocationCounts: { createWeight: Long('1'), createScorer: Long('6') }
33 },
34 match: {
35 millisElapsed: 24.986327,
36 invocationCounts: { nextDoc: Long('20881') }
37 },
38 score: {
39 millisElapsed: 33.324657,
40 invocationCounts: { score: Long('20878') }
41 }
42 }
43 },
44 collectStats: {
45 allCollectorStats: {
46 millisElapsed: 72.243101,
47 invocationCounts: {
48 collect: Long('20878'),
49 competitiveIterator: Long('3'),
50 setScorer: Long('3')
51 }
52 },
53 facet: {
54 collectorStats: {
55 millisElapsed: 10.424621,
56 invocationCounts: { collect: Long('20878'), setScorer: Long('3') }
57 },
58 createCountsStats: {
59 millisElapsed: 60.095261,
60 invocationCounts: { generateFacetCounts: Long('2') }
61 },
62 stringFacetCardinalities: { genresFacet: { queried: 10, total: 25 } }
63 }
64 },
65 resultMaterialization: {
66 stats: {
67 millisElapsed: 13.764287,
68 invocationCounts: { retrieveAndSerialize: Long('1') }
69 }
70 },
71 metadata: {
72 <hostname>.mongodb.netmongotVersion: '1.42.0',
73 mongotHostName: '<hostname>.mongodb.net',
74 indexName: 'default',
75 totalLuceneDocs: 21349
76 },
77 resourceUsage: {
78 majorFaults: Long('10'),
79 minorFaults: Long('13'),
80 userTimeMs: Long('20'),
81 systemTimeMs: Long('0'),
82 maxReportingThreads: 1,
83 numBatches: 1
84 }
85 },
86 requiresSearchMetaCursor: true
87 },
88 nReturned: Long('1'),
89 executionTimeMillisEstimate: Long('336')
90 }
91 ],
92 queryShapeHash: '582DB864C9BCFB96896CF1A3079CF70FAC10A9A1E19E8D66DF20A2BB40424FB5',
93 serverInfo: {
94 host: '<hostname>.mongodb.net',
95 port: 27017,
96 version: '8.2.0',
97 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
98 },
99 serverParameters: {
100 ...
101 },
102 command: {
103 aggregate: 'movies',
104 pipeline: [
105 {
106 '$searchMeta': {
107 facet: {
108 operator: {
109 near: {
110 path: 'released',
111 origin: ISODate('1921-11-01T00:00:00.000Z'),
112 pivot: 7776000000
113 }
114 },
115 facets: {
116 genresFacet: { type: 'string', path: 'genres' },
117 yearFacet: {
118 type: 'number',
119 path: 'year',
120 boundaries: [ 1910, 1920, 1930, 1940 ]
121 }
122 }
123 }
124 }
125 }
126 ],
127 cursor: {},
128 '$db': 'sample_mflix'
129 },
130 ok: 1,
131 '$clusterTime': {
132 clusterTime: Timestamp({ t: 1758304279, i: 1 }),
133 signature: {
134 hash: Binary.createFromBase64('DI9+ZTogU1QxHCWId6QLcA4R4tQ=', 0),
135 keyId: Long('7551379485140975621')
136 }
137 },
138 operationTime: Timestamp({ t: 1758304279, i: 1 })
139}
db.movies.explain("allPlansExecution").aggregate([
{
$search: {
"text": {
"path": "title",
"query": "yark",
"fuzzy": {
"maxEdits": 1,
"maxExpansions": 100,
}
}
}
}
])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$_internalSearchMongotRemote': {
6 mongotQuery: {
7 text: {
8 path: 'title',
9 query: 'yark',
10 fuzzy: { maxEdits: 1, maxExpansions: 100 }
11 }
12 },
13 explain: {
14 query: {
15 type: 'BooleanQuery',
16 args: {
17 must: [],
18 mustNot: [],
19 should: [
20 {
21 type: 'BoostQuery',
22 args: {
23 query: {
24 type: 'TermQuery',
25 args: { path: 'title', value: 'mark' },
26 stats: {
27 context: { millisElapsed: 0 },
28 match: { millisElapsed: 0 },
29 score: { millisElapsed: 0 }
30 }
31 },
32 boost: 0.75
33 },
34 stats: {
35 context: {
36 millisElapsed: 0.164466,
37 invocationCounts: {
38 createWeight: Long('2'),
39 createScorer: Long('18')
40 }
41 },
42 match: {
43 millisElapsed: 0.055889,
44 invocationCounts: { nextDoc: Long('22') }
45 },
46 score: {
47 millisElapsed: 0.01638,
48 invocationCounts: { score: Long('16') }
49 }
50 }
51 },
52 {
53 type: 'BoostQuery',
54 args: {
55 query: {
56 type: 'TermQuery',
57 args: { path: 'title', value: 'yard' },
58 stats: {
59 context: { millisElapsed: 0 },
60 match: { millisElapsed: 0 },
61 score: { millisElapsed: 0 }
62 }
63 },
64 boost: 0.75
65 },
66 stats: {
67 context: {
68 millisElapsed: 0.109841,
69 invocationCounts: {
70 createWeight: Long('2'),
71 createScorer: Long('14')
72 }
73 },
74 match: {
75 millisElapsed: 0.009747,
76 invocationCounts: { nextDoc: Long('10') }
77 },
78 score: {
79 millisElapsed: 0.005449,
80 invocationCounts: { score: Long('6') }
81 }
82 }
83 },
84 {
85 type: 'BoostQuery',
86 args: {
87 query: {
88 type: 'TermQuery',
89 args: { path: 'title', value: 'york' },
90 stats: {
91 context: { millisElapsed: 0 },
92 match: { millisElapsed: 0 },
93 score: { millisElapsed: 0 }
94 }
95 },
96 boost: 0.75
97 },
98 stats: {
99 context: {
100 millisElapsed: 0.140144,
101 invocationCounts: {
102 createWeight: Long('2'),
103 createScorer: Long('18')
104 }
105 },
106 match: {
107 millisElapsed: 0.058885,
108 invocationCounts: { nextDoc: Long('62') }
109 },
110 score: {
111 millisElapsed: 0.877508,
112 invocationCounts: { score: Long('56') }
113 }
114 }
115 },
116 {
117 type: 'BoostQuery',
118 args: {
119 query: {
120 type: 'TermQuery',
121 args: { path: 'title', value: 'ark' },
122 stats: {
123 context: { millisElapsed: 0 },
124 match: { millisElapsed: 0 },
125 score: { millisElapsed: 0 }
126 }
127 },
128 boost: 0.6666666269302368
129 },
130 stats: {
131 context: {
132 millisElapsed: 0.26056,
133 invocationCounts: {
134 createWeight: Long('2'),
135 createScorer: Long('10')
136 }
137 },
138 match: {
139 millisElapsed: 1.028141,
140 invocationCounts: { nextDoc: Long('6') }
141 },
142 score: {
143 millisElapsed: 0.004226,
144 invocationCounts: { score: Long('4') }
145 }
146 }
147 },
148 {
149 type: 'BoostQuery',
150 args: {
151 query: {
152 type: 'TermQuery',
153 args: { path: 'title', value: 'dark' },
154 stats: {
155 context: { millisElapsed: 0 },
156 match: { millisElapsed: 0 },
157 score: { millisElapsed: 0 }
158 }
159 },
160 boost: 0.75
161 },
162 stats: {
163 context: {
164 millisElapsed: 0.3029,
165 invocationCounts: {
166 createWeight: Long('2'),
167 createScorer: Long('18')
168 }
169 },
170 match: {
171 millisElapsed: 2.294511,
172 invocationCounts: { nextDoc: Long('172') }
173 },
174 score: {
175 millisElapsed: 1.806661,
176 invocationCounts: { score: Long('166') }
177 }
178 }
179 },
180 {
181 type: 'BoostQuery',
182 args: {
183 query: {
184 type: 'TermQuery',
185 args: { path: 'title', value: 'park' },
186 stats: {
187 context: { millisElapsed: 0 },
188 match: { millisElapsed: 0 },
189 score: { millisElapsed: 0 }
190 }
191 },
192 boost: 0.75
193 },
194 stats: {
195 context: {
196 millisElapsed: 0.154143,
197 invocationCounts: {
198 createWeight: Long('2'),
199 createScorer: Long('18')
200 }
201 },
202 match: {
203 millisElapsed: 0.052283,
204 invocationCounts: { nextDoc: Long('60') }
205 },
206 score: {
207 millisElapsed: 0.050278,
208 invocationCounts: { score: Long('54') }
209 }
210 }
211 }
212 ],
213 filter: [],
214 minimumShouldMatch: 0
215 },
216 stats: {
217 context: {
218 millisElapsed: 2.024454,
219 invocationCounts: { createWeight: Long('2'), createScorer: Long('12') }
220 },
221 match: {
222 millisElapsed: 4.020593,
223 invocationCounts: { nextDoc: Long('308') }
224 },
225 score: {
226 millisElapsed: 3.181962,
227 invocationCounts: { score: Long('302') }
228 }
229 }
230 },
231 collectStats: {
232 allCollectorStats: {
233 millisElapsed: 4.062801,
234 invocationCounts: {
235 collect: Long('302'),
236 competitiveIterator: Long('6'),
237 setScorer: Long('6')
238 }
239 },
240 facet: { collectorStats: { millisElapsed: 0 } }
241 },
242 resultMaterialization: {
243 stats: {
244 millisElapsed: 127.205476,
245 invocationCounts: { retrieveAndSerialize: Long('2') }
246 }
247 },
248 metadata: {
249 <hostname>.mongodb.netmongotVersion: '1.42.0',
250 mongotHostName: '<hostname>.mongodb.net',
251 indexName: 'default',
252 cursorOptions: { batchSize: 108, requiresSearchSequenceToken: false },
253 totalLuceneDocs: 21349
254 },
255 resourceUsage: {
256 majorFaults: Long('100'),
257 minorFaults: Long('31'),
258 userTimeMs: Long('20'),
259 systemTimeMs: Long('10'),
260 maxReportingThreads: 1,
261 numBatches: 2
262 }
263 },
264 requiresSearchMetaCursor: false,
265 internalMongotBatchSizeHistory: [ Long('108'), Long('162') ]
266 },
267 nReturned: Long('151'),
268 executionTimeMillisEstimate: Long('57')
269 },
270 {
271 '$_internalSearchIdLookup': {
272 subPipeline: [
273 { '$match': { _id: { '$eq': '_id placeholder' } } }
274 ],
275 totalDocsExamined: Long('151'),
276 totalKeysExamined: Long('151'),
277 numDocsFilteredByIdLookup: Long('0')
278 },
279 nReturned: Long('151'),
280 executionTimeMillisEstimate: Long('64')
281 }
282 ],
283 queryShapeHash: '6FD3791F785FA329D4ECD1171E0E5AF6772C18F5F0A7A50FC416D080A93C8CB7',
284 serverInfo: {
285 host: '<hostname>.mongodb.net',
286 port: 27017,
287 version: '8.2.0',
288 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
289 },
290 serverParameters: {
291 ...
292 },
293 command: {
294 aggregate: 'movies',
295 pipeline: [
296 {
297 '$search': {
298 text: {
299 path: 'title',
300 query: 'yark',
301 fuzzy: { maxEdits: 1, maxExpansions: 100 }
302 }
303 }
304 }
305 ],
306 cursor: {},
307 '$db': 'sample_mflix'
308 },
309 ok: 1,
310 '$clusterTime': {
311 clusterTime: Timestamp({ t: 1758302299, i: 1 }),
312 signature: {
313 hash: Binary.createFromBase64('pCKOPlBY/K4IObOkqDlOSnbRqw0=', 0),
314 keyId: Long('7551379485140975621')
315 }
316 },
317 operationTime: Timestamp({ t: 1758302299, i: 1 })
318}

다음 예시에서는 다양한 연산자를 사용하여 queryPlanner 상세 수준 모드로 title 필드를 쿼리합니다.

db.movies.explain("queryPlanner").aggregate([
{
$search: {
"text": {
"path": "title",
"query": "yark",
"fuzzy": {
"maxEdits": 1,
"maxExpansions": 100,
}
}
}
}
])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$_internalSearchMongotRemote': {
6 mongotQuery: {
7 text: {
8 path: 'title',
9 query: 'yark',
10 fuzzy: { maxEdits: 1, maxExpansions: 100 }
11 }
12 },
13 explain: {
14 query: {
15 type: 'BooleanQuery',
16 args: {
17 must: [],
18 mustNot: [],
19 should: [
20 {
21 type: 'BoostQuery',
22 args: {
23 query: {
24 type: 'TermQuery',
25 args: { path: 'title', value: 'park' }
26 },
27 boost: 0.75
28 }
29 },
30 {
31 type: 'BoostQuery',
32 args: {
33 query: {
34 type: 'TermQuery',
35 args: { path: 'title', value: 'york' }
36 },
37 boost: 0.75
38 }
39 },
40 {
41 type: 'BoostQuery',
42 args: {
43 query: {
44 type: 'TermQuery',
45 args: { path: 'title', value: 'dark' }
46 },
47 boost: 0.75
48 }
49 },
50 {
51 type: 'BoostQuery',
52 args: {
53 query: {
54 type: 'TermQuery',
55 args: { path: 'title', value: 'mark' }
56 },
57 boost: 0.75
58 }
59 },
60 {
61 type: 'BoostQuery',
62 args: {
63 query: {
64 type: 'TermQuery',
65 args: { path: 'title', value: 'yard' }
66 },
67 boost: 0.75
68 }
69 },
70 {
71 type: 'BoostQuery',
72 args: {
73 query: {
74 type: 'TermQuery',
75 args: { path: 'title', value: 'ark' }
76 },
77 boost: 0.6666666269302368
78 }
79 }
80 ],
81 filter: [],
82 minimumShouldMatch: 0
83 }
84 },
85 metadata: {
86 <hostname>.mongodb.netmongotVersion: '1.42.0',
87 mongotHostName: '<hostname>.mongodb.net',
88 indexName: 'default',
89 totalLuceneDocs: 21349
90 }
91 },
92 requiresSearchMetaCursor: false
93 }
94 },
95 {
96 '$_internalSearchIdLookup': {
97 subPipeline: [
98 { '$match': { _id: { '$eq': '_id placeholder' } } }
99 ]
100 }
101 }
102 ],
103 queryShapeHash: '6FD3791F785FA329D4ECD1171E0E5AF6772C18F5F0A7A50FC416D080A93C8CB7',
104 serverInfo: {
105 host: '<hostname>.mongodb.net',
106 port: 27017,
107 version: '8.2.0',
108 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
109 },
110 serverParameters: {
111 ...
112 },
113 command: {
114 aggregate: 'movies',
115 pipeline: [
116 {
117 '$search': {
118 text: {
119 path: 'title',
120 query: 'yark',
121 fuzzy: { maxEdits: 1, maxExpansions: 100 }
122 }
123 }
124 }
125 ],
126 cursor: {},
127 '$db': 'sample_mflix'
128 },
129 ok: 1,
130 '$clusterTime': {
131 clusterTime: Timestamp({ t: 1758305729, i: 1 }),
132 signature: {
133 hash: Binary.createFromBase64('IUnIrXR/VeUrj1cGgyEFlkoQKAM=', 0),
134 keyId: Long('7551379485140975621')
135 }
136 },
137 operationTime: Timestamp({ t: 1758305729, i: 1 })
138}
db.movies.explain("queryPlanner").aggregate([
{
$search: {
"text": {
"path": "title",
"query": "prince"
},
"highlight": {
"path": "title",
"maxNumPassages": 1,
"maxCharsToExamine": 40
}
}
},
{
$project: {
"description": 1,
"_id": 0,
"highlights": { "$meta": "searchHighlights" }
}
}
])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$_internalSearchMongotRemote': {
6 mongotQuery: {
7 text: { path: 'title', query: 'prince' },
8 highlight: { path: 'title', maxNumPassages: 1, maxCharsToExamine: 40 }
9 },
10 explain: {
11 query: {
12 type: 'TermQuery',
13 args: { path: 'title', value: 'prince' }
14 },
15 highlight: { resolvedHighlightPaths: [ '$type:string/title' ] },
16 metadata: {
17 <hostname>.mongodb.netmongotVersion: '1.42.0',
18 mongotHostName: '<hostname>.mongodb.net',
19 indexName: 'default',
20 totalLuceneDocs: 21349
21 }
22 },
23 requiresSearchMetaCursor: false
24 }
25 },
26 {
27 '$_internalSearchIdLookup': {
28 subPipeline: [
29 { '$match': { _id: { '$eq': '_id placeholder' } } }
30 ]
31 }
32 },
33 {
34 '$project': {
35 description: true,
36 highlights: { '$meta': 'searchHighlights' },
37 _id: false
38 }
39 }
40 ],
41 queryShapeHash: 'D08444272924C1E04A6E99D0CD4BF82FD929893862B3356F79EC18BBD1F0EF0C',
42 serverInfo: {
43 host: '<hostname>.mongodb.net',
44 port: 27017,
45 version: '8.2.0',
46 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
47 },
48 serverParameters: {
49 ...
50 },
51 command: {
52 aggregate: 'movies',
53 pipeline: [
54 {
55 '$search': {
56 text: { path: 'title', query: 'prince' },
57 highlight: { path: 'title', maxNumPassages: 1, maxCharsToExamine: 40 }
58 }
59 },
60 {
61 '$project': {
62 description: 1,
63 _id: 0,
64 highlights: { '$meta': 'searchHighlights' }
65 }
66 }
67 ],
68 cursor: {},
69 '$db': 'sample_mflix'
70 },
71 ok: 1,
72 '$clusterTime': {
73 clusterTime: Timestamp({ t: 1758305809, i: 1 }),
74 signature: {
75 hash: Binary.createFromBase64('R7wN4/xS0eg0XFd23xeo/+hMPBY=', 0),
76 keyId: Long('7551379485140975621')
77 }
78 },
79 operationTime: Timestamp({ t: 1758305809, i: 1 })
80}
db.movies.explain("queryPlanner").aggregate([
{
"$searchMeta": {
"facet": {
"operator": {
"near": {
"path": "released",
"origin": ISODate("1921-11-01T00:00:00.000+00:00"),
"pivot": 7776000000
}
},
"facets": {
"genresFacet": {
"type": "string",
"path": "genres"
},
"yearFacet" : {
"type" : "number",
"path" : "year",
"boundaries" : [1910,1920,1930,1940]
}
}
}
}
}
])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$searchMeta': {
6 mongotQuery: {
7 facet: {
8 operator: {
9 near: {
10 path: 'released',
11 origin: ISODate('1921-11-01T00:00:00.000Z'),
12 pivot: 7776000000
13 }
14 },
15 facets: {
16 genresFacet: { type: 'string', path: 'genres' },
17 yearFacet: {
18 type: 'number',
19 path: 'year',
20 boundaries: [ 1910, 1920, 1930, 1940 ]
21 }
22 }
23 }
24 },
25 explain: {
26 query: { type: 'LongDistanceFeatureQuery', args: {} },
27 collectStats: {
28 facet: {
29 stringFacetCardinalities: { genresFacet: { queried: 10, total: 25 } }
30 }
31 },
32 metadata: {
33 <hostname>.mongodb.netmongotVersion: '1.42.0',
34 mongotHostName: '<hostname>.mongodb.net',
35 indexName: 'default',
36 totalLuceneDocs: 21349
37 }
38 },
39 requiresSearchMetaCursor: true
40 }
41 }
42 ],
43 queryShapeHash: '582DB864C9BCFB96896CF1A3079CF70FAC10A9A1E19E8D66DF20A2BB40424FB5',
44 serverInfo: {
45 host: '<hostname>.mongodb.net',
46 port: 27017,
47 version: '8.2.0',
48 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
49 },
50 serverParameters: {
51 ...
52 },
53 command: {
54 aggregate: 'movies',
55 pipeline: [
56 {
57 '$searchMeta': {
58 facet: {
59 operator: {
60 near: {
61 path: 'released',
62 origin: ISODate('1921-11-01T00:00:00.000Z'),
63 pivot: 7776000000
64 }
65 },
66 facets: {
67 genresFacet: { type: 'string', path: 'genres' },
68 yearFacet: {
69 type: 'number',
70 path: 'year',
71 boundaries: [ 1910, 1920, 1930, 1940 ]
72 }
73 }
74 }
75 }
76 }
77 ],
78 cursor: {},
79 '$db': 'sample_mflix'
80 },
81 ok: 1,
82 '$clusterTime': {
83 clusterTime: Timestamp({ t: 1758305859, i: 1 }),
84 signature: {
85 hash: Binary.createFromBase64('8Zm16MEkzHnPpP9uLJK1YlT7a3o=', 0),
86 keyId: Long('7551379485140975621')
87 }
88 },
89 operationTime: Timestamp({ t: 1758305859, i: 1 })
90}

파이프라인에서 $limit 단계를 지정하는 쿼리의 경우 explain 결과에는 mongodmongot 에서 요청한 문서 수를 보여주는 mongotDocsRequested 지표가 포함됩니다.

예시

{
"mongotQuery": {},
"explain": {},
"limit": <int>,
"sortSpec": {},
"mongotDocsRequested": <int>,
}

다음 예시에서는 자동 완성을 사용하여 executionStats 상세 수준 모드로 title 필드를 쿼리합니다.

1db.movies.explain("executionStats").aggregate([
2 {
3 "$search": {
4 "autocomplete": {
5 "path": "title",
6 "query": "pre",
7 "fuzzy": {
8 "maxEdits": 1,
9 "prefixLength": 1,
10 "maxExpansions": 256
11 }
12 }
13 }
14 }
15])
1{
2 explainVersion: '1',
3 stages: [
4 {
5 '$_internalSearchMongotRemote': {
6 mongotQuery: {
7 autocomplete: {
8 path: 'title',
9 query: 'pre',
10 fuzzy: { maxEdits: 1, prefixLength: 1, maxExpansions: 256 }
11 }
12 },
13 explain: {
14 query: {
15 type: 'BooleanQuery',
16 args: {
17 must: [
18 {
19 type: 'MultiTermQueryConstantScoreBlendedWrapper',
20 args: {
21 queries: [
22 {
23 type: 'DefaultQuery',
24 args: { queryType: 'AutomatonQuery' },
25 stats: {
26 context: { millisElapsed: 0 },
27 match: { millisElapsed: 0 },
28 score: { millisElapsed: 0 }
29 }
30 }
31 ]
32 },
33 stats: {
34 context: {
35 millisElapsed: 12.517877,
36 invocationCounts: {
37 createWeight: Long('4'),
38 createScorer: Long('48')
39 }
40 },
41 match: {
42 millisElapsed: 0.970794,
43 invocationCounts: { nextDoc: Long('2436') }
44 },
45 score: {
46 millisElapsed: 0.638731,
47 invocationCounts: { score: Long('2420') }
48 }
49 }
50 }
51 ],
52 mustNot: [],
53 should: [
54 {
55 type: 'TermQuery',
56 args: { path: 'title', value: 'pre' },
57 stats: {
58 context: {
59 millisElapsed: 1.481341,
60 invocationCounts: {
61 createWeight: Long('4'),
62 createScorer: Long('16')
63 }
64 },
65 match: { millisElapsed: 0 },
66 score: { millisElapsed: 0 }
67 }
68 }
69 ],
70 filter: [],
71 minimumShouldMatch: 0
72 },
73 stats: {
74 context: {
75 millisElapsed: 15.118651,
76 invocationCounts: { createWeight: Long('4'), createScorer: Long('32') }
77 },
78 match: {
79 millisElapsed: 1.923822,
80 invocationCounts: { nextDoc: Long('2436') }
81 },
82 score: {
83 millisElapsed: 1.954216,
84 invocationCounts: { score: Long('2420') }
85 }
86 }
87 },
88 collectStats: {
89 allCollectorStats: {
90 millisElapsed: 4.189904,
91 invocationCounts: {
92 collect: Long('2420'),
93 competitiveIterator: Long('16'),
94 setScorer: Long('16')
95 }
96 },
97 facet: { collectorStats: { millisElapsed: 0 } }
98 },
99 resultMaterialization: {
100 stats: {
101 millisElapsed: 21.876621,
102 invocationCounts: { retrieveAndSerialize: Long('4') }
103 }
104 },
105 metadata: {
106 <hostname>.mongodb.netmongotVersion: '1.42.0',
107 mongotHostName: '<hostname>.mongodb.net',
108 indexName: 'default',
109 cursorOptions: { batchSize: 108, requiresSearchSequenceToken: false },
110 totalLuceneDocs: 21349
111 },
112 resourceUsage: {
113 majorFaults: Long('2'),
114 minorFaults: Long('242'),
115 userTimeMs: Long('40'),
116 systemTimeMs: Long('0'),
117 maxReportingThreads: 1,
118 numBatches: 4
119 }
120 },
121 requiresSearchMetaCursor: false,
122 internalMongotBatchSizeHistory: [ Long('108'), Long('162'), Long('243'), Long('365') ]
123 },
124 nReturned: Long('605'),
125 executionTimeMillisEstimate: Long('44')
126 },
127 {
128 '$_internalSearchIdLookup': {
129 subPipeline: [
130 { '$match': { _id: { '$eq': '_id placeholder' } } }
131 ],
132 totalDocsExamined: Long('605'),
133 totalKeysExamined: Long('605'),
134 numDocsFilteredByIdLookup: Long('0')
135 },
136 nReturned: Long('605'),
137 executionTimeMillisEstimate: Long('91')
138 }
139 ],
140 queryShapeHash: '6FD3791F785FA329D4ECD1171E0E5AF6772C18F5F0A7A50FC416D080A93C8CB7',
141 serverInfo: {
142 host: '<hostname>.mongodb.net',
143 port: 27017,
144 version: '8.2.0',
145 gitVersion: '13e629eeccd63f00d17568fc4c12b7530fa34b54'
146 },
147 serverParameters: {
148 ...
149 },
150 command: {
151 aggregate: 'movies',
152 pipeline: [
153 {
154 '$search': {
155 autocomplete: {
156 path: 'title',
157 query: 'pre',
158 fuzzy: { maxEdits: 1, prefixLength: 1, maxExpansions: 256 }
159 }
160 }
161 }
162 ],
163 cursor: {},
164 '$db': 'sample_mflix'
165 },
166 ok: 1,
167 '$clusterTime': {
168 clusterTime: Timestamp({ t: 1758306209, i: 1 }),
169 signature: {
170 hash: Binary.createFromBase64('MIipFR5NAfl728L6h4ueQeZBLGM=', 0),
171 keyId: Long('7551379485140975621')
172 }
173 },
174 operationTime: Timestamp({ t: 1758306209, i: 1 })
175}

explain 응답 요소에 대한 자세한 내용은 Explain 결과를 참조하세요.

이 페이지의 내용