`facet` （MongoDB搜索操作符）

定义

facet

facet 收集器按指定分面字段中的值或范围对结果进行分组，并返回每个组的计数。

您可将 facet 与 $search 和 $searchMeta 阶段一起使用。MongoDB 建议使用附带 $searchMeta 阶段的 facet 来仅检索查询的元数据结果。要使用 $search 阶段来检索元数据结果和查询结果，则须使用 $$SEARCH_META 聚合变量。请参阅 SEARCH_META 聚合变量以了解详情。

如果在 embeddedDocuments 字段类型定义中定义了 storedSource ，就可以使用 returnScope 和 returnStoredSource 对对象数组内的嵌套字段进行分面。否则，您只能在根 embeddedDocuments 类型字段上进行分面。关于分面的示例：

嵌套在对象数组内的字段，请参阅 returnScope 示例。
使用 embeddedDocument 匹配 embeddedDocuments 数组的子项，请参阅嵌入式作用域分面（Facet）示例。
根 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`	文档	是	用于对每个分面（Facet）的数据进行分桶的信息。您必须指定至少一个分面（Facet）定义。每个分面（Facet）定义还可以指定分面（Facet）聚合，以计算每个存储桶的指标。
`operator`	文档	no	用于执行分面（Facet）面操作的操作符。如果省略， MongoDB搜索将对集合中的所有文档执行分面（Facet）。

内存要求

无论您的集群层如何，分面（Facet）查询都是内存密集型的。指定分面（Facet）聚合或嵌套分面（Facet）的查询比其他分面（Facet）查询需要更多的内存和磁盘。在生产环境中使用分面（Facet）之前，请确认您的集群有足够的内存来处理您的工作负载。要了解更多信息，请参阅搜索内存管理。要获取工作负载的规模调整指导，请请求支持。

分面（Facet）查询所需的内存取决于您进行分面（Facet）的字段中的独特值数，而不是您使用 numBuckets 或 boundaries 请求的桶数。示例，在具有 500 万个独特值的字段上请求 20 个桶的分面（Facet）仍然会计算每个独特值，以确定前 20 个桶。

对于嵌套分面（Facet），查询中计算出的唯一值总数会根据每个嵌套级别的唯一值进行乘法运算。即使每个单独的字段具有较低的关联基数，嵌套路径上的值组合也可能产生大量的唯一存储桶。要了解有关嵌套分面（Facet）如何增加存储桶数量的更多信息，请参阅嵌套分面（Facet）。

MongoDB Search 会为每个查询分别追踪分面（Facet）计数，因此总内存使用量会随着并发分面（Facet）查询的数量而扩展。在分片集群上，MongoDB Search 还需要内存来合并来自每个分片的存储桶，这会随着分片的数量和存储桶的数量而扩展。

分面定义

分面（Facet）定义文档包含分面（Facet）名称和特定于分面（Facet）类型的选项。MongoDB Search 支持以下类型的分面：

字符串分面
数值分面
日期分面

字符串分面

重要

stringFacet 现已过时。请改用令牌，以改进分面（Facet）。

要详细了解分面（Facet）的更新和过时字段类型之间的区别，请参阅比较分面（Facet）的字段类型。

string 分面（Facet）允许您根据指定 string 字段中最常见的 string 值缩小 MongoDB Search 结果的范围。请注意，字符串字段必须建立索引为 token。要对嵌入式文档中的string字段进行分面（Facet），您还必须对要作为文档类型的父字段进行索引。当您在数组或嵌入式文档中对字符串进行分面（Facet）时，MongoDB Search 会根据匹配的根文档数量返回分面（Facet）计数。

语法

字符串分面采用以下语法：

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

选项

选项	类型	说明	必需？
`embeddedDocument`	对象	将分面（Facet）的存储桶计数范围限定为 `embeddedDocuments` 数组中与查询谓词匹配的子文档。要了解更多信息，请参阅对嵌入式文档数组的匹配子项进行分面（Facet）。	no
`numBuckets`	int	结果中要返回的最大分面（Facet）类别数量。值必须小于或等于 `10000`。如果指定，如果数据分组的类别数量少于您请求的数量，MongoDB Search 返回的类别数量可能少于请求的数量。如果省略，则默认为 `10` ，这意味着 MongoDB Search 将仅返回按计数排列靠前的 `10`分面（Facet）类别。	no
`path`	字符串	用于分面的字段路径。您可将被索引字段指定为 token。	是
`type`	字符串	分面类型。值必须是 `string`。	是

例子

以下示例将对 sample_mflix.movies 集合使用名为 default 的索引。集合中的 genres 字段被索引为 token 类型，而 year 字段被索引为 number 类型。

{
  "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 现已过时。请改用数字，以改进分面（Facet）。

要详细了解分面（Facet）的更新和过时字段类型之间的区别，请参阅比较分面（Facet）的字段类型。

数字分面允许您将搜索结果分解为不同的数字范围，从而确定数字值在搜索结果中的频率。当您对数组或嵌入式文档中的数字进行分面（Facet）时， MongoDB Search 会根据匹配的根文档的数量返回分面（Facet）计数。

语法

数字分面采用以下语法：

{
  "$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`	数字数组	按升序排列的数值列表，指定存储桶的边界。您必须指定介于 2 到 10,000 个 (`[2, 10000]`) 边界值。每对相邻的值定义一个存储桶，具有包含下限和不包含上限。您可以指定以下 BSON types值的任意组合： 32 位整数 (`int32`) 64 位整数 (`int64`) 64 位二进制浮点数 (`double`)	是
