解释Atlas Vector Search结果

在此页面上

语法
详细程度
解释结果
collectors
allCollectorStats
metadata
query
args
stats
resourceUsage
示例
allPlansExecution
queryPlanner
executionStats

使用 explain 方法运行Atlas 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	Atlas 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 类型。要学习；了解有关此类型的字段以及特定于预筛选查询的其他查询类型的更多信息，请参阅Atlas Search解释页面上的查询类型。

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 方法。如果您想在自己的环境中运行以下示例，则必须首先使用完成Atlas Vector Search快速入门。mongosh

`allPlansExecution`

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

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

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding',
        queryVector: [
            -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
            ...
            -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
        ],
        numCandidates: 150,
        limit: 10,
        explain: {
          query: {
            type: 'WrappedKnnQuery',
            args: {
              query: [
                {
                  type: 'KnnFloatVectorQuery',
                  args: { field: '$type:knnVector/plot_embedding', k: 150 },
                  stats: {
                    context: { millisElapsed: 0 },
                    match: { millisElapsed: 0 },
                    score: { millisElapsed: 0 }
                  }
                },
                {
                  type: 'DocAndScoreQuery',
                  args: {},
                  stats: {
                    context: {
                      millisElapsed: 0.011281,
                      invocationCounts: {
                        createWeight: Long('1'),
                        createScorer: Long('2')
                      }
                    },
                    match: {
                      millisElapsed: 0.045831,
                      invocationCounts: { nextDoc: Long('151') }
                    },
                    score: {
                      millisElapsed: 0.049853,
                      invocationCounts: {
                        score: Long('150'),
                        setMinCompetitiveScore: Long('30')
                      }
                    }
                  }
                }
              ]
            },
            stats: {
              context: {
                millisElapsed: 3.226133,
                invocationCounts: {
                  vectorExecution: Long('1'),
                  createWeight: Long('1'),
                  createScorer: Long('2')
                }
              },
              match: {
                millisElapsed: 0.045831,
                invocationCounts: { nextDoc: Long('151') }
              },
              score: {
                millisElapsed: 0.049853,
                invocationCounts: {
                  score: Long('150'),
                  setMinCompetitiveScore: Long('30')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 0.211472,
              invocationCounts: {
                collect: Long('150'),
                competitiveIterator: Long('1'),
                setScorer: Long('1')
              }
            },
            facet: { collectorStats: { millisElapsed: 0 } }
          },
          metadata: {
            mongotVersion: '1.44.0',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            totalLuceneDocs: 3483
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          }
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('29')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('29')
    }
  ],
  queryShapeHash: '9EFFBE6AC5B8DC66D20DB8939CF3ED6669D0C09BB6938C17AD3FB8C7793765B8',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.5',
    gitVersion: 'cb9e2e5e552ee39dea1e39d7859336456d0c9820'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding',
          queryVector: [
              -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
              ...
              -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
          ],
          numCandidates: 150,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1740781674, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('gpGnPOB17p3NnKu74vhm+kCLXf8=', 0),
      keyId: Long('7446434162581438465')
    }
  },
  operationTime: Timestamp({ t: 1740781674, i: 1 })
}

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

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding',
        queryVector: [
            -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
            ...
            -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
        ],
        exact: true,
        limit: 10,
        explain: {
          query: {
            type: 'ExactVectorSearchQuery',
            args: {
              field: '$type:knnVector/plot_embedding',
              similarityFunction: 'dotProduct',
              filter: {
                type: 'DefaultQuery',
                args: { queryType: 'FieldExistsQuery' },
                stats: {
                  context: {
                    millisElapsed: 0.031999,
                    invocationCounts: {
                      createWeight: Long('1'),
                      createScorer: Long('2')
                    }
                  },
                  match: {
                    millisElapsed: 1.2138,
                    invocationCounts: { nextDoc: Long('3403') }
                  },
                  score: { millisElapsed: 0 }
                }
              }
            },
            stats: {
              context: {
                millisElapsed: 0.055318,
                invocationCounts: { createWeight: Long('1'), createScorer: Long('2') }
              },
              match: {
                millisElapsed: 2.578062,
                invocationCounts: { nextDoc: Long('3403') }
              },
              score: {
                millisElapsed: 5.624325,
                invocationCounts: {
                  score: Long('3402'),
                  setMinCompetitiveScore: Long('71')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 7.095773,
              invocationCounts: {
                collect: Long('3402'),
                competitiveIterator: Long('1'),
                setScorer: Long('1')
              }
            },
            facet: { collectorStats: { millisElapsed: 0 } }
          },
          metadata: {
            mongotVersion: '1.44.0',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            totalLuceneDocs: 3483
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          }
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('19')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('19')
    }
  ],
  queryShapeHash: '9EFFBE6AC5B8DC66D20DB8939CF3ED6669D0C09BB6938C17AD3FB8C7793765B8',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.5',
    gitVersion: 'cb9e2e5e552ee39dea1e39d7859336456d0c9820'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding',
          queryVector: [
              -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
              ...
              -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
          ],
          exact: true,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1740781894, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('cNmipB7AsFGaT4ipmWCKizM/EbU=', 0),
      keyId: Long('7446434162581438465')
    }
  },
  operationTime: Timestamp({ t: 1740781894, i: 1 })
}

