mongodb
diff --git a/‎snooty.toml
Lines changed: 1 addition & 0 deletions b/‎snooty.toml
Lines changed: 1 addition & 0 deletions
diff --git a/‎source/core/capped-collections.txt
Lines changed: 94 additions & 216 deletions b/‎source/core/capped-collections.txt
Lines changed: 94 additions & 216 deletions
@@ -46,6 +46,7 @@ toc_landing_pages = [
    "/core/authentication",
    "/core/authorization",
    "/core/backups",
+   "/core/capped-collections",
    "/core/crud",
    "/core/csfle",
    "/core/csfle/fundamentals/",
 
@@ -1,4 +1,5 @@
 .. _manual-capped-collection:
+.. _capped_collections_remove_documents:
 
 ==================
 Capped Collections
@@ -12,66 +13,81 @@ Capped Collections
    :depth: 2
    :class: singlecol
 
-Overview
---------
+.. facet::
+   :name: genre
+   :values: reference
 
-:term:`Capped collections <capped collection>` are fixed-size
-collections that support high-throughput operations that insert
-and retrieve documents based on insertion order. Capped
-collections work in a way similar to circular buffers: once a
-collection fills its allocated space, it makes room for new documents
-by overwriting the oldest documents in the collection.
+Capped collections are fixed-size collections that insert and retrieve
+documents based on insertion order. Capped collections work similarly to
+circular buffers: once a collection fills its allocated space, it makes
+room for new documents by overwriting the oldest documents in the
+collection.
 
-See :method:`~db.createCollection()` or :dbcommand:`create`
-for more information on creating capped collections.
+Restrictions
+------------
 
-.. tip::
+- Capped collections cannot be sharded.
 
-   As an alternative to capped collections, consider MongoDB's
-   :ref:`TTL (Time To Live) indexes <index-feature-ttl>`. As
-   described in :ref:`ttl-collections`, these indexes allow you
-   to expire and remove data from normal collections based on the value
-   of a date-typed field and a TTL value for the index.
+- You cannot create capped collections on :atlas:`serverless instances
+  </tutorial/create-serverless-instance/>`.
 
-   TTL indexes are not compatible with capped collections.
+- Capped collections are not supported in :ref:`Stable API <stable-api>`
+  V1.
 
+- You cannot write to capped collections in :ref:`transactions
+  <transactions>`.
 
-Behavior
---------
+- The :pipeline:`$out` aggregation pipeline stage cannot write results
+  to a capped collection.
 
-Insertion Order
-~~~~~~~~~~~~~~~
+- You cannot use read concern :readconcern:`"snapshot"` when reading
+  from a capped collection.
 
-Capped collections guarantee preservation of the insertion order. As a
-result, queries do not need an index to return documents in insertion
-order. Without this indexing overhead, capped collections can support
-higher insertion throughput.
+Command Syntax
+--------------
 
-.. _capped_collections_remove_documents:
+The following example creates a capped collection called ``log`` with a
+maximum size of 100,000 bytes.
+
+.. code-block:: javascript
+
+   db.createCollection( "log", { capped: true, size: 100000 } )
+
+For more information on creating capped collections, see
+:method:`~db.createCollection()` or :dbcommand:`create`.
+
+Use Cases
+---------
+
+.. include:: /includes/capped-collections/use-ttl-index.rst
+
+The most common use case for a capped collection is to store log
+information. When the capped collection reaches its maximum size, old
+log entries are automatically overwritten with new entries.
+
+Get Started
+-----------
 
-Automatic Removal of Oldest Documents
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+To create and query capped collections, see these pages:
 
-To make room for new documents, capped collections automatically remove
-the oldest documents in the collection without requiring scripts or
-explicit remove operations.
+- :ref:`capped-collections-create`
 
-Consider the following potential use cases for capped
-collections:
+- :ref:`capped-collections-query`
 
-- Store log information generated by high-volume systems. Inserting
-  documents in a capped collection without an index is close to the
-  speed of writing log information directly to a file
-  system. Furthermore, the built-in *first-in-first-out* property
-  maintains the order of events, while managing storage use.
-  For example, the :ref:`oplog <capped-collections-oplog>` 
-  uses a capped collection.
+- :ref:`capped-collections-check`
 
-- Cache small amounts of data in a capped collections. Since caches
-  are read rather than write heavy, you would either need to ensure
-  that this collection *always* remains in the working set (i.e. in
-  RAM) *or* accept some write penalty for the required index or
-  indexes.
+- :ref:`capped-collections-convert`
+
+- :ref:`capped-collections-change-size`
+
+- :ref:`capped-collections-change-max-docs`
+
+.. _capped-collections-recommendations-and-restrictions:
+
+Details
+-------
+
+Consider these behavioral details for capped collections.
 
 .. _capped-collections-oplog:
 
@@ -81,203 +97,65 @@ Oplog Collection
 The :term:`oplog.rs <oplog>` collection that stores a log
 of the operations in a :term:`replica set` uses a capped collection.
 
-Starting in MongoDB 4.0, unlike other capped collections, the oplog can
-grow past its configured size limit to avoid deleting the :data:`majority
-commit point <replSetGetStatus.optimes.lastCommittedOpTime>`. 
+Unlike other capped collections, the oplog can grow past its configured
+size limit to avoid deleting the :data:`majority commit point
+<replSetGetStatus.optimes.lastCommittedOpTime>`.
 
 .. note:: 
 
    MongoDB rounds the capped size of the oplog up to the nearest 
    integer multiple of 256, in bytes.
 
-``_id`` Index
-~~~~~~~~~~~~~
+_id Index
+~~~~~~~~~
 
 Capped collections have an ``_id`` field and an index on the ``_id``
 field by default.
 
-.. _capped-collections-recommendations-and-restrictions:
-
-Restrictions and Recommendations
---------------------------------
-
-Reads
-~~~~~
-
-.. include:: /includes/extracts/transactions-capped-collection-read-change.rst
-
 Updates
 ~~~~~~~
 
-If you plan to update documents in a capped collection, create an index
-so that these update operations do not require a collection scan.
-
-Sharding
-~~~~~~~~
-
-You cannot shard a capped collection.
+Avoid updating data in a capped collection. Because capped collections
+are fixed-size, updates can cause your data to expand beyond the
+collection's allocated space, which can cause unexpected behavior.
 
 Query Efficiency
 ~~~~~~~~~~~~~~~~
 
-Use natural ordering to retrieve the most recently inserted elements
-from the collection efficiently. This is similar to using the ``tail``
-command on a log file.
-
-Aggregation ``$out``
-~~~~~~~~~~~~~~~~~~~~
-
-The aggregation pipeline stage :pipeline:`$out` 
-cannot write results to a capped collection.
-
-.. include:: /includes/replacement-mms.rst
-
-Transactions
-~~~~~~~~~~~~
+.. include:: /includes/capped-collections/query-natural-order.rst
 
-.. include:: /includes/extracts/transactions-capped-collection-change.rst
-
-Stable API
-~~~~~~~~~~
+Tailable Cursor
+~~~~~~~~~~~~~~~
 
-Capped collections are not supported in :ref:`Stable API
-<stable-api>` V1.
+You can use a :term:`tailable cursor` with capped collections. Similar to the
+Unix ``tail -f`` command, the tailable cursor "tails" the end of a
+capped collection. As new documents are inserted into the capped
+collection, you can use the tailable cursor to continue retrieving
+documents.
 
-Procedures
-----------
+For information on creating a tailable cursor, see
+:ref:`tailable-cursors-landing-page`.
 
-Create a Capped Collection
+Multiple Concurrent Writes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-You must create capped collections explicitly using the
-:method:`db.createCollection()` method, which is a
-:binary:`~bin.mongosh` helper for the :dbcommand:`create` command.
-When creating a capped collection you must specify the maximum size of
-the collection in bytes, which MongoDB will pre-allocate for the
-collection. The size of the capped collection includes a small amount of
-space for internal overhead.
+.. include:: /includes/capped-collections/concurrent-writes.rst
 
-.. code-block:: javascript
-
-   db.createCollection( "log", { capped: true, size: 100000 } )
-
-.. note:: 
-   
-   The value that you provide for the ``size`` field 
-   must be greater than ``0`` and less than or equal to
-   ``1024^5`` (1 {+pb+}). MongoDB rounds the ``size`` of all capped 
-   collections up to the nearest integer multiple of 256, in bytes.
-
-Additionally, you may also specify a maximum number of documents for the
-collection using the ``max`` field as in the following document:
-
-.. code-block:: javascript
-
-   db.createCollection("log", { capped : true, size : 5242880, max :
-   5000 } )
-
-.. important:: 
-   
-   The ``size`` field is *always* required, even when
-   you specify the ``max`` number of documents. MongoDB removes older
-   documents if a collection reaches the maximum size limit before it
-   reaches the maximum document count.
-
-.. see::
-
-   :method:`db.createCollection()` and  :dbcommand:`create`.
-
-.. _capped-collections-options:
-
-Query a Capped Collection
-~~~~~~~~~~~~~~~~~~~~~~~~~
-
-If you perform a :method:`~db.collection.find()` on a capped collection
-with no ordering specified, MongoDB guarantees that the ordering of
-results is the same as the insertion order.
-
-To retrieve documents in reverse insertion order, issue
-:method:`~db.collection.find()` along with the :method:`~cursor.sort()`
-method with the :operator:`$natural` parameter set to ``-1``, as shown
-in the following example:
-
-.. code-block:: javascript
-
-   db.cappedCollection.find().sort( { $natural: -1 } )
-
-Check if a Collection is Capped
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-Use the :method:`~db.collection.isCapped()` method to determine if a
-collection is capped, as follows:
-
-.. code-block:: javascript
-
-   db.collection.isCapped()
-
-Convert a Collection to Capped
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-You can convert a non-capped collection to a capped collection with
-the :dbcommand:`convertToCapped` command:
-
-.. code-block:: javascript
-
-   db.runCommand({"convertToCapped": "mycoll", size: 100000});
-
-The ``size`` parameter specifies the size of the capped collection in
-bytes.
-
-.. include:: /includes/fact-database-lock.rst
-
-Change a Capped Collection's Size
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. versionadded:: 6.0
-
-You can resize a capped collection using the :dbcommand:`collMod` command's 
-``cappedSize`` option to set the ``cappedSize`` in bytes. ``cappedSize`` must be 
-greater than ``0`` and less than or equal to ``1024^5`` (1 {+pb+}).
-
-.. note::
-
-   Before you can resize a capped collection, you must have already set
-   the :ref:`featureCompatibilityVersion <set-fcv>` to at least version
-   ``"6.0"``.
-
-For example, the following command sets the maximum size of the ``"log"`` capped 
-collection to 100000 bytes:
-
-.. code-block:: javascript
-
-   db.runCommand( { collMod: "log", cappedSize: 100000 } )
-
-Change the Maximum Number of Documents in a Capped Collection
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-.. versionadded:: 6.0
-
-To change the maximum number of documents in a capped collection, use the
-:dbcommand:`collMod` command's ``cappedMax`` option. If ``cappedMax`` is less 
-than or equal to ``0``, there is no maximum document limit. If
-``cappedMax`` is less than the current number of documents in the
-collection, MongoDB removes the excess documents on the next insert operation.
-
-For example, the following command sets the maximum number of documents in the
-``"log"`` capped collection to 500:
+Learn More
+----------
 
-.. code-block:: javascript
+- :ref:`index-feature-ttl`
 
-   db.runCommand( { collMod: "log", cappedMax: 500 } )
+- :ref:`index-properties`
 
-Tailable Cursor
-~~~~~~~~~~~~~~~
+- :ref:`indexing-strategies`
 
-You can use a :term:`tailable cursor` with capped collections. Similar to the
-Unix ``tail -f`` command, the tailable cursor "tails" the end of a
-capped collection. As new documents are inserted into the capped
-collection, you can use the tailable cursor to continue retrieving
-documents.
+.. toctree::
+   :titlesonly:
 
-See :doc:`/core/tailable-cursors` for information on creating
-a tailable cursor.
+   /core/capped-collections/create-capped-collection
+   /core/capped-collections/query-capped-collection
+   /core/capped-collections/check-if-collection-is-capped
+   /core/capped-collections/convert-collection-to-capped
+   /core/capped-collections/change-size-capped-collection
+   /core/capped-collections/change-max-docs-capped-collection