解释MongoDB Vector Search 结果

当您使用 explain 方法运行MongoDB Vector Search查询时，该查询会返回一个 BSON文档，其中包含查询计划和描述查询在内部运行方式的执行统计信息。

提示

语法

db.<myCollection>.explain("<verbosity>").aggregate([
   {
     "$vectorSearch": {
       "exact": true | false,
       "filter": {<filter-specification>},
       "index": "<index-name>",
       "limit": <number-of-results>,
       "numCandidates": <number-of-candidates>,
       "path": "<field-to-search>",
       "queryVector": [<array-of-numbers>]
     }
   }
])

详细程度

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

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

提示

Verbosity 模式

解释结果

explain 方法返回包含以下字段的BSON文档。

选项	类型	必要性	用途
`collectors`	文档	Optional	描述收集器的执行统计信息。
`metadata`	文档	Optional	包含有用的元数据。
`query`	文档	Optional	描述查询的执行统计信息。它不存在于 `indexPartitionExplain` 的顶层。
`resultMaterialization`	文档	Optional	有关在查询执行后检索每个文档数据的详细信息。`queryPlanner` 详细模式不会返回此值。
`resourceUsage`	文档	Optional	详细说明执行查询时的资源使用情况。对于 `queryPlanner` 详细模式，不会返回此值。

`collectors`

collectors 是包含以下字段的BSON文档：

字段	类型	必要性	用途
`allCollectorStats`	文档	必需	查询的所有收集器的统计信息。报告的统计信息表示查询中使用的所有收集器的最大值或所有子收集器的统计信息总和。计时统计信息相加求和，以反映整个查询中所有收集器所花费的总时间。要学习；了解详情，请参阅 `allCollectorStats`。

`allCollectorStats`

allCollectorStats 是一个BSON文档，描述查询中指定的所有收集器的收集器统计信息。它包含以下键：

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

`metadata`

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

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

`query`

explain 响应是一个 BSON 文档，其中的键和值描述了查询的执行统计数据。结果集中的 explain 文档包含以下字段：

字段	类型	必要性	用途
`path`	字符串	Optional	所查询的 embedding 字段的路径（前提是它不是根）。
`type`	字符串	必需	向量搜索查询类型的名称。有关更多信息，请参阅 `query`。
`args`	文档	必需	向量搜索查询信息。有关更多信息，请参阅 `query`。
`stats`	文档	Optional	如果 `explain` 以 `executionStats` 或 `allPlansExecution` 的详细程度运行，则 `stats` 查询。

`args`

解释响应包含如何在内部执行查询的信息。args字段包括以下详细信息：

查询类型
每种查询类型的结构化摘要示例
结构化摘要中的查询选项

以下部分描述了查询类型和结构化摘要中的字段：

WrappedKnnQuery

用于组合多个查询的ANN向量搜索的包装器查询。结构化摘要包含有关以下选项的详细信息：

字段	类型	必要性	说明
`query`	阵列	必需	向量搜索中使用的子查询数组，通常包含 `KnnFloatVectorQuery` 和 `DocAndScoreQuery`。

KnnFloatVectorQuery

特定于浮点向量上的ANN搜索的查询类型。结构化摘要包含有关以下选项的详细信息：

字段	类型	必要性	说明
`field`	字符串	必需	正在搜索的向量字段路径（Field Path）。
`k`	整型	必需	要检索的最近邻数量。

DocAndScoreQuery: 一种处理文档匹配和评分的查询类型。结构化摘要通常包括有关查询执行的统计信息。

ExactVectorSearchQuery

用于新奥向量搜索的查询类型。结构化摘要包含有关以下选项的详细信息：

字段	类型	必要性	说明
`field`	字符串	必需	正在搜索的向量字段路径（Field Path）。
`similarityFunction`	字符串	必需	使用的相似度函数（`dotProduct`、`cosine` 或 `euclidean`）。
`filter`	文档	Optional	用于限制向量搜索范围的预过滤查询。

BooleanQuery: 如果您在向量搜索查询中使用预过滤器，则您的解释结果将包含 BooleanQuery 类型。要进一步学习；了解此类型的字段以及特定于预筛选查询的其他查询类型，请参阅MongoDB搜索解释页面上的查询类型。

DefaultQuery

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

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

`stats`

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

时序细分

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

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

查询区域

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

选项

说明

context

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