`default`	字符串	附加存储桶的名称，用于对从操作符返回的不属于指定边界的文档进行计数。如果省略， MongoDB Search 也会包含不属于指定存储桶的分面（Facet）操作符符的结果，但不将其包含在任何存储桶计数中。	no
`embeddedDocument`	对象	将分面（Facet）的存储桶计数范围限定为 `embeddedDocuments` 数组中与查询谓词匹配的子文档。要了解更多信息，请参阅对嵌入式文档数组的匹配子项进行分面（Facet）。	no
`path`	字符串	用于分面的字段路径。您可以指定一个已建立 number 类型索引的字段。	是
`type`	字符串	分面类型。值必须是 `number`。	是

例子

以下示例将对 sample_mflix.movies 集合使用名为 default 的索引。集合中的 year 字段被索引为 number 类型。

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

此查询使用 $searchMeta 阶段在 movies 集合中的 year 字段中搜索 1980 到 2000 年间的影片，并检索查询的元数据结果。此查询指定了三个存储桶：

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 现已过时。请改用日期，这样可以改进分面（Facet）。

要详细了解分面（Facet）的更新和过时字段类型之间的区别，请参阅比较分面（Facet）的字段类型。

日期分面允许您根据日期缩小搜索结果的范围。当您对数组或嵌入式文档中的日期进行分面（Facet）时， MongoDB Search 会根据匹配的根文档的数量返回分面（Facet）计数。

语法

日期分面采用以下语法：

{
  "$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, 10000]`) 值按升序排列，最早日期在最前面每对相邻的值都充当存储桶的包含下限和不包含上限。	是
`default`	字符串	附加存储桶的名称，用于对从操作符返回的不属于指定边界的文档进行计数。如果省略， MongoDB Search 也会包含不属于指定存储桶的分面（Facet）操作符符的结果，但MongoDB Search 不会将这些结果包含在任何存储桶计数中。	no
`embeddedDocument`	对象	将分面（Facet）的存储桶计数范围限定为 `embeddedDocuments` 数组中与查询谓词匹配的子文档。要了解更多信息，请参阅对嵌入式文档数组的匹配子项进行分面（Facet）。	no
`path`	字符串	用于分面的字段路径。您可将被索引字段指定为 date 类型。	是
`type`	字符串	分面类型。值必须是 `date`。	是

例子

以下示例将对 sample_mflix.movies 集合使用名为 default 的索引。集合中的 released 字段将索引为 date 类型。

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

此查询使用 $searchMeta 阶段在 movies 集合中的 released 字段中搜索 2000 到 2015 年间的影片，并检索查询的元数据结果。此查询指定了四个存储桶：

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 ]

要了解有关这些结果的更多信息，请参阅分面结果。

比较分面（Facet）的字段类型

与过时的类型（stringFacet、numberFacet、dateFacet）相比，更新的MongoDB搜索字段类型改进了支持分面（Facet）的功能。下表概述了功能上的主要区别：

