MongoDB Limits and ThresholdsMongoDB限制和阈值

BSON DocumentsBSON文件

BSON Document SizeBSON文档大小

The maximum BSON document size is 16 megabytes.BSON文档的最大大小为16兆字节。

The maximum document size helps ensure that a single document cannot use excessive amount of RAM or, during transmission, excessive amount of bandwidth. 最大文档大小有助于确保单个文档不会使用过多的RAM，或者在传输过程中不会使用过大的带宽。To store documents larger than the maximum size, MongoDB provides the GridFS API. See mongofiles and the documentation for your driver for more information about GridFS.为了存储大于最大大小的文档，MongoDB提供了GridFS API。有关GridFS的更多信息，请参阅mongofiles和驱动程序的文档。

Nested Depth for BSON DocumentsBSON文档的嵌套深度

MongoDB supports no more than 100 levels of nesting for BSON documents. MongoDB支持BSON文档的嵌套级别不超过100个。Each object or array adds a level.每个对象或数组都会添加一个级别。

Naming Restrictions命名限制

Use of Case in Database Names数据库名称中大小写的使用

Do not rely on case to distinguish between databases. 不要依赖案例来区分数据库。For example, you cannot use two databases with names like, salesData and SalesData.例如，不能使用名称为salesData和SalesData的两个数据库。

After you create a database in MongoDB, you must use consistent capitalization when you refer to it. 在MongoDB中创建数据库后，在引用数据库时必须使用一致的大写字母。For example, if you create the salesData database, do not refer to it using alternate capitalization such as salesdata or SalesData.例如，如果创建salesData数据库，请不要使用salesdata或salesData等其他大写字母引用它。

Restrictions on Database Names for WindowsWindows数据库名称的限制

For MongoDB deployments running on Windows, database names cannot contain any of the following characters:对于在Windows上运行的MongoDB部署，数据库名称不能包含以下任何字符：

/\. "$*<>:|?

Also database names cannot contain the null character.此外，数据库名称不能包含null字符。

Restrictions on Database Names for Unix and Linux SystemsUnix和Linux系统的数据库名称限制

For MongoDB deployments running on Unix and Linux systems, database names cannot contain any of the following characters:对于在Unix和Linux系统上运行的MongoDB部署，数据库名称不能包含以下任何字符：

/\. "$

Also database names cannot contain the null character.此外，数据库名称不能包含null字符。

Length of Database Names数据库名称的长度

Database names cannot be empty and must have fewer than 64 characters.数据库名称不能为空，并且必须少于64个字符。

Restriction on Collection Names集合名称限制

Collection names should begin with an underscore or a letter character, and cannot:集合名称应以下划线或字母字符开头，并且不能：

• contain the $.包含$。
• be an empty string (e.g. "").是一个空字符串（例如""）。
• contain the null character.包含null字符。
• begin with the system. prefix. (Reserved for internal use.)从system.前缀开始（保留供内部使用。）

If your collection name includes special characters, such as the underscore character, or begins with numbers, then to access the collection use the db.getCollection() method in mongosh or a similar method for your driver.如果集合名称包含特殊字符，如下划线或以数字开头，则要访问集合，请使用mongosh中的db.getCollection()方法或驱动程序的类似方法。

Namespace Length:命名空间长度：

• For featureCompatibilityVersion set to "4.4" or greater, MongoDB raises the limit for unsharded collections and views to 255 bytes, and to 235 bytes for sharded collections. 对于设置为“4.4”或更高版本的featureCompatibilityVersion，MongoDB将未排序集合和视图的限制提高到255字节，将分片集合的限制提高至235字节。For a collection or a view, the namespace includes the database name, the dot (.) separator, and the collection/view name (e.g. <database>.<collection>),对于集合或视图，名称空间包括数据库名称、句点（.）分隔符和集合/视图名称（例如<database>.<collection>），
• For featureCompatibilityVersion set to "4.2" or earlier, the maximum length of unsharded collections and views namespace remains 120 bytes and 100 bytes for sharded collection.对于设置为“4.2”或更早版本的featureCompatibilityVersion，未排序集合和视图命名空间的最大长度保持为120字节，而对于分片集合，则保持为100字节。

Restrictions on Field Names字段名称的限制

• Field names cannot contain the null character.字段名称不能包含null字符。
• The server permits storage of field names that contain dots (.) and dollar signs ($).服务器允许存储包含点（.）和美元符号（$）的字段名。
• MongodB 5.0 adds improved support for the use of ($) and (.) in field names. MongodB 5.0增加了对字段名称中使用（$）和（.）的改进支持。There are some restrictions. See Field Name Considerations for more details.有一些限制。有关更多详细信息，请参阅字段名称注意事项。

Restrictions on _id对_id的限制

The field name _id is reserved for use as a primary key; its value must be unique in the collection, is immutable, and may be of any type other than an array. 字段名称_id被保留用作主键；它的值在集合中必须是唯一的，是不可变的，并且可以是数组以外的任何类型。If the _id contains subfields, the subfield names cannot begin with a ($) symbol.如果_id包含子字段，则子字段名称不能以（$）符号开头。

Naming Warnings命名警告

Namespaces命名空间