`createScorer`	评分器遍历文档并为每个文档生成分数。调用`createScorer`会创建负责评分的对象。请注意，与此任务相关的时间不是实际对文档进行评分所花费的时间。计数包括`scorerSupplier`调用次数。
`createWeight`	权重存储与查询和`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)
  }
}

`resourceUsage`

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

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

示例

以下示例对示例ANN 和 ENN 查询使用 explain 方法。如果要在自己的环境中运行以下示例，则必须首先完成MongoDB Vector Search 快速入门，使用mongosh。

`allPlansExecution`

以下示例对plot_embedding_voyage_3_large 字段的 ANN 和 ENN向量搜索查询运行所述解释方法，详细程度模式为allPlansExecution 。

db.embedded_movies.explain("allPlansExecution").aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding_voyage_3_large",
      "queryVector": QUERY_EMBEDDING,
      "numCandidates": 150,
      "limit": 10
    }
  }
])

1 {
2   explainVersion: '1',
3   stages: [
4     {
5       '$vectorSearch': {
6         index: 'vector_index',
7         path: 'plot_embedding_voyage_3_large',
8         queryVector: [
9           -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
10           ...,
11           -0.006688767,  0.047527634,  0.040714234
12         ],
13         numCandidates: 150,
14         limit: 10,
15         explain: {
16           query: {
17             type: 'WrappedKnnQuery',
18             args: {
19               query: [
20                 {
21                   type: 'InstrumentableKnnFloatVectorQuery',
22                   args: {
23                     field: '$type:knnVector/plot_embedding_voyage_3_large',
24                     k: 150
25                   },
26                   stats: {
27                     context: { millisElapsed: 0 },
28                     match: { millisElapsed: 0 },
29                     score: { millisElapsed: 0 }
30                   }
31                 },
32                 {
33                   type: 'DocAndScoreQuery',
34                   args: {},
35                   stats: {
36                     context: {
37                       millisElapsed: 15.794112,
38                       invocationCounts: {
39                         createWeight: Long('1'),
40                         createScorer: Long('4')
41                       }
42                     },
43                     match: {
44                       millisElapsed: 0.084957,
45                       invocationCounts: { nextDoc: Long('152') }
46                     },
47                     score: {
48                       millisElapsed: 0.688285,
49                       invocationCounts: {
50                         score: Long('150'),
51                         setMinCompetitiveScore: Long('25')
52                       }
53                     }
54                   }
55                 }
56               ]
57             },
58             stats: {
59               context: {
60                 millisElapsed: 76.547561,
61                 invocationCounts: {
62                   vectorExecution: Long('1'),
63                   createWeight: Long('1'),
64                   createScorer: Long('4')
65                 }
66               },
67               match: {
68                 millisElapsed: 0.084957,
69                 invocationCounts: { nextDoc: Long('152') }
70               },
71               score: {
72                 millisElapsed: 0.688285,
73                 invocationCounts: {
74                   score: Long('150'),
75                   setMinCompetitiveScore: Long('25')
76                 }
77               }
78             }
79           },
80           collectors: {
81             allCollectorStats: {
82               millisElapsed: 2.513847,
83               invocationCounts: {
84                 collect: Long('150'),
85                 competitiveIterator: Long('2'),
86                 setScorer: Long('2')
87               }
88             }
89           },
90           metadata: {
91             mongotVersion: '1.49.3',
92             mongotHostName: '<hostname>.mongodb.net',
93             indexName: 'vector_index',
94             lucene: { totalSegments: 2, totalDocs: 3483 }
95           },
96           resourceUsage: {
97             majorFaults: Long('0'),
98             minorFaults: Long('0'),
99             userTimeMs: Long('0'),
100             systemTimeMs: Long('0'),
101             maxReportingThreads: 1,
102             numBatches: 1
103           },
104           luceneVectorSegmentStats: [
105             {
106               executionType: 'Approximate',
107               docCount: 3420,
108               approximateStage: { millisElapsed: 47.246946 }
109             },
110             {
111               executionType: 'Approximate',
112               docCount: 63,
113               approximateStage: { millisElapsed: 0.520547 }
114             }
115           ]
116         }
117       },
118       nReturned: Long('0'),
119       executionTimeMillisEstimate: Long('306')
120     },
121     {
122       '$_internalSearchIdLookup': { limit: Long('10') },
123       nReturned: Long('0'),
124       executionTimeMillisEstimate: Long('306')
125     }
126   ],
127   queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
128   serverInfo: {
129     host: '<hostname>.mongodb.net',
130     port: 27017,
131     version: '8.0.3',
132     gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
133   },
134   serverParameters: {
135     internalQueryFacetBufferSizeBytes: 104857600,
136     internalQueryFacetMaxOutputDocSizeBytes: 104857600,
137     internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
138     internalDocumentSourceGroupMaxMemoryBytes: 104857600,
139     internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
140     internalQueryProhibitBlockingMergeOnMongoS: 0,
141     internalQueryMaxAddToSetBytes: 104857600,
142     internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
143     internalQueryFrameworkControl: 'trySbeRestricted',
144     internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
145   },
146   command: {
147     aggregate: 'embedded_movies',
148     pipeline: [
149       {
150         '$vectorSearch': {
151           index: 'vector_index',
152           path: 'plot_embedding_voyage_3_large',
153           queryVector: [
154             -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
155             ...,
156             -0.006688767,  0.047527634,  0.040714234
157           ],
158           numCandidates: 150,
159           limit: 10
160         }
161       }
162     ],
163     cursor: {},
164     '$db': 'sample_mflix'
165   },
166   ok: 1,
167   '$clusterTime': {
168     clusterTime: Timestamp({ t: 1752447925, i: 20 }),
169     signature: {
170       hash: Binary.createFromBase64('JELVXSAkvhOwS5+CSP58Hj7wJZA=', 0),
171       keyId: Long('7485474929970774018')
172     }
173   },
174   operationTime: Timestamp({ t: 1752447925, i: 20 })
175 }

db.embedded_movies.explain("allPlansExecution").aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding_voyage_3_large",
      "queryVector": QUERY_EMBEDDING,
      "exact": true,
      "limit": 10
    }
  }
])

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding_voyage_3_large',
        queryVector: [
          -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
          ...,
          -0.006688767,  0.047527634,  0.040714234
        ],
        exact: true,
        limit: 10,
        explain: {
          query: {
            type: 'ExactVectorSearchQuery',
            args: {
              field: '$type:knnVector/plot_embedding_voyage_3_large',
              similarityFunction: 'dotProduct',
              filter: {
                type: 'DefaultQuery',
                args: { queryType: 'FieldExistsQuery' },
                stats: {
                  context: {
                    millisElapsed: 0.930996,
                    invocationCounts: {
                      createWeight: Long('1'),
                      createScorer: Long('4')
                    }
                  },
                  match: {
                    millisElapsed: 4.238513,
                    invocationCounts: { nextDoc: Long('3405') }
                  },
                  score: { millisElapsed: 0 }
                }
              }
            },
            stats: {
              context: {
                millisElapsed: 1.657495,
                invocationCounts: { createWeight: Long('1'), createScorer: Long('4') }
              },
              match: {
                millisElapsed: 17.668666,
                invocationCounts: { nextDoc: Long('3405') }
              },
              score: {
                millisElapsed: 19.425755,
                invocationCounts: {
                  score: Long('3403'),
                  setMinCompetitiveScore: Long('63')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 23.323921,
              invocationCounts: {
                collect: Long('3403'),
                competitiveIterator: Long('2'),
                setScorer: Long('2')
              }
            }
          },
          metadata: {
            mongotVersion: '1.49.3',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            lucene: { totalSegments: 2, totalDocs: 3483 }
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          }
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('75')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('75')
    }
  ],
  queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.3',
    gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding_voyage_3_large',
          queryVector: [
            -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
            ...,
            -0.006688767,  0.047527634,  0.040714234
          ],
          exact: true,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1752448055, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('CgUWjXI0nRt1qJLXIPYHurdhutI=', 0),
      keyId: Long('7485474929970774018')
    }
  },
  operationTime: Timestamp({ t: 1752448055, i: 1 })
}

`queryPlanner`

以下示例对plot_embedding_voyage_3_large 字段的 ANN 和 ENN向量搜索查询运行所述解释方法，详细程度模式为queryPlanner 。

db.embedded_movies.explain("queryPlanner").aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding_voyage_3_large",
      "queryVector": QUERY_EMBEDDING,
      "numCandidates": 150,
      "limit": 10
    }
  }
])

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding_voyage_3_large',
        queryVector: [
          -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
          ...,
          -0.006688767,  0.047527634,  0.040714234
        ],
        numCandidates: 150,
        limit: 10,
        explain: {
          query: {
            type: 'WrappedKnnQuery',
            args: {
              query: [
                {
                  type: 'InstrumentableKnnFloatVectorQuery',
                  args: {
                    field: '$type:knnVector/plot_embedding_voyage_3_large',
                    k: 150
                  }
                },
                { type: 'DocAndScoreQuery', args: {} }
              ]
            }
          },
          metadata: {
            mongotVersion: '1.49.3',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            lucene: { totalSegments: 2, totalDocs: 3483 }
          }
        }
      }
    },
    { '$_internalSearchIdLookup': { limit: Long('10') } }
  ],
  queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.3',
    gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding_voyage_3_large',
          queryVector: [
            -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
            ...,
            -0.006688767,  0.047527634,  0.040714234
          ],
          numCandidates: 150,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1752448485, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('iYSyi5w37pkDySHs527CKYShigA=', 0),
      keyId: Long('7485474929970774018')
    }
  },
  operationTime: Timestamp({ t: 1752448485, i: 1 })
}

db.embedded_movies.explain("queryPlanner").aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding_voyage_3_large",
      "queryVector": QUERY_EMBEDDING,
      "exact": true,
      "limit": 10
    }
  }
])

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding_voyage_3_large',
        queryVector: [
          -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
          ...,
          -0.006688767,  0.047527634,  0.040714234
        ],
        exact: true,
        limit: 10,
        explain: {
          query: {
            type: 'ExactVectorSearchQuery',
            args: {
              field: '$type:knnVector/plot_embedding_voyage_3_large',
              similarityFunction: 'dotProduct',
              filter: {
                type: 'DefaultQuery',
                args: { queryType: 'FieldExistsQuery' }
              }
            }
          },
          metadata: {
            mongotVersion: '1.49.3',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            lucene: { totalSegments: 2, totalDocs: 3483 }
          }
        }
      }
    },
    { '$_internalSearchIdLookup': { limit: Long('10') } }
  ],
  queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.3',
    gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding_voyage_3_large',
          queryVector: [
            -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
            ...,
            -0.006688767,  0.047527634,  0.040714234
          ],
          exact: true,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1752448635, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('owXx/7Ttr9TxABg103TayYunJN4=', 0),
      keyId: Long('7485474929970774018')
    }
  },
  operationTime: Timestamp({ t: 1752448635, i: 1 })
}

`executionStats`

以下示例对plot_embedding_voyage_3_large 字段的 ANN 和 ENN向量搜索查询运行所述解释方法，详细程度模式为executionStats 。

db.embedded_movies.explain("executionStats").aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding_voyage_3_large",
      "queryVector": QUERY_EMBEDDING,
      "numCandidates": 150,
      "limit": 10
    }
  }
])

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding_voyage_3_large',
        queryVector: [
          -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
          ...,
          -0.006688767,  0.047527634,  0.040714234
        ],
        numCandidates: 150,
        limit: 10,
        explain: {
          query: {
            type: 'WrappedKnnQuery',
            args: {
              query: [
                {
                  type: 'InstrumentableKnnFloatVectorQuery',
                  args: {
                    field: '$type:knnVector/plot_embedding_voyage_3_large',
                    k: 150
                  },
                  stats: {
                    context: { millisElapsed: 0 },
                    match: { millisElapsed: 0 },
                    score: { millisElapsed: 0 }
                  }
                },
                {
                  type: 'DocAndScoreQuery',
                  args: {},
                  stats: {
                    context: {
                      millisElapsed: 0.013604,
                      invocationCounts: {
                        createWeight: Long('1'),
                        createScorer: Long('4')
                      }
                    },
                    match: {
                      millisElapsed: 0.036124,
                      invocationCounts: { nextDoc: Long('152') }
                    },
                    score: {
                      millisElapsed: 0.068273,
                      invocationCounts: {
                        score: Long('150'),
                        setMinCompetitiveScore: Long('25')
                      }
                    }
                  }
                }
              ]
            },
            stats: {
              context: {
                millisElapsed: 4.770557,
                invocationCounts: {
                  vectorExecution: Long('1'),
                  createWeight: Long('1'),
                  createScorer: Long('4')
                }
              },
              match: {
                millisElapsed: 0.036124,
                invocationCounts: { nextDoc: Long('152') }
              },
              score: {
                millisElapsed: 0.068273,
                invocationCounts: {
                  score: Long('150'),
                  setMinCompetitiveScore: Long('25')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 0.235587,
              invocationCounts: {
                collect: Long('150'),
                competitiveIterator: Long('2'),
                setScorer: Long('2')
              }
            }
          },
          metadata: {
            mongotVersion: '1.49.3',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            lucene: { totalSegments: 2, totalDocs: 3483 }
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          },
          luceneVectorSegmentStats: [
            {
              executionType: 'Approximate',
              docCount: 3420,
              approximateStage: { millisElapsed: 3.849357 }
            },
            {
              executionType: 'Approximate',
              docCount: 63,
              approximateStage: { millisElapsed: 0.265218 }
            }
          ]
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('16')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('16')
    }
  ],
  queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.3',
    gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding_voyage_3_large',
          queryVector: [
            -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
            ...,
            -0.006688767,  0.047527634,  0.040714234
          ],
          numCandidates: 150,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1752448765, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('fPG6SZuq84jgloPSQYmnngr1kdU=', 0),
      keyId: Long('7485474929970774018')
    }
  },
  operationTime: Timestamp({ t: 1752448765, i: 1 })
}

db.embedded_movies.explain("executionStats").aggregate([
  {
    "$vectorSearch": {
      "index": "vector_index",
      "path": "plot_embedding_voyage_3_large",
      "queryVector": QUERY_EMBEDDING,
      "exact": true,
      "limit": 10
    }
  }
])

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding_voyage_3_large',
        queryVector: [
          -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
          ...,
          -0.006688767,  0.047527634,  0.040714234
        ],
        exact: true,
        limit: 10,
        explain: {
          query: {
            type: 'ExactVectorSearchQuery',
            args: {
              field: '$type:knnVector/plot_embedding_voyage_3_large',
              similarityFunction: 'dotProduct',
              filter: {
                type: 'DefaultQuery',
                args: { queryType: 'FieldExistsQuery' },
                stats: {
                  context: {
                    millisElapsed: 0.098481,
                    invocationCounts: {
                      createWeight: Long('1'),
                      createScorer: Long('4')
                    }
                  },
                  match: {
                    millisElapsed: 0.430795,
                    invocationCounts: { nextDoc: Long('3405') }
                  },
                  score: { millisElapsed: 0 }
                }
              }
            },
            stats: {
              context: {
                millisElapsed: 0.143681,
                invocationCounts: { createWeight: Long('1'), createScorer: Long('4') }
              },
              match: {
                millisElapsed: 0.928141,
                invocationCounts: { nextDoc: Long('3405') }
              },
              score: {
                millisElapsed: 7.96188,
                invocationCounts: {
                  score: Long('3403'),
                  setMinCompetitiveScore: Long('63')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 12.335932,
              invocationCounts: {
                collect: Long('3403'),
                competitiveIterator: Long('2'),
                setScorer: Long('2')
              }
            }
          },
          metadata: {
            mongotVersion: '1.49.3',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            lucene: { totalSegments: 2, totalDocs: 3483 }
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          }
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('38')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('38')
    }
  ],
  queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.3',
    gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding_voyage_3_large',
          queryVector: [
            -0.034731735,  0.008558298,   -0.0153717, -0.029912498,  0.011549547,
            ...,
            -0.006688767,  0.047527634,  0.040714234
          ],
          exact: true,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1752449065, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('TwyeFcQsr24W6cTIx7ZIb/R0H6I=', 0),
      keyId: Long('7485474929970774018')
    }
  },
  operationTime: Timestamp({ t: 1752449065, i: 1 })
}

后退

查询参考

来年

使用兼容视图

1	{
2	explainVersion: '1',
3	stages: [
4	{
5	'$vectorSearch': {
6	index: 'vector_index',
7	path: 'plot_embedding_voyage_3_large',
8	queryVector: [
9	-0.034731735, 0.008558298, -0.0153717, -0.029912498, 0.011549547,
10	...,
11	-0.006688767, 0.047527634, 0.040714234
12	],
13	numCandidates: 150,
14	limit: 10,
15	explain: {
16	query: {
17	type: 'WrappedKnnQuery',
18	args: {
19	query: [
20	{
21	type: 'InstrumentableKnnFloatVectorQuery',
22	args: {
23	field: '$type:knnVector/plot_embedding_voyage_3_large',
24	k: 150
25	},
26	stats: {
27	context: { millisElapsed: 0 },
28	match: { millisElapsed: 0 },
29	score: { millisElapsed: 0 }
30	}
31	},
32	{
33	type: 'DocAndScoreQuery',
34	args: {},
35	stats: {
36	context: {
37	millisElapsed: 15.794112,
38	invocationCounts: {
39	createWeight: Long('1'),
40	createScorer: Long('4')
41	}
42	},
43	match: {
44	millisElapsed: 0.084957,
45	invocationCounts: { nextDoc: Long('152') }
46	},
47	score: {
48	millisElapsed: 0.688285,
49	invocationCounts: {
50	score: Long('150'),
51	setMinCompetitiveScore: Long('25')
52	}
53	}
54	}
55	}
56	]
57	},
58	stats: {
59	context: {
60	millisElapsed: 76.547561,
61	invocationCounts: {
62	vectorExecution: Long('1'),
63	createWeight: Long('1'),
64	createScorer: Long('4')
65	}
66	},
67	match: {
68	millisElapsed: 0.084957,
69	invocationCounts: { nextDoc: Long('152') }
70	},
71	score: {
72	millisElapsed: 0.688285,
73	invocationCounts: {
74	score: Long('150'),
75	setMinCompetitiveScore: Long('25')
76	}
77	}
78	}
79	},
80	collectors: {
81	allCollectorStats: {
82	millisElapsed: 2.513847,
83	invocationCounts: {
84	collect: Long('150'),
85	competitiveIterator: Long('2'),
86	setScorer: Long('2')
87	}
88	}
89	},
90	metadata: {
91	mongotVersion: '1.49.3',
92	mongotHostName: '<hostname>.mongodb.net',
93	indexName: 'vector_index',
94	lucene: { totalSegments: 2, totalDocs: 3483 }
95	},
96	resourceUsage: {
97	majorFaults: Long('0'),
98	minorFaults: Long('0'),
99	userTimeMs: Long('0'),
100	systemTimeMs: Long('0'),
101	maxReportingThreads: 1,
102	numBatches: 1
103	},
104	luceneVectorSegmentStats: [
105	{
106	executionType: 'Approximate',
107	docCount: 3420,
108	approximateStage: { millisElapsed: 47.246946 }
109	},
110	{
111	executionType: 'Approximate',
112	docCount: 63,
113	approximateStage: { millisElapsed: 0.520547 }
114	}
115	]
116	}
117	},
118	nReturned: Long('0'),
119	executionTimeMillisEstimate: Long('306')
120	},
121	{
122	'$_internalSearchIdLookup': { limit: Long('10') },
123	nReturned: Long('0'),
124	executionTimeMillisEstimate: Long('306')
125	}
126	],
127	queryShapeHash: '2816D59590F550220114018918B7CF7D39CFFD6832A9D0FAAAD28D70B83A3185',
128	serverInfo: {
129	host: '<hostname>.mongodb.net',
130	port: 27017,
131	version: '8.0.3',
132	gitVersion: 'bed99f699da6cb2b74262aa6d473446c41476643'
133	},
134	serverParameters: {
135	internalQueryFacetBufferSizeBytes: 104857600,
136	internalQueryFacetMaxOutputDocSizeBytes: 104857600,
137	internalLookupStageIntermediateDocumentMaxSizeBytes: 16793600,
138	internalDocumentSourceGroupMaxMemoryBytes: 104857600,
139	internalQueryMaxBlockingSortMemoryUsageBytes: 33554432,
140	internalQueryProhibitBlockingMergeOnMongoS: 0,
141	internalQueryMaxAddToSetBytes: 104857600,
142	internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
143	internalQueryFrameworkControl: 'trySbeRestricted',
144	internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
145	},
146	command: {
147	aggregate: 'embedded_movies',
148	pipeline: [
149	{
150	'$vectorSearch': {
151	index: 'vector_index',
152	path: 'plot_embedding_voyage_3_large',
153	queryVector: [
154	-0.034731735, 0.008558298, -0.0153717, -0.029912498, 0.011549547,
155	...,
156	-0.006688767, 0.047527634, 0.040714234
157	],
158	numCandidates: 150,
159	limit: 10
160	}
161	}
162	],
163	cursor: {},
164	'$db': 'sample_mflix'
165	},
166	ok: 1,
167	'$clusterTime': {
168	clusterTime: Timestamp({ t: 1752447925, i: 20 }),
169	signature: {
170	hash: Binary.createFromBase64('JELVXSAkvhOwS5+CSP58Hj7wJZA=', 0),
171	keyId: Long('7485474929970774018')
172	}
173	},
174	operationTime: Timestamp({ t: 1752447925, i: 20 })
175	}