/ /

クエリ参照

演算子とコレクター

Docs Home

開発

`facet` （MongoDB Search 演算子）

定義

facet

facet コレクターは、指定されたファセットフィールドの値または範囲で結果をグループ化し、各グループのカウントを返します。

You can use facet with both the $search and $searchMeta stages. MongoDB recommends using facet with the $searchMeta stage to retrieve metadata results only for the query. To retrieve metadata results and query results using the $search stage, you must use the $$SEARCH_META aggregation variable. See SEARCH_META Aggregation Variable to learn more.

embeddedDocuments フィールド型定義で storedSource を定義すると、 returnStoredSource とともに returnScope を使用して、オブジェクト配列内のネストされたフィールドにファセットを設定できます。それ以外の場合は、ルートの embeddedDocuments 型フィールドに対してのみファセットを設定できます。ファセットの例：

Nested fields inside an array of objects, see returnScope Example.
Matching children of an embeddedDocuments array using embeddedDocument, see Embedded-Scoped Facet Example.
ルートembeddedDocuments型フィールドについては、ファセットクエリを参照してください。

構文

facet の構文は次のとおりです。

{
  "$searchMeta"|"$search": {
    "index": <index name>, // optional, defaults to "default"
    "facet": {
      "operator": {
        <operator-specifications>
      },
      "facets": {
        <facet-definitions>
      }
    },
    "returnScope": {
      "path": "<embedded-documents-field-to-query>"
    },
    "returnStoredSource": true
  }
}

フィールド

フィールド	タイプ	必須	説明
`facets`	ドキュメント	はい	Information for bucketing the data for each facet. You must specify at least one Facet Definition. Each facet definition can also specify Facet Aggregations to compute metrics for each bucket.
`operator`	ドキュメント	no	ファセットを実行するために使用する演算子。省略した場合、 MongoDB Search はコレクション内のすべてのドキュメントに対してファセットを実行します。

メモリ要件

Facet queries are memory-intensive, regardless of your cluster tier. Queries that specify Facet Aggregations or nested facets require more memory and disk than other facet queries. Before you use facets in production, confirm that your cluster has enough memory for your workload. To learn more, see Search Memory Management. To get sizing guidance for your workload, request support.

ファセットクエリが必要とするメモリは、numBuckets または boundaries を使用してリクエストするバケットの数ではなく、ファセットするフィールドの一意の値の数によって異なります。例、500 万個の一意の値を持つフィールドで 20 個のバケットをリクエストするファセットでは、上位 20 個のバケットを決定するためにすべての一意の値をカウントします。

For nested facets, the total unique values computed in a query multiply based on the unique values across each level of nesting. Even when each individual field has low cardinality, the combination of values across nested paths can produce a large number of unique buckets. To learn more about how nested facets multiply buckets, see Nested Facets.

MongoDB Searchはクエリごとにバケット数を個別に追跡するため、合計メモリ使用量は同時実行されるファセットクエリの数に応じて増加します。シャーディングされたクラスターでは、MongoDB Searchは各シャードからのバケットをマージするためにもメモリを必要とします。このメモリ使用量は、シャードの数とバケットの数に応じて増加します。

ファセットの定義

ファセット定義ドキュメントには、ファセット名とファセットのタイプに固有のオプションが含まれています。MongoDB Search は次の型のファセットをサポートしています。

文字列ファセット
数値ファセット
日付ファセット

文字列ファセット

重要

stringFacet は廃止予定です。代わりにトークンを使用することで、ファセットが改善されます。

ファセットの更新されたフィールド型と古いフィールド型の違いの詳細については、ファセットのフィールド型の比較を参照してください。

文字列ファセットを使用すると、指定された文字列フィールド内の最も頻繁に出現する文字列値に基づいて、MongoDB Search 結果を絞り込むことができます。文字列フィールドは、トークンとしてインデックス付けする必要があることに注意してください。埋め込みドキュメント内のstringフィールドをファセットするには、親フィールドもドキュメント型としてインデックス付けする必要があります。配列内の文字列または埋め込みドキュメントをファセットすると、MongoDB Search は一致するルートドキュメントの数に基づいてファセット数を返します。

構文

文字列ファセットの構文は次のとおりです。

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "string",
          "path" : "<field-path>",
          "numBuckets" : <number-of-categories>,
          "embeddedDocument": { <embedded-document-scope> } // optional
        }
      }
    }
  }
}

オプション

オプション	タイプ	説明	必須
`embeddedDocument`	オブジェクト	Scopes the facet's bucket counts to only the child documents of an `embeddedDocuments` array that match a query predicate. To learn more, see Facet on Matching Children of an Embedded Documents Array.	no
`numBuckets`	整数	結果で返されるファセットカテゴリの最大数。値は `10000` 以下である必要があります。指定した場合、データがリクエストされた数よりも少ないカテゴリにグループ化されると、MongoDB Search はリクエストされた数よりも少ないカテゴリを返すことがあります。省略した場合、デフォルトは `10` になります。つまり、MongoDB Search はカウントで上位 `10` 個のファセットカテゴリのみを返します。	no
`path`	string	ファセットするフィールドパス。トークンとしてインデックス付けされたフィールドを指定できます。	はい
`type`	string	ファセットの型。値は`string`でなければなりません。	はい

例

次の例では、sample_mflix.movies コレクションで default という名前のインデックスを使用します。コレクション内の genres フィールドはトークン型としてインデックス付けされ、year フィールドは数値型としてインデックス付けされます。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "genres": {
        "type": "token"
      },
      "year": {
        "type": "number"
      }
    }
  }
}

クエリは、$searchMeta ステージを使用して、movies コレクションの year フィールドで 2000 年から 2015 年までの映画を検索し、各ジャンルの映画の数を検索します。

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "range": {
7             "path": "year",
8             "gte": 2000,
9             "lte": 2015
10           }
11         },
12         "facets": {
13           "genresFacet": {
14             "type": "string",
15             "path": "genres"
16           }
17         }
18       }
19     }
20   }
21 ])

1 [
2   {
3     count: { lowerBound: Long('12568') },
4     facet: {
5       genresFacet: {
6         buckets: [
7           { _id: 'Drama', count: Long('7079') },
8           { _id: 'Comedy', count: Long('3689') },
9           { _id: 'Romance', count: Long('1764') },
10           { _id: 'Thriller', count: Long('1584') },
11           { _id: 'Documentary', count: Long('1472') },
12           { _id: 'Action', count: Long('1471') },
13           { _id: 'Crime', count: Long('1367') },
14           { _id: 'Adventure', count: Long('1056') },
15           { _id: 'Horror', count: Long('866') },
16           { _id: 'Biography', count: Long('796') }
17         ]
18       }
19     }
20   }
21 ]

これらの結果の詳細については、「ファセット結果」を参照してください。

数値ファセット

重要

numberFacet は廃止予定です。代わりに数値を使用してください。これにより、ファセットが改善されます。

ファセットの更新されたフィールド型と古いフィールド型の違いの詳細については、ファセットのフィールド型の比較を参照してください。

数値ファセットを使用すると、結果を個別の数値の範囲に分割して、検索結果内の数値の頻度を判断できます。配列または埋め込みドキュメント内の数値をファセットと、 MongoDB Search は一致するルートドキュメントの数に基づいてファセット数を返します。

構文

数値ファセットの構文は次のとおりです。

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "number",
          "path" : "<field-path>",
          "boundaries" : <array-of-numbers>,
          "default": "<bucket-name>",
          "embeddedDocument": { <embedded-document-scope> } // optional
        }
      }
    }
  }
}

オプション