`queryPlanner`

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

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

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding',
        queryVector: [
            -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
            ...
            -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
        ],
        numCandidates: 150,
        limit: 10,
        explain: {
          query: {
            type: 'WrappedKnnQuery',
            args: {
              query: [
                {
                  type: 'KnnFloatVectorQuery',
                  args: { field: '$type:knnVector/plot_embedding', k: 150 }
                },
                { type: 'DocAndScoreQuery', args: {} }
              ]
            }
          },
          metadata: {
            mongotVersion: '1.44.0',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            totalLuceneDocs: 3483
          }
        }
      }
    },
    { '$_internalSearchIdLookup': { limit: Long('10') } }
  ],
  queryShapeHash: '9EFFBE6AC5B8DC66D20DB8939CF3ED6669D0C09BB6938C17AD3FB8C7793765B8',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.5',
    gitVersion: 'cb9e2e5e552ee39dea1e39d7859336456d0c9820'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding',
          queryVector: [
              -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
              ...
              -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
          ],
          numCandidates: 150,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1740782044, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('/ZHh6h+2qbJtYdOBHmeZepo1Wsc=', 0),
      keyId: Long('7446434162581438465')
    }
  },
  operationTime: Timestamp({ t: 1740782044, i: 1 })
}

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

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding',
        queryVector: [
            -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
            ...
            -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
        ],
        exact: true,
        limit: 10,
        explain: {
          query: {
            type: 'ExactVectorSearchQuery',
            args: {
              field: '$type:knnVector/plot_embedding',
              similarityFunction: 'dotProduct',
              filter: {
                type: 'DefaultQuery',
                args: { queryType: 'FieldExistsQuery' }
              }
            }
          },
          metadata: {
            mongotVersion: '1.44.0',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            totalLuceneDocs: 3483
          }
        }
      }
    },
    { '$_internalSearchIdLookup': { limit: Long('10') } }
  ],
  queryShapeHash: '9EFFBE6AC5B8DC66D20DB8939CF3ED6669D0C09BB6938C17AD3FB8C7793765B8',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.5',
    gitVersion: 'cb9e2e5e552ee39dea1e39d7859336456d0c9820'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding',
          queryVector: [
              -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
              ...
              -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
          ],
          exact: true,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1740782103, i: 23 }),
    signature: {
      hash: Binary.createFromBase64('yn3TtM4cfhu6HXCGzBGPbLmlM4E=', 0),
      keyId: Long('7446434162581438465')
    }
  },
  operationTime: Timestamp({ t: 1740782103, i: 23 })
}

`executionStats`

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

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

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding',
        queryVector: [
            -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
            ...
            -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
        ],
        numCandidates: 150,
        limit: 10,
        explain: {
          query: {
            type: 'WrappedKnnQuery',
            args: {
              query: [
                {
                  type: 'KnnFloatVectorQuery',
                  args: { field: '$type:knnVector/plot_embedding', k: 150 },
                  stats: {
                    context: { millisElapsed: 0 },
                    match: { millisElapsed: 0 },
                    score: { millisElapsed: 0 }
                  }
                },
                {
                  type: 'DocAndScoreQuery',
                  args: {},
                  stats: {
                    context: {
                      millisElapsed: 0.015853,
                      invocationCounts: {
                        createWeight: Long('1'),
                        createScorer: Long('2')
                      }
                    },
                    match: {
                      millisElapsed: 0.013112,
                      invocationCounts: { nextDoc: Long('151') }
                    },
                    score: {
                      millisElapsed: 0.033269,
                      invocationCounts: {
                        score: Long('150'),
                        setMinCompetitiveScore: Long('30')
                      }
                    }
                  }
                }
              ]
            },
            stats: {
              context: {
                millisElapsed: 3.979414,
                invocationCounts: {
                  vectorExecution: Long('1'),
                  createWeight: Long('1'),
                  createScorer: Long('2')
                }
              },
              match: {
                millisElapsed: 0.013112,
                invocationCounts: { nextDoc: Long('151') }
              },
              score: {
                millisElapsed: 0.033269,
                invocationCounts: {
                  score: Long('150'),
                  setMinCompetitiveScore: Long('30')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 0.115101,
              invocationCounts: {
                collect: Long('150'),
                competitiveIterator: Long('1'),
                setScorer: Long('1')
              }
            },
            facet: { collectorStats: { millisElapsed: 0 } }
          },
          metadata: {
            mongotVersion: '1.44.0',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            totalLuceneDocs: 3483
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          }
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('13')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('13')
    }
  ],
  queryShapeHash: '9EFFBE6AC5B8DC66D20DB8939CF3ED6669D0C09BB6938C17AD3FB8C7793765B8',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.5',
    gitVersion: 'cb9e2e5e552ee39dea1e39d7859336456d0c9820'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding',
          queryVector: [
              -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
              ...
              -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
          ],
          numCandidates: 150,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1740782136, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('33LuqO946oIzmslClhuu+Z+PthQ=', 0),
      keyId: Long('7446434162581438465')
    }
  },
  operationTime: Timestamp({ t: 1740782136, i: 1 })
}

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