Namespace Length命名空间长度

• For featureCompatibilityVersion set to "4.4" or greater, MongoDB raises the limit for unsharded collections and views to 255 bytes, and to 235 bytes for sharded collections. 对于设置为“4.4”或更高版本的featureCompatibilityVersion，MongoDB将未排序集合和视图的限制提高到255字节，将分片集合的限制提高至235字节。For a collection or a view, the namespace includes the database name, the dot (.) separator, and the collection/view name (e.g. <database>.<collection>),对于集合或视图，名称空间包括数据库名称、句点（.）分隔符和集合/视图名称（例如<database>.<collection>），
• For featureCompatibilityVersion set to "4.2" or earlier, the maximum length of unsharded collections and views namespace remains 120 bytes and 100 bytes for sharded collection.对于设置为“4.2”或更早版本的featureCompatibilityVersion，未排序集合和视图命名空间的最大长度保持为120字节，而对于分片集合，则保持为100字节。

Tip

See also: 另请参阅：

Naming Restrictions命名限制

Indexes索引

Index Key Limit索引键限制

Note

Changed in version 4.2在版本4.2中更改

Starting in version 4.2, MongoDB removes the Index Key Limit for featureCompatibilityVersion (fCV) set to "4.2" or greater.从4.2版本开始，MongoDB删除了featureCompatibilityVersion（fCV）设置为“4.2”或更高版本的索引键限制。

For MongoDB 2.6 through MongoDB versions with fCV set to "4.0" or earlier, the total size of an index entry, which can include structural overhead depending on the BSON type, must be less than 1024 bytes.对于fCV设置为“4.0”或更早版本的MongoDB 2.6到MongoDB版本，索引项的总大小必须小于1024字节，根据BSON类型，索引项可能包括结构开销。

When the Index Key Limit applies:当应用索引键限制时：

• MongoDB will not create an index on a collection if the index entry for an existing document exceeds the index key limit.如果现有文档的索引项超过索引键限制，MongoDB将不会在集合上创建索引。
• Reindexing operations will error if the index entry for an indexed field exceeds the index key limit. Reindexing operations occur as part of the compact command as well as the db.collection.reIndex() method.如果索引字段的索引项超过索引键限制，则重新索引操作将出错。重新索引操作是compact命令和db.collection.reIndex()方法的一部分。

  Because these operations drop all the indexes from a collection and then recreate them sequentially, the error from the index key limit prevents these operations from rebuilding any remaining indexes for the collection.由于这些操作会从集合中删除所有索引，然后按顺序重新创建它们，因此索引键限制的错误会阻止这些操作为集合重新生成任何剩余索引。

• MongoDB will not insert into an indexed collection any document with an indexed field whose corresponding index entry would exceed the index key limit, and instead, will return an error. MongoDB不会将任何具有索引字段的文档插入到索引集合中，该字段的相应索引条目将超过索引键限制，相反，它将返回一个错误。Previous versions of MongoDB would insert but not index such documents.MongoDB的早期版本会插入但不会索引此类文档。
• Updates to the indexed field will error if the updated value causes the index entry to exceed the index key limit.如果更新的值导致索引项超过索引键限制，则对索引字段的更新将出错。

  If an existing document contains an indexed field whose index entry exceeds the limit, any update that results in the relocation of that document on disk will error.如果现有文档包含索引项超过限制的索引字段，则导致该文档在磁盘上重新定位的任何更新都将出错。

• mongorestore and mongoimport will not insert documents that contain an indexed field whose corresponding index entry would exceed the index key limit.mongorestore和mongoimport不会插入包含相应索引项超过索引键限制的索引字段的文档。
• In MongoDB 2.6, secondary members of replica sets will continue to replicate documents with an indexed field whose corresponding index entry exceeds the index key limit on initial sync but will print warnings in the logs.在MongoDB 2.6中，副本集的辅助成员将继续复制具有索引字段的文档，该字段的相应索引条目在初始同步时超过了索引键限制，但会在日志中打印警告。

  Secondary members also allow index build and rebuild operations on a collection that contains an indexed field whose corresponding index entry exceeds the index key limit but with warnings in the logs.辅助成员还允许对包含索引字段的集合执行索引生成和重新生成操作，该字段的相应索引项超过了索引键限制，但日志中出现警告。

  With mixed version replica sets where the secondaries are version 2.6 and the primary is version 2.4, secondaries will replicate documents inserted or updated on the 2.4 primary, but will print error messages in the log if the documents contain an indexed field whose corresponding index entry exceeds the index key limit.对于混合版本副本集（其中辅助副本为2.6版，主副本为2.4版），辅助副本将复制在2.4主副本上插入或更新的文档，但如果文档包含相应索引项超过索引键限制的索引字段，则会在日志中打印错误消息。

• For existing sharded collections, chunk migration will fail if the chunk has a document that contains an indexed field whose index entry exceeds the index key limit.对于现有的分片集合，如果区块的文档包含索引项超过索引键限制的索引字段，则区块迁移将失败。

Number of Indexes per Collection每个集合的索引数

A single collection can have no more than 64 indexes.一个集合的索引不能超过64个。

Index Name Length索引名称长度

Note

