如何检索查询计划和执行统计信息

在使用 explain 方法运行查询时，MongoDB Search 查询返回有关 $search 查询计划和执行统计信息的信息。在使用 explain 运行查询时，MongoDB Search 返回 BSON 文档，其中包含统计信息和元数据，描述查询在 Lucene 内部的运行方式。

提示

explain 命令

提示

在 Playground 中可视化查询计划

使用MongoDB Search Playground生成和查看 explain 计划摘要。

语法

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

详细程度

详细模式控制 explain 的行为和返回的信息量。值可以是以下之一，按详细程度降序排列：

allPlansExecution	有关查询计划的信息，包括 `stats` 字段，其中包含查询的执行统计信息。包括在计划选择期间捕获的部分执行数据。
executionStats	有关查询计划的信息，包括 `stats` 字段，其中包含查询的执行统计信息。
queryPlanner（默认）	有关查询计划的信息。不包括 `stats` 字段，其中包含查询的执行统计信息。

提示

Verbosity 模式

输出

使用 explain 方法的查询返回 stages.$_internalSearchMongotRemote 对象中的以下字段：

选项	类型	用途
`mongotQuery`	文档	包含您运行的查询。
`explain`	文档	包含 `explain` 个结果。要了解更多信息，请参阅解释结果。
`internalMongotBatchSizeHistory`	整数数组	包含 `mongot` 返回到 `mongod` 的每批处理文档大小。

解释结果

explain 方法返回一个 BSON 文档，其中包含 explain 文档中的以下字段。

选项	类型	必要性	用途
`collectors`	文档	Optional	描述收集器的执行统计信息。如果 `indexPartitionExplain` 存在，它将嵌套在每个 `indexPartitionExplain` 中，而不是在顶层。
`highlight`	文档	Optional	关于突出显示查询执行的详细信息。仅当您在查询中指定突出显示时，才会返回此值。
`indexPartitionExplain`	文档数组	Optional	包含每个索引分区的详细信息。仅当您配置了两个或多个索引分区时，才会返回此信息。
`metadata`	文档	Optional	包含有用的元数据。
`query`	文档	Optional	描述查询的执行统计信息。该值不予退回。如果 `indexPartitionExplain` 存在，它将嵌套在每个 `indexPartitionExplain` 中，而不是在顶层。
`resultMaterialization`	文档	Optional	有关在查询执行后从 Lucene 检索每个文档数据的详细信息。对于 `queryPlanner` 详细模式，不会返回此值。
`resourceUsage`	文档	Optional	详细说明执行查询时的资源使用情况。对于 `queryPlanner` 详细模式，不会返回此值。

`collectors`

collectors BSON 文档包含以下字段：

字段	类型	必要性	用途
`allCollectorStats`	文档	必需	查询的所有收集器的统计信息。报告的统计信息表示查询中使用的所有收集器的最大值或所有子收集器的统计信息总和。计时统计信息相加求和，以反映整个查询中所有收集器所花费的总时间。要学习；了解详情，请参阅allCollectorStats。
`facet`	文档	Optional	指定分面（Facet）的查询的明细信息。要了解更多信息，请参阅 `facet`。
`sort`	文档	Optional	指定排序的查询明细信息。要了解更多信息，请参阅 `sort`。

`allCollectorStats`

allCollectorStats BSON 文档描述了查询中指定的所有收集器的统计信息，包括 facet 和 sort。它包含以下键：

字段	说明
`collect`	追踪收集器收集的结果数量和持续时间。
`competitiveIterator`	统计信息跟踪从收集器请求 `competitiveIterator` 的总持续时间和次数。
`setScorer`	统计信息跟踪在收集器上设置记分器的总持续时间和次数。

`facet`

facet 是一个 BSON 文档，当您在查询中指定分面时，该文档会详细说明查询和执行统计信息。它包含以下字段：

