$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. This $facet stage has three sub-pipelines that use $sortByCount, $bucket, or $bucketAuto to perform this multi-faceted aggregation. The input documents from artwork are fetched from the database only once, at the beginning of the operation:

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.

The following Movie class models the documents in the sample_mflix.movies collection:

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.

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.

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. 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.

To use the MongoDB Node.js driver to add a $facet stage to an aggregation pipeline, use the $facet operator in a pipeline object.

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. 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:

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

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