分面（Facet）类别	更新的字段类型	过时的分面（Facet）类型	主要差异
字符串	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.
数值	数字	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` 类型考虑分面（Facet）存储桶数组中的值。示例，包含日期的数组值可以影响多个日期范围存储桶，而 `dateFacet` 会完全忽略数组值。

注意

当为同一字段定义过时和更新的字段类型时，过时的分面（Facet）类型优先。示例，如果为字段同时定义了 token 和 stringFacet，分面（Facet）计算将使用 stringFacet 映射。

对嵌入式文档数组的匹配子项进行分面（Facet）

每个分面（Facet）定义都可以包含一个可选的 embeddedDocument 字段，该字段将分面（Facet）的存储桶计数范围仅限于 embeddedDocuments 数组中与查询谓词匹配的子文档。如果省略 embeddedDocument 字段，则分面（Facet）是文档索引的。

如果没有 embeddedDocument，如果根文档有任何属于该存储桶的子文档，则该根文档会计入该存储桶，即使该子文档与 facet.operator 块中定义的查询不匹配。embeddedDocument 字段将存储桶贡献限制为仅与指定 embeddedDocument.operator 匹配的子项。它在每个存储桶中最多对每个根文档计数一次。

embeddedDocument 字段包含以下字段：

字段	类型	说明	必需？
`path`	字符串	索引 `embeddedDocuments` 类型字段，以将分面（Facet）限定在该字段内。分面（Facet）的 `path` 必须是此字段的后代。	是
`operator`	对象	在中指定的每个数组文档上运行的操作符`embeddedDocuments` `path`。只有匹配此操作符的子文档才会计入分面（Facet）的存储桶计数。此操作符中引用的每个路径都必须是 `path` 的后代。	是

对于数字或日期分面（Facet），如果指定了 default 存储桶，则其值超出配置的 boundaries 的匹配子项将计入该存储桶，规则与文档索引分面（Facet）相同。没有匹配子项的根文档不会计入 embeddedDocument 范围的分面（Facet），但仍可计入同一查询中的任何其他无范围分面（Facet）。

重要

您不能将 embeddedDocument 范围的分面（Facet）与其他几个分面（Facet）选项结合使用。要了解更多信息，请参阅限制。

有关示例，请参阅嵌入式作用域分面（Facet）示例。

分面（Facet）聚合

重要

分面（Facet）聚合处于预览阶段。“预览”期间，功能和相应的文档可能随时更改。要了解更多信息，请参阅预览功能。

要为每个分面（Facet）存储桶计算指标，请将 aggregations 文档添加到分面（Facet）定义中。MongoDB Search 从 MongoDB Search 索引计算指标，因此它比稍后在管道中运行 $group 阶段要高效得多。

对于每个分面（Facet）桶，aggregations 允许您计算以下值：

总和
平均值
最低
最大值
first
last

使用 aggregations 时，必须：

为每个指标在 path 中指定的字段建立索引，类型为 token、number 或 date。
如果您需要存储桶计数，请明确包含 count 指标。
仅在嵌套分面（Facet）的叶子级别指定 aggregations。

如果您想计算中间分组的指标，请将该分组指定为带有 aggregations 且没有嵌套分面（Facet）的单独顶级分面（Facet）。

MongoDB Search 对 MongoDB Search 索引中的数据进行 aggregations 计算，该索引是最终一致的。

注意

内存要求

指定 aggregations 或嵌套分面（Facet）的分面（Facet）查询会增加 MongoDB Search 索引所需的内存和磁盘空间，超出其他分面（Facet）查询的要求。要了解更多信息，请参阅内存要求。

语法

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`	字符串	用于计算指标的字段路径（Field Path）。除 `count` 外，所有指标类型都需要此项，因为不接受 `path`。其他所有指标类型都会根据第二个字段计算值，因此您必须命名该字段。示例，要返回存储桶中文档的平均评分，请指定 `avg`，并将 `path` 设置为 `rating`。`count` 指标会计算存储桶中的文档，因此不需要第二个字段。	视条件而定
`type`	字符串	要计算的指标类型。值可以是以下值之一： `count` `sum` `avg` `min` `max` `first` `last` 要了解有关每种指标类型的更多信息，请参阅指标类型。	是