选项	类型	必要性	用途
`collectorStats`	文档	Optional	仅显示 `facet` 收集器的统计信息。这里的密钥与 `allCollectorStats` 是相同的。如果您在查询中使用了 `sort`，您可以评估它与 `allCollectorStats` 之间的差异，以确定 `sort` 收集器执行统计信息。
`createCountsStats`	文档	Optional	显示与创建内部 Lucene 对象相关的统计信息，该对象包含所有分面分组。它包含 `generateFacetCounts` 字段，该字段返回统计信息，跟踪 `mongot` 生成 Lucene 对象的总持续时间和次数，该对象包含所有分面及其计数。
`stringFacetFieldCardinalities`	文档	必需	对于与查询匹配的文档和整个 Lucene 索引，将分面字段映射到其关联基数。它为每个字段提供以下关联基数信息： `queried` - 表示跨所有查询文档的字段的分面关联基数。 `total` - 表示跨索引中所有文档的字段的分面关联基数。

`sort`

sort 是一个 BSON 文档，详细说明了在查询中指定排序时的查询和执行统计信息。它包含以下字段：

选项	类型	必要性	用途
`stats`	文档	Optional	追踪与`sort`执行相关的统计信息，涵盖所有排序字段。它包含以下字段： `comparator` - 显示有关 Lucene 如何排序结果的统计信息和元数据。 `setBottom` — 返回将当前竞争性最低的排序值更新为更具竞争性的新值的频率。排序时， MongoDB Search 会追踪谷值，如果新值在相关性或竞争力方面超过当前谷值，则该指标会递增。 `compareBottom` - 返回与将当前 `bottom` 值与候选 `bottom` 值进行比较相关的计时和调用统计信息。 `compareTop` - 返回与将当前 `top` 值与候选 `top` 值进行比较相关的计时和调用统计信息。 `setHitsThresholdReached` - 返回与何时达到最大结果数（`limit`）相关的计时和调用统计信息。 `competitiveIterator` - 返回与（仅）迭代可能在排序结果中竞争顶部位置的文档相关的计时和调用统计信息。 `setScorer` - 返回与计算文档分数和相关性相关的计时和调用统计信息。 `prunedResultIterator` - 显示 Lucene 的 `competitiveIterator` 上 `nextDoc` 和 `advance` 方法调用的调用和计时统计信息。如果执行混合数据类型排序，输出中不会出现此内容。它仅包含 `nextDoc` 字段。
`fieldInfos`	文档	必需	将正在排序的字段映射到该字段索引中的数据类型列表。
`usesIndexSort`	布尔	Optional	指示查询是否可以从索引排序中受益。当查询的排序字段与索引排序匹配或形成其前缀时，查询受益。如果值为： `true`，该查询可以使用排序索引优化。 `false`, 查询无法从排序索引优化中获益。如果查询未指定排序，或索引没有排序规范，则输出中不存在此内容。

`highlight`

highlight是一个BSON文档，当您在查询中指定突出显示时，它详细说明了查询和执行统计信息。它包含以下字段：

选项	类型	必要性	用途
`resolvedHighlightPaths`	列表<String>	必需	所有高亮字段的列表。如果您在查询的 `highlight` 部分指定了通配符路径，则会包含一个完全解析的文档路径列表。
`stats`	QueryExecutionArea	Optional	与设置和执行突出显示相关的调用和计时统计信息。它包含以下字段： `setupHighlight` - 设置 `executeHighlight` 阶段使用的内部 Lucene 对象所花费的时间。 `executeHighlight` - 运行高亮显示匹配文档所需的时间。

`indexPartitionExplain`

indexPartitionExplain 包含每个索引分区的解释结果。顶层 collectors 和 query 位于每个索引分区的 explain 信息中，而不在顶层。

`metadata`

metadata 包含有用的元数据，例如：