オプション	タイプ	説明	必須
`boundaries`	数字の配列	List of numeric values in ascending order that specify the boundaries for your buckets. You must specify between two and ten thousand (`[2, 10000]`) boundary values. Each adjacent pair of values defines a bucket with an inclusive lower bound and an exclusive upper bound. You can specify any combination of values of the following BSON types: 32 ビット整数（`int32`） 64 ビット整数（`int64`） 64 ビットバイナリ浮動小数点（`double`）	はい
`default`	string	指定された境界内に含まれない、演算子から返されたドキュメントをカウントする追加のバケットの名前。省略した場合、 MongoDB Search には、指定されたバケットに該当しないファセット演算子の結果も含まれますが、バケット数には含まれません。	no
`embeddedDocument`	オブジェクト	Scopes the facet's bucket counts to only the child documents of an `embeddedDocuments` array that match a query predicate. To learn more, see Facet on Matching Children of an Embedded Documents Array.	no
`path`	string	ファセットするフィールドパス。数値型としてインデックス付けされたフィールドを指定できます。	はい
`type`	string	ファセットの型。値は`number`でなければなりません。	はい

例

次の例では、sample_mflix.movies コレクションで default という名前のインデックスを使用します。コレクション内の year フィールドは、数値型としてインデックスされます。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "year": [
        {
          "type": "number"
        }
      ]
    }
  }
}

クエリは、$searchMeta ステージを使用して、movies コレクションの year フィールドで 1980 年から 2000 年までの映画を検索し、クエリのメタデータ結果を検索します。クエリでは 3 つのバケットを指定します。

1980（このバケットの下限値を含む）
1990（1980 バケットの上限（排他的）とこのバケットの下限（包括的））
2000（1990 バケットの排他的上限）

クエリでは、指定された境界のいずれにも該当しないクエリの結果を検索するために、other という名前の default バケットも指定します。

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6          "range": {
7             "path": "year",
8             "gte": 1980,
9             "lte": 2000
10           }
11         },
12         "facets": {
13           "yearFacet": {
14             "type": "number",
15             "path": "year",
16             "boundaries": [1980,1990,2000],
17             "default": "other"
18           }
19         }
20       }
21     }
22   }
23 ])

1 [
2   {
3     count: { lowerBound: Long('6095') },
4     facet: {
5       yearFacet: {
6         buckets: [
7           { _id: 1980, count: Long('1956') },
8           { _id: 1990, count: Long('3558') },
9           { _id: 'other', count: Long('581') }
10         ]
11       }
12     }
13   }
14 ]

これらの結果の詳細については、「ファセット結果」を参照してください。

日付ファセット

重要

dateFacet は廃止予定です。代わりに date を使用することで、ファセットが改善されます。

ファセットの更新されたフィールド型と古いフィールド型の違いの詳細については、ファセットのフィールド型の比較を参照してください。

日付ファセットを使用すると、日付に基づいて検索結果を絞り込むことができます。配列または埋め込みドキュメント内の日付をファセットと、 MongoDB Search は一致するルートドキュメントの数に基づいてファセット数を返します。

構文

日付ファセットの構文は次のとおりです。

{
  "$searchMeta": {
    "facet":{
      "operator": {
        <operator-specification>
      },
      "facets": {
        "<facet-name>" : {
          "type" : "date",
          "path" : "<field-path>",
          "boundaries" : <array-of-dates>,
          "default": "<bucket-name>",
          "embeddedDocument": { <embedded-document-scope> } // optional
        }
      }
    }
  }
}

オプション

オプション	タイプ	説明	必須
`boundaries`	数字の配列	各バケットの境界を指定する日付値のリスト。以下を指定する必要があります: 少なくとも 2 つの境界を設定し、それらは 10,000（`[2, 10000]`）以下とします。値は昇順で表示され、日付が最も古いものから順に表示されています隣接する各値のペアは、バケットの包括的な下限と排他的な上限として機能します。	はい
`default`	string	指定された境界内に含まれない、演算子から返されたドキュメントをカウントする追加のバケットの名前。省略した場合、 MongoDB Search には指定されたバケットに該当しないファセット演算子の結果も含まれますが、 MongoDB Search はこれらの結果をバケットカウントに含めません。	no
`embeddedDocument`	オブジェクト	Scopes the facet's bucket counts to only the child documents of an `embeddedDocuments` array that match a query predicate. To learn more, see Facet on Matching Children of an Embedded Documents Array.	no
`path`	string	ファセットするフィールドパス。日付型としてインデックス付けされたフィールドを指定できます。	はい
`type`	string	ファセットの型。値は`date`でなければなりません。	はい

例

次の例では、sample_mflix.movies コレクションで default という名前のインデックスを使用します。コレクション内の released フィールドは、date 型としてインデックス付けされます。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "released": [
        {
          "type": "date"
        }
      ]
    }
  }
}

クエリは、$searchMeta ステージを使用して、movies コレクションの released フィールドで 2000 年から 2015 年までの映画を検索し、クエリのメタデータ結果を検索します。このクエリでは、次の 4 つのバケットを指定します。

2000-01-01（このバケットの下限値を含む）
2005-01-01（2000-01-01 バケットの上限（排他的）とこのバケットの下限（包括的））
2010-01-01（2005-01-01 バケットの上限（排他的）とこのバケットの下限（包括的））
2015-01-01（2010-01-01 バケットの排他的上限）

クエリでは、指定された境界のいずれにも該当しないクエリの結果を検索するために、other という名前の default バケットも指定します。

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "range": {
7             "path": "released",
8             "gte": ISODate("2000-01-01T00:00:00.000Z"),
9             "lte": ISODate("2015-01-31T00:00:00.000Z")
10           }
11         },
12         "facets": {
13           "yearFacet": {
14             "type": "date",
15             "path": "released",
16             "boundaries": [ISODate("2000-01-01"), ISODate("2005-01-01"), ISODate("2010-01-01"), ISODate("2015-01-01")],
17             "default": "other"
18           }
19         }
20       }
21     }
22   }
23 ])

1 [
2   {
3     count: { lowerBound: Long('11922') },
4     facet: {
5       yearFacet: {
6         buckets: [
7           {
8             _id: ISODate('2000-01-01T00:00:00.000Z'),
9             count: Long('3028')
10           },
11           {
12             _id: ISODate('2005-01-01T00:00:00.000Z'),
13             count: Long('3953')
14           },
15           {
16             _id: ISODate('2010-01-01T00:00:00.000Z'),
17             count: Long('4832')
18           },
19           { _id: 'other', count: Long('109') }
20         ]
21       }
22     }
23   }
24 ]

これらの結果の詳細については、「ファセット結果」を参照してください。

ファセットのフィールド型の比較

更新されたMongoDB検索フィールドタイプは、古いタイプ（stringFacet、numberFacet、dateFacet）と比較して、ファセットをサポートする機能が改善されています。次の表では、機能における主な違いをまとめています。

ファセットカテゴリ	更新されたフィールドタイプ	古いファセットの型	重要な違い
文字列	token	stringFacet（廃止予定）	Normalizer Support: The `token` type supports normalizers that transform facet buckets. For example, with `normalizer: lowercase`, "ADIDAS" and "adidas" count toward the same bucket while `stringFacet` treats them as separate buckets.
Numeric	数値	numberFacet（廃止予定）	Array Support: The `number` type considers values within arrays for facet buckets. For example, a document with an array value `[0, 10]` counts toward both buckets `[1, 5]` and `[6, 10]` while `numberFacet` ignores array values completely.
日付	date	dateFacet（廃止予定）	配列サポート: `date` タイプは、ファセットバケットの配列内の値を考慮します。例、日付を含む配列値は複数の日付範囲バケットに貢献できますが、`dateFacet` は配列値を完全に無視します。

注意

古いフィールド型と更新されたフィールド型の両方が同じフィールドで定義されている場合は、古いファセット型が優先されます。例、フィールドに token と stringFacet の両方が定義されている場合、ファセット計算では stringFacet マッピングが使用されます。

埋め込みドキュメントの配列の一致する子に対するファセット

各ファセット定義には、任意の embeddedDocument フィールドを含めることができます。このフィールドは、ファセットのバケットカウントを、クエリ述語に一致する embeddedDocuments 配列内の子ドキュメントのみにスコープします。embeddedDocument フィールドを省略した場合、ファセットはドキュメントインデックスになります。