指标类型

类型	字段要求	说明
`count`	无	计算存储桶中的文档数量。请勿为此指标类型指定 `path`。如果您在分面（Facet）定义中省略了 `aggregations`，MongoDB Search 将返回该存储桶的 `count` 指标。如果您指定了 `aggregations`，则仅当您在 `aggregations` 文档中指定了 `count` 时，MongoDB Search 才会返回 `count` 指标。
`sum`	数字	将存储桶中文档的指定字段的值相加。
`avg`	数字	返回桶中文档指定字段的平均值。如果桶中没有任何文档具有该字段的值，MongoDB Search 返回 `null`。
`min`	无	返回存储桶中文档指定字段的最小值。
`max`	无	返回存储桶中文档指定字段的最高值。
`first`	无	根据查询排序选项定义的顺序，返回存储桶中第一个文档的指定字段的值。如果查询未指定排序，则顺序是任意的。要学习如何指定排序，请参阅排序 MongoDB Search 结果。
`last`	无	根据查询 sort 选项定义的顺序，返回存储桶中最后一个文档的指定字段的值。如果查询未指定排序，则顺序是任意的。要学习如何指定排序，请参阅排序 MongoDB Search 结果。

重要

min 和 max 支持所有字段类型，包括 token。当 MongoDB Search 计算这些指标时，它会跳过字段解析为不支持类型的任何文档。当 MongoDB Search 跳过文档时，不会返回错误。要确定 MongoDB Search 是否跳过了存储桶中的文档，请将 count 指标添加到同一个 aggregations 文档中，并将其与您预期的文档数量进行比较。

对于 MongoDB Search 不会跳过的值，min 会选择存储桶中的最小值，而 max 会选择最大值。如果这些值并非全部属于同一类型，MongoDB Search 将应用 BSON 类型比较顺序来确定哪个值最小或最大。

数组注意事项

每种指标类型对解析为多个值（例如数组）的字段的处理方式各不相同：

sum 并 avg 跳过该文档。
min 并 max 选择数组中的最小值和最大值，用作文档的代表性元素。
first 并 last 将所有值作为数组返回。

对于 first 和 last，返回的数组与源文档的区别如下：

值的顺序可能会有所不同。MongoDB Search 从索引中读取值，这不会保留源文档的顺序。例如，如果文档包含 ["red", "blue", "green"]，MongoDB Search 可能会返回 ["blue", "green", "red"]。
MongoDB Search 仅返回重复值的一个实例。
MongoDB Search 会返回路径中的每个值，包括无法进行分面（Facet）的类型的值。示例，如果一个数组同时包含字符串和布尔值，MongoDB Search 会将布尔值与字符串一起返回。

要返回与源文档中完全一致的值，请在索引定义中为该字段定义 storedSource，并在查询中将 returnStoredSource 设置为 true。

嵌套分面（Facet）

重要

嵌套分面（Facet）目前处于预览阶段。“预览”期间，功能和相应的文档可能随时更改。要了解更多信息，请参阅预览功能。

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:

您只能在嵌套分面（Facet）树的叶分面（Facet）上指定 aggregations。指定了 facets 的分面（Facet）定义不能同时指定 aggregations。要计算中间分组的指标，请将该分组指定为带有 aggregations 且没有嵌套分面（Facet）的单独顶级分面（Facet）。
You can't name a nested facet count. MongoDB Search reserves count for the document count of intermediate buckets.
一个查询可以返回的唯一分面（Facet）桶的总数不能超过 100000。要计算一个分面（Facet）树生成的存储桶，请将其嵌套分支每一层的存储桶数量相乘。对于 string 分面（Facet），某一层级的存储桶数量为 numBuckets，或者对于数字或日期分面（Facet），则为 boundaries 和 default 定义的存储桶数量。示例，一个请求 20 个桶的分面（Facet）包含一个请求 20 个桶的嵌套分面（Facet），会产生 400 个唯一桶。因为每一层都会乘以这个总数，所以在每一层请求更多的存储桶会减少您可以嵌套的层数。

分面结果

对于分面（Facet）查询， MongoDB Search 返回定义的分面（Facet）名称到结果中该分面（Facet）的存储桶大量的映射。分面（Facet）结果文档包含 buckets 选项，它是分面（Facet）结果存储桶的大量。大量中的每个分面（Facet）存储桶文档都包含以下字段：