字段	类型	必要性	用途
`mongotVersion`	字符串	Optional	`mongot` 的当前版本。
`mongotHostName`	字符串	Optional	用于标识 `mongot` 主机的人类可读标签。
`indexName`	字符串	Optional	查询中使用的MongoDB Search索引。
`cursorOptions`	文档	Optional	为 `mongot` 提供的游标选项。
`totalLuceneDocs`	整型	Optional	索引中包括已删除文档的索引对象总数。

`query`

query BSON 文档描述了查询的执行统计信息。它包含以下字段：

字段	类型	必要性	用途
`path`	字符串	Optional	操作符的路径，前提是它不是根目录。
`type`	字符串	必需	MongoDB Search操作符创建的Lucene查询的名称。有关更多信息，请参阅 `query`。
`analyzer`	字符串	Optional	与查询一起使用的MongoDB Search分析器。
`args`	文档	必需	Lucene 查询信息。有关更多信息，请参阅 `query`。
`stats`	文档	Optional	如果 `explain` 以 `executionStats` 或 `allPlansExecution` 的详细程度运行，则为查询 `stats`。

`args`

搜索命令的解释响应包含有关使用该命令执行的查询的信息。args字段中的响应包括MongoDB Search 为满足 $search查询而执行的Lucene查询的结构化详细信息。

本节包含：

MongoDB Search 操作符创建的一些Lucene查询
结构化摘要中包含的 Lucene 查询选项
每个 Lucene 查询类型的 Lucene 查询结构化摘要示例

注意

关于示例

本节中的示例基于对具有详细程度模式的示例数据集queryPlanner 运行的查询。在示例响应中：

mongotQuery 字段显示MongoDB Search操作符和运行的查询。
explain.type 字段显示操作符创建的 Lucene 查询。

有关完整示例，请参阅示例。

BooleanQuery

对于 Lucene BooleanQuery，结构化摘要包含有关以下选项的详细信息：

字段	类型	必要性	说明
`must`	<Explain Results>	Optional	必须匹配的条款。
`mustNot`	<Explain Results>	Optional	不得匹配的子句。
`should`	<Explain Results>	Optional	应匹配的子句。
`filter`	<Explain Results>	Optional	必须全部匹配的子句。
`minimumShouldMatch`	整型	Optional	必须匹配的最小 `should` 子句数量。

以下示例显示了针对 sample_airbnb.listingsAndReviews 集合运行的查询的 explain 响应。

1 {
2   "stages" : [
3     {
4       "$_internalSearchMongotRemote" : {
5         "mongotQuery" : {
6           "compound" : {
7             "must" : [ {
8               "compound" : {
9                 "should" : [ {
10                   "text" : {
11                     "query" : "historic",
12                     "path" : "summary"
13                   }
14                 },
15                 {
16                   "text" : {
17                     "query" : "Portugal",
18                     "path" : "address.country"
19                   }
20                 },
21                 {
22                   "text" : {
23                     "query" : "railway",
24                     "path" : "transit"
25                   }
26                 } ]
27               }
28             } ],
29             "mustNot" : [ {
30               "text" : {
31                 "query" : "Apartment",
32                 "path" : "property_type"
33               }
34             } ]
35           }
36         },
37         "explain" : {
38           "type" : "BooleanQuery",
39           "args" : {
40             "must" : [ {
41               "path" : "compound.must",
42               "type" : "BooleanQuery",
43               "args" : {
44                 "must" : [ ],
45                 "mustNot" : [ ],
46                 "should" : [ 
47                   {
48                     "path" : "compound.must.compound.should[0]",
49                     "type" : "TermQuery",
50                     "args" : {
51                       "path" : "summary",
52                       "value" : "historic"
53                     }
54                   },
55                   {
56                     "path" : "compound.must.compound.should[1]",
57                     "type" : "TermQuery",
58                     "args" : {
59                       "path" : "address.country",
60                       "value" : "portugal"
61                     }
62                   },
63                   {
64                     "path" : "compound.must.compound.should[2]",
65                     "type" : "TermQuery",
66                     "args" : {
67                       "path" : "transit",
68                       "value" : "railway"
69                     }
70                   } 
71                 ],
72                 "filter" : [ ],
73                 "minimumShouldMatch" : 0
74               }
75             } ],
76             "mustNot" : [ {
77               "path" : "compound.mustNot",
78               "type" : "TermQuery",
79               "args" : {
80                 "path" : "property_type",
81                 "value" : "apartment"
82               }
83             } ],
84             "should" : [ ],
85             "filter" : [ ],
86             "minimumShouldMatch" : 0
87           }
88         }
89       },
90       ...
91     },
92     ...
93   ],
94   ...
95 }

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

