$facet (aggregation stage)（聚合阶段）

Consider an online store whose inventory is stored in the following artwork collection:考虑一个在线商店，其inventory存储在以下artwork（艺术品）集合中：

{ "_id" : 1, "title" : "The Pillars of Society", "artist" : "Grosz", "year" : 1926,
  "price" : Decimal128("199.99"),
  "tags" : [ "painting", "satire", "Expressionism", "caricature" ] }
{ "_id" : 2, "title" : "Melancholy III", "artist" : "Munch", "year" : 1902,
  "price" : Decimal128("280.00"),
  "tags" : [ "woodcut", "Expressionism" ] }
{ "_id" : 3, "title" : "Dancer", "artist" : "Miro", "year" : 1925,
  "price" : Decimal128("76.04"),
  "tags" : [ "oil", "Surrealism", "painting" ] }
{ "_id" : 4, "title" : "The Great Wave off Kanagawa", "artist" : "Hokusai",
  "price" : Decimal128("167.30"),
  "tags" : [ "woodblock", "ukiyo-e" ] }
{ "_id" : 5, "title" : "The Persistence of Memory", "artist" : "Dali", "year" : 1931,
  "price" : Decimal128("483.00"),
  "tags" : [ "Surrealism", "painting", "oil" ] }
{ "_id" : 6, "title" : "Composition VII", "artist" : "Kandinsky", "year" : 1913,
 "price" : Decimal128("385.00"),
  "tags" : [ "oil", "painting", "abstract" ] }
{ "_id" : 7, "title" : "The Scream", "artist" : "Munch", "year" : 1893,
  "tags" : [ "Expressionism", "painting", "oil" ] }
{ "_id" : 8, "title" : "Blue Flower", "artist" : "O'Keefe", "year" : 1918,
  "price" : Decimal128("118.42"),
  "tags" : [ "abstract", "painting" ] }

The following operation uses MongoDB's faceting features to provide customers with the store's inventory categorized across multiple dimensions such as tags, price, and year created. 以下操作使用MongoDB的分面功能为客户提供跨多个维度（如标签、价格和创建年份）分类的商店inventory。This $facet stage has three sub-pipelines that use $sortByCount, $bucket, or $bucketAuto to perform this multi-faceted aggregation. 这个$facet阶段有三个子管道，它们使用$sortByCount、$bucket或$bucketAuto来执行这种多面聚合。The input documents from artwork are fetched from the database only once, at the beginning of the operation:在操作开始时，artwork（艺术品）的输入文档只从数据库中提取一次：

db.artwork.aggregate( [
 {
   $facet: {
     "categorizedByTags": [
       { $unwind: "$tags" },
       { $sortByCount: "$tags" }
     ],
     "categorizedByPrice": [
       // Filter out documents without a price e.g., _id: 7
       { $match: { price: { $exists: 1 } } },
       {
         $bucket: {
           groupBy: "$price",
           boundaries: [  0, 150, 200, 300, 400 ],
           default: "Other",
           output: {
             "count": { $sum: 1 },
             "titles": { $push: "$title" }
           }
         }
       }
     ],
     "categorizedByYears(Auto)": [
       {
         $bucketAuto: {
           groupBy: "$year",
           buckets: 4
         }
       }
     ]
   }
 }
])

The operation returns the following document:该操作返回以下文档：

{
 "categorizedByYears(Auto)" : [
   // First bucket includes the document without a year, e.g., _id: 4
   { "_id" : { "min" : null, "max" : 1902 }, "count" : 2 },
   { "_id" : { "min" : 1902, "max" : 1918 }, "count" : 2 },
   { "_id" : { "min" : 1918, "max" : 1926 }, "count" : 2 },
   { "_id" : { "min" : 1926, "max" : 1931 }, "count" : 2 }
 ],
 "categorizedByPrice" : [
   {
     "_id" : 0,
     "count" : 2,
     "titles" : [
       "Dancer",
       "Blue Flower"
     ]
   },
   {
     "_id" : 150,
     "count" : 2,
     "titles" : [
       "The Pillars of Society",
       "The Great Wave off Kanagawa"
     ]
   },
   {
     "_id" : 200,
     "count" : 1,
     "titles" : [
       "Melancholy III"
     ]
   },
   {
     "_id" : 300,
     "count" : 1,
     "titles" : [
       "Composition VII"
     ]
   },
   {
     // Includes document price outside of bucket boundaries, e.g., _id: 5
     "_id" : "Other",
     "count" : 1,
     "titles" : [
       "The Persistence of Memory"
     ]
   }
 ],
 "categorizedByTags" : [
   { "_id" : "painting", "count" : 6 },
   { "_id" : "oil", "count" : 4 },
   { "_id" : "Expressionism", "count" : 3 },
   { "_id" : "Surrealism", "count" : 2 },
   { "_id" : "abstract", "count" : 2 },
   { "_id" : "woodblock", "count" : 1 },
   { "_id" : "woodcut", "count" : 1 },
   { "_id" : "ukiyo-e", "count" : 1 },
   { "_id" : "satire", "count" : 1 },
   { "_id" : "caricature", "count" : 1 }
 ]
}