Changed in version 4.2在版本4.2中更改

Starting in version 4.2, MongoDB removes the Index Name Length limit for MongoDB versions with featureCompatibilityVersion (fCV) set to "4.2" or greater.从4.2版本开始，MongoDB删除了featureCompatibilityVersion（fCV）设置为“4.2”或更高版本的MongoDB版本的索引名称长度限制。

In previous versions of MongoDB or MongoDB versions with fCV set to "4.0" or earlier, fully qualified index names, which include the namespace and the dot separators (i.e. <database name>.<collection name>.$<index name>), cannot be longer than 127 bytes.在MongoDB的早期版本或fCV设置为"4.0"或更早版本的MongoDB版本中，包括命名空间和点分隔符（即<database name>.<collection name>.$<index name>）的完全限定索引名称不能超过127字节。

By default, <index name> is the concatenation of the field names and index type. 默认情况下，<index name>是字段名称和索引类型的串联。You can explicitly specify the <index name> to the createIndex() method to ensure that the fully qualified index name does not exceed the limit.您可以显式地为createIndex()方法指定<index name>，以确保完全限定的索引名称不超过限制。

Number of Indexed Fields in a Compound Index复合索引中的索引字段数

There can be no more than 32 fields in a compound index.一个复合索引中的字段不能超过32个。

Queries cannot use both text and Geospatial Indexes查询不能同时使用文本索引和地理空间索引

You cannot combine the $text query, which requires a special text index, with a query operator that requires a different type of special index. For example you cannot combine $text query with the $near operator.不能将需要特殊文本索引的$text查询与需要不同类型特殊索引的查询运算符组合在一起。例如，不能将$text查询与$near运算符组合使用。

Fields with 2dsphere Indexes can only hold Geometries具有2dsphere索引的字段只能包含几何图形

Fields with 2dsphere indexes must hold geometry data in the form of coordinate pairs or GeoJSON data. 具有2dsphere索引的字段必须以坐标对或GeoJSON数据的形式保存几何数据。If you attempt to insert a document with non-geometry data in a 2dsphere indexed field, or build a 2dsphere index on a collection where the indexed field has non-geometry data, the operation will fail.如果尝试在2dsphere索引字段中插入包含非几何数据的文档，或者在索引字段包含非几何体数据的集合上构建2dsphere索引，则操作将失败。

Tip

See also: 另请参阅：

The unique indexes limit in Sharding Operational Restrictions.分片操作限制中的唯一索引限制。

Limited Number of 2dsphere index keys2dsphere索引键的数量有限

To generate keys for a 2dsphere index, mongod maps GeoJSON shapes to an internal representation. 为了生成2dsphere索引的键，mongod将GeoJSON形状映射到内部表示。The resulting internal representation may be a large array of values.所得到的内部表示可以是一个大的值数组。

When mongod generates index keys on a field that holds an array, mongod generates an index key for each array element. 当mongod在包含数组的字段上生成索引键时，mongod会为每个数组元素生成一个索引键。For compound indexes, mongod calculates the cartesian product of the sets of keys that are generated for each field. 对于复合索引，mongod计算为每个字段生成的键集的笛卡尔乘积。If both sets are large, then calculating the cartesian product could cause the operation to exceed memory limits.如果两个集合都很大，那么计算笛卡尔乘积可能会导致操作超出内存限制。

indexMaxNumGeneratedKeysPerDocument limits the maximum number of keys generated for a single document to prevent out of memory errors. 限制为单个文档生成的最大键数，以防止内存不足错误。The default is 100000 index keys per document. 默认值为每个文档100000个索引键。It is possible to raise the limit, but if an operation requires more keys than the indexMaxNumGeneratedKeysPerDocument parameter specifies, the operation will fail.可以提高限制，但如果操作需要的键数超过indexMaxNumGeneratedKeysPerDocument参数指定的键数，则操作将失败。

NaN values returned from Covered Queries by the WiredTiger Storage Engine are always of type doubleWiredTiger存储引擎从覆盖查询返回的NaN值始终为double类型

If the value of a field returned from a query that is covered by an index is NaN, the type of that NaN value is always double.如果从索引所覆盖的查询返回的字段的值为NaN，则该NaN值的类型始终为double。

Multikey Index多键索引

Multikey indexes多键索引 cannot cover queries over array fields.无法覆盖对数组字段的查询。

Geospatial Index地理空间索引

Geospatial indexes can't cover a query.地理空间索引无法覆盖查询。

Memory Usage in Index Builds索引构建中的内存使用情况

createIndexes supports building one or more indexes on a collection. 支持在集合上生成一个或多个索引。createIndexes uses a combination of memory and temporary files on disk to complete index builds. 使用磁盘上的内存和临时文件的组合来完成索引构建。The default limit on memory usage for createIndexes is 200 megabytes (for versions 4.2.3 and later) and 500 (for versions 4.2.2 and earlier), shared between all indexes built using a single createIndexes command. createIndexes的内存使用默认限制为200兆字节（适用于4.2.3及更高版本）和500兆字节（用于4.2.2及更早版本），在使用单个createIndexes命令构建的所有索引之间共享。Once the memory limit is reached, createIndexes uses temporary disk files in a subdirectory named _tmp within the --dbpath directory to complete the build.一旦达到内存限制，createIndexes就会使用--dbpath目录中名为_tmp的子目录中的临时磁盘文件来完成构建。