embeddedDocumentがない場合、ルートドキュメントは、facet.operatorブロックで定義されたクエリに一致しない子ドキュメントであっても、そのバケットに該当する子ドキュメントがあれば、そのバケットでカウントされます。embeddedDocumentフィールドは、バケットへの寄与を、指定されたembeddedDocument.operatorに一致する子のみに制限します。各ルートドキュメントは、バケットごとに最大1回カウントされます。

embeddedDocument フィールドは、次のフィールドがあります。

フィールド	タイプ	説明	必須
`path`	string	ファセットのスコープを絞り込むためのインデックス付き `embeddedDocuments` 型フィールド。ファセットの `path` は、このフィールドの子孫である必要があります。	はい
`operator`	オブジェクト	`path` で指定する `embeddedDocuments` 配列内の各子ドキュメントに対して実行する演算子。この演算子に一致する子ドキュメントのみが、ファセットのバケットカウントに寄与します。この演算子で参照されるすべてのパスは、`path` の子孫である必要があります。	はい

For a number or date facet, a matching child whose value falls outside the configured boundaries counts in the default bucket, if you specify one, using the same rule as a document-indexed facet. A root document with no matching child doesn't contribute to the embeddedDocument-scoped facet, but can still contribute to any other, unscoped facet in the same query.

重要

You can't combine an embeddedDocument-scoped facet with several other faceting options. To learn more, see Limitations.

For an example, see the Embedded-Scoped Facet Example.

ファセット集計

重要

Facet aggregations is in Preview. The feature and corresponding documentation might change at any time during the Preview period. To learn more, see Preview Features.

To compute metrics for each facet bucket, add an aggregations document to a facet definition. MongoDB Search computes the metrics from the MongoDB Search index, so it is much more efficient than running a $group stage later in your pipeline.

各ファセットバケットでは、aggregations を使用して次の値を計算できます。

合計
平均
minimum
maximum
最初に
last

aggregationsを使用する場合は、次のことを行う必要があります。

各メトリクスのpathで指定するフィールドをtoken、number、またはdateとしてインデックス化します。
バケット数が必要な場合は、count メトリクスを明示的に含めてください。
aggregationsは、ネストされたファセットのリーフレベルでのみ指定してください。

中間的なグループ化のメトリクスを計算する場合は、そのグループ化を aggregations を使用した個別のトップレベルのファセットとして指定し、ネストされたファセットは指定しないでください。

MongoDB Search は、MongoDB Search インデックス内のデータに対して aggregations を計算します。このインデックスは終極的にコンシステントです。

注意

メモリ要件

Facet queries that specify aggregations or nested facets increase the memory and disk that your MongoDB Search index requires beyond the requirements for other facet queries. To learn more, see Memory Requirements.

構文

aggregations の構文は次のとおりです。

{
  "$searchMeta": {
    "facet": {
      "facets": {
        "<facet-name>": {
          "type": "<facet-type>",
          "path": "<field-path>",
          "aggregations": {
            "<aggregation-name>": {
              "type": "sum" | "min" | "max" | "avg" | "first" | "last",
              "path": "<field-path>"
            }
          }
        }
      }
    }
  }
}

aggregations ドキュメントの各キーは、指定した集計名です。MongoDB Search は、指定した名前の下にあるバケットドキュメント内の各集計を返します。

オプション

オプション	タイプ	説明	必須
`path`	string	メトリクスを計算するフィールドパス。これは、`path`を受け入れない`count`を除くすべてのメトリクスタイプで必須です。他のすべてのメトリクスタイプは2番目のフィールドから値を計算するため、そのフィールドに名前を付ける必要があります。例として、バケット内のドキュメントの平均評価を返すには、`avg`を`rating`の`path`で指定します。`count`メトリクスはバケット内のドキュメントをカウントするため、2番目のフィールドは必要ありません。	条件付き
`type`	string	計算するメトリクスのタイプ。値は次のいずれかになります。 `count` `sum` `avg` `min` `max` `first` `last` To learn more about each metric type, see Metric Types.	はい

メトリクス型

タイプ	フィールドの要件	説明
`count`	なし	バケット内のドキュメントをカウントします。このメトリクスタイプには `path` を指定しないでください。ファセット定義から `aggregations` を省略した場合、MongoDB Search はバケットに対して `count` メトリクスを返します。`aggregations` を指定した場合、MongoDB Search は `aggregations` ドキュメントで `count` を指定した場合にのみ `count` メトリクスを返します。
`sum`	数値	バケット内のドキュメントについて、指定されたフィールドの値を加算します。
`avg`	数値	バケット内のドキュメントの指定したフィールドの値の平均を返します。bucket 内のドキュメントのいずれにもフィールドの値が設定されていない場合、MongoDB Search は `null` を返します。
`min`	なし	バケット内のドキュメントについて、指定されたフィールドの最小値を返します。
`max`	なし	バケット内のドキュメントについて、指定されたフィールドの最大値を返します。
`first`	なし	クエリのソートオプションで定義された順序に従って、バケット内の最初のドキュメントの指定されたフィールドの値を返します。クエリでソートが指定されていない場合、順序は任意です。ソートを指定する方法を学ぶには、MongoDB Search結果のソートを参照してください。
`last`	なし	クエリのソートオプションで定義された順序に従って、バケット内の最後のドキュメントの指定されたフィールドの値を返します。クエリでソートが指定されていない場合、順序は任意です。ソートを指定する方法を学ぶには、MongoDB Search結果のソートを参照してください。

重要

min また、maxはtokenを含むすべてのフィールドタイプをサポートしています。MongoDB Searchがこれらのメトリクスを計算する際、フィールドがサポートされていない型に解決されるドキュメントはスキップされます。MongoDB Searchは、ドキュメントをスキップしてもエラーを返しません。MongoDB Searchがバケット内のドキュメントをスキップしたかどうかを確認するには、同じaggregationsドキュメントにcountメトリクスを追加し、期待されるドキュメント数と比較します。

For values that MongoDB Search doesn't skip, min selects the smallest value in the bucket and max selects the largest. If the values aren't all of the same type, MongoDB Search applies BSON type comparison order to determine which value is smallest or largest.

配列の考慮事項

各メトリクスタイプは、配列のように複数の値に解決されるフィールドをそれぞれ異なる方法で取り扱います。

sum および avg ドキュメントをスキップします。
min そして max 配列内の最小値と最大値を選択し、ドキュメントの代表要素として使用します。
first および last は、すべての値を配列として返します。

first および last の場合、返される配列は、次の点でソースドキュメントと異なります。

値の順序は異なる場合があります。MongoDB Searchはインデックスから値を読み取りますが、これはソースドキュメントの順序を保持しません。例として、ドキュメントに["red", "blue", "green"]が含まれている場合、MongoDB Searchは["blue", "green", "red"]を返す可能性があります。
MongoDB Searchは、重複する値のインスタンスを1つだけ返します。
MongoDB Searchは、ファセットに使用できない型の値を含め、パスにあるすべての値を返します。例として、配列に文字列とブール値の両方が含まれている場合、MongoDB Searchは文字列とともにブール値を返します。

ソースドキュメントに含まれているとおりに値を返すには、インデックス定義でフィールドの storedSource を定義し、クエリで returnStoredSource を true に設定します。

ネストされたファセット

重要

Nested facets is in Preview. The feature and corresponding documentation might change at any time during the Preview period. To learn more, see Preview Features.

To group the documents in each bucket by additional fields, add a facets document to an existing facet definition. Each nested facet definition uses the same syntax as a top-level facet definition, so you can nest facets to build a tree of groupings. MongoDB Search returns the buckets for a nested facet inside each bucket of its parent facet.

For each bucket of a facet that contains a nested facet, MongoDB Search also returns a count field with the number of documents in the bucket. You don't need to specify a count metric for these intermediate buckets.

You can nest facets without limit on the number of levels. However, the following restrictions apply:

aggregations は、ネストされたファセットツリーのリーフファセットでのみ指定できます。facets を指定するファセット定義では、aggregations を指定することもできません。中間グループ化のメトリクスを計算するには、そのグループ化を aggregations を持つ個別のトップレベルファセットとして指定し、ネストされたファセットは指定しません。
You can't name a nested facet count. MongoDB Search reserves count for the document count of intermediate buckets.
クエリが返すことができる一意のバケットの総数は、100000を超えることはできません。1つのファセットツリーが生成するバケットを計算するには、そのネストされたブランチの各レベルにあるバケットの数を掛け合わせます。レベルごとのバケット数は、string ファセットの場合は numBuckets、数値または日付ファセットの場合は boundaries と default で定義されるバケット数になります。例として、20個のバケットをリクエストし、20個のバケットをリクエストするネストされたファセットを含むファセットは、400個の一意のバケットを生成します。各レベルでこの合計が乗算されるため、各レベルでより多くのバケットをリクエストすると、ネストできるレベルの数が減ります。

ファセット結果

ファセットクエリの場合、 MongoDB Search は、定義されたファセット名と、そのファセットのバケットの配列とのマッピングを結果に返します。ファセット結果ドキュメントには、ファセットの結果バケットの配列である buckets オプションが含まれています。配列内の各ファセットバケットドキュメントには、次のフィールドがあります。

オプション	タイプ	説明
`_id`	オブジェクト	このファセットバケットを識別するユニークな識別子。この値は、ファセットされるデータ型と一致します。
`count`	整数	このファセットバケット内のドキュメントの数。`count`フィールドの詳細については、 MongoDB検索結果のカウントを参照してください。

If the facet definition specifies Facet Aggregations, each bucket document contains the metrics that you name in the aggregations document instead of the count field. If the facet definition specifies nested facets, each bucket document contains a count field with the number of documents in the bucket, and the results for the nested facet.

複数選択ファセット

MongoDB Search を使用すると、同じファセット内の複数のバケットを同時に表示および選択できます。通常、ファセット内でバケットを選択すると、その選択に従って検索結果がフィルタリングされ、すべてのファセットのカウントが変更されます。

例

sample_airbnb.listingsコレクションのインデックス定義で、次のフィールドのファセットが指定されているとします。

cancellation_policy
room_type
accommodates

cancellation_policyファセットには次のバケットがあります。

flexible
moderate
strict_14_with_grace_period
super_strict_30
super_strict_60

各バケットには、独自の結果カウントがあります。moderate cancellation_policy を検索すると、他の 4 つのバケットのカウントは 0 になります。さらに、room_type ファセットと accommodates ファセットのバケットのカウントは、同様に flexiblecancellation_policy を持つ各バケットの結果の数に減ります。

ファセットが検索結果のカウントに与える影響をより細かく制御する必要があるシナリオでは、ファセットクエリで doesNotAffectプロパティを使用して複数選択のファセットを有効にします。これらのファセットは引き続き結果をフィルタリングしますが、クエリは結果数を変更しません。

以下の演算子で doesNotAffect を指定できます。

複数のファセットを除外するには、ファセット名の配列を指定します。ほとんどのユースケースでは、フィルターとパスを共有するファセットのみを除外します。例として、rating フィールドに対する equals フィルターは、rating をパスとして使用するファセットの名前を指定します。

注意

The doesNotAffect option doesn't work with facets that specify aggregations. To learn more, see Limitations.

例

moderate cancellation_policy があるドキュメントのsample_airbnb.listingsAndReviews コレクションに対するクエリを検討します。doesNotAffect の値を cancellation_policy に指定すると、cancellation_policy ファセットのバケットのカウントは変更されませんが、他のファセットのバケットの結果カウントは、同様に moderatecancellation_policy を持つ各バケットの結果の数に減ります。

詳細については、複数選択ファセットの例を参照してください。

You can't combine doesNotAffect with an embeddedDocument-scoped facet. To learn more, see Facet on Matching Children of an Embedded Documents Array.

最後に、多くのファセットを持つユースケースでは、特定のファセットに影響する他のフィルターを制限できます。これを行うには、他のフィールドのファセットを含め、任意のフィルターの doesNotAffect プロパティで任意のファセットを指定します。これにより、どの選択がより迅速に、またはより緩やかに選択肢を絞り込むかを一目で確認できます。

例

accommodates 値が 3 であるドキュメントの sample_airbnb.listingsAndReviews コレクションに対するクエリを検討します。doesNotAffect の値として cancellation_policy を指定した場合、room_type バケットの結果数は、3 人も収容できる各バケット内の結果数に減少しますが、cancellation_policy のバケットの結果数は影響を受けません。

詳細については、「ファセット間フィルター除外の例」を参照してください。

`SEARCH_META` 集計変数

When you run your query using the $search stage, MongoDB Search stores the metadata results in the $$SEARCH_META variable and returns only the search results. You can use the $$SEARCH_META variable in all the supported aggregation pipeline stages to view the metadata results for your $search query. You can also use the $$SEARCH_META variable with facet.aggregations.

MongoDB では、検索結果とメタデータ結果の両方が必要な場合にのみ $$SEARCH_META 変数を使用することを推奨します。それ以外の場合は、次を使用します。

$search ステージを使用して、検索結果のみを取得します。
$searchMeta ステージを使用して、メタデータ結果のみを取得します。

制限

ファセットクエリは単一のフィールドに対してのみ実行できます。フィールドのグループに対してファセットクエリを実行することはできません。

埋め込みスコープのファセットの制限事項

The following limitations apply to Facet on Matching Children of an Embedded Documents Array:

同じクエリ内で、トップレベルの returnScope オプションと embeddedDocument スコープのファセットを結合することはできません。
embeddedDocumentスコープのファセットはカウントのみを返します。
ドリルサイドウェイズファセット（doesNotAffect）とembeddedDocumentスコープのファセットを同じクエリで組み合わせることはできません。

ファセット集計の制限事項

The following limitations apply to Facet Aggregations:

aggregations では、次のオプションは使用できません。
- returnScope
- doesNotAffect for Multi-Select Facets
You can't facet or compute aggregations on the following BSON types:
- binData
- bool
- decimal
- null
- objectId
- timestamp
To compute metrics over one of these types, use a view to convert the field to a supported type before you index it.

例

The following examples use the sample data. The metadata results example demonstrates how to run a $searchMeta query with facet to retrieve only the metadata in the results. The metadata and search results example demonstrates how to run a $search query with facet and the $SEARCH_META aggregation variable to retrieve both the search and metadata results. The returnScope example demonstrates how to facet on nested fields in an array of objects dynamically indexed using the embeddedDocuments type. The embedded-scoped facet example demonstrates how to facet on only the matching children of an embeddedDocuments array. The multi-select and inter-facet filter exclusion examples demonstrate how to use doesNotAffect to control how facets affect each other's counts. The aggregation example demonstrates how to compute metrics for each facet bucket, and the nested facet example demonstrates how to group results by a second field and compute metrics for each bucket.

sample_mflix.moviesコレクションのインデックス定義では、インデックスを作成するフィールドに対して次の内容を指定します。

フィールド名	データ型
`directors`	token
`year`	数値
`released`	date

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "directors": {
        "type": "token"
      },
      "year": {
        "type": "number"
      },
      "released": {
        "type": "date"
      }
    }
  }
}

次のクエリでは、01 年 2000 月 31 日から 2015 年月日の間に公開された映画を検索します。directors フィールドと year フィールドのメタデータをリクエストします。

1 db.movies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "range": {
7             "path": "released",
8             "gte": ISODate("2000-01-01T00:00:00.000Z"),
9             "lte": ISODate("2015-01-31T00:00:00.000Z")
10           }
11         },
12         "facets": {
13           "directorsFacet": {
14             "type": "string",
15             "path": "directors",
16             "numBuckets" : 7
17           },
18           "yearFacet" : {
19             "type" : "number",
20             "path" : "year",
21             "boundaries" : [2000,2005,2010, 2015]
22           }
23         }
24       }
25     }
26   }
27 ])

