db.collection.aggregate()

On this page本页内容

Definition释义

db.collection.aggregate(pipeline, options)

mongo Shell Method方法

This page documents the mongo shell method, and does not refer to the MongoDB Node.js driver (or any other driver) method.此页面记录了mongo Shell方法，未提及MongoDB Node.js驱动程序（或任何其他驱动程序）方法。For corresponding MongoDB driver API, refer to your specific MongoDB driver documentation instead.有关相应的MongoDB驱动程序API，请参阅特定的MongoDB驱动程序文档。

Calculates aggregate values for the data in a collection or a view.计算集合或视图中数据的聚合值。

Parameter参数Type类型Description描述
pipeline array

A sequence of data aggregation operations or stages.一系列数据聚合操作或阶段。See the aggregation pipeline operators for details.有关详细信息，请参阅聚合管道操作符。

The method can still accept the pipeline stages as separate arguments instead of as elements in an array; however, if you do not specify the pipeline as an array, you cannot specify the options parameter.该方法仍然可以接受管道阶段作为单独的参数，而不是作为数组中的元素；但是，如果未将pipeline指定为数组，则无法指定options参数。

options document Optional.可选。Additional options that aggregate() passes to the aggregate command.aggregate()传递给aggregate命令的其他选项。Available only if you specify the pipeline as an array.仅当将pipeline指定为数组时可用。

The options document can contain the following fields and values:options文档可以包含以下字段和值：

Parameter参数Type类型Description描述
explain boolean

Optional.可选。Specifies to return the information on the processing of the pipeline.指定返回有关管道处理的信息。See Return Information on Aggregation Pipeline Operation for an example.有关示例，请参阅聚合管道操作的返回信息。

Not available in multi-document transactions.在多文档事务中不可用。

allowDiskUse boolean

Optional.可选。Enables writing to temporary files.允许写入临时文件。When set to true, aggregation operations can write data to the _tmp subdirectory in the dbPath directory.当设置为true时，聚合操作可以将数据写入dbPath目录中的_tmp子目录。See Perform Large Sort Operation with External Sort for an example.有关示例，请参阅使用外部排序执行大型排序操作。

Starting in MongoDB 4.2, the profiler log messages and diagnostic log messages includes a usedDisk indicator if any aggregation stage wrote data to temporary files due to memory restrictions.从MongoDB 4.2开始，如果任何聚合阶段由于内存限制将数据写入临时文件，探查器日志消息和诊断日志消息将包含usedDisk指示符。

cursor document Optional.可选。Specifies the initial batch size for the cursor.指定游标的初始批大小。The value of the cursor field is a document with the field batchSize.cursor字段的值是具有batchSize字段的文档。See Specify an Initial Batch Size for syntax and example.有关语法和示例，请参阅指定初始批处理大小。
maxTimeMS non-negative integer非负整数

Optional.可选。Specifies a time limit in milliseconds for processing operations on a cursor.指定处理光标上的操作的时间限制（以毫秒为单位）。If you do not specify a value for maxTimeMS, operations will not time out.如果未为maxTimeMS指定值，则操作将不会超时。A value of 0 explicitly specifies the default unbounded behavior.值0显式指定默认的无界行为。

MongoDB terminates operations that exceed their allotted time limit using the same mechanism as db.killOp().MongoDB使用与db.killOp()相同的机制终止超过分配时间限制的操作。MongoDB only terminates an operation at one of its designated interrupt points.MongoDB仅在其指定的中断点之一终止操作。

bypassDocumentValidation boolean

Optional.可选。Applicable only if you specify the $out or $merge aggregation stages.仅当指定$out或$merge聚合阶段时适用。

Enables db.collection.aggregate to bypass document validation during the operation. 启用db.collection.aggregate以在操作期间绕过文档验证。This lets you insert documents that do not meet the validation requirements.这样可以插入不符合验证要求的文档。

New in version 3.2.版本3.2中的新功能。

readConcern document

Optional.可选。Specifies the read concern.指定读取关注点。

Starting in MongoDB 3.6, the readConcern option has the following syntax: readConcern: { level: <value> }从MongoDB 3.6开始，readConcern选项具有以下语法：readConcern:{level:<value>}

Possible read concern levels are:可能的读取关注级别为：