You can override the memory limit by setting the maxIndexBuildMemoryUsageMegabytes server parameter. 您可以通过设置maxIndexBuildMemoryUsageMegabytes服务器参数来覆盖内存限制。Setting a higher memory limit may result in faster completion of index builds. 设置更高的内存限制可能会更快地完成索引构建。However, setting this limit too high relative to the unused RAM on your system can result in memory exhaustion and server shutdown.但是，相对于系统上未使用的RAM，将此限制设置得过高可能会导致内存耗尽和服务器关闭。

• For feature compatibility version (fcv) "4.2" and later, the index build memory limit applies to all index builds.对于功能兼容性版本（fcv）“4.2”及更高版本，索引构建内存限制适用于所有索引构建。

Index builds may be initiated either by a user command such as createIndexes or by an administrative process such as an initial sync. 索引构建可以由用户命令（如createIndexes）启动，也可以由管理过程（如初始同步）启动。Both are subject to the limit set by maxIndexBuildMemoryUsageMegabytes.两者都受maxIndexBuildMemoryUsageMegabytes设置的限制。

An initial sync populates only one collection at a time and has no risk of exceeding the memory limit. 初始同步一次只填充一个集合，并且没有超过内存限制的风险。However, it is possible for a user to start index builds on multiple collections in multiple databases simultaneously and potentially consume an amount of memory greater than the limit set by maxIndexBuildMemoryUsageMegabytes.但是，用户可能同时在多个数据库中的多个集合上启动索引生成，并且可能消耗的内存量大于maxIndexBuildMemoryUsageMegabytes设置的限制。

Tip

To minimize the impact of building an index on replica sets and sharded clusters with replica set shards, use a rolling index build procedure as described on Rolling Index Builds on Replica Sets.要最大限度地减少对副本集和具有副本集分片的分片集群构建索引的影响，请使用滚动索引构建过程，如在副本集上滚动索引构建中所述。

Collation and Index Types排序规则和索引类型

The following index types only support simple binary comparison and do not support collation:以下索引类型仅支持简单的二进制比较，不支持排序规则：

• Text indexes索引
• 2d indexes索引

Tip

To create a text or 2d index on a collection that has a non-simple collation, you must explicitly specify {collation: {locale: "simple"} } when creating the index.若要在具有非简单排序规则的集合上创建text索引或2d索引，必须在创建索引时显式指定{collation: {locale: "simple"} }。

Hidden Indexes隐藏索引

• You cannot hide the _id index.不能隐藏_id索引。
• You cannot use hint() on a hidden index.不能对隐藏索引使用hint()。

Sorts排序

Maximum Number of Sort Keys排序键的最大数目

You can sort on a maximum of 32 keys.最多可以对32个键进行排序。

Data数据

Maximum Number of Documents in a Capped Collection有上限集合中的最大文档数

If you specify the maximum number of documents in a capped collection with create's max parameter, the value must be less than 2 ³¹ documents.如果使用create的max参数指定带上限集合中的最大文档数，则该值必须小于2³¹个文档。

If you do not specify a maximum number of documents when creating a capped collection, there is no limit on the number of documents.如果在创建上限集合时未指定最大文档数，则文档数没有限制。

Replica Sets复制集

Number of Members of a Replica Set副本集的成员数

Replica sets can have up to 50 members.副本集最多可以有50个成员。

Number of Voting Members of a Replica Set副本集的投票成员数

Replica sets can have up to 7 voting members. 副本集最多可以有7个投票成员。For replica sets with more than 7 total members, see Non-Voting Members.有关总共有7个以上成员的副本集，请参阅无表决权成员。

Maximum Size of Auto-Created Oplog自动创建的操作日志的最大大小

If you do not explicitly specify an oplog size (i.e. with oplogSizeMB or --oplogSize) MongoDB will create an oplog that is no larger than 50 gigabytes. 如果您没有明确指定oplog大小（即使用oplogSizeMB或--oplogSize），MongoDB将创建一个不超过50 GB的oplog。[1]

[1]	The oplog can grow past its configured size limit to avoid deleting the majority commit point.oplog可以超过其配置的大小限制，以避免删除多数提交点。

Sharded Clusters分片集群

Sharded clusters have the restrictions and thresholds described here.分片集群具有此处描述的限制和阈值。

Operations操作

Sort Operations排序操作

If MongoDB cannot use an index or indexes to obtain the sort order, MongoDB must perform a blocking sort operation on the data. 如果MongoDB不能使用一个或多个索引来获得排序顺序，那么MongoDB必须对数据执行阻塞排序操作。The name refers to the requirement that the SORT stage reads all input documents before returning any output documents, blocking the flow of data for that specific query.该名称指的是SORT阶段在返回任何输出文档之前读取所有输入文档的要求，从而阻止特定查询的数据流。