1 [
2   {
3     count: { lowerBound: Long('11922') },
4     facet: {
5       yearFacet: {
6         buckets: [
7           { _id: 2000, count: Long('3064') },
8           { _id: 2005, count: Long('4035') },
9           { _id: 2010, count: Long('4553') }
10         ]
11       },
12       directorsFacet: {
13         buckets: [
14           { _id: 'Takashi Miike', count: Long('26') },
15           { _id: 'Johnnie To', count: Long('20') },
16           { _id: 'Steven Soderbergh', count: Long('18') },
17           { _id: 'Michael Winterbottom', count: Long('16') },
18           { _id: 'Ridley Scott', count: Long('15') },
19           { _id: 'Tyler Perry', count: Long('15') },
20           { _id: 'Clint Eastwood', count: Long('14') }
21         ]
22       }
23     }
24   }
25 ]

sample_mflix.movies コレクション内にある次のアイテムがカウントされて、結果に表示されます。

MongoDB Search によりクエリに返された、2000（下限）から 2015（排他的上限）の間の映画の本数
MongoDB Search によりクエリに返された、各役員の映画の本数

これらの結果の詳細については、「ファセット結果」を参照してください。

sample_mflix.moviesコレクションのインデックス定義では、インデックスを作成するフィールドに対して次の内容を指定します。

フィールド名	データ型
`genres`	token
`released`	date

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "genres": {
        "type": "token"
      },
      "released": {
        "type": "date"
      }
    }
  }
}

The following query searches for movies released near July 01, 1999 using the $search stage. The query includes a $facet stage to process the input documents using the following sub-pipeline stages:

$project stage to exclude all fields in the documents except the title and released fields in the docs output field
$limit ステージでは、次を実行できます。
- $search ステージ出力を 2 ドキュメントに制限します
- meta 出力フィールドの 1 ドキュメントへの出力を制限します
注意
結果が 16 MB のドキュメントに収まるように、制限を小さくする必要があります。
$replaceWith stage to include the metadata results stored in the $$SEARCH_META variable in the meta output field

The query also includes a $set stage to add the meta field.

注意

次のクエリのメタデータ結果を表示するには、 MongoDB Search がクエリに一致するドキュメントを返す必要があります。

1 db.movies.aggregate([
2  {
3    "$search": {
4      "facet": {
5        "operator": {
6          "near": {
7            "path": "released",
8            "origin": ISODate("1999-07-01T00:00:00.000+00:00"),
9            "pivot": 7776000000
10          }
11        },
12        "facets": {
13          "genresFacet": {
14            "type": "string",
15            "path": "genres"
16          }
17        }
18      }
19    }
20  },
21  { "$limit": 2 },
22  {
23    "$facet": {
24      "docs": [
25        { "$project":
26          {
27            "title": 1,
28            "released": 1
29          }
30        }
31      ],
32      "meta": [
33        {"$replaceWith": "$$SEARCH_META"},
34        {"$limit": 1}
35      ]
36    }
37  },
38  {
39    "$set": {
40      "meta": {
41        "$arrayElemAt": ["$meta", 0]
42      }
43    }
44  }
45 ])

1 [
2  {
3    docs: [
4      {
5        _id: ObjectId('573a1393f29313caabcde1ae'),
6        title: 'Begone Dull Care',
7        released: ISODate('1999-07-01T00:00:00.000Z')
8      },
9      {
10        _id: ObjectId('573a13a9f29313caabd2048a'),
11        title: 'Fara'                released: ISODate('1999-07-01T00:00:00.000Z')
12      }
13    ],
14    meta: {
15      count: { lowerBound: Long('20878') },
16      facet: {
17        genresFacet: {
18          buckets: [
19            { _id: 'Drama', count: Long('12149') },
20            { _id: 'Comedy', count: Long('6436') },
21            { _id: 'Romance', count: Long('3274') },
22            { _id: 'Crime', count: Long('2429') },
23            { _id: 'Thriller', count: Long('2400') },
24            { _id: 'Action', count: Long('2349') },
25            { _id: 'Adventure', count: Long('1876') },
26            { _id: 'Documentary', count: Long('1755') },
27            { _id: 'Horror', count: Long('1432') },
28            { _id: 'Biography', count: Long('1244') }
29          ]
30        }
31      }
32    }
33  }
34 ]

これらの結果の詳細については、「ファセット結果」を参照してください。

sample_training.companies コレクションのインデックス定義は、funding_rounds フィールドを embeddedDocuments 型としてインデックスします。funding_rounds オブジェクト配列内のすべてのフィールドに動的にインデックスを付け、storedSourceオプションを使用してfunding_rounds オブジェクト配列内にraised_currency_code とraised_amount フィールドを保存します。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "funding_rounds": {
        "type": "embeddedDocuments",
        "dynamic": true,
        "storedSource": {
          "include": [
            "raised_currency_code",
            "raised_amount"
          ]
        }
      }
    }
  }
}

以下のクエリでは、

text（MongoDB Search 演算子）を使用して、USDで調達された資金を検索します。
returnScope オプションを使用して、クエリコンテキストをfunding_rounds という名前のembeddedDocuments フィールドに設定します。returnScope を使用すると、クエリは以下を実行します。
- 保存されたソースフィールドを返すために必要な returnStoredSource オプションを指定します。
funding_rounds オブジェクト配列のraised_amount フィールド内のファセット。クエリでは 3 つのバケットを指定します。
- 5000000 （このバケットの下限値を含む）
- 5250000: 5000000 バケットの排他的上限であり、このバケットの下限
- 5500000: 5250000 の排他的上限

1 db.companies.aggregate([
2  {
3    "$searchMeta": {
4      "returnStoredSource": true,
5      "returnScope": {
6        "path": "funding_rounds"
7      },
8      "facet": {
9        "operator": {
10          "text": {
11            "path": "funding_rounds.raised_currency_code",
12            "query": "USD"
13          }
14        },
15        "facets": {
16          "raisedAmountFacet": {
17            "type": "number",
18            "path": "funding_rounds.raised_amount",
19            "boundaries": [5000000, 5250000, 5500000]
20          }
21        }
22      }
23    }
24  }
25 ])

1 [
2   {
3     count: { lowerBound: Long('5329') },
4     facet: {
5       raisedAmountFacet: {
6         buckets: [
7           { _id: 5000000, count: Long('251') },
8           { _id: 5250000, count: Long('32') }
9         ]
10       }
11     }
12   }
13 ]

前述の MongoDB Search の結果では、ファセット数は親ではなく、埋め込まれた子ドキュメントに基づいています。

sample_training.companies コレクションのインデックス定義は、funding_rounds フィールドを embeddedDocuments 型としてインデックスし、各資金調達ラウンドの round_code フィールドと raised_currency_code フィールドを token としてインデックスします。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "name": {
        "type": "token"
      },
      "funding_rounds": {
        "type": "embeddedDocuments",
        "dynamic": false,
        "fields": {
          "round_code": {
            "type": "token"
          },
          "raised_currency_code": {
            "type": "token"
          }
        }
      }
    }
  }
}

KickAppsTopix、StumbleUpon、USDにはそれぞれいくつかの資金調達ラウンドがありますが、その一部のみがで調達されました。

// KickApps
{ "name": "KickApps",
  "funding_rounds": [
    { "round_code": "a", "raised_currency_code": "USD" },
    { "round_code": "b", "raised_currency_code": "USD" },
    { "round_code": "c", "raised_currency_code": "GBP" }
  ]
}
// Topix
{ "name": "Topix",
  "funding_rounds": [
    { "round_code": "a", "raised_currency_code": null },
    { "round_code": "b", "raised_currency_code": "USD" }
  ]
}
// StumbleUpon
{ "name": "StumbleUpon",
  "funding_rounds": [
    { "round_code": "seed", "raised_currency_code": "USD" },
    { "round_code": "a", "raised_currency_code": null },
    { "round_code": "b", "raised_currency_code": "USD" },
    { "round_code": "angel", "raised_currency_code": null }
  ]
}

次のクエリでは、in 演算子を使用してファセットをこれら3つの会社に制限し、次に funding_rounds.round_code でファセット化します。roundFacet 定義は、raised_currency_code が USD である資金調達ラウンドのみにファセットをスコープする embeddedDocument ブロックを指定します。

