Atlas ベクトル検索結果の説明

explain メソッドを使用して Atlas ベクトル検索クエリを実行すると、クエリはクエリプランとクエリが内部で実行された方法を説明する実行統計を含む BSONドキュメントを返します。

Tip

構文

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` フィールドは、クエリの実行統計をもつため、含まれていません。

Tip

冗長モード

explain の結果

explain メソッドは、次のフィールドを含むBSONドキュメントを返します。

オプション	タイプ	必要性	目的
`collectors`	ドキュメント	任意	コレクターの実行統計を説明します。
`metadata`	ドキュメント	任意	有用なメタデータを含んでいます。
`query`	ドキュメント	任意	クエリの実行統計を記述します。これは `indexPartitionExplain` の最上位には存在しません。
`resultMaterialization`	ドキュメント	任意	クエリ実行後にドキュメントごとのデータを取得する方法の詳細。これは、`queryPlanner` の冗長モードでは返されません。
`resourceUsage`	ドキュメント	任意	クエリが実行されたときのリソース使用状況を詳述します。`queryPlanner`の冗長モードでは返されません。

`collectors`

collectors は、次のフィールドを含むBSONドキュメントです。

フィールド	タイプ	必要性	目的
`allCollectorStats`	ドキュメント	必須	クエリのすべてのコレクターの統計情報。報告される統計は、クエリで使用されるすべてのコレクターにわたる最大値または、すべてのサブコレクションにわたる統計の合計を表します。タイミング統計は、クエリ全体のすべてのコレクターで費やされた合計時間を反映するように合計されます。詳しくは、 `allCollectorStats` を参照してください。

`allCollectorStats`

allCollectorStats は、クエリで指定されたすべてのコレクターのコレクター統計を記述するBSONドキュメントです。これには、次のキーが含まれています。

フィールド	説明
`collect`	コレクターが収集した期間と結果の数を追跡します。
`competitiveIterator`	コレクターから `competitiveIterator` が要求された合計時間と回数を追跡する統計。
`setScorer`	スコアラーがコレクターに設定された合計時間と回数を追跡する統計。

`metadata`

metadata には、次のような有用なメタデータが含まれています。

フィールド	タイプ	必要性	目的
`mongotVersion`	文字列	任意	`mongot`の現在のバージョンです。
`mongotHostName`	文字列	任意	`mongot` ホストを識別する、人間が判読できるラベル。
`indexName`	文字列	任意	クエリで使用される Atlas ベクトル検索インデックス。
`cursorOptions`	ドキュメント	任意	`mongot` に指定されたカーソルオプション。
`totalLuceneDocs`	整数	任意	削除されたドキュメントを含むインデックス内のドキュメントの合計数。

`query`

explain応答は、クエリの実行統計を説明するキーと値を含むBSONドキュメントです。結果セット内のexplainドキュメントには、次のフィールドが含まれています。

フィールド	タイプ	必要性	目的
`path`	string	任意	クエリされた埋め込みフィールドへのパス（ルートでない場合にのみ）。
`type`	string	必須	ベクトル検索クエリーのタイプの名前。詳しくは、 `query` を参照してください。
`args`	ドキュメント	必須	ベクトル検索クエリー情報。詳しくは、 `query` を参照してください。
`stats`	ドキュメント	任意	`explain` が `executionStats` または `allPlansExecution` の冗長度で実行された場合、クエリの `stats`。

`args`

explain 応答には、クエリが内部的に実行された方法に関する情報が含まれます。argsフィールドには、次の詳細が含まれます。

クエリタイプ
各クエリタイプの構造化された概要の例
構造化サマリー内のクエリオプション

次のセクションでは、クエリのタイプと構造化サマリーのフィールドについて説明します。

WrappedKnnQuery

複数のクエリを組み合わせた Annベクトル検索に使用されるラッパークエリ。構造化されたサマリーには、次のオプションの詳細が含まれます。

フィールド	タイプ	必要性	説明
`query`	配列	必須	ベクトル検索で使用されるサブクエリの配列。通常、`KnnFloatVectorQuery` と `DocAndScoreQuery` が含まれます。

KnnFloatVectorQuery

浮動小数ベクトルに対する ANN 検索に固有のクエリタイプ。構造化されたサマリーには、次のオプションに関する詳細が含まれています。

フィールド	タイプ	必要性	説明
`field`	文字列	必須	検索対象のベクトルフィールドパス。
`k`	整数	必須	検索する最近傍の数。

DocAndScoreQuery: ドキュメントの一致とスコアリングを処理するクエリタイプ。構造化されたサマリーには通常、クエリの実行に関する統計が含まれます。

ExactVectorSearchQuery

ENNベクトル検索のクエリタイプ。構造化されたサマリーには、次のオプションに関する詳細が含まれています。

フィールド	タイプ	必要性	説明
`field`	文字列	必須	検索対象のベクトルフィールドパス。
`similarityFunction`	文字列	必須	使用される類似性関数（`dotProduct`、`cosine`、または `euclidean`）。
`filter`	ドキュメント	任意	ベクトル検索範囲を制限するプレフィルタークエリ。

BooleanQuery: ベクトル検索クエリーで事前フィルターを使用する場合、説明結果には BooleanQuery 型が含まれます。このタイプのフィールドおよび事前フィルタークエリに固有のその他のクエリタイプの詳細については、Atlas Search Explain ページの「クエリタイプ」を参照してください。

DefaultQuery

別のクエリによって明示的に定義されていないクエリは、デフォルトのクエリを使用して直列化されます。構造化されたサマリーには、次のオプションの詳細が含まれます。

フィールド	タイプ	必要性	説明
`queryType`	文字列	必須	クエリのタイプ。

`stats`

executionStats と allPlansExecution の冗長モードのexplain レスポンスにはstats 、クエリ実行のさまざまな段階でクエリに費やされた時間に関する情報を含むフィールドが含まれています。

タイミングの内訳

タイミングの内訳は、クエリ実行の領域に関連する実行統計を示します。次のフィールドは、タイミングの内訳を示しています。

フィールド	タイプ	説明
`millisElapsed`	Long	この領域でクエリの子がこの領域で費やした時間数を含む、この領域でタスクの実行に経過したおおよそのウォールクロック時間。値は、この領域でタスクを実行中に経過したおおよそのミリ秒数です。
`invocationCounts`	ドキュメント	この領域に含まれるタスクの呼び出しの数。この値は、タスク名とその呼び出し回数のマッピングです。

クエリの領域

統計は、クエリの次の領域で利用できます。

オプション

説明

context

ベクトル検索クエリーの実行に関連する統計。この領域には、呼び出し回数が列挙されるタスクが 2 つあります。

createScorer

スコアリングはドキュメントを反復処理し、各ドキュメントに対してスコアを生成します。 createScorerを呼び出すと、スコアリングを担当するオブジェクトが作成されます。このタスクに関連付けられている時間は、実際にドキュメントのスコアリングに費やされた時間ではないことに注意してください。カウントにはscorerSupplier呼び出しの数が含まれます。

createWeight

重みはクエリとIndexSearcherに関連付けられた状態を保存します。カウントにはcreateWeight呼び出しの数が含まれます。

この領域で費やされる時間はクエリの構造に関連しており、反復処理されスコア付けされる結果の数には基づいていません。

以下に例を挙げます。

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

match

結果ドキュメントの反復処理と一致に関連する統計。この統計は、どのドキュメントが次の一致であるかを決定するのにかかる時間を示しています。結果のマッチングに費やされる時間は、クエリの性質によって大きく異なる場合があります。この領域には、呼び出し回数が列挙されるタスクが 2 つあります。

nextDoc

結果セットの次のドキュメントに進むことを要求します。これには、スキップを識別して過去のスキップに移動するか、次の一致を見つけるために必要なその他のタスクが含まれます。カウントには、 nextDocとadvanceの呼び出しの数が含まれます。

refineRoughMatch

より完全な一致を実行します。一部のクエリは 2 段階のプロセスで実行されます。このプロセスではドキュメントは最初に「ほぼ」一致し、最初のおおよその一致を満たした後にのみ、2 番目のより詳細なフェーズでチェックされます。 refineRoughMatchタスクは、2 フェーズプロセスの 2 番目のフェーズです。カウントにはrefineRoughMatch呼び出しの数が含まれます。

以下に例を挙げます。

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

score

結果セット内のドキュメントのスコアリングに関連する統計。この領域には、呼び出し回数が列挙されるタスクが 2 つあります。

`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`が使用したスレッドの最大数。非並行のExplainクエリの場合、値は`1`です。
`numBatches`	整数	必須	クエリのプロセシング中に `mongot` が要求されたバッチの総数。

例

次の例では、サンプルAnn と ENNクエリで explain メソッドを使用します。自分の環境で次の例を実行するには、まずを使用して Atlas ベクトル検索クイック mongoshスタートを完了する必要があります。

`allPlansExecution`

plot_embedding次の例では、allPlansExecution の冗長モードを使用して、フィールドの DN と ENNベクトル検索クエリーで explain メソッドを実行します。

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次の例では、queryPlanner の冗長モードを使用して、フィールドの DN と ENNベクトル検索クエリーで explain メソッドを実行します。

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次の例では、executionStats の冗長モードを使用して、フィールドの DN と ENNベクトル検索クエリーで explain メソッドを実行します。

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

戻る

クエリの作成および実行

ドキュメントの変換 & コレクションのフィルタリング