If MongoDB requires using more than 100 megabytes of system memory for the blocking sort operation, MongoDB returns an error unless the query specifies cursor.allowDiskUse() (New in MongoDB 4.4). 如果MongoDB需要使用超过100兆字节的系统内存进行阻塞排序操作，则除非查询指定cursor.allowDiskUse()，否则MongoDB将返回错误（MongoDB 4.4中的新增）。allowDiskUse() allows MongoDB to use temporary files on disk to store data exceeding the 100 megabyte system memory limit while processing a blocking sort operation.允许MongoDB在处理阻塞排序操作时使用磁盘上的临时文件来存储超过100兆字节系统内存限制的数据。

Changed in version 4.44.4版更改: For MongoDB 4.2 and prior, blocking sort operations could not exceed 32 megabytes of system memory.：对于MongoDB 4.2及以前版本，阻塞排序操作不能超过32兆字节的系统内存。

For more information on sorts and index use, see Sort and Index Use.有关排序和索引使用的详细信息，请参阅排序和索引的使用。

Aggregation Pipeline Operation聚合管道操作

Starting in MongoDB 6.0, the allowDiskUseByDefault parameter controls whether pipeline stages that require more than 100 megabytes of memory to execute write temporary files to disk by default.从MongoDB 6.0开始，allowDiskUseByDefault参数控制需要超过100MB内存才能执行的管道阶段是否默认将临时文件写入磁盘。

• If allowDiskUseByDefault is set to true, pipeline stages that require more than 100 megabytes of memory to execute write temporary files to disk by default. 如果allowDiskUseByDefault设置为true，则默认情况下，需要超过100兆字节内存才能执行的管道阶段会将临时文件写入磁盘。You can disable writing temporary files to disk for specific find or aggregate commands using the { allowDiskUse: false } option.您可以使用{ allowDiskUse: false }选项禁用将临时文件写入磁盘以执行特定的find或aggregate命令。
• If allowDiskUseByDefault is set to false, pipeline stages that require more than 100 megabytes of memory to execute raise an error by default. 如果allowDiskUseByDefault设置为false，则需要超过100兆字节内存才能执行的管道阶段在默认情况下会引发错误。You can enable writing temporary files to disk for specific find or aggregate using the { allowDiskUse: true } option.您可以使用{ allowDiskUse: true }选项将临时文件写入磁盘以进行特定find或aggregate。

The $search aggregation stage is not restricted to 100 megabytes of RAM because it runs in a separate process.$search聚合阶段不限于100兆字节的RAM，因为它在一个单独的进程中运行。

Examples of stages that can write temporary files to disk when allowDiskUse is true are:当allowDiskUse为true时，可以将临时文件写入磁盘的阶段示例如下：

• $bucket
• $bucketAuto
• $group
• $setWindowFields
• $sort when the sort operation is not supported by an index当索引不支持排序操作时
• $sortByCount

Note

Pipeline stages operate on streams of documents with each pipeline stage taking in documents, processing them, and then outputing the resulting documents.管道阶段对文档流进行操作，每个管道阶段接收文档，对其进行处理，然后输出生成的文档。

Some stages can't output any documents until they have processed all incoming documents. These pipeline stages must keep their stage output in RAM until all incoming documents are processed. 某些阶段在处理完所有传入文档后才能输出任何文档。这些流水线阶段必须将其阶段输出保存在RAM中，直到处理完所有传入的文档。As a result, these pipeline stages may require more space than the 100 MB limit.因此，这些流水线阶段可能需要比100MB限制更多的空间。

If the results of one of your $sort pipeline stages exceed the limit, consider adding a $limit stage.如果某个$sort管道阶段的结果超过了限制，请考虑添加一个$limit阶段。

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指示符。

Aggregation and Read Concern聚合和读取关注

• 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阶段。

2d Geospatial queries cannot use the $or operator二维地理空间查询不能使用$or运算符

Tip

See:

• $or
• 2d Index Internals2d索引内部构件

Geospatial Queries地理空间查询

Using a 2d index for queries on spherical data can return incorrect results or an error. For example, 2d indexes don't support spherical queries that wrap around the poles.使用2d索引查询球形数据可能会返回不正确的结果或错误。例如，2d索引不支持环绕极点的球形查询。

Geospatial Coordinates地理空间坐标

• Valid longitude values are between -180 and 180, both inclusive.有效的经度值介于-180和180之间（包括-180和180）。
• Valid latitude values are between -90 and 90, both inclusive.有效的纬度值介于-90和90之间（包括-90和90）。

Area of GeoJSON PolygonsGeoJSON多边形面积

For $geoIntersects or $geoWithin, if you specify a single-ringed polygon that has an area greater than a single hemisphere, include the custom MongoDB coordinate reference system in the $geometry expression. 对于$geoIntersects或$geoWithin，如果指定面积大于单个半球的单个环形多边形，请在$geometry表达式中包含自定义MongoDB坐标参考系。Otherwise, $geoIntersects or $geoWithin queries for the complementary geometry. 否则，$geoIntersects或$geoWithin将查询互补几何体。For all other GeoJSON polygons with areas greater than a hemisphere, $geoIntersects or $geoWithin queries for the complementary geometry.对于面积大于半球的所有其他GeoJSON多边形，$geoIntersects或$geoWithin查询互补几何体。

Multi-document Transactions多文档事务处理

For multi-document transactions:对于多文档事务：