1 db.companies.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "in": {
7             "path": "name",
8             "value": ["KickApps", "Topix", "StumbleUpon"]
9           }
10         },
11         "facets": {
12           "roundFacet": {
13             "type": "string",
14             "path": "funding_rounds.round_code",
15             "embeddedDocument": {
16               "path": "funding_rounds",
17               "operator": {
18                 "equals": {
19                   "path": "funding_rounds.raised_currency_code",
20                   "value": "USD"
21                 }
22               }
23             }
24           }
25         }
26       }
27     }
28   }
29 ])

1 [
2   {
3     count: { lowerBound: Long('3') },
4     facet: {
5       roundFacet: {
6         buckets: [
7           { _id: 'b', count: Long('3') },
8           { _id: 'a', count: Long('1') },
9           { _id: 'seed', count: Long('1') }
10         ]
11       }
12     }
13   }
14 ]

各会社は、USDで少なくとも1回の資金調達ラウンドを実施したラウンドコードごとに1回カウントされます。

b 3件のカウント：KickApps、Topix、StumbleUponはそれぞれ、USDにbラウンドの資金調達を行いました。
a カウント 1: KickApps のみが USD に a ラウンドを調達しています。Topix と StumbleUpon の a ラウンドには記録された通貨がないため、一致しません。
seed カウント 1: StumbleUpon の seed ラウンドは USD に調達されました。

KickAppsのcラウンドは、USDではなくGBPで調達されたため、cバケットには寄与しません。embeddedDocumentブロックがない場合、funding_rounds.round_codeでファセットを行うには、代わりにfunding_roundsをドキュメントタイプとしてインデックスを作成する必要があります。また、スコープなしのファセットでは、ルートドキュメントが通貨に関係なくそのバケットに一致する子を持っているため、KickAppsもcバケットにカウントされます。

次の sample_airbnb.listingsAndReviews コレクションのインデックス定義は、すべての動的にインデックス可能なフィールドを自動的にインデックスし、cancellation_policy、room_type、price フィールドをファセット検索用に設定します。

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "cancellation_policy": {
        "type": "token"
      },
      "room_type": {
        "type": "token"
      },
      "accommodates": {
        "type": "number"
      }
    }
  }
}

次のクエリは、 $searchMetaステージを使用して次のアクションを実行します。

cancellation_policy、roomType、accommodatesフィールドのファセット。

cancellation_policyファセットには次のバケットがあります。
- "strict_14_with_grace_period"
- "moderate"
- "flexible"
- "super_strict_30"
- "super_strict_60"
room_typeファセットには次のバケットがあります。
- "Entire home/apt"
- "Private room"
- "Shared room"
このクエリは、accommodatesファセットを次のバケットに分割します。
- 1（このバケットの下限値を含む）
- 2、1 バケットの上限（排他的）であり、このバケットの下限（包括的）。
- 4、2 バケットの上限（排他的）であり、このバケットの下限（包括的）。
- 8（4 バケットの排他的上限）
compoundにテキストを含む必要があるリストをnew york city description演算子で検索し、リストの結果をmoderatecancellation_policy でフィルターします。doesNotAffect 設定により、moderate cancellation_policy によるフィルターによってファセット内の他のバケットのカウントは変更されなくなります。 "strict_14_with_grace_period"、"flexible"、"super_strict_30"、"super_strict_60" のカウントはゼロ以外の値です。

1 db.listingsAndReviews.aggregate([
2   {
3     $searchMeta: {
4       facet: {
5         facets: {
6           accommodatesFacet: {
7             path: "accommodates",
8             type: "number",
9             boundaries: [1,2,4,8]
10           },
11           cancellationFacet: {
12             path: "cancellation_policy",
13             type: "string"
14           },
15           roomTypeFacet: {
16             path: "room_type",
17             type: "string"
18           }
19         },
20         operator: {
21           compound: {
22             must: [
23               {
24                 text: {
25                   path: "description",
26                   query: "new york city"
27                 },
28               },
29             ],
30             filter: [
31               {
32                 equals: {
33                   path: "cancellation_policy",
34                   value: "moderate",
35                   doesNotAffect:
36                     "cancellationFacet"
37                 }
38               }
39             ]
40           }
41         }
42       }
43     }
44   }
45 ])

1 [
2   {
3     count: { lowerBound: Long('531') },
4     facet: {
5       accommodatesFacet: {
6         buckets: [
7           { _id: 1, count: Long('25') },
8           { _id: 2, count: Long('270') },
9           { _id: 4, count: Long('204') }
10         ]
11       },
12       cancellationFacet: {
13         buckets: [
14           { _id: 'strict_14_with_grace_period', count: Long('849') },
15           { _id: 'moderate', count: Long('531') },
16           { _id: 'flexible', count: Long('380') },
17           { _id: 'super_strict_60', count: Long('25') },
18           { _id: 'super_strict_30', count: Long('11') }
19         ]
20       },
21       roomTypeFacet: {
22         buckets: [
23           { _id: 'Entire home/apt', count: Long('369') },
24           { _id: 'Private room', count: Long('159') },
25           { _id: 'Shared room', count: Long('3') }
26         ]
27       }
28     }
29   }
30 ]

cancellationFacet のバケットのカウントは、クエリフィルターが moderate の値に設定されているにもかかわらず、ゼロに削減されません。

sample_airbnb.listingsAndReviewsコレクションの次のインデックス定義は、cancellation_policy、room_type、price フィールドにインデックスを作成し、ファセット検索を有効にします。

{
  "mappings": {
    "dynamic": true,
    "fields": {
      "cancellation_policy": {
        "type": "token"
      },
      "room_type": {
        "type": "token"
      },
      "accommodates": {
        "type": "number"
      }
    }
  }
}

以下のクエリでは、

description において new york city のテキストを含み、moderate の cancellation_policy を持つリスティングを検索します。
cancellation_policy、roomType、accommodatesフィールドのファセット。

cancellation_policy および roomType ファセットにはそれぞれ3つのバケットがあり、コレクション全体のこれらのフィールドの3つの一意の値に対応します。このクエリは、accommodates ファセットを以下のバケットに分割します。
- 1（このバケットの下限値を含む）
- 2、1 バケットの上限（排他的）であり、このバケットの下限（包括的）。
- 4、2 バケットの上限（排他的）であり、このバケットの下限（包括的）。
- 8（4 バケットの排他的上限）
compound.filter の equals 演算子で doesNotAffect プロパティを accommodatesFacet に設定します。これにより、accommodates ファセット内のバケットがフィルター処理から除外されます。その結果、moderate cancellation_policy でのフィルタリングにより、cancellation_policy ファセットの他のバケットのカウントが 0 に減少し、roomType ファセットのバケットのカウントが減少しますが、accommodates ファセットのバケットのカウントは変更されません。これにより、さまざまなファセットに対するフィルターの影響を比較できます。

1 db.listingsAndReviews.aggregate([
2   {
3     $searchMeta: {
4       facet: {
5         facets: {
6           accommodatesFacet: {
7             path: "accommodates",
8             type: "number",
9             boundaries: [1,2,4,8],
10           },
11           cancellationFacet: {
12             path: "cancellation_policy",
13             type: "string",
14           },
15           roomTypeFacet: {
16             path: "room_type",
17             type: "string",
18           }
19         },
20         operator: {
21           compound: {
22             must: [
23               {
24                 text: {
25                   path: "description",
26                   query: "new york city",
27                 },
28               },
29             ],
30             filter: [
31               {
32                 equals: {
33                   path: "cancellation_policy",
34                   value: "moderate",
35                   doesNotAffect:
36                     "accommodatesFacet",
37                 },
38               },
39             ],
40           },
41         },
42       },
43     },
44   },
45 ]

1 [
2   {
3     count: { lowerBound: Long('531') },
4     facet: {
5       accommodatesFacet: {
6         buckets: [
7           { _id: 1, count: Long('141') },
8           { _id: 2, count: Long('834') },
9           { _id: 4, count: Long('703') }
10         ]
11       },
12       cancellationFacet: {
13         buckets: [
14           { _id: 'moderate', count: Long('531') }
15         ]
16       },
17       roomTypeFacet: {
18         buckets: [
19           { _id: 'Entire home/apt', count: Long('369') },
20           { _id: 'Private room', count: Long('159') },
21           { _id: 'Shared room', count: Long('3') }
22         ]
23       }
24     }
25   }
26 ]

次の例では、sample_airbnb.listingsAndReviews コレクションで default という名前のインデックスを使用します。コレクション内の property_type フィールドと amenities フィールドはトークン型としてインデックス付けされ、accommodates フィールドは数値型としてインデックス付けされます。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "property_type": [
        {
          "type": "token"
        }
      ],
      "amenities": [
        {
          "type": "token"
        }
      ],
      "accommodates": [
        {
          "type": "number"
        }
      ]
    }
  }
}