For more formation on the read concern levels, see Read Concern Levels.有关读取关注级别的更多信息，请参阅读取关注级别。

Starting in MongoDB 4.2, the $out stage cannot be used in conjunction with read concern "linearizable".从MongoDB 4.2开始，$out阶段不能与读取关注点"linearizable"结合使用。That is, if you specify "linearizable" read concern for db.collection.aggregate(), you cannot include the $out stage in the pipeline.也就是说，如果指定db.collection.aggregate()的"linearizable"读取关注点，不能在管道中包含$out阶段。

The $merge stage cannot be used in conjunction with read concern "linearizable". $merge阶段不能与读取关注点"linearizable"一起使用。That is, if you specify "linearizable" read concern for db.collection.aggregate(), you cannot include the $merge stage in the pipeline.也就是说，如果指定db.collection.aggregate()的"linearizable"读取关注点，不能在管道中包含$merge阶段。

collation document

Optional.

Specifies the collation to use for the operation.指定要用于该操作的排序规则。

Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音符号的规则。

The collation option has the following syntax:语法如下所示：

collation: {
   locale: <string>,
   caseLevel: <boolean>,
   caseFirst: <string>,
   strength: <int>,
   numericOrdering: <boolean>,
   alternate: <string>,
   maxVariable: <string>,
   backwards: <boolean>
}

When specifying collation, the locale field is mandatory; all other collation fields are optional. 指定排序规则时，locale设置字段是必需的；所有其他排序规则字段都是可选的。For descriptions of the fields, see Collation Document.有关这些字段的描述，请参阅排序规则文档。

If the collation is unspecified but the collection has a default collation (see db.createCollection()), the operation uses the collation specified for the collection.如果未指定排序规则，但集合具有默认排序规则（请参见db.createCollection()），则操作将使用为集合指定的排序规则。

If no collation is specified for the collection or for the operations, MongoDB uses the simple binary comparison used in prior versions for string comparisons.如果没有为集合或操作指定排序规则，MongoDB将使用以前版本中用于字符串比较的简单二进制比较。

You cannot specify multiple collations for an operation. 不能为一个操作指定多个排序规则。For example, you cannot specify different collations per field, or if performing a find with a sort, you cannot use one collation for the find and another for the sort.例如，不能为每个字段指定不同的排序规则，或者如果使用排序执行查找，则不能对查找使用一种排序规则，对排序使用另一种排序规则。

New in version 3.4.版本3.4中的新功能。

hint string or document字符串或文档

Optional.可选。The index to use for the aggregation. The index is on the initial collection/view against which the aggregation is run.用于聚合的索引。索引位于运行聚合的初始集合/视图上。

Specify the index either by the index name or by the index specification document.通过索引名称或索引规范文档指定索引。

Note

The hint does not apply to $lookup and $graphLookup stages.该hint不适用于$lookup阶段和$graphLookup阶段。

New in version 3.6.版本3.6中的新功能。

comment string

Optional.可选。Users can specify an arbitrary string to help trace the operation through the database profiler, currentOp, and logs.用户可以指定任意字符串，以帮助通过数据库探查器、currentOp和日志跟踪操作。

New in version 3.6.版本3.6中的新功能。

writeConcern document

Optional.可选。A document that expresses the write concern to use with the $out or $merge stage.表示要与$out阶段或$merge阶段一起使用的写入关注点的文档。

Omit to use the default write concern with the $out or $merge stage.忽略在$out阶段或$merge阶段使用默认写关注点。

Returns:返回：A cursor to the documents produced by the final stage of the aggregation pipeline operation, or if you include the explain option, the document that provides details on the processing of the aggregation operation. 游标指向聚合管道操作最后阶段生成的文档，或者如果包含explain选项，则指向提供聚合操作处理细节的文档。

If the pipeline includes the $out operator, aggregate() returns an empty cursor. 如果管道包含$out运算符，则aggregate()返回一个空游标。See $out for more information.更多信息请参见$out。

Behavior行为

Error Handling错误处理

If an error occurs, the aggregate() helper throws an exception.如果发生错误，aggregate()助手将抛出异常。

Cursor Behavior游标行为