{
  explainVersion: '1',
  stages: [
    {
      '$vectorSearch': {
        index: 'vector_index',
        path: 'plot_embedding',
        queryVector: [
            -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
            ...
            -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
        ],
        exact: true,
        limit: 10,
        explain: {
          query: {
            type: 'ExactVectorSearchQuery',
            args: {
              field: '$type:knnVector/plot_embedding',
              similarityFunction: 'dotProduct',
              filter: {
                type: 'DefaultQuery',
                args: { queryType: 'FieldExistsQuery' },
                stats: {
                  context: {
                    millisElapsed: 0.029472,
                    invocationCounts: {
                      createWeight: Long('1'),
                      createScorer: Long('2')
                    }
                  },
                  match: {
                    millisElapsed: 0.234054,
                    invocationCounts: { nextDoc: Long('3403') }
                  },
                  score: { millisElapsed: 0 }
                }
              }
            },
            stats: {
              context: {
                millisElapsed: 0.050328,
                invocationCounts: { createWeight: Long('1'), createScorer: Long('2') }
              },
              match: {
                millisElapsed: 0.622028,
                invocationCounts: { nextDoc: Long('3403') }
              },
              score: {
                millisElapsed: 3.03997,
                invocationCounts: {
                  score: Long('3402'),
                  setMinCompetitiveScore: Long('71')
                }
              }
            }
          },
          collectors: {
            allCollectorStats: {
              millisElapsed: 3.601357,
              invocationCounts: {
                collect: Long('3402'),
                competitiveIterator: Long('1'),
                setScorer: Long('1')
              }
            },
            facet: { collectorStats: { millisElapsed: 0 } }
          },
          metadata: {
            mongotVersion: '1.44.0',
            mongotHostName: '<hostname>.mongodb.net',
            indexName: 'vector_index',
            totalLuceneDocs: 3483
          },
          resourceUsage: {
            majorFaults: Long('0'),
            minorFaults: Long('0'),
            userTimeMs: Long('0'),
            systemTimeMs: Long('0'),
            maxReportingThreads: 1,
            numBatches: 1
          }
        }
      },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('12')
    },
    {
      '$_internalSearchIdLookup': { limit: Long('10') },
      nReturned: Long('0'),
      executionTimeMillisEstimate: Long('12')
    }
  ],
  queryShapeHash: '9EFFBE6AC5B8DC66D20DB8939CF3ED6669D0C09BB6938C17AD3FB8C7793765B8',
  serverInfo: {
    host: '<hostname>.mongodb.net',
    port: 27017,
    version: '8.0.5',
    gitVersion: 'cb9e2e5e552ee39dea1e39d7859336456d0c9820'
  },
  serverParameters: {
    internalQueryFacetBufferSizeBytes: 104857600,
    internalQueryFacetMaxOutputDocSizeBytes: 104857600,
    internalLookupStageIntermediateDocumentMaxSizeBytes: 104857600,
    internalDocumentSourceGroupMaxMemoryBytes: 104857600,
    internalQueryMaxBlockingSortMemoryUsageBytes: 104857600,
    internalQueryProhibitBlockingMergeOnMongoS: 0,
    internalQueryMaxAddToSetBytes: 104857600,
    internalDocumentSourceSetWindowFieldsMaxMemoryBytes: 104857600,
    internalQueryFrameworkControl: 'trySbeRestricted',
    internalQueryPlannerIgnoreIndexWithCollationForRegex: 1
  },
  command: {
    aggregate: 'embedded_movies',
    pipeline: [
      {
        '$vectorSearch': {
          index: 'vector_index',
          path: 'plot_embedding',
          queryVector: [
              -0.0016261312,   -0.028070757,   -0.011342932,    -0.012775794,
              ...
              -0.0060913274,   -0.007130985,   -0.013109017,    -0.009710136
          ],
          exact: true,
          limit: 10
        }
      }
    ],
    cursor: {},
    '$db': 'sample_mflix'
  },
  ok: 1,
  '$clusterTime': {
    clusterTime: Timestamp({ t: 1740782184, i: 1 }),
    signature: {
      hash: Binary.createFromBase64('tpxoW70Y+Z5HmDqaswag+matLQQ=', 0),
      keyId: Long('7446434162581438465')
    }
  },
  operationTime: Timestamp({ t: 1740782184, i: 1 })
}

后退

创建和运行查询

来年

转换文档和过滤器集合