对于 Lucene 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

对于 Lucene 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

对于 Lucene 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

对于 Lucene PointRangeQuery 查询，结构化摘要包含有关以下参数的详细信息：

字段	类型	必要性	说明
`path`	字符串	必需	要搜索的索引字段。
`representation`	字符串	Optional	数字表示形式。对日期类型数据的查询不包括表示形式。
`gte`	数值	Optional	查询的下限。
`lte`	数值	Optional	查询的上限。

以下示例显示了针对 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

未由其他 Lucene 查询显式定义的 Lucene 查询将使用默认查询进行序列化。结构化摘要包含有关以下选项的详细信息：

字段	类型	必要性	说明
`queryType`	字符串	必需。	Lucene 查询的类型。

以下示例显示了针对 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 }

`stats`

executionStats 和 allPlansExecution 详细模式的explain 响应包含一个stats 字段，该字段包含有关查询在查询执行的各个阶段所花费的时间的信息。

时序细分

时间细分描述了与查询执行区域相关的执行统计信息。以下字段显示时间细分：

字段	类型	说明
`millisElapsed`	Long	在该区域执行任务所用的大约时间，包括查询子级在此区域所用的时间。该值是在该区域中执行任务时经过的近似毫秒数。
`invocationCounts`	文档	调用此区域中包含的任务的次数。该值是任务名称到其调用计数的映射。

查询区域

统计信息可用于以下查询领域：

选项

说明

context

与 Lucene 查询执行相关的统计信息。此区域中枚举了两个任务的调用计数：

createScorer: Scorer 遍历文档并为每个文档生成一个分数。调用 createScorer 会创建负责评分的对象。请注意，与此任务相关的时间并非实际用于对文档进行评分的时间。计数包括 scorerSupplier 调用的次数。
createWeight: Weight 存储与查询和 IndexSearcher 相关的省/市/自治区。计数包含 createWeight 次调用的数量。

此区域花费的时间与查询的结构有关，而不是基于迭代和评分的结果数量。

例如：

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

match

与遍历和匹配结果文档相关的统计信息。此统计信息显示确定下一个匹配的文档所需的时间。根据查询的性质，匹配结果所花费的时间可能会有很大差异。此区域中枚举了两个任务的调用计数：

nextDoc：用于推进到结果集中的下一个文档的请求。这涉及识别并跳过跳过项，或执行查找下一个匹配项所需的其他任务。计数包括 nextDoc 和 advance 调用次数。
refineRoughMatch：执行更彻底的匹配。某些查询以两阶段过程执行，其中文档首先被“粗略”匹配，并且仅在满足第一次粗略匹配后才通过第二个更彻底的阶段进行检查。refineRoughMatch 任务是两阶段过程的第二阶段。计数包括 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`

resultMaterialization 文档显示 mongot 完成以下任务所需的时间：

检索以 _id 或 storedSource 形式存储在 Lucene 中的结果数据。
将数据序列化为 BSON 格式，然后发送到 mongod。

要了解更多信息，请参阅 stats。

`resourceUsage`

resourceUsage 文档显示了用于运行查询的资源。它包含以下字段：

字段	类型	必要性	用途
`majorFaults`	Long	必需	主要页面错误的数量，当系统在查询执行期间无法在内存中找到所需数据，导致从磁盘等后备存储中读取数据时，就会发生这种错误。
`minorFaults`	Long	必需	次要页面错误的数量，当数据在页面缓存中，但尚未映射到进程的页表时发生。
`userTimeMs`	Long	必需	在用户空间中花费的 CPU 时间，以毫秒为单位。
`systemTimeMs`	Long	必需	在系统空间中花费的 CPU 时间，以毫秒为单位。
`maxReportingThreads`	整型	必需	在所有批处理中执行查询期间，`mongot` 使用的最大线程数。对于非并发解释查询，值为 `1`。
`numBatches`	整型	必需	处理查询时请求 `mongot` 的批处理总数。

示例

以下示例使用 sample_mflix 数据库中的 movies 集合。

提示

如果您已经加载了示例数据集，请参阅 MongoDB Search 快速入门教程以创建索引定义并运行 MongoDB Search 查询。

`allPlansExecution`

以下示例使用不同的操作符以 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`

