Database Manual / Reference / Query Language / Aggregation Stages

$bucket (aggregation stage)(聚合阶段)

Definition定义

$bucket

Categorizes incoming documents into groups, called buckets, based on a specified expression and bucket boundaries and outputs a document per each bucket. Each output document contains an _id field whose value specifies the inclusive lower bound of the bucket. 根据指定的表达式和桶边界将传入文档分类到称为桶的组中,并为每个桶输出一个文档。每个输出文档都包含一个_id字段,其值指定桶的包含下限。The output option specifies the fields included in each output document.output选项指定每个输出文档中包含的字段。

$bucket only produces output documents for buckets that contain at least one input document.仅为至少包含一个输入文档的桶生成输出文档。

Considerations注意事项

$bucket and Memory Restrictions和内存限制

The $bucket stage has a limit of 100 megabytes of RAM. By default, if the stage exceeds this limit, $bucket returns an error. $bucket阶段的RAM限制为100兆字节。默认情况下,如果阶段超过此限制,$bucket将返回错误。To allow more space for stage processing, use the allowDiskUse option to enable aggregation pipeline stages to write data to temporary files.要为阶段处理提供更多空间,请使用allowDiskUse选项启用聚合管道阶段将数据写入临时文件。

Syntax语法

{
$bucket: {
groupBy: <expression>,
boundaries: [ <lowerbound1>, <lowerbound2>, ... ],
default: <literal>,
output: {
<output1>: { <$accumulator expression> },
...
<outputN>: { <$accumulator expression> }
}
}
}

The $bucket document contains the following fields:$bucket文档包含以下字段:

Field字段Type类型Description描述
groupByexpressionAn expression to group documents by. 用于对文档进行分组的表达式To specify a field path, prefix the field name with a dollar sign $ and enclose it in quotes.要指定字段路径,请在字段名前加上美元符号$,并将其括在引号中。
Unless $bucket includes a default specification, each input document must resolve the groupBy field path or expression to a value that falls within one of the ranges specified by the boundaries.除非$bucket包含default规范,否则每个输入文档都必须将groupBy字段路径或表达式解析为落在boundaries指定范围内的值。
boundariesarrayAn array of values based on the groupBy expression that specify the boundaries for each bucket. Each adjacent pair of values acts as the inclusive lower boundary and the exclusive upper boundary for the bucket. You must specify at least two boundaries.基于groupBy表达式的值数组,用于指定每个桶的边界。每对相邻的值都充当桶的包容性下限和排他性上限。您必须至少指定两个边界。
The specified values must be in ascending order and all of the same type. The exception is if the values are of mixed numeric types, such as:指定的值必须按升序排列,并且类型必须相同。例外情况是,如果值是混合数字类型,例如:
[ 10, Long(20), Int32(30) ]
For example, an array of [ 0, 5, 10 ] creates two buckets:例如,一个[0,5,10]的数组创建了两个桶:
  • [0, 5) with inclusive lower bound 0 and exclusive upper bound 5.[5, 10),具有包含下限0和排除上限5
  • [5, 10) with inclusive lower bound 5 and exclusive upper bound 10.[5, 10),具有包含下限5和排除上限10
defaultliteralOptional. A literal that specifies the _id of an additional bucket that contains all documents whose groupBy expression result does not fall into a bucket specified by boundaries.可选。一个指定附加桶的_id的文字,该桶包含其groupBy表达式结果不属于边界指定的桶的所有文档。
If unspecified, each input document must resolve the groupBy expression to a value within one of the bucket ranges specified by boundaries or the operation throws an error.如果未指定,则每个输入文档必须将groupBy表达式解析为边界指定的桶范围内的值,否则操作将抛出错误。
The default value must be less than the lowest boundaries value, or greater than or equal to the highest boundaries value.default值必须小于最低boundaries值,或大于或等于最高boundaries值。
The default value can be of a different type than the entries in boundaries.default值的类型可以与boundaries中的条目不同。
outputdocumentOptional. A document that specifies the fields to include in the output documents in addition to the _id field. 可选。一种文档,除了_id字段外,还指定了输出文档中要包含的字段。To specify the field to include, you must use accumulator expressions.要指定要包含的字段,必须使用累加器表达式
<outputfield1>: { <accumulator>: <expression1> },
...
<outputfieldN>: { <accumulator>: <expressionN> }
If you do not specify an output document, the operation returns a count field containing the number of documents in each bucket.如果不指定output文档,该操作将返回一个count字段,其中包含每个桶中的文档数量。
If you specify an output document, only the fields specified in the document are returned; i.e. the count field is not returned unless it is explicitly included in the output document.如果指定output文档,则只返回文档中指定的字段;即,除非输出文档中明确包含count字段,否则不会返回count字段。