• You can specify read/write (CRUD) operations on existing collections. 您可以在现有集合上指定读/写（CRUD）操作。For a list of CRUD operations, see CRUD Operations.有关CRUD操作的列表，请参阅CRUD操作。
• Starting in MongoDB 4.4, you can create collections and indexes in transactions. 从MongoDB 4.4开始，您可以在事务中创建集合和索引。For details, see Create Collections and Indexes In a Transaction有关详细信息，请参阅在事务中创建集合和索引
• The collections used in a transaction can be in different databases.事务中使用的集合可以在不同的数据库中。
  Note

  You cannot create new collections in cross-shard write transactions. 不能在跨分片写入事务中创建新集合。For example, if you write to an existing collection in one shard and implicitly create a collection in a different shard, MongoDB cannot perform both operations in the same transaction.例如，如果您在一个分片中写入一个现有集合，并在另一个分片中隐式创建一个集合，则MongoDB无法在同一事务中执行这两个操作。

• You cannot write to capped collections. (Starting in MongoDB 4.2)您不能写入封顶集合。（从MongoDB 4.2开始）
• You cannot use read concern "snapshot" when reading from a capped collection. (Starting in MongoDB 5.0)从封顶集合中读取时，不能使用读取关注"snapshot"。（从MongoDB 5.0开始）
• You cannot read/write to collections in the config, admin, or local databases.无法读取/写入config、admin或local数据库中的集合。
• You cannot write to system.* collections.无法写入system.*集合。
• You cannot return the supported operation's query plan (i.e. explain).无法返回支持的操作的查询计划（即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。

• Starting in MongoDB 4.2, you cannot specify killCursors as the first operation in a transaction.从MongoDB 4.2开始，您不能将killCursors指定为事务中的第一个操作。

Changed in version 4.44.4版更改.

The following operations are not allowed in transactions:事务记录中不允许执行以下操作：

• Operations that affect the database catalog, such as creating or dropping a collection or an index when using MongoDB 4.2 or lower. 影响数据库目录的操作，例如在使用MongoDB 4.2或更低版本时创建或删除集合或索引。Starting in MongoDB 4.4, you can create collections and indexes in transactions unless the transaction is a cross-shard write transaction. For details, see Create Collections and Indexes In a Transaction.从MongoDB 4.4开始，您可以在事务中创建集合和索引，除非事务是跨分片写入事务。有关详细信息，请参阅在事务中创建集合和索引。
• Creating new collections in cross-shard write transactions. 在跨分片写入事务中创建新集合。For example, if you write to an existing collection in one shard and implicitly create a collection in a different shard, MongoDB cannot perform both operations in the same transaction.例如，如果您在一个分片中写入一个现有集合，并在另一个分片中隐式创建一个集合，则MongoDB无法在同一事务中执行这两个操作。
• Explicit creation of collections, e.g. db.createCollection() method, and indexes, e.g. db.collection.createIndexes() and db.collection.createIndex() methods, when using a read concern level other than "local".当使用“local”以外的读取关注级别时，显式创建集合，例如db.createCollection()方法，以及索引，例如db.collection.createIndexes()和db.collection.createIndex()方法。
• The listCollections and listIndexes commands and their helper methods.listCollections和listIndexes命令及其辅助方法。
• Other non-CRUD and non-informational operations, such as createUser, getParameter, count, etc. and their helpers.其他非CRUD和非信息性操作，如createUser、getParameter、count等及其助手。

Transactions have a lifetime limit as specified by transactionLifetimeLimitSeconds. 事务具有transactionLifetimeLimitSeconds指定的生存期限制。The default is 60 seconds.默认值为60秒。

Write Command Batch Limit Size写入命令批限制大小

100,000 writes are allowed in a single batch operation, defined by a single request to the server.单个批处理操作允许100000次写入，该操作由对服务器的单个请求定义。

Changed in version 3.6:3.6版更改：The limit raises from 1,000 to 100,000 writes. 写入次数限制从1000次提高到100000次。This limit also applies to legacy OP_INSERT messages.此限制也适用于旧式OP_INSERT消息。

The Bulk() operations in mongosh and comparable methods in the drivers do not have this limit.mongosh中的Bulk()操作和驱动程序中的类似方法没有这个限制。

Views视图

A view definition pipeline cannot include the $out or the $merge stage. 视图定义pipeline不能包含$out或$merge阶段。This restriction also applies to embedded pipelines, such as pipelines used in $lookup or $facet stages.此限制也适用于嵌入式管道，例如$lookup或$facet阶段中使用的管道。

Views have the following operation restrictions:视图具有以下操作限制：

• Views are read-only.视图是只读的。
• You cannot rename views.不能重命名视图。
• find() operations on views do not support the following Query and Projection Operators operators:视图上的find()操作不支持以下查询运算符和投影运算符：
  • $
  • $elemMatch
  • $slice
  • $meta
• Views视图 do not support text search.不支持文本搜索。
• Views<视图 do not support map-reduce operations.不支持map-reduce操作。
• Views视图 do not support geoNear operations (specifically, the $geoNear pipeline stage).不支持geoNear操作（特别是$geoNear管道阶段）。