以下示例使用不同的操作符以 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 }

db.movies.explain("queryPlanner").aggregate([
  {
    $search: {
      index: "default",
      range: {
        path: "released",
        gt: ISODate("2015-01-01T00:00:00.000Z"),
        lt: ISODate("2015-12-31T00:00:00.000Z")
      },
      sort: {
        released: -1
      }
    }
  },
  { $limit: 5 },
  {
    $project: {
      _id: 0,
      title: 1,
      released: 1
    }
  }
])

1 {
2   explainVersion: '1',
3   stages: [
4     {
5       '$_internalSearchMongotRemote': {
6         mongotQuery: {
7           index: 'default',
8           range: {
9             path: 'released',
10             gt: ISODate('2015-01-01T00:00:00.000Z'),
11             lt: ISODate('2015-12-31T00:00:00.000Z')
12           },
13           sort: { released: -1 }
14         },
15         explain: {
16           query: {
17             type: 'ConstantScoreQuery',
18             args: {
19               query: {
20                 type: 'IndexOrDocValuesQuery',
21                 args: {
22                   query: [
23                     {
24                       type: 'PointRangeQuery',
25                       args: {
26                         path: 'released',
27                         gte: ISODate('2015-01-01T00:00:00.001Z'),
28                         lte: ISODate('2015-12-30T23:59:59.999Z')
29                       }
30                     },
31                     {
32                       type: 'SortedNumericDocValuesRangeQuery',
33                       args: {}
34                     }
35                   ]
36                 }
37               }
38             }
39           },
40           collectors: {
41             sort: {
42               fieldInfos: { released: [ 'dateV2' ] },
43               usesIndexSort: true
44             }
45           },
46           metadata: {
47             mongotVersion: '1.67.0',
48             mongotHostName: '<hostname>.mongodb.net',
49             indexName: 'default',
50             lucene: { totalSegments: 1, totalDocs: 21349 }
51           },
52           featureFlags: [
53             {
54               featureFlag: 'mongot.featureFlag.numericV2Semantics',
55               evaluationResult: true,
56               decisiveField: 'Phase'
57             }
58           ]
59         },
60         mongotDocsRequested: Long('5'),
61         requiresSearchMetaCursor: false
62       }
63     },
64     {
65       '$_internalSearchIdLookup': {
66         limit: Long('5'),
67         subPipeline: [
68           { '$match': { _id: { '$eq': '_id placeholder' } } }
69         ]
70       }
71     },
72     { '$limit': Long('5') },
73     { '$project': { title: true, released: true, _id: false } }
74   ],
75   queryShapeHash: 'CA4950A32339C9853C4A295D89E9523DE568624672C87C231135012D27896CAE',
76   serverInfo: {
77     host: '<hostname>.mongodb.net',
78     port: 27017,
79     version: '8.3.2',
80     gitVersion: '89f54eb32e217d2f7bfcad50e5919f3033bb9611'
81   },
82   serverParameters: {
83     internalQueryFacetBufferSizeBytes: 104857600,
84     internalDocumentSourceGroupMaxMemoryBytes: 104857600,
85     internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
86     internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
87     internalQueryFacetMaxOutputDocSizeBytes: 104857600,
88     internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
89     internalQueryProhibitBlockingMergeOnMongoS: 0,
90     internalQueryMaxAddToSetBytes: 104857600,
91     internalQueryFrameworkControl: 'trySbeRestricted',
92     internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
93   },
94   command: {
95     aggregate: 'movies',
96     pipeline: [
97       {
98         '$search': {
99           index: 'default',
100           range: {
101             path: 'released',
102             gt: ISODate('2015-01-01T00:00:00.000Z'),
103             lt: ISODate('2015-12-31T00:00:00.000Z')
104           },
105           sort: { released: -1 }
106         }
107       },
108       { '$limit': 5 },
109       { '$project': { _id: 0, title: 1, released: 1 } }
110     ],
111     cursor: {},
112     '$db': 'sample_mflix'
113   },
114   ok: 1,
115   '$clusterTime': {
116     clusterTime: Timestamp({ t: 1778545038, i: 1 }),
117     signature: {
118       hash: Binary.createFromBase64('mExdEPAwssnzlpKaA1Rt+Ypv+cA=', 0),
119       keyId: Long('7634583163557117960')
120     }
121   },
122   operationTime: Timestamp({ t: 1778545038, i: 1 })
123 }