In the mongo shell, if the cursor returned from the db.collection.aggregate() is not assigned to a variable using the var keyword, then the mongo shell automatically iterates the cursor up to 20 times. 在mongo shell中，如果游标从没有使用var关键字分配给一个变量的db.collection.aggregate()返回，则mongo shell会自动将游标迭代多达20次。See Iterate a Cursor in the mongo Shell for handling cursors in the mongo shell.有关在mongo Shell中处理游标的信息，请参阅在mongo Shell中迭代游标。

Cursors returned from aggregation only supports cursor methods that operate on evaluated cursors (i.e. cursors whose first batch has been retrieved), such as the following methods:从聚合返回的游标仅支持对已评估游标（即已检索第一批的游标）进行操作的游标方法，例如以下方法：

See also参阅

For more information, see Aggregation Pipeline, Aggregation Reference, Aggregation Pipeline Limits, and aggregate.有关更多信息，请参阅聚合管道、聚合参考、聚合管道限制和aggregate。

Sessions

New in version 4.0.版本4.0中的新功能。

For cursors created inside a session, you cannot call getMore outside the session.对于在会话内创建的游标，不能在会话外调用getMore。

Similarly, for cursors created outside of a session, you cannot call getMore inside a session.同样，对于在会话外部创建的游标，不能在会话内部调用getMore。

Session Idle Timeout会话空闲超时

Starting in MongoDB 3.6, MongoDB drivers and the mongo shell associate all operations with a server session, with the exception of unacknowledged write operations. 从MongoDB 3.6开始，MongoDB驱动程序和mongo shell将所有操作与服务器会话相关联，但未确认的写入操作除外。For operations not explicitly associated with a session (i.e. using Mongo.startSession()), MongoDB drivers and the mongo shell creates an implicit session and associates it with the operation.对于与会话没有显式关联的操作（即使用Mongo.startSession()），MongoDB驱动程序和mongo shell会创建一个隐式会话，并将其与操作关联。

If a session is idle for longer than 30 minutes, the MongoDB server marks that session as expired and may close it at any time. 如果会话空闲时间超过30分钟，MongoDB服务器会将该会话标记为已过期，并可随时将其关闭。When the MongoDB server closes the session, it also kills any in-progress operations and open cursors associated with the session. 当MongoDB服务器关闭会话时，它还会终止任何正在进行的操作以及与会话相关的打开游标。This includes cursors configured with noCursorTimeout or a maxTimeMS greater than 30 minutes.这包括配置了noCursorTimeout或maxTimeMS（大于30分钟）的游标。

For operations that return a cursor, if the cursor may be idle for longer than 30 minutes, issue the operation within an explicit session using Session.startSession() and periodically refresh the session using the refreshSessions command. 对于返回游标的操作，如果游标空闲时间可能超过30分钟，请使用Session.startSession()在显式会话中发出该操作，并使用refreshSessions命令定期刷新会话。See Session Idle Timeout for more information.有关更多信息，请参阅Session Idle Timeout。

Transactions事务

db.collection.aggregate() can be used inside multi-document transactions.可以在多文档事务中使用db.collection.aggregate()。

However, the following stages are not allowed within transactions:但是，事务中不允许以下阶段：

You also cannot specify the explain option.也不能指定explain选项。

  • For cursors created outside of a transaction, you cannot call getMore inside the transaction.对于在事务外部创建的游标，不能在事务内部调用getMore。
  • For cursors created in a transaction, you cannot call getMore outside the transaction.对于在事务中创建的游标，不能在事务外部调用getMore。

Important重要的

In most cases, multi-document transaction incurs a greater performance cost over single document writes, and the availability of multi-document transactions should not be a replacement for effective schema design. 在大多数情况下，与单文档写入相比，多文档事务会带来更大的性能成本，而多文档事务的可用性不应取代有效的模式设计。For many scenarios, the denormalized data model (embedded documents and arrays) will continue to be optimal for your data and use cases. 对于许多场景，非规范化数据模型（嵌入式文档和数组）将继续适合您的数据和用例。That is, for many scenarios, modeling your data appropriately will minimize the need for multi-document transactions.也就是说，对于许多场景，适当地建模数据将最大限度地减少对多文档事务的需求。

For additional transactions usage considerations (such as runtime limit and oplog size limit), see also Production Considerations.有关其他事务使用注意事项（如运行时限制和oplog大小限制），请参阅生产注意事项。

Client Disconnection客户端断开