Projection Restrictions投影限制

New in version 4.4:4.4版新增：

$-Prefixed Field Path Restriction前缀字段路径限制

Starting in MongoDB 4.4, the find() and findAndModify() projection cannot project a field that starts with $ with the exception of the DBRef fields.从MongoDB 4.4开始，find()和findAndModify()投影不能投影以$开头的字段，DBRef字段除外。For example, starting in MongoDB 4.4, the following operation is invalid: 例如，在MongoDB 4.4中启动时，以下操作无效：

db.inventory.find( {}, { "$instock.warehouse": 0, "$item": 0, "detail.$price": 1 } ) // Invalid starting in 4.4

In earlier version, MongoDB ignores the $-prefixed field projections.在早期版本中，MongoDB忽略了前缀为$的字段投影。

$ Positional Operator Placement Restriction位置运算符安置限制

Starting in MongoDB 4.4, the $ projection operator can only appear at the end of the field path, for example "field.$" or "fieldA.fieldB.$".从MongoDB 4.4开始，$投影运算符只能出现在字段路径的末尾，例如"field.$"或"fieldA.fieldB.$"。For example, starting in MongoDB 4.4, the following operation is invalid: 例如，在MongoDB 4.4中启动时，以下操作无效：

db.inventory.find( { }, { "instock.$.qty": 1 } ) // Invalid starting in 4.4

To resolve, remove the component of the field path that follows the $ projection operator.若要解决此问题，请删除$投影运算符后面的字段路径的组件。In previous versions, MongoDB ignores the part of the path that follows the $; i.e. the projection is treated as "instock.$".在以前的版本中，MongoDB会忽略跟在$后面的路径部分；即投影被视为"instock.$"。

Empty Field Name Projection Restriction空字段名称投影限制

Starting in MongoDB 4.4, find() and findAndModify() projection cannot include a projection of an empty field name.从MongoDB 4.4开始，find()和findAndModify()投影不能包含空字段名的投影。For example, starting in MongoDB 4.4, the following operation is invalid: 例如，在MongoDB 4.4中启动时，以下操作无效：

db.inventory.find( { }, { "": 0 } ) // Invalid starting in 4.4

In previous versions, MongoDB treats the inclusion/exclusion of the empty field as it would the projection of non-existing fields.在以前的版本中，MongoDB将空字段的包含/排除视为不存在字段的投影。

Path Collision: Embedded Documents and Its Fields路径冲突：嵌入文档及其字段

Starting in MongoDB 4.4, it is illegal to project an embedded document with any of the embedded document's fields. For example, consider a collection inventory with documents that contain a size field:从MongoDB 4.4开始，用嵌入文档的任何字段投影嵌入文档都是非法的。例如，考虑一个包含size字段的文档的集合inventory：

{ ..., size: { h: 10, w: 15.25, uom: "cm" }, ... }

Starting in MongoDB 4.4, the following operation fails with a Path collision error because it attempts to project both size document and the size.uom field: 从MongoDB 4.4开始，以下操作失败，出现Path collision错误，因为它试图同时投影size文档和size.uom字段：

db.inventory.find( {}, { size: 1, "size.uom": 1 } )  // Invalid starting in 4.4

In previous versions, lattermost projection between the embedded documents and its fields determines the projection:在以前的版本中，嵌入文档及其字段之间的最新投影决定了投影：

• If the projection of the embedded document comes after any and all projections of its fields, MongoDB projects the embedded document. 如果嵌入文档的投影在其字段的任何和所有投影之后，MongoDB将对嵌入文档进行投影。For example, the projection document { "size.uom": 1, size: 1 } produces the same result as the projection document { size: 1 }.例如，投影文档{ "size.uom": 1, size: 1 }产生的结果与投影文档{ size: 1 }相同。
• If the projection of the embedded document comes before the projection any of its fields, MongoDB projects the specified field or fields. 如果嵌入文档的投影先于其任何字段的投影，MongoDB将投影指定的一个或多个字段。For example, the projection document { "size.uom": 1, size: 1, "size.h": 1 } produces the same result as the projection document { "size.uom": 1, "size.h": 1 }.例如，投影文档{ "size.uom": 1, size: 1, "size.h": 1 }产生的结果与投影文档{ "size.uom": 1, "size.h": 1 }相同。。

Path Collision: $slice of an Array and Embedded Fields路径冲突：数组和嵌入字段的$slice

Starting in MongoDB 4.4, find() and findAndModify() projection cannot contain both a $slice of an array and a field embedded in the array.从MongoDB 4.4开始，find()和findAndModify()投影不能同时包含数组的$slice和数组中嵌入的字段。For example, consider a collection inventory that contains an array field instock: 例如，考虑一个包含数组字段instock的集合inventory：

{ ..., instock: [ { warehouse: "A", qty: 35 }, { warehouse: "B", qty: 15 }, { warehouse: "C", qty: 35 } ], ... }

Starting in MongoDB 4.4, the following operation fails with a Path collision error:从MongoDB 4.4开始，以下操作失败，出现Path collision错误：

db.inventory.find( {}, { "instock": { $slice: 1 }, "instock.warehouse": 0 } ) // Invalid starting in 4.4