对于在管道中指定$limit阶段的查询， explain结果包括mongotDocsRequested指标，该指标显示mongod从mongot请求的文档数。

例子

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

`executionStats`

以下示例使用 autocomplete 以 executionStats 详细程度模式查询 title 字段。

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 }

要了解有关 explain 响应元素的更多信息，请参阅解释结果。

后退

同义词

来年

提高性能(Improve Performance)

1	{
2	"stages" : [
3	{
4	"$_internalSearchMongotRemote" : {
5	"mongotQuery" : {
6	"compound" : {
7	"must" : [ {
8	"compound" : {
9	"should" : [ {
10	"text" : {
11	"query" : "historic",
12	"path" : "summary"
13	}
14	},
15	{
16	"text" : {
17	"query" : "Portugal",
18	"path" : "address.country"
19	}
20	},
21	{
22	"text" : {
23	"query" : "railway",
24	"path" : "transit"
25	}
26	} ]
27	}
28	} ],
29	"mustNot" : [ {
30	"text" : {
31	"query" : "Apartment",
32	"path" : "property_type"
33	}
34	} ]
35	}
36	},
37	"explain" : {
38	"type" : "BooleanQuery",
39	"args" : {
40	"must" : [ {
41	"path" : "compound.must",
42	"type" : "BooleanQuery",
43	"args" : {
44	"must" : [ ],
45	"mustNot" : [ ],
46	"should" : [
47	{
48	"path" : "compound.must.compound.should[0]",
49	"type" : "TermQuery",
50	"args" : {
51	"path" : "summary",
52	"value" : "historic"
53	}
54	},
55	{
56	"path" : "compound.must.compound.should[1]",
57	"type" : "TermQuery",
58	"args" : {
59	"path" : "address.country",
60	"value" : "portugal"
61	}
62	},
63	{
64	"path" : "compound.must.compound.should[2]",
65	"type" : "TermQuery",
66	"args" : {
67	"path" : "transit",
68	"value" : "railway"
69	}
70	}
71	],
72	"filter" : [ ],
73	"minimumShouldMatch" : 0
74	}
75	} ],
76	"mustNot" : [ {
77	"path" : "compound.mustNot",
78	"type" : "TermQuery",
79	"args" : {
80	"path" : "property_type",
81	"value" : "apartment"
82	}
83	} ],
84	"should" : [ ],
85	"filter" : [ ],
86	"minimumShouldMatch" : 0
87	}
88	}
89	},
90	...
91	},
92	...
93	],
94	...
95	}

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	])