Behavior行为

$bucket requires at least one of the following conditions to be met or the operation throws an error:需要满足以下条件中的至少一个,否则操作会抛出错误:

  • Each input document resolves the groupBy expression to a value within one of the bucket ranges specified by boundaries, or每个输入文档将groupBy表达式解析为边界指定的桶范围内的值,或
  • A default value is specified to bucket documents whose groupBy values are outside of the boundaries or of a different BSON type than the values in boundaries.groupBy值超出boundariesBSON类型与边界中的值不同的桶文档指定default值。

If the groupBy expression resolves to an array or a document, $bucket arranges the input documents into buckets using the comparison logic from $sort.如果groupBy表达式解析为数组或文档,则$bucket将使用$sort中的比较逻辑将输入文档排列到桶中。

Examples示例

MongoDB Shell

Bucket by Year and Filter by Bucket Results按年份和按桶结果筛选

In mongosh, create a sample collection named artists with the following documents:mongosh中,使用以下文档创建一个名为artists的样本集:

db.artists.insertMany([
{ "_id" : 1, "last_name" : "Bernard", "first_name" : "Emil", "year_born" : 1868, "year_died" : 1941, "nationality" : "France" },
{ "_id" : 2, "last_name" : "Rippl-Ronai", "first_name" : "Joszef", "year_born" : 1861, "year_died" : 1927, "nationality" : "Hungary" },
{ "_id" : 3, "last_name" : "Ostroumova", "first_name" : "Anna", "year_born" : 1871, "year_died" : 1955, "nationality" : "Russia" },
{ "_id" : 4, "last_name" : "Van Gogh", "first_name" : "Vincent", "year_born" : 1853, "year_died" : 1890, "nationality" : "Holland" },
{ "_id" : 5, "last_name" : "Maurer", "first_name" : "Alfred", "year_born" : 1868, "year_died" : 1932, "nationality" : "USA" },
{ "_id" : 6, "last_name" : "Munch", "first_name" : "Edvard", "year_born" : 1863, "year_died" : 1944, "nationality" : "Norway" },
{ "_id" : 7, "last_name" : "Redon", "first_name" : "Odilon", "year_born" : 1840, "year_died" : 1916, "nationality" : "France" },
{ "_id" : 8, "last_name" : "Diriks", "first_name" : "Edvard", "year_born" : 1855, "year_died" : 1930, "nationality" : "Norway" }
])

The following operation groups the documents into buckets according to the year_born field and filters based on the count of documents in the buckets:以下操作根据year_born字段将文档分组到桶中,并根据桶中的文档计数进行筛选:

 db.artists.aggregate( [
// First Stage第一阶段
{
$bucket: {
groupBy: "$year_born", // Field to group by用来分组的字段
boundaries: [ 1840, 1850, 1860, 1870, 1880 ], // Boundaries for the buckets桶的边界
default: "Other", // Bucket ID for documents which do not fall into a bucket未放入桶中的文档的桶ID
output: { // Output for each bucket每个桶的输出每个桶的输出
"count": { $sum: 1 },
"artists" :
{
$push: {
"name": { $concat: [ "$first_name", " ", "$last_name"] },
"year_born": "$year_born"
}
}
}
}
},
// Second Stage第二阶段
{
$match: { count: {$gt: 3} }
}
] )
First Stage第一阶段