For db.collection.aggregate() operation that do not include the $out or $merge stages:对于不包括$out阶段或$merge阶段的db.collection.aggregate()操作：

Starting in MongoDB 4.2, if the client that issued the db.collection.aggregate() disconnects before the operation completes, MongoDB marks the db.collection.aggregate() for termination (i.e. killOp on the operation).从MongoDB 4.2开始，如果发布在操作完成之前断开连接的db.collection.aggregate()的客户端，MongoDB会标记db.collection.aggregate()用于终止（即killOp操作）。

Examples示例

The following examples use the collection orders that contains the following documents:以下示例使用包含以下文档的集合orders：

{ _id: 1, cust_id: "abc1", ord_date: ISODate("2012-11-02T17:04:11.102Z"), status: "A", amount: 50 }
{ _id: 2, cust_id: "xyz1", ord_date: ISODate("2013-10-01T17:04:11.102Z"), status: "A", amount: 100 }
{ _id: 3, cust_id: "xyz1", ord_date: ISODate("2013-10-12T17:04:11.102Z"), status: "D", amount: 25 }
{ _id: 4, cust_id: "xyz1", ord_date: ISODate("2013-10-11T17:04:11.102Z"), status: "D", amount: 125 }
{ _id: 5, cust_id: "abc1", ord_date: ISODate("2013-11-12T17:04:11.102Z"), status: "A", amount: 25 }

Group by and Calculate a Sum分组计算一个总数

The following aggregation operation selects documents with status equal to "A", groups the matching documents by the cust_id field and calculates the total for each cust_id field from the sum of the amount field, and sorts the results by the total field in descending order:以下聚合操作选择状态等于"A"的文档，按cust_id字段对匹配的文档进行分组，并根据amount字段的总和计算每个cust_id字段的合计（total），并按total字段降序排列结果：

db.orders.aggregate([
                     { $match: { status: "A" } },
                     { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },
                     { $sort: { total: -1 } }
                   ])

The operation returns a cursor with the following documents:该操作将返回包含以下文档的游标：

{ "_id" : "xyz1", "total" : 100 }
{ "_id" : "abc1", "total" : 75 }

The mongo shell iterates the returned cursor automatically to print the results. mongo shell会自动迭代返回的游标以打印结果。See Iterate a Cursor in the mongo Shell for handling cursors manually in the mongo shell.有关在mongo Shell中手动处理游标的信息，请参阅在mongo Shell中迭代游标。

Return Information on Aggregation Pipeline Operation返回有关聚合管道操作的信息

The following example uses db.collection.explain() to view detailed information regarding the execution plan of the aggregation pipeline.下面的示例使用db.collection.explain()查看有关聚合管道执行计划的详细信息。

db.orders.explain().aggregate([
   { $match: { status: "A" } },
   { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },
   { $sort: { total: -1 } }
])

The operation returns a document that details the processing of the aggregation pipeline. 该操作返回一个文档，详细说明聚合管道的处理过程。For example, the document may show, among other details, which index, if any, the operation used. 例如，除其他细节外，文档可能会显示所使用的操作的索引（如果有的话）。[1] If the orders collection is a sharded collection, the document would also show the division of labor between the shards and the merge operation, and for targeted queries, the targeted shards.如果orders集合是分片集合，文档还将显示分片和合并操作之间的分工，对于目标查询，显示目标分片。

Note

The intended readers of the explain output document are humans, and not machines, and the output format is subject to change between releases.explain输出文档的目标读者是人类，而不是机器，输出格式可能会在不同版本之间发生变化。

You can view more verbose explain output by passing the executionStats or allPlansExecution explain modes to the db.collection.explain() method.通过将executionStats或allPlansExecution解释模式传递给数db.collection.explain()方法，可以查看更详细的解释输出。

[1]Index Filters can affect the choice of index used. 索引筛选器会影响所用索引的选择。See Index Filters for details.有关详细信息，请参阅索引过滤器。

Perform Large Sort Operation with External Sort使用外部排序执行大型排序操作

Aggregation pipeline stages have maximum memory use limit. 聚合管道阶段有最大内存使用限制。To handle large datasets, set allowDiskUse option to true to enable writing data to temporary files, as in the following example:要处理大型数据集，请将allowDiskUse选项设置为true，以允许将数据写入临时文件，如下例所示：

