/ /

How to Retrieve Query Plan and Execution Statistics

The MongoDB Search query returns information about the $search query plan and execution statistics when the query is run with the explain method enabled. When you run a query with explain, MongoDB Search returns a BSON document containing statistics and metadata that describes how the query was run internally in Lucene.

Tip

explain command

Syntax

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

Verbosity

Verbosity mode controls the behavior of explain and the amount of information returned. Value can be one of the following, in order of decreasing verbosity:

allPlansExecution	Information about the query plan including the `stats` fields, which contain execution statistics for the query. Includes partial execution data captured during plan selection.
executionStats	Information about the query plan including the `stats` fields, which contain execution statistics for the query.
queryPlanner (default)	Information about the query plan. Does not include the `stats` fields, which contain execution statistics for the query.

Tip

Verbosity Modes

Output

The query with the explain method returns the following fields in the stages.$_internalSearchMongotRemote object:

Option	Type	Purpose
`mongotQuery`	document	Contains the query that you ran.
`explain`	document	Contains the `explain` results. To learn more, see Explain Results.
`internalMongotBatchSizeHistory`	array of integers	Contains the size of each batch of documents that `mongot` returned to `mongod`.

Explain Results

The explain method returns a BSON document with the following fields in the explain document.

Option	Type	Necessity	Purpose
`collectors`	document	Optional	Describes the execution statistics for the collector. If `indexPartitionExplain` is present, this is nested within each `indexPartitionExplain` instead of at the top-level.
`highlight`	document	Optional	Details about the highlight execution for the query. This is returned only if you specified highlighting in the query.
`indexPartitionExplain`	array of documents	Optional	Contains per index partition details. This is only returned if you configured two or more index partitions.
`metadata`	document	Optional	Contains useful metadata.
`query`	document	Optional	Describes the execution statistics for the query. This is not returned. If `indexPartitionExplain` is present, this is nested within each `indexPartitionExplain`, instead of at the top-level.
`resultMaterialization`	document	Optional	Details related to retrieving per-document data from Lucene after query execution. This is not returned for `queryPlanner` verbosity mode.
`resourceUsage`	document	Optional	Details the resource usage of the query when it was executed. This is not returned for `queryPlanner` verbosity mode.

`collectors`

The collectors BSON document contains the following fields:

Field	Type	Necessity	Purpose
`allCollectorStats`	document	Required	Statistics of all collectors of the query. Statistics reported represent either the maximum value across all collectors used in the query or a sum of the statistic across all the sub-collectors. The timing statistics are summed to reflect the total time spent across all collectors for the entire query. To learn more, see `allCollectorStats`.
`facet`	document	Optional	Breakdown of the query that specifies facet. To learn more, see `facet`.
`sort`	document	Optional	Breakdown of the query that specifies sort. To learn more, see `sort`.

`allCollectorStats`

The allCollectorStats BSON document describes collector statistics across all collectors specified in the query, including facet and sort. It contains the following keys:

Field	Description
`collect`	Tracks the duration and number of results collected by the collector.
`competitiveIterator`	Statistics tracking the total duration and the number of times a `competitiveIterator` was requested from the collector.
`setScorer`	Statistics tracking the total duration and number of times a scorer was set on the collector.

`facet`

The facet is a BSON document that details query and execution statistics when you specify a facet in the query. It contains the following fields:

Option	Type	Necessity	Purpose
`collectorStats`	document	Optional	Shows statistics only for the `facet` collector. The keys in here are identical to the `allCollectorStats`. You can evaluate the difference between this and the `allCollectorStats` to determine the `sort` collector execution statistics if you used `sort` in the query.
`createCountsStats`	document	Optional	Shows statistics related to creating the internal Lucene object that holds all of the facet groupings. It contains `generateFacetCounts` field, which returns the statistics tracking the total duration and number of times `mongot` generates the Lucene object that holds all of the facets and their counts.
`stringFacetFieldCardinalities`	document	Required	Maps the field being faceted on to their cardinalities for both the documents that matched the query and across the entire Lucene index. It provides the following cardinality information for each field: `queried` - Represents the facet cardinality of the field across all queried documents. `total` - Represents the facet cardinality of the field across all documents in the index.

`sort`

The sort is a BSON document that details query and execution statistics when you specify a sort in the query. It contains the following fields:

Option	Type	Necessity	Purpose
`stats`	document	Optional	Tracks statistics related to `sort` execution across all sort fields. It contains the following fields: `comparator` - Shows statistics and metadata around how the Lucene sorts the results. `setBottom` - Returns how often the current least competitive sort value is updated with a new and more competitive value. When sorting, MongoDB Search keeps track of the bottom value and if a new value surpasses the current bottom value in relevance or competitiveness, this metric is incremented. `compareBottom` - Returns the timing and invocation statistics related to comparing the current `bottom` value with a candidate `bottom` value. `compareTop` - Returns the timing and invocation statistics related to comparing the current `top` value with a candidate `top` value. `setHitsThresholdReached` - Returns the timing and invocation statistics related to when the maximum number of results (`limit`) was reached. `competitiveIterator` - Returns the timing and invocation statistics related to iterating (only) over documents that are likely to compete for top spots in the sorted results. `setScorer` - Returns the timing and invocation statistics related to computing the score and relevance of documents. `prunedResultIterator` - Shows the invocations and timing statistics of `nextDoc` and `advance` method calls on Lucene's `competitiveIterator`. This is not present in the output if it performs a mixed data type sort. It contains only the `nextDoc` field.
`fieldInfos`	document	Required	Maps the field being sorted on to the list of data types present in the index for the field.

`highlight`

The highlight is a BSON document that details query and execution statistics when you specify highlighting in the query. It contains the following fields:

Option	Type	Necessity	Purpose
`resolvedHighlightPaths`	List<String>	Required	List of all the highlighted fields. If you specified a wildcard path in the `highlight` section of your query, contains a list of fully resolved document paths.
`stats`	QueryExecutionArea	Optional	Invocation and timing statistics related to setting up and executing highlights. It contains the following fields: `setupHighlight` - Time it took for setting up the internal Lucene objects used during the `executeHighlight` phase. `executeHighlight` - Time it took to run highlighting over the matching documents.

`indexPartitionExplain`

the indexPartitionExplain contains Explain Results for each index partition. The top-level collectors and query are inside the explain information of each index partition and absent at the top-level.

`metadata`

The metadata contains helpful metadata, such as the following:

Field	Type	Necessity	Purpose
`mongotVersion`	String	Optional	Current version of `mongot`.
`mongotHostName`	String	Optional	Human readable label that identifies the `mongot` host.
`indexName`	String	Optional	MongoDB Search index used in the query.
`cursorOptions`	Document	Optional	Cursor options given to `mongot`.
`totalLuceneDocs`	Integer	Optional	Total number of index objects in the index including deleted documents.

`query`

The query BSON document describes the execution statistics for the query. It contains the following fields:

Field	Type	Necessity	Purpose
`path`	string	Optional	Path to the operator, only if it isn't the root.
`type`	string	Required	Name of the Lucene Query that the MongoDB Search operator created. See `query` for more information.
`analyzer`	string	Optional	MongoDB Search analyzer used with the query.
`args`	document	Required	Lucene query information. See `query` for more information.
`stats`	document	Optional	`stats` for the query if `explain` ran with `executionStats` or `allPlansExecution` verbosity.

`args`

The explain response of a search command contains information about the query executed with that command. The response in the args field includes structured details of what Lucene queries MongoDB Search executed to satisfy a $search query.

This section contains:

Some of the Lucene queries that MongoDB Search operators create
Lucene query options that are included in the structured summary
Lucene query structured summary example for each Lucene query type

Note

About the Examples

The examples in this section are based on queries run against the sample datasets with the queryPlanner verbosity mode. In the example response, the:

mongotQuery field shows the MongoDB Search operator and the query that was run.
explain.type field shows the Lucene Query that the operator created.

For complete examples, see Examples.

BooleanQuery

For Lucene BooleanQuery, the structured summary includes details on the following options:

Field	Type	Necessity	Description
`must`	<Explain Results>	Optional	Clauses which must match.
`mustNot`	<Explain Results>	Optional	Clauses which must not match.
`should`	<Explain Results>	Optional	Clauses which should match.
`filter`	<Explain Results>	Optional	Clauses which must all match.
`minimumShouldMatch`	Integer	Optional	The minimum number of `should` clauses which must match.

ConstantScoreQuery

For constant score queries, the structured summary includes details on the following options:

Field	Type	Necessity	Description
`query`	Explain Results	Required	Child of the `ConstantScoreQuery`.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For Lucene FunctionScoreQuery queries, the structured summary includes details on the following options:

Field	Type	Necessity	Description
`scoreFunction`	string	Required	Scoring expression used in the query.
`query`	Explain Results	Required	The query.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For Lucene LatLonPointDistanceQuery queries, the response contains an stats only.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For Lucene LatLonShapeQuery queries, the response contains an stats only.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For Lucene LongDistanceFeatureQuery, the response contains an stats only.

The following example shows the explain response for a query run against the sample_mflix.movies collection.

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

For Lucene MultiTermQueryConstantScoreWrapper queries, the structured summary includes details on the following arguments:

Field	Type	Necessity	Description
`queries`	List<Explain Results>	Required	List of queries.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For Lucene PhraseQuery queries, the structured summary includes details on the following arguments:

Field	Type	Necessity	Description
`path`	String	Required	Indexed field to search.
`query`	String	Required	String or strings to search for.
`slop`	Number	Required	Allowable distance between words in the `query` phrase.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For Lucene PointRangeQuery queries, the structured summary includes details on the following arguments:

Field	Type	Necessity	Description
`path`	String	Required	Indexed field to search.
`representation`	String	Optional	Numeric representation. Queries over date-typed data do not include representation.
`gte`	Number	Optional	Lower bound of the query.
`lte`	Number	Optional	Upper bound of the query.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

For term queries, the structured summary includes details on the following arguments:

Field	Type	Necessity	Description
`path`	String	Required	Indexed field to search.
`value`	String	Required	String to search for.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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

Lucene queries that are not explicitly defined by another Lucene query are serialized using the default query. The structured summary includes details on the following option:

Field	Type	Necessity	Description
`queryType`	String	Required.	Type of Lucene query.

The following example shows the explain response for a query run against the sample_airbnb.listingsAndReviews collection.

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 }

`stats`

The explain response for executionStats and allPlansExecution verbosity modes includes a stats field that contains information on how much time a query spends in various stages of query execution.

Timing Breakdown

The timing breakdown describes execution statistics pertinent to an areas of query execution. The following fields show the timing breakdown:

Field	Type	Description
`millisElapsed`	Long	Approximate wall-clock time elapsed performing tasks in this area including the amount of time the children of the query spent in this area. The value is approximate number of milliseconds elapsed while performing tasks in this area.
`invocationCounts`	Document	Number of invocations of tasks included in this area. The value is a map of task names to their invocation count.

Areas of Query

Statistics are available for the following areas of query:

Option

Description

context

Statistics related to the execution of the Lucene query. There are two tasks whose invocation counts are enumerated in this area:

`createScorer`	Scorer iterates over documents and generates a score for each document. Invocations of `createScorer` create the object responsible for scoring. Note that time associated with this task is not time spent actually scoring documents. Count includes the number of `scorerSupplier` invocations.
`createWeight`	Weight stores state associated with a query and `IndexSearcher`. Count includes the number of `createWeight` invocations.

The time spent in this area is related to the structure of the query, and is not based on the number of results that are iterated through and scored.

For example:

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

match

Statistics related to iterating over and matching result documents. This statistic shows the time it takes to determine which document is the next match. Time spent matching results can vary significantly depending on the nature of the query. There are two tasks whose invocation counts are enumerated in this area:

`nextDoc`	Requests to advance to the next document of the result set. This involves identifying and moving past skips, or other tasks necessary to find the next match. Count includes the number of `nextDoc` and `advance` invocations.
`refineRoughMatch`	Performs a more thorough match. Some queries execute in a two-phase process where a document is first "roughly" matched, and is checked with a second, more thorough phase only after satisfying the first rough match. The `refineRoughMatch` task is the second phase of the two-phase process. Count includes the number of `refineRoughMatch` invocations.

For example:

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

score

Statistics related to scoring documents in the result set. There are two tasks whose invocation counts are enumerated in this area:

`score`	Scores each document in the result set. Count includes the number of `score` invocations.
`setMinCompetitiveScore`	Ignores documents whose score is less than the given value. Indicates that a query may have been able to reduce the number of scoring operations performed by ignoring documents with scores below some uncompetitive threshold. Count includes the number of `setMinCompetitiveScore` invocations.

For example:

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

`resultMaterialization`

The resultMaterialization document shows the amount of time mongot takes to accomplish the following:

Retrieve result data stored in Lucene in the form of either _id or storedSource.
Serialize the data into BSON format before sending it to mongod.

To learn more, see stats.

`resourceUsage`

The resourceUsage document shows the resource used for running the query. It contains the following fields:

Field	Type	Necessity	Purpose
`majorFaults`	Long	Required	Number of major page faults, which occur when the system can't find the required data in memory resulting in reading from the backing store such as disk, during query execution.
`minorFaults`	Long	Required	Number of minor page faults, which occur when the data is in the page cache, but hasn't yet been mapped to the process' page table.
`userTimeMs`	Long	Required	Amount of CPU time, in milliseconds, spent in user space.
`systemTimeMs`	Long	Required	Amount of CPU time, in milliseconds, spent in system space.
`maxReportingThreads`	Integer	Required	Maximum number of threads that `mongot` used during query execution across all batches. For non-concurrent explain queries, the value is `1`.
`numBatches`	Integer	Required	Total number of batches that `mongot` was requested when processing the query.

Examples

The following examples use the movies collection in the sample_mflix database.

Tip

If you've already loaded the sample dataset, refer to the MongoDB Search Quick Start tutorial to create an index definition and run MongoDB Search queries.

`allPlansExecution`

The following example uses different operators to query the title field with the allPlansExecution verbosity mode.

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`

The following example uses different operators to query the title field with the queryPlanner verbosity mode.

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 }

For queries that specify a $limit stage in the pipeline, the explain results include the mongotDocsRequested metric, which shows the number of documents that mongod requested from mongot.

Example

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

`executionStats`

The following example uses the autocomplete to query the title field with the executionStats verbosity mode.

1 db.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 }

To learn more about the explain response elements, see Explain Results.

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	}

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	}

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	}

1	db.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	])