In previous versions, the projection applies both projections and returns the first element ($slice: 1) in the instock array but suppresses the warehouse field in the projected element. 在以前的版本中，投影应用两个投影并返回instock数组中的第一个元素（$slice:1），但抑制投影元素中的warehouse字段。Starting in MongoDB 4.4, to achieve the same result, use the db.collection.aggregate() method with two separate $project stages.从MongoDB 4.4开始，要获得相同的结果，请使用带有两个独立$project阶段的db.collection.aggregate()方法。

$ Positional Operator and $slice Restriction$位置运算符和$slice限制

Starting in MongoDB 4.4, find() and findAndModify() projection cannot include $slice projection expression as part of a $ projection expression.For example, starting in MongoDB 4.4, the following operation is invalid:从MongoDB 4.4开始，find()和findAndModify()投影不能包含$slice投影表达式作为$投影表达式的一部分。例如，从MongoDB 3.4开始，以下操作无效：

db.inventory.find( { "instock.qty": { $gt: 25 } }, { "instock.$": { $slice: 1 } } ) // Invalid starting in 4.4

In previous versions, MongoDB returns the first element (instock.$) in the instock array that matches the query condition; i.e. the positional projection "instock.$" takes precedence and the $slice:1 is a no-op. 在以前的版本中，MongoDB返回instock数组中与查询条件匹配的第一个元素（instock.$）；即，位置投影"instock.$"优先，$slice:1是no-op。The "instock.$": { $slice: 1 } does not exclude any other document field."instock.$": { $slice: 1 }不排除任何其他文档字段。

Sessions会话

Sessions and $external Username Limit会话和$external用户名限制

To use Client Sessions and Causal Consistency Guarantees with $external authentication users (Kerberos, LDAP, or x.509 users), usernames cannot be greater than 10k bytes.要对$external身份验证用户（Kerberos、LDAP或x.509用户）使用客户端会话和因果一致性保证，用户名不能大于10k字节。

Session Idle Timeout会话空闲超时

Sessions that receive no read or write operations for 30 minutes or that are not refreshed using refreshSessions within this threshold are marked as expired and can be closed by the MongoDB server at any time. 30分钟内未接收到读取或写入操作的会话，或在此阈值内未使用refreshSessions刷新的会话被标记为过期，MongoDB服务器可以随时关闭这些会话。Closing a session kills any in-progress operations and open cursors associated with the session. 关闭会话会杀死任何正在进行的操作和打开的与会话相关的游标。This includes cursors configured with noCursorTimeout() or a maxTimeMS() greater than 30 minutes.这包括配置为noCursorTimeout()或maxTimeMS()大于30分钟的游标。

Consider an application that issues a db.collection.find(). 考虑一个发出db.collection.find()的应用程序。The server returns a cursor along with a batch of documents defined by the cursor.batchSize() of the find(). 服务器返回一个游标以及find()的cursor.batchSize()定义的一批文档。The session refreshes each time the application requests a new batch of documents from the server. 每当应用程序从服务器请求新的一批文档时，会话都会刷新。However, if the application takes longer than 30 minutes to process the current batch of documents, the session is marked as expired and closed. 但是，如果应用程序处理当前一批文档的时间超过30分钟，则会话将标记为过期并关闭。When the application requests the next batch of documents, the server returns an error as the cursor was killed when the session was closed.当应用程序请求下一批文档时，服务器会返回一个错误，因为会话关闭时游标已被终止。

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 Mongo.startSession() and periodically refresh the session using the refreshSessions command. 对于返回游标的操作，如果游标空闲时间可能超过30分钟，请使用Mongo.startSession()在显式会话中发出操作，并使用refreshSessions命令定期刷新会话。For example:例如：

var session = db.getMongo().startSession()
var sessionId = session
sessionId  // show the sessionId显示会话ID

var cursor = session.getDatabase("examples").getCollection("data").find().noCursorTimeout()
var refreshTimestamp = new Date() // take note of time at operation start注意操作开始时的时间

while (cursor.hasNext()) {

  // Check if more than 5 minutes have passed since the last refresh检查自上次刷新以来是否超过5分钟
  if ( (new Date()-refreshTimestamp)/1000 > 300 ) {
    print("refreshing session")
    db.adminCommand({"refreshSessions" : [sessionId]})
    refreshTimestamp = new Date()
  }

  // process cursor normally正常处理游标

}

In the example operation, the db.collection.find() method is associated with an explicit session. 在示例操作中，db.collection.find()方法与一个显式会话相关联。The cursor is configured with noCursorTimeout() to prevent the server from closing the cursor if idle. 游标配置为noCursorTimeout()，以防止服务器在空闲时关闭游标。The while loop includes a block that uses refreshSessions to refresh the session every 5 minutes. while循环包括一个块，该块使用refreshSessions每隔5分钟刷新一次会话。Since the session will never exceed the 30 minute idle timeout, the cursor can remain open indefinitely.由于会话永远不会超过30分钟的空闲超时，因此游标可以无限期地保持打开状态。

For MongoDB drivers, defer to the driver documentation for instructions and syntax for creating sessions.对于MongoDB驱动程序，有关创建会话的说明和语法，请参阅驱动程序文档。