このクエリでは、$searchMetaステージを使用して、指定されたアメニティの少なくとも1つを提供するリスティングを見つけ、それらをproperty_typeでグループ化します。各プロパティタイプについて、クエリはリスティングの数と、リスティングが収容できる最小および最大のゲスト数を計算します。

1 db.listingsAndReviews.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "operator": {
6           "in": {
7             "path": "amenities",
8             "value": ["Wifi", "Pets allowed", "Wheelchair accessible"]
9           }
10         },
11         "facets": {
12           "propertyTypeFacet": {
13             "type": "string",
14             "path": "property_type",
15             "aggregations": {
16               "listingCount": {
17                 "type": "count"
18               },
19               "minAccommodates": {
20                 "type": "min",
21                 "path": "accommodates"
22               },
23             "maxAccommodates": {
24                 "type": "max",
25                 "path": "accommodates"
26               }
27             }
28           }
29         }
30       }
31     }
32   }
33 ])

[
  {
    count: { lowerBound: Long('5355') },
    facet: {
      propertyTypeFacet: {
        buckets: [
          {
            _id: 'Apartment',
            listingCount: Long('3488'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'House',
            listingCount: Long('584'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Condominium',
            listingCount: Long('386'),
            minAccommodates: 1,
            maxAccommodates: 12
          },
          {
            _id: 'Serviced apartment',
            listingCount: Long('182'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Loft',
            listingCount: Long('139'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Townhouse',
            listingCount: Long('104'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Guest suite',
            listingCount: Long('79'),
            minAccommodates: 1,
            maxAccommodates: 8
          },
          {
            _id: 'Bed and breakfast',
            listingCount: Long('64'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Boutique hotel',
            listingCount: Long('51'),
            minAccommodates: 1,
            maxAccommodates: 16
          },
          {
            _id: 'Guesthouse',
            listingCount: Long('49'),
            minAccommodates: 1,
            maxAccommodates: 8
          }
        ]
      }
    }
  }
]

次の例では、sample_airbnb.listingsAndReviews コレクションで default という名前のインデックスを使用します。コレクション内の property_type フィールドはトークン型としてインデックス付けされ、bedrooms フィールドと accommodates フィールドは数値型としてインデックス付けされます。

{
  "mappings": {
    "dynamic": false,
    "fields": {
      "property_type": [
        {
          "type": "token"
        }
      ],
      "bedrooms": [
        {
          "type": "number"
        }
      ],
      "accommodates": [
        {
          "type": "number"
        }
      ]
    }
  }
}

The query groups the listings by property_type, and then groups the listings in each property type by number of bedrooms (0, 2, or 4). The query computes the number of listings and the largest number of guests that a listing accommodates for each bedroom range.

1 db.listingsAndReviews.aggregate([
2   {
3     "$searchMeta": {
4       "facet": {
5         "facets": {
6           "propertyTypeFacet": {
7             "type": "string",
8             "path": "property_type",
9             "facets": {
10               "bedroomsFacet": {
11                 "type": "number",
12                 "path": "bedrooms",
13                 "boundaries": [0, 2, 4],
14                 "default": "other",
15                 "aggregations": {
16                   "listingCount": {
17                     "type": "count"
18                   },
19                   "maxAccommodates": {
20                     "type": "max",
21                     "path": "accommodates"
22                   }
23                 }
24               }
25             }
26           }
27         }
28       }
29     }
30   }
31 ])

[
  {
    count: { lowerBound: Long('5555') },
    facet: {
      propertyTypeFacet: {
        buckets: [
          {
            _id: 'Apartment',
            count: { total: Long('3626') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('2534'), maxAccommodates: 12 },
                { _id: 2, listingCount: Long('1006'), maxAccommodates: 13 },
                { _id: 'other', listingCount: Long('86'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'House',
            count: { total: Long('606') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('312'), maxAccommodates: 16 },
                { _id: 2, listingCount: Long('183'), maxAccommodates: 16 },
                { _id: 'other', listingCount: Long('111'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Condominium',
            count: { total: Long('399') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('256'), maxAccommodates: 10 },
                { _id: 2, listingCount: Long('138'), maxAccommodates: 11 },
                { _id: 'other', listingCount: Long('5'), maxAccommodates: 12 }
              ]
            }
          },
          {
            _id: 'Serviced apartment',
            count: { total: Long('185') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('128'), maxAccommodates: 7 },
                { _id: 2, listingCount: Long('53'), maxAccommodates: 12 },
                { _id: 'other', listingCount: Long('4'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Loft',
            count: { total: Long('142') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('123'), maxAccommodates: 16 },
                { _id: 2, listingCount: Long('15'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('4'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Townhouse',
            count: { total: Long('108') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('59'), maxAccommodates: 8 },
                { _id: 2, listingCount: Long('42'), maxAccommodates: 10 },
                { _id: 'other', listingCount: Long('7'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Guest suite',
            count: { total: Long('81') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('68'), maxAccommodates: 7 },
                { _id: 2, listingCount: Long('12'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('1'), maxAccommodates: 8 }
              ]
            }
          },
          {
            _id: 'Bed and breakfast',
            count: { total: Long('69') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('61'), maxAccommodates: 12 },
                { _id: 2, listingCount: Long('6'), maxAccommodates: 9 },
                { _id: 'other', listingCount: Long('2'), maxAccommodates: 16 }
              ]
            }
          },
          {
            _id: 'Boutique hotel',
            count: { total: Long('53') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('47'), maxAccommodates: 16 },
                { _id: 2, listingCount: Long('5'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('1'), maxAccommodates: 15 }
              ]
            }
          },
          {
            _id: 'Guesthouse',
            count: { total: Long('50') },
            bedroomsFacet: {
              buckets: [
                { _id: 0, listingCount: Long('43'), maxAccommodates: 8 },
                { _id: 2, listingCount: Long('7'), maxAccommodates: 6 },
                { _id: 'other', listingCount: Long('0'), maxAccommodates: null }
              ]
            }
          }
        ]
      }
    }
  }
]

MongoDB Search returns the following information for each facet bucket:

The number of listings (count) in the bucket (such as Apartment, House, and so on).
The maximum number of guests that a listing in the bucket range (0 bedrooms, 2 bedrooms, and so on) accommodates (maxAccommodates).

学び続ける

詳しくは、 MongoDB Searchでファセットの使用方法を参照してください。

You can learn more about facet (MongoDB Search Operator) in MongoDB Search with our course and video.

コースで学ぶ

To learn more about using facets in MongoDB Search, take Unit 9 of the Intro To MongoDB Course on MongoDB University. The 1.5 hour unit includes an overview of MongoDB Search and lessons on creating MongoDB Search indexes, running $search queries using compound operators, and grouping results using facet.

ビデオで学ぶ

Watch this video to learn about how you can create and use a numeric and string facet (MongoDB Search Operator) in your query to group results and retrieve a count of the results in the groups.

所要時間: 11 分

戻る

exists

geoShape

1	db.movies.aggregate([
2	{
3	"$searchMeta": {
4	"facet": {
5	"operator": {
6	"range": {
7	"path": "year",
8	"gte": 2000,
9	"lte": 2015
10	}
11	},
12	"facets": {
13	"genresFacet": {
14	"type": "string",
15	"path": "genres"
16	}
17	}
18	}
19	}
20	}
21	])

1	[
2	{
3	count: { lowerBound: Long('12568') },
4	facet: {
5	genresFacet: {
6	buckets: [
7	{ _id: 'Drama', count: Long('7079') },
8	{ _id: 'Comedy', count: Long('3689') },
9	{ _id: 'Romance', count: Long('1764') },
10	{ _id: 'Thriller', count: Long('1584') },
11	{ _id: 'Documentary', count: Long('1472') },
12	{ _id: 'Action', count: Long('1471') },
13	{ _id: 'Crime', count: Long('1367') },
14	{ _id: 'Adventure', count: Long('1056') },
15	{ _id: 'Horror', count: Long('866') },
16	{ _id: 'Biography', count: Long('796') }
17	]
18	}
19	}
20	}
21	]

1	[
2	{
3	count: { lowerBound: Long('6095') },
4	facet: {
5	yearFacet: {
6	buckets: [
7	{ _id: 1980, count: Long('1956') },
8	{ _id: 1990, count: Long('3558') },
9	{ _id: 'other', count: Long('581') }
10	]
11	}
12	}
13	}
14	]

1	[
2	{
3	count: { lowerBound: Long('11922') },
4	facet: {
5	yearFacet: {
6	buckets: [
7	{
8	_id: ISODate('2000-01-01T00:00:00.000Z'),
9	count: Long('3028')
10	},
11	{
12	_id: ISODate('2005-01-01T00:00:00.000Z'),
13	count: Long('3953')
14	},
15	{
16	_id: ISODate('2010-01-01T00:00:00.000Z'),
17	count: Long('4832')
18	},
19	{ _id: 'other', count: Long('109') }
20	]
21	}
22	}
23	}
24	]

1	db.movies.aggregate([
2	{
3	"$search": {
4	"facet": {
5	"operator": {
6	"near": {
7	"path": "released",
8	"origin": ISODate("1999-07-01T00:00:00.000+00:00"),
9	"pivot": 7776000000
10	}
11	},
12	"facets": {
13	"genresFacet": {
14	"type": "string",
15	"path": "genres"
16	}
17	}
18	}
19	}
20	},
21	{ "$limit": 2 },
22	{
23	"$facet": {
24	"docs": [
25	{ "$project":
26	{
27	"title": 1,
28	"released": 1
29	}
30	}
31	],
32	"meta": [
33	{"$replaceWith": "$$SEARCH_META"},
34	{"$limit": 1}
35	]
36	}
37	},
38	{
39	"$set": {
40	"meta": {
41	"$arrayElemAt": ["$meta", 0]
42	}
43	}
44	}
45	])

1	[
2	{
3	docs: [
4	{
5	_id: ObjectId('573a1393f29313caabcde1ae'),
6	title: 'Begone Dull Care',
7	released: ISODate('1999-07-01T00:00:00.000Z')
8	},
9	{
10	_id: ObjectId('573a13a9f29313caabd2048a'),
11	title: 'Fara' released: ISODate('1999-07-01T00:00:00.000Z')
12	}
13	],
14	meta: {
15	count: { lowerBound: Long('20878') },
16	facet: {
17	genresFacet: {
18	buckets: [
19	{ _id: 'Drama', count: Long('12149') },
20	{ _id: 'Comedy', count: Long('6436') },
21	{ _id: 'Romance', count: Long('3274') },
22	{ _id: 'Crime', count: Long('2429') },
23	{ _id: 'Thriller', count: Long('2400') },
24	{ _id: 'Action', count: Long('2349') },
25	{ _id: 'Adventure', count: Long('1876') },
26	{ _id: 'Documentary', count: Long('1755') },
27	{ _id: 'Horror', count: Long('1432') },
28	{ _id: 'Biography', count: Long('1244') }
29	]
30	}
31	}
32	}
33	}
34	]

1	db.companies.aggregate([
2	{
3	"$searchMeta": {
4	"returnStoredSource": true,
5	"returnScope": {
6	"path": "funding_rounds"
7	},
8	"facet": {
9	"operator": {
10	"text": {
11	"path": "funding_rounds.raised_currency_code",
12	"query": "USD"
13	}
14	},
15	"facets": {
16	"raisedAmountFacet": {
17	"type": "number",
18	"path": "funding_rounds.raised_amount",
19	"boundaries": [5000000, 5250000, 5500000]
20	}
21	}
22	}
23	}
24	}
25	])

1	[
2	{
3	count: { lowerBound: Long('5329') },
4	facet: {
5	raisedAmountFacet: {
6	buckets: [
7	{ _id: 5000000, count: Long('251') },
8	{ _id: 5250000, count: Long('32') }
9	]
10	}
11	}
12	}
13	]

1	[
2	{
3	count: { lowerBound: Long('3') },
4	facet: {
5	roundFacet: {
6	buckets: [
7	{ _id: 'b', count: Long('3') },
8	{ _id: 'a', count: Long('1') },
9	{ _id: 'seed', count: Long('1') }
10	]
11	}
12	}
13	}
14	]

1	db.listingsAndReviews.aggregate([
2	{
3	$searchMeta: {
4	facet: {
5	facets: {
6	accommodatesFacet: {
7	path: "accommodates",
8	type: "number",
9	boundaries: [1,2,4,8]
10	},
11	cancellationFacet: {
12	path: "cancellation_policy",
13	type: "string"
14	},
15	roomTypeFacet: {
16	path: "room_type",
17	type: "string"
18	}
19	},
20	operator: {
21	compound: {
22	must: [
23	{
24	text: {
25	path: "description",
26	query: "new york city"
27	},
28	},
29	],
30	filter: [
31	{
32	equals: {
33	path: "cancellation_policy",
34	value: "moderate",
35	doesNotAffect:
36	"cancellationFacet"
37	}
38	}
39	]
40	}
41	}
42	}
43	}
44	}
45	])

1	[
2	{
3	count: { lowerBound: Long('531') },
4	facet: {
5	accommodatesFacet: {
6	buckets: [
7	{ _id: 1, count: Long('25') },
8	{ _id: 2, count: Long('270') },
9	{ _id: 4, count: Long('204') }
10	]
11	},
12	cancellationFacet: {
13	buckets: [
14	{ _id: 'strict_14_with_grace_period', count: Long('849') },
15	{ _id: 'moderate', count: Long('531') },
16	{ _id: 'flexible', count: Long('380') },
17	{ _id: 'super_strict_60', count: Long('25') },
18	{ _id: 'super_strict_30', count: Long('11') }
19	]
20	},
21	roomTypeFacet: {
22	buckets: [
23	{ _id: 'Entire home/apt', count: Long('369') },
24	{ _id: 'Private room', count: Long('159') },
25	{ _id: 'Shared room', count: Long('3') }
26	]
27	}
28	}
29	}
30	]

facet （MongoDB Search 演算子）

定義

構文

フィールド

メモリ要件

ファセットの定義

文字列ファセット

構文

オプション

例

数値ファセット

構文

オプション

例

日付ファセット

構文

オプション

例

ファセットのフィールド型の比較

埋め込みドキュメントの配列の一致する子に対するファセット

ファセット集計

構文

オプション

メトリクス型

配列の考慮事項

ネストされたファセット

ファセット結果

複数選択ファセット

SEARCH_META 集計変数

制限

埋め込みスコープのファセットの制限事項

ファセット集計の制限事項

例

メタデータ結果の例チュートリアルの前の手順を完了し、依存関係をインストールします。

メタデータと検索結果の例$search を使用して検索し、$$SEARCH_META 変数を用いて検索結果とメタデータの両方を検索する。

returnScope 例embeddedDocuments 内の子フィールドでファセットとファセットを使用して検索します。

埋め込みスコープのファセットの例embeddedDocuments 配列の一致する子のみに対するファセット。

複数選択ファセットの例doesNotAffectを使用して検索すると、ファセットのフィルター処理をより詳細に制御できます。

ファセット間フィルター除外の例クエリ済みフィールド以外のファセットで doesNotAffect を使用して検索します。

集計の例ファセット集計を使用した検索。

ネストされたファセットの例ネストされたファセットを使用して検索します。

学び続ける

コースで学ぶ

ビデオで学ぶ

`facet` （MongoDB Search 演算子）

`SEARCH_META` 集計変数