The C# examples on this page use the sample_mflix database from the Atlas sample datasets. To learn how to create a free MongoDB Atlas cluster and load the sample datasets, see Get Started in the MongoDB .NET/C# Driver documentation.本页上的C#示例使用Atlas示例数据集中的sample_mflix数据库。要了解如何创建免费的MongoDB Atlas集群并加载示例数据集，请参阅MongoDB NET/C#驱动程序文档中的入门。

The following Movie class models the documents in the sample_mflix.movies collection:以下Movie类对sample_mflix.movies集合中的文档进行建模：

public class Movie
{
    public ObjectId Id { get; set; }

    public int Runtime { get; set; }
    
    public string Title { get; set; }

    public string Rated { get; set; }

    public List<string> Genres { get; set; }

    public string Plot { get; set; }
    
    public ImdbData Imdb { get; set; }

    public int Year { get; set; }

    public int Index { get; set; }
    
    public string[] Comments { get; set; }
   
    [BsonElement("lastupdated")]
    public DateTime LastUpdated { get; set; }
}

var camelCaseConvention = new ConventionPack { new CamelCaseElementNameConvention() };
ConventionRegistry.Register("CamelCase", camelCaseConvention, type => true);

To use the MongoDB .NET/C# driver to add a $facet stage to an aggregation pipeline, call the Facet() method on a PipelineDefinition object.要使用MongoDB NET/C#驱动程序向聚合管道添加$facet阶段，请在PipelineDefinition对象上调用Facet()方法。

The following example creates a pipeline stage that executes two parallel aggregations. 以下示例创建了一个执行两个并行聚合的管道阶段。The first aggregation distributes incoming documents into five groups by the value of their Runtime field. The second aggregation counts each value in the Rated field and returns the count for each value, limited to the top five values.第一个聚合根据其Runtime字段的值将传入文档分为五组。第二个聚合对Rated字段中的每个值进行计数，并返回每个值的计数，仅限于前五个值。

var bucketPipeline = new EmptyPipelineDefinition<Movie>()
    .BucketAuto(
        groupBy: m => m.Runtime,
        buckets: 5);
var bucketFacet = AggregateFacet.Create(
    name: "Runtimes",
    pipeline: bucketPipeline);

var countLimitPipeline = new EmptyPipelineDefinition<Movie>()
    .SortByCount(m => m.Rated)
    .Limit(5);
var countFacet = AggregateFacet.Create(
    "Ratings", countLimitPipeline);

var pipeline = new EmptyPipelineDefinition<Movie>()
    .Facet(bucketFacet, countFacet);

The Node.js examples on this page use the sample_mflix database from the Atlas sample datasets. 本页上的Node.js示例使用Atlas示例数据集中的sample_mflix数据库。To learn how to create a free MongoDB Atlas cluster and load the sample datasets, see Get Started in the MongoDB Node.js driver documentation.要了解如何创建免费的MongoDB Atlas集群并加载示例数据集，请参阅MongoDB Node.js驱动程序文档中的入门。

To use the MongoDB Node.js driver to add a $facet stage to an aggregation pipeline, use the $facet operator in a pipeline object.要使用MongoDB Node.js驱动程序向聚合管道添加$facet阶段，请在管道对象中使用$facet运算符。

The following example creates a pipeline stage that executes two parallel aggregations. The first aggregation distributes incoming documents into five groups by the value of their runtime field by using the $bucketAuto stage. 以下示例创建了一个执行两个并行聚合的管道阶段。第一个聚合使用$bucketAuto阶段，根据runtime字段的值将传入文档分为五组。The second aggregation counts each value in the rated field and returns the count of the top five values by using the $sortByCount and $limit stages. The example then runs the aggregation pipeline:第二个聚合对rated（额定）字段中的每个值进行计数，并使用$sortByCount和$limit阶段返回前五个值的计数。然后，该示例运行聚合管道：

const pipeline = [
  {
    $facet: {
      bucketPipeline: [
        {
          $bucketAuto: {
            groupBy: "$runtime",
            buckets: 5
          }
        }
      ],
      countLimit: [
        { $sortByCount: "$rated" },
        { $limit: 5 }
      ]
    }
  }
];

const cursor = collection.aggregate(pipeline);
return cursor;