选项	类型	说明
`_id`	对象	标识此方面存储桶的唯一标识符。此值与正在分面的数据类型相匹配。
`count`	int	此分面（Facet）存储桶中的文档计数。要学习；了解有关 `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 允许您同时查看和选择同一分面（Facet）中的多个存储桶。通常，选择分面（Facet）中的存储桶会根据该选择筛选搜索结果，并更改所有分面的计数。

例子

假设 sample_airbnb.listings集合的索引定义指定了以下字段的分面：

cancellation_policy
room_type
accommodates

cancellation_policy分面（Facet）具有以下存储桶：

flexible
moderate
strict_14_with_grace_period
super_strict_30
super_strict_60

每个桶都有自己的结果计数。当搜索 moderate cancellation_policy 时，其他四个桶的计数变为 0。此外，room_type 和 accommodates 分面（Facet）中存储桶的计数减少为每个存储桶中也具有 flexible cancellation_policy 的结果数量。

如果您需要更精细地控制分面如何影响搜索结果计数，请在分面查询中启用doesNotAffect属性启用多选分面。这些分面仍会过滤结果，但查询不会更改其结果计数。

您可以在以下操作符中指定 doesNotAffect：

要排除多个分面（Facet），请指定一个分面（Facet）名称数组。大多数使用案例仅排除与过滤器共享路径的分面（Facet）。示例，rating 字段上的 equals 过滤器指定了使用 rating 作为其路径的分面（Facet）的名称。

注意

doesNotAffect 选项不能与指定聚合的分面（Facet）一起使用。要了解更多信息，请参阅限制。

例子

考虑对 sample_airbnb.listingsAndReviews 集合的查询，查找包含 moderate cancellation_policy 的文档。如果您指定 doesNotAffect 值为 cancellation_policy，则 cancellation_policy 分面（Facet）中存储桶的计数不会改变，但其他分面（Facet）的存储桶结果计数将减少为每个存储桶中也具有 moderate cancellation_policy 的结果数量。

有关更多信息，请参阅多选分面（Facet）示例。

您不能将 doesNotAffect 与 embeddedDocument 范围的分面（Facet）结合使用。要了解更多信息，请参阅对嵌入式文档数组的匹配子项进行分面（Facet）。

最后，对于具有多个分面的使用案例，您可以限制影响给定分面的其他过滤器。您可以通过在任何过滤器的 doesNotAffect 属性中指定任何分面（Facet）（包括其他字段上的分面（Facet））来实现此目的。这使您能够一眼看出哪些选择会更快或更慢地缩小选项范围。

例子

考虑对 sample_airbnb.listingsAndReviews 集合的查询，查找 accommodates 值为 3 的文档。如果您指定 doesNotAffect 值为 cancellation_policy，则 room_type 存储桶的结果计数会减少到每个存储桶中同样容纳 3 人的结果数量，但 cancellation_policy 中存储桶的结果计数不受影响。

更多信息，请参阅跨分面过滤器排除示例。

`SEARCH_META` 聚合变量

当您使用 $search 阶段运行查询时，MongoDB Search 会将元数据结果存储在 $$SEARCH_META 变量中，并且仅返回搜索结果。您可以在所有支持的聚合管道阶段使用 $$SEARCH_META 变量来查看 $search 查询的元数据结果。您还可以将 $$SEARCH_META 变量与分面（Facet）.聚合. 一起使用

只有同时需要搜索结果和元数据结果时，MongoDB 才建议使用 $$SEARCH_META 变量。否则，请使用：

$search 阶段以仅显示搜索结果。
$searchMeta 阶段以仅显式元数据结果。

限制

只能对单个字段运行分面查询。无法对字段群组运行分面查询。

嵌入式范围分面（Facet）的限制

以下限制适用于分面（Facet）匹配嵌入式文档数组中的子文档：

您不能在同一个查询中将顶级 returnScope 选项与 embeddedDocument 范围的分面（Facet）结合使用。
embeddedDocument 范围分面（Facet）仅返回计数。
您不能在同一个查询中将侧向钻取分面（Facet）（doesNotAffect）与 embeddedDocument 范围的分面（Facet）结合使用。

分面（Facet）聚合的限制

以下限制适用于分面（Facet）聚合：

不能将以下选项与 aggregations 一起使用：
- returnScope
- doesNotAffect 用于多选分面（Facet）
您无法对以下 BSON types 进行分面（Facet）或计算聚合：
- binData
- bool
- decimal
- null
- objectId
- timestamp
要对其中一种类型计算指标，请使用视图在索引字段之前将其转换为受支持的类型。

示例

以下示例使用示例数据。元数据结果示例演示如何使用 $searchMeta 运行 facet 查询，以便仅检索结果中的元数据。元数据和搜索结果示例演示了如何使用$search facet和$SEARCH_META 聚合变量运行查询，以便检索搜索结果和元数据结果。returnScope 示例演示了如何在使用 embeddedDocuments 类型动态索引的对象数组中对嵌套字段进行分面（Facet）。嵌入式范围分面（Facet）示例演示了如何仅对 embeddedDocuments 数组的匹配子项进行分面（Facet）。多选和分面（Facet）间过滤器排除示例演示了如何使用 doesNotAffect 来控制分面（Facet）如何相互影响计数。聚合示例演示了如何计算每个分面（Facet）存储桶的指标，嵌套分面（Facet）示例演示了如何按第二个字段对结果进行分组并计算每个存储桶的指标。

sample_mflix.movies 集合上的索引定义为要索引的字段指定了以下内容：

字段名称	数据类型
`directors`	token
`year`	数字
`released`	日期

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

以下查询搜索 2000 年 1 月 01 日至 2015年 1 月 31 日之间上映的电影。它请求提供 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搜索为查询返回的从 2000 年（含下边界）到 2015 年（不包括上边界）的电影数量
MongoDB搜索为查询返回的每位导演的电影数量

要了解有关这些结果的更多信息，请参阅分面结果。

sample_mflix.movies 集合上的索引定义为要索引的字段指定了以下内容：

字段名称	数据类型
`genres`	token
`released`	日期

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

以下查询使用 $search 阶段搜索 1999 年 7 月 01 上映的电影。该查询包括 $facet 阶段，用于使用以下子管道阶段处理输入文档：

$project 阶段，在 docs 输出字段中排除文件中除title 和 released 字段以外的所有字段
$limit 阶段来执行以下操作：
- 将 $search 阶段的输出限制为 2 个文档
- 在 meta 输出字段中将输出限制为 1 个文档。
注意
限制必须很小，结果才能适合 16 MB 的文档。
$replaceWith 阶段将存储在 $$SEARCH_META 变量中的元数据结果包含在 meta 输出字段中

该查询还包括用于添加 meta 字段的 $set 阶段。

注意

要查看以下查询的元数据结果， 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 选项将 raised_currency_code 和 raised_amount 字段存储在funding_rounds 数组中。

{
  "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 字段上的分面。此查询指定了三个存储桶：
- 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"
          }
        }
      }
    }
  }
}

KickApps、Topix 和 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 操作符将分面（Facet）限制为这三家公司，然后对 funding_rounds.round_code 进行分面（Facet）。roundFacet 定义指定了一个 embeddedDocument 块，将分面（Facet）的作用域仅限于 raised_currency_code 为 USD 的融资轮次。

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 中至少筹集了一轮融资的每个公司，每个轮次代码仅计算一次：

b 计数 3：KickApps、Topix 和 StumbleUpon 各自完成了 USD 的 b 轮融资。
a 计数 1：只有 KickApps 在 USD 中筹集了 a 轮资金。Topix 和 StumbleUpon 的 a 轮融资没有记录货币，因此它们不匹配。
seed 计数 1：StumbleUpon 的 seed 轮融资是在 USD 完成的。

KickApps 的 c 轮融资不计入 c 存储桶，因为它是以 GBP 而非 USD 筹集的。如果没有 embeddedDocument 块，对 funding_rounds.round_code 进行分面（Facet）需要将 funding_rounds 索引为文档类型，并且未限定范围的分面（Facet）也会将 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 字段进行分面（Facet）。

cancellation_policy分面（Facet）具有以下存储桶：
- "strict_14_with_grace_period"
- "moderate"
- "flexible"
- "super_strict_30"
- "super_strict_60"
room_type分面（Facet）具有以下存储桶：
- "Entire home/apt"
- "Private room"
- "Shared room"
该查询将 accommodates分面（Facet）划分为多个存储桶：
- 1，包括此存储桶的下限
- 2、1 存储桶的不含上限以及此存储桶的包含下限。
- 4、2 存储桶的不含上限以及此存储桶的包含下限。
- 8， 4存储桶的独占上限
对必须在 操作符中包含文本的列表执行compound 搜索，并在结果中过滤器new york city description带有moderatecancellation_policy 的列表。doesNotAffect 设置可确保按 moderate cancellation_policy 进行筛选不会更改分面（Facet）中其他存储桶的计数； "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 ]

即使查询筛选条件为 moderate，cancellationFacet 中存储桶的计数也不会减少为零。

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 并且 cancellation_policy 为 moderate 的列表。
对 cancellation_policy、roomType 和 accommodates 字段进行分面（Facet）。

cancellation_policy 和 roomType 分面（Facet）均具有三个存储桶，分别对应于这些字段在集合中的三个唯一值。查询将 accommodates 分面（Facet）分解为以下存储桶：
- 1，包括此存储桶的下限
- 2、1 存储桶的不含上限以及此存储桶的包含下限。
- 4、2 存储桶的不含上限以及此存储桶的包含下限。
- 8， 4存储桶的独占上限
将 compound.filter 的 equals 操作符中的 doesNotAffect 属性设置为 accommodatesFacet。这会将 accommodates 分面（Facet）中的存储桶排除在过滤器之外。因此，对 moderate cancellation_policy 进行过滤器会将 cancellation_policy 分面（Facet）中其他存储桶的计数减少到 0，并减少 roomType 分面（Facet）中存储桶的计数，但 accommodates 分面（Facet）中存储桶的计数保持不变。这使您可以比较过滤器对不同分面（Facet）的影响。

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 字段被索引为 token 类型，而 accommodates 字段被索引为 number 类型。

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

该查询使用 $searchMeta 阶段来查找提供至少一种指定便利设施的房源，并按 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 字段被索引为 token 类型，而 bedrooms 和 accommodates 字段被索引为 number 类型。

{
  "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 中使用分面。

facet您可以通过我们的课程和视频，学习；了解有关MongoDB搜索中的（ MongoDB搜索操作符）的更多信息。

通过课程学习

要学习；了解有关在MongoDB Search 中使用分面的更多信息，请学习MongoDB University的MongoDB简介课程的 9 单元。1.5 小时单元包括MongoDB Search 概述以及有关创建MongoDB Search 索引、使用复合运算符运行$search 查询以及使用 facet 对结果进行分组的课程。

通过观看学习

观看此视频，了解如何在查询中创建和使用数字和 string facet （MongoDB 搜索操作符），对结果进行分组并检索分组中的结果计数。

时长：11 分钟

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搜索操作符）

定义

语法

字段

内存要求

分面定义

字符串分面

语法

选项

例子

数值分面

语法

选项

例子

日期分面

语法

选项

例子

比较分面（Facet）的字段类型

对嵌入式文档数组的匹配子项进行分面（Facet）

分面（Facet）聚合

语法

选项

指标类型

数组注意事项

嵌套分面（Facet）

分面结果

多选分面

SEARCH_META 聚合变量

限制

嵌入式范围分面（Facet）的限制

分面（Facet）聚合的限制

示例

Metadata Results ExampleComplete the previous steps in the tutorial and install dependencies

Metadata and Search Results ExampleSearch using $search and retrieve both search and metadata results using $$SEARCH_META variable.

returnScope ExampleSearch using facet and facet on child fields in embeddedDocuments.

Embedded-Scoped Facet ExampleFacet on only the matching children of an embeddedDocuments array.

Multi-Select Faceting ExampleSearch with doesNotAffect for more granular control over facet filtering.

Inter-Facet Filter Exclusion ExampleSearch with doesNotAffect on a facet other than the queried field.

Aggregation ExampleSearch with facet aggregations.

Nested Facet ExampleSearch with nested facets.

继续学习

通过课程学习

通过观看学习

`facet` （MongoDB搜索操作符）

`SEARCH_META` 聚合变量