The $bucket stage groups the documents into buckets by the year_born field. The buckets have the following boundaries:$bucket阶段按year_born字段将文档分组到桶中。桶有以下boundaries

  • [1840, 1850) with inclusive lowerbound 1840 and exclusive upper bound 1850.,具有包含下限1840和排除上限1850
  • [1850, 1860) with inclusive lowerbound 1850 and exclusive upper bound 1860.,具有包含下限1850和排除上限1860
  • [1860, 1870) with inclusive lowerbound 1860 and exclusive upper bound 1870.,具有包含下限1860和排除上限1870
  • [1870, 1880) with inclusive lowerbound 1870 and exclusive upper bound 1880.,具有包含下限1870和排除上限1880
  • If a document did not contain the year_born field or its year_born field was outside the ranges above, it would be placed in the default bucket with the _id value "Other".如果文档不包含year_born字段或其year_born域超出上述范围,则将其放置在_id值为"Other"default桶中。

The stage includes the output document to determine the fields to return:该阶段包括output文档,以确定要返回的字段:

Field字段Description描述
_idInclusive lower bound of the bucket.包括桶的下限。
countCount of documents in the bucket.清点桶中的文件数。
artistsArray of documents containing information on each artist in the bucket. Each document contains the artist's包含桶中每个艺术家信息的文档数组。每个文档都包含艺术家的
  • name, which is a concatenation (i.e. $concat) of the artist's first_name and last_name.,这是艺术家的first_namelast_name的连接(即$concat)。
  • year_born

This stage passes the following documents to the next stage:此阶段将以下文件传递到下一阶段:

{ "_id" : 1840, "count" : 1, "artists" : [ { "name" : "Odilon Redon", "year_born" : 1840 } ] }

{ "_id" : 1850, "count" : 2, "artists" : [ { "name" : "Vincent Van Gogh", "year_born" : 1853 },
{ "name" : "Edvard Diriks", "year_born" : 1855 } ] }

{ "_id" : 1860, "count" : 4, "artists" : [ { "name" : "Emil Bernard", "year_born" : 1868 },
{ "name" : "Joszef Rippl-Ronai", "year_born" : 1861 },
{ "name" : "Alfred Maurer", "year_born" : 1868 },
{ "name" : "Edvard Munch", "year_born" : 1863 } ] }

{ "_id" : 1870, "count" : 1, "artists" : [ { "name" : "Anna Ostroumova", "year_born" : 1871 } ] }
Second Stage第二阶段

The $match stage filters the output from the previous stage to only return buckets which contain more than 3 documents.$match阶段筛选前一阶段的输出,只返回包含3个以上文档的桶。

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

{ "_id" : 1860, "count" : 4, "artists" :
[
{ "name" : "Emil Bernard", "year_born" : 1868 },
{ "name" : "Joszef Rippl-Ronai", "year_born" : 1861 },
{ "name" : "Alfred Maurer", "year_born" : 1868 },
{ "name" : "Edvard Munch", "year_born" : 1863 }
]
}

Use $bucket with $facet to Bucket by Multiple Fields使用$bucket$facet按多个字段创建桶

You can use the $facet stage to perform multiple $bucket aggregations in a single stage.您可以使用$facet阶段在单个阶段中执行多个$bucket聚合。

In mongosh, create a sample collection named artwork with the following documents:mongosh中,使用以下文档创建一个名为artwork的样本集:

db.artwork.insertMany([
{ "_id" : 1, "title" : "The Pillars of Society", "artist" : "Grosz", "year" : 1926,
"price" : Decimal128("199.99") },
{ "_id" : 2, "title" : "Melancholy III", "artist" : "Munch", "year" : 1902,
"price" : Decimal128("280.00") },
{ "_id" : 3, "title" : "Dancer", "artist" : "Miro", "year" : 1925,
"price" : Decimal128("76.04") },
{ "_id" : 4, "title" : "The Great Wave off Kanagawa", "artist" : "Hokusai",
"price" : Decimal128("167.30") },
{ "_id" : 5, "title" : "The Persistence of Memory", "artist" : "Dali", "year" : 1931,
"price" : Decimal128("483.00") },
{ "_id" : 6, "title" : "Composition VII", "artist" : "Kandinsky", "year" : 1913,
"price" : Decimal128("385.00") },
{ "_id" : 7, "title" : "The Scream", "artist" : "Munch", "year" : 1893
/* No price*/ },
{ "_id" : 8, "title" : "Blue Flower", "artist" : "O'Keefe", "year" : 1918,
"price" : Decimal128("118.42") }
])