var results = db.stocks.aggregate(
                                   [
                                     { $project : { cusip: 1, date: 1, price: 1, _id: 0 } },
                                     { $sort : { cusip : 1, date: 1 } }
                                   ],
                                   {
                                     allowDiskUse: true
                                   }
                                 )

Starting in MongoDB 4.2, the profiler log messages and diagnostic log messages includes a usedDisk indicator if any aggregation stage wrote data to temporary files due to memory restrictions.从MongoDB 4.2开始，如果任何聚合阶段由于内存限制将数据写入临时文件，探查器日志消息和诊断日志消息将包括usedDisk指示符。

Specify an Initial Batch Size指定初始批量大小

To specify an initial batch size for the cursor, use the following syntax for the cursor option:要为游标指定初始批量大小，请对cursor选项使用以下语法：

cursor: { batchSize: <int> }

For example, the following aggregation operation specifies the initial batch size of 0 for the cursor:例如，以下聚合操作将游标的初始批量大小指定为0：

db.orders.aggregate(
                     [
                       { $match: { status: "A" } },
                       { $group: { _id: "$cust_id", total: { $sum: "$amount" } } },
                       { $sort: { total: -1 } },
                       { $limit: 2 }
                     ],
                     {
                       cursor: { batchSize: 0 }
                     }
                   )

A batchSize of 0 means an empty first batch and is useful for quickly returning a cursor or failure message without doing significant server-side work. batchSize为0表示第一批为空，用于快速返回游标或失败消息，而无需执行大量服务器端工作。Specify subsequent batch sizes to OP_GET_MORE operations as with other MongoDB cursors.与其他MongoDB游标一样，对OP_GET_MORE操作指定后续批处理大小。

The mongo shell iterates the returned cursor automatically to print the results. mongo shell会自动迭代返回的游标以打印结果。See Iterate a Cursor in the mongo Shell for handling cursors manually in the mongo shell.有关在mongo Shell中手动处理游标的信息，请参阅在mongo Shell中迭代游标。

Specify a Collation指定排序规则

New in version 3.4.版本3.4中的新功能。

Collation allows users to specify language-specific rules for string comparison, such as rules for lettercase and accent marks.排序规则允许用户为字符串比较指定特定于语言的规则，例如字母大小写和重音符号的规则。

A collection myColl has the following documents:myColl集合包含以下文档：

{ _id: 1, category: "café", status: "A" }
{ _id: 2, category: "cafe", status: "a" }
{ _id: 3, category: "cafE", status: "a" }

The following aggregation operation includes the collation option:以下聚合操作包括排序规则选项：

db.myColl.aggregate(
   [ { $match: { status: "A" } }, { $group: { _id: "$category", count: { $sum: 1 } } } ],
   { collation: { locale: "fr", strength: 1 } }
);

Note

If performing an aggregation that involves multiple views, such as with $lookup or $graphLookup, the views must have the same collation.如果执行涉及多个视图的聚合，例如使用$lookup或$graphLookup，则这些视图必须具有相同的排序规则。

For descriptions on the collation fields, see Collation Document.有关排序规则字段的说明，请参阅排序规则文档。

Hint an Index提示索引

New in version 3.6.版本3.6中的新功能。

Create a collection foodColl with the following documents:使用以下文档创建集合foodColl：

db.foodColl.insert([
   { _id: 1, category: "cake", type: "chocolate", qty: 10 },
   { _id: 2, category: "cake", type: "ice cream", qty: 25 },
   { _id: 3, category: "pie", type: "boston cream", qty: 20 },
   { _id: 4, category: "pie", type: "blueberry", qty: 15 }
])

Create the following indexes:创建以下索引：

db.foodColl.createIndex( { qty: 1, type: 1 } );
db.foodColl.createIndex( { qty: 1, category: 1 } );

The following aggregation operation includes the hint option to force the usage of the specified index:以下聚合操作包括hint选项，用于强制使用指定的索引：

db.foodColl.aggregate(
   [ { $sort: { qty: 1 }}, { $match: { category: "cake", qty: 10  } }, { $sort: { type: -1 } } ],
   { hint: { qty: 1, category: 1 } }
)

Override 覆盖readConcern

Use the readConcern option to specify the read concern for the operation.使用readConcern选项指定操作的读取关注点。