The following operation uses two $bucket stages within a $facet stage to create two groupings, one by price and the other by year:以下操作在$facet阶段中使用两个$bucket阶段来创建两个分组,一个按price,另一个按year

db.artwork.aggregate( [
{
$facet: { // Top-level $facet stage顶级$facet阶段
"price": [ // Output field 1输出字段1
{
$bucket: {
groupBy: "$price", // Field to group by用来分组的字段
boundaries: [ 0, 200, 400 ], // Boundaries for the buckets桶的边界
default: "Other", // Bucket ID for documents which do not fall into a bucket未放入桶中的文档的桶ID
output: { // Output for each bucket每个桶的输出
"count": { $sum: 1 },
"artwork" : { $push: { "title": "$title", "price": "$price" } },
"averagePrice": { $avg: "$price" }
}
}
}
],
"year": [ // Output field 2输出字段2
{
$bucket: {
groupBy: "$year", // Field to group by用来分组的字段
boundaries: [ 1890, 1910, 1920, 1940 ], // Boundaries for the buckets桶的边界
default: "Unknown", // Bucket ID for documents which do not fall into a bucket未放入桶中的文档的桶ID
output: { // Output for each bucket每个桶的输出
"count": { $sum: 1 },
"artwork": { $push: { "title": "$title", "year": "$year" } }
}
}
}
]
}
}
] )
First Facet第一方面

The first facet groups the input documents by price. The buckets have the following boundaries:第一个方面按price对输入文档进行分组。桶有以下边界:

  • [0, 200) with inclusive lowerbound 0 and exclusive upper bound 200.具有包含下限0和排除上限200
  • [200, 400) with inclusive lowerbound 200 and exclusive upper bound 400.具有包含下限200和排除上限400
  • "Other", the default bucket containing documents without prices or prices outside the ranges above.default桶包含没有价格或价格超出上述范围的文档。

The $bucket stage includes the output document to determine the fields to return:$bucket阶段包括output文档,以确定要返回的字段:

Field字段Description描述
_idInclusive lower bound of the bucket.包括桶的下限。
countCount of documents in the bucket.清点桶中的文件数。
artworkArray of documents containing information on each artwork in the bucket.包含桶中每件艺术品信息的文档数组。
averagePriceEmploys the $avg operator to display the average price of all artwork in the bucket.使用$avg运算符显示桶中所有艺术品的平均价格。
Second Facet第二方面

The second facet groups the input documents by year. The buckets have the following boundaries:第二个方面按年份对输入文档进行分组。桶有以下边界:

  • [1890, 1910) with inclusive lowerbound 1890 and exclusive upper bound 1910.具有包含下限1890和排除上限1910
  • [1910, 1920) with inclusive lowerbound 1910 and exclusive upper bound 1920.具有包含下限1910和排除上限1920
  • [1920, 1940) with inclusive lowerbound 1920 and exclusive upper bound 1940.具有包含下限1920和排除上限1940
  • "Unknown", the default bucket containing documents without years or years outside the ranges above.default桶包含没有年份或超出上述范围的文档。

The $bucket stage includes the output document to determine the fields to return:$bucket阶段包括output文档,以确定要返回的字段:

Field字段Description描述
countCount of documents in the bucket.清点桶中的文件数。
artworkArray of documents containing information on each artwork in the bucket.包含桶中每件艺术品信息的文档数组。
Output输出

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

 {
"price" : [ // Output of first facet第一面输出
{
"_id" : 0,
"count" : 4,
"artwork" : [
{ "title" : "The Pillars of Society", "price" : Decimal128("199.99") },
{ "title" : "Dancer", "price" : Decimal128("76.04") },
{ "title" : "The Great Wave off Kanagawa", "price" : Decimal128("167.30") },
{ "title" : "Blue Flower", "price" : Decimal128("118.42") }
],
"averagePrice" : Decimal128("140.4375")
},
{
"_id" : 200,
"count" : 2,
"artwork" : [
{ "title" : "Melancholy III", "price" : Decimal128("280.00") },
{ "title" : "Composition VII", "price" : Decimal128("385.00") }
],
"averagePrice" : Decimal128("332.50")
},
{
// Includes documents without prices and prices greater than 400包括没有价格和价格超过400的文件
"_id" : "Other",
"count" : 2,
"artwork" : [
{ "title" : "The Persistence of Memory", "price" : Decimal128("483.00") },
{ "title" : "The Scream" }
],
"averagePrice" : Decimal128("483.00")
}
],
"year" : [ // Output of second facet第二面输出
{
"_id" : 1890,
"count" : 2,
"artwork" : [
{ "title" : "Melancholy III", "year" : 1902 },
{ "title" : "The Scream", "year" : 1893 }
]
},
{
"_id" : 1910,
"count" : 2,
"artwork" : [
{ "title" : "Composition VII", "year" : 1913 },
{ "title" : "Blue Flower", "year" : 1918 }
]
},
{
"_id" : 1920,
"count" : 3,
"artwork" : [
{ "title" : "The Pillars of Society", "year" : 1926 },
{ "title" : "Dancer", "year" : 1925 },
{ "title" : "The Persistence of Memory", "year" : 1931 }
]
},
{
// Includes documents without a year包括没有年份的文件
"_id" : "Unknown",
"count" : 1,
"artwork" : [
{ "title" : "The Great Wave off Kanagawa" }
]
}
]
}
C#

The C# examples on this page use the sample_mflix database from the Atlas sample datasets. 本页上的C#示例使用Atlas示例数据集中的sample_mflix数据库。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.要了解如何创建免费的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; }
}

Note

ConventionPack for Pascal CasePascal案例的约定包

The C# classes on this page use Pascal case for their property names, but the field names in the MongoDB collection use camel case. To account for this difference, you can use the following code to register a ConventionPack when your application starts:此页面上的C#类使用Pascal大小写作为其属性名,但MongoDB集合中的字段名使用驼峰大小写。为了解释这种差异,您可以在应用程序启动时使用以下代码注册ConventionPack

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

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

The following example creates a pipeline stage that groups incoming documents by the value of their Runtime field, inclusive of the lower boundary and exclusive of the upper boundary:以下示例创建了一个管道阶段,该阶段根据其Runtime字段的值对传入文档进行分组,包括下限,不包括上限:

var pipeline = new EmptyPipelineDefinition<Movie>()
.Bucket(
groupBy: m => m.Runtime,
boundaries: new List<int>() { 0, 71, 91, 121, 151, 201, 999 });

To customize the $bucket operation, pass an AggregateBucketOptions object to the Bucket() method. 要自定义$bucket操作,请将AggregateBucketOptions对象传递给Bucket()方法。The following example performs the same $bucket operation as the previous example, but groups all documents with a Runtime value greater than 999 into the default bucket, named "Other":以下示例执行与前一个示例相同的$bucket操作,但将所有Runtime值大于999的文档分组到名为"Other"的默认桶中:

var bucketOptions = new AggregateBucketOptions<BsonValue>()
{
DefaultBucket = (BsonValue)"Other"
};

var pipeline = new EmptyPipelineDefinition<Movie>()
.Bucket(
groupBy: m => m.Runtime,
boundaries: new List<BsonValue>() { 0, 71, 91, 121, 151, 201, 999 },
options: bucketOptions);
Node.js

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 $bucket stage to an aggregation pipeline, use the $bucket operator in a pipeline object.要使用MongoDB Node.js驱动程序向聚合管道添加$bucket阶段,请在管道对象中使用$bucket运算符。

The following example creates a pipeline stage that groups incoming documents by the value of their runtime field, inclusive of the lower boundary and exclusive of the upper boundary. 以下示例创建了一个管道阶段,该阶段根据runtime字段的值对传入文档进行分组,包括下限,不包括上限。The aggregation stage groups all documents with a runtime value greater than 999 into the default bucket, named "other". 聚合阶段将所有运行时值大于999的文档分组到名为"other"的默认桶中。The example then runs the aggregation pipeline:然后,该示例运行聚合管道:

const pipeline = [
{
$bucket: {
groupBy: "$runtime",
boundaries: [0, 17, 91, 121, 151, 201, 999],
default: "other"
}
}
];

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

Learn More了解更多

To learn more about related pipeline stages, see the $bucketAuto guide.要了解有关相关管道阶段的更多信息,请参阅$bucketAuto指南。