You cannot use the $out or the $merge stage in conjunction with read concern "linearizable". 不能将$out阶段或$merge阶段与读取关注点"linearizable"结合使用。That is, if you specify "linearizable" read concern for db.collection.aggregate(), you cannot include either stages in the pipeline.也就是说，如果指定db.collection.aggregate()的"linearizable"读取关注点，不能在管道中包含任何阶段。

The following operation on a replica set specifies a Read Concern of "majority" to read the most recent copy of the data confirmed as having been written to a majority of the nodes.以下对副本集的操作指定"majority"（多数）的读取关注点，以读取确认已写入多数Node的数据的最新副本。

Note

  • To use read concern level of "majority", replica sets must use WiredTiger storage engine.要使用"majority"的读关注级别，副本集必须使用WiredTiger存储引擎。

    You can disable read concern "majority" for a deployment with a three-member primary-secondary-arbiter (PSA) architecture; however, this has implications for change streams (in MongoDB 4.0 and earlier only) and transactions on sharded clusters. 对于具有三成员主从仲裁器（PSA）体系结构的部署，可以禁用读关注点"majority"；然而，这对变更流（仅在MongoDB 4.0及更早版本中）和分片集群上的事务有影响。For more information, see Disable Read Concern Majority.有关更多信息，请参阅禁用读取关注多数。

  • To ensure that a single thread can read its own writes, use "majority" read concern and "majority" write concern against the primary of the replica set.要确保单个线程可以读取自己的写入，请对副本集的主线程使用"majority"读取关注点和"majority"写入关注点。
  • Starting in MongoDB 4.2, you can specify read concern level "majority" for an aggregation that includes an $out stage.从MongoDB 4.2开始，可以为包含$out阶段的聚合指定读关注级别"majority"。

    In MongoDB 4.0 and earlier, you cannot include the $out stage to use "majority" read concern for the aggregation.在MongoDB 4.0及更早版本中，不能将$out阶段包含在聚合中使用"majority"读取关注点。

  • Regardless of the read concern level, the most recent data on a node may not reflect the most recent version of the data in the system.无论读取关注级别如何，Node上的最新数据可能不会反映系统中数据的最新版本。
db.restaurants.aggregate(
   [ { $match: { rating: { $lt: 5 } } } ],
   { readConcern: { level: "majority" } }
)

Specify a Comment指定注释

A collection named movies contains documents formatted as such:名为movies的集合包含以下格式的文档：

{
  "_id" : ObjectId("599b3b54b8ffff5d1cd323d8"),
  "title" : "Jaws",
  "year" : 1975,
  "imdb" : "tt0073195"
}

The following aggregation operation finds movies created in 1995 and includes the comment option to provide tracking information in the logs, the db.system.profile collection, and db.currentOp.下面的聚合操作将查找1995年创建的电影，并包括comment选项，以在logs、db.system.profile集合和db.currentOp中提供跟踪信息。

db.movies.aggregate( [ { $match: { year : 1995 } } ], { comment : "match_all_movies_from_1995" } ).pretty()

On a system with profiling enabled, you can then query the system.profile collection to see all recent similar aggregations, as shown below:在启用了分析功能的系统上，可以查询system.profile集合以查看所有最近的类似聚合，如下所示：

db.system.profile.find( { "command.aggregate": "movies", "command.comment" : "match_all_movies_from_1995" } ).sort( { ts : -1 } ).pretty()

This will return a set of profiler results in the following format:这将以以下格式返回一组探查器结果：

{
  "op" : "command",
  "ns" : "video.movies",
  "command" : {
    "aggregate" : "movies",
    "pipeline" : [
      {
        "$match" : {
          "year" : 1995
        }
      }
    ],
    "comment" : "match_all_movies_from_1995",
    "cursor" : {

    },
    "$db" : "video"
  },
  ...
}

An application can encode any arbitrary information in the comment in order to more easily trace or identify specific operations through the system. 应用程序可以对注释中的任意信息进行编码，以便通过系统更容易地跟踪或识别特定操作。For instance, an application might attach a string comment incorporating its process ID, thread ID, client hostname, and the user who issued the command.例如，应用程序可能会附加一个字符串注释，其中包含其进程ID、线程ID、客户端主机名和发出命令的用户。