DOCSP-16397 headings and sidebar toc (#177)

* added sidebar TOC

Author: kyuan-mongodb

source/fundamentals/crud/compound-operations.txt

@@ -10,6 +10,9 @@ Compound Operations
    :depth: 1
    :class: singlecol
 
+Overview
+--------
+
 Most database requests only need to read data out of a database or
 write data into a database. However, client applications sometimes need
 to read and write data in a single interaction with the database.
@@ -35,7 +38,7 @@ multiple potential error states. This increases the complexity of your
 code and can make your client application brittle and difficult to test.
 
 Built-in Methods
-~~~~~~~~~~~~~~~~
+----------------
 
 There are three major compound operations:
 

source/fundamentals/crud/read-operations/cursor.txt

@@ -10,6 +10,9 @@ Access Data From a Cursor
    :depth: 2
    :class: singlecol
 
+Overview
+--------
+
 Read operations that return multiple documents do not immediately return
 all values matching the query. Because a query can potentially match
 very large sets of documents, these operations rely upon an

source/fundamentals/crud/read-operations/limit.txt

@@ -4,6 +4,15 @@ Limit the Number of Returned Results
 
 .. default-domain:: mongodb
 
+.. contents:: On this page
+   :local:
+   :backlinks: none
+   :depth: 2
+   :class: singlecol
+
+Overview
+--------
+
 Use ``limit`` to cap the number of documents that can be returned from a
 read operation. ``limit`` functions as a cap on the maximum number of
 documents that the operation can return, but the operation can return
@@ -13,6 +22,9 @@ to reach the limit. If ``limit`` is used with the
 first and the limit only applies to the documents left over after
 the skip.
 
+Sample Documents
+~~~~~~~~~~~~~~~~
+
 Follow the instructions in the examples below to insert data into
 a collection and return only certain results from a query using a sort,
 a skip, and a limit. Consider the following collection of documents that
@@ -29,6 +41,9 @@ describe books:
      { "_id": 6, "name": "A Dance With Dragons", "author": "Tolkein", "length": 1104 },
    ]
 
+Limit
+-----
+
 The following example queries the collection to return the top three
 longest books. It matches all the documents with the query, applies
 a ``sort`` on the ``length`` field to return books with longer lengths before
@@ -78,6 +93,9 @@ For more information on the ``options`` settings for the ``find()``
 method, see the
 :node-api:`API documentation on find() <Collection.html#find>`.
 
+Skip
+----
+
 To see the next three books in the results, append the ``skip()`` method,
 passing the number of documents to bypass as shown below:
 

source/fundamentals/crud/read-operations/project.txt

@@ -4,6 +4,15 @@ Specify Which Fields to Return
 
 .. default-domain:: mongodb
 
+.. contents:: On this page
+   :local:
+   :backlinks: none
+   :depth: 2
+   :class: singlecol
+
+Overview
+--------
+
 Use a projection to control which fields appear in the documents
 returned by read operations. Many requests only require certain fields,
 so projections can help you limit unnecessary network bandwidth usage.
@@ -19,6 +28,9 @@ These two methods of projection are mutually exclusive: if you
 explicitly include fields, you cannot explicitly exclude fields, and
 vice versa.
 
+Sample Documents
+~~~~~~~~~~~~~~~~
+
 Consider the following collection containing documents that describe
 varieties of fruit:
 
@@ -31,6 +43,9 @@ varieties of fruit:
      { "_id": 4, "name": "avocados", "qty": 3, "rating": 5 },
    ]
 
+Single Field
+------------
+
 In the following query, pass the projection to only return the ``name``
 field of each document:
 
@@ -93,6 +108,9 @@ the following results:
    { "name": "oranges" }
    { "name": "avocados" }
 
+Multiple Fields
+---------------
+
 You can also specify multiple fields to include in your projection. Note: the
 order in which you specify the fields in the projection does not alter the
 order in which they are returned.

source/fundamentals/crud/read-operations/skip.txt

@@ -4,6 +4,14 @@ Skip Returned Results
 
 .. default-domain:: mongodb
 
+.. contents:: On this page
+   :local:
+   :backlinks: none
+   :depth: 2
+   :class: singlecol
+
+Overview
+--------
 
 Use ``skip`` to omit documents from the beginning of the list of
 returned documents for a read operation. You can combine ``skip`` with
@@ -17,6 +25,9 @@ arbitrary documents.
 If the value of ``skip`` exceeds the number of matched documents for
 a query, that query returns no documents.
 
+Sample Documents
+~~~~~~~~~~~~~~~~
+
 Follow the instructions in the examples below to insert data into
 a collection and perform a sort and skip on the results of a query.
 Consider a collection containing documents that describe varieties of
@@ -31,6 +42,9 @@ fruit:
       { "_id": 4, "name": "avocados", "qty": 3, "rating": 5 },
    ]
 
+Example
+-------
+
 In the following example, we query the collection with a filter that
 matches all the documents and pass options that specifies ``sort`` and
 ``skip`` commands as query options. The sort option specifies that fruit

source/fundamentals/crud/read-operations/sort.txt

@@ -4,6 +4,15 @@ Sort Results
 
 .. default-domain:: mongodb
 
+.. contents:: On this page
+   :local:
+   :backlinks: none
+   :depth: 2
+   :class: singlecol
+
+Overview
+--------
+
 Use ``sort`` to change the order in which read operations return
 documents. ``Sort`` tells MongoDB to order returned documents by the
 values of one or more fields in a certain direction. To sort returned
@@ -12,6 +21,9 @@ documents by a field in ascending (lowest first) order, use a value of
 If you do not specify a sort, MongoDB does not guarantee the order of
 query results.
 
+Sample Documents
+~~~~~~~~~~~~~~~~
+
 Follow the instructions in the examples below to insert data into
 a collection and perform a sort on the results of a query.
 Consider a collection containing documents that describe books. To
@@ -28,6 +40,9 @@ insert this data into a collection, run the following operation:
      { "_id": 6, "name": "A Dance with Dragons", "author": "Martin", "length": 1104 },
    ]);
 
+Example
+-------
+
 Pass the following sort document to a read operation to ensure that the
 operation returns books with longer lengths before books with shorter
 lengths:

source/fundamentals/crud/write-operations/embedded-arrays.txt

@@ -7,9 +7,12 @@ Update Arrays in a Document
 .. contents:: On this page
    :local:
    :backlinks: none
-   :depth: 1
+   :depth: 2
    :class: singlecol
 
+Overview
+--------
+
 If you need to modify an array embedded within a document, you can use an
 array update operator in your update method call. In this guide, we
 explain and show examples on usage of these operators including:
@@ -22,8 +25,8 @@ See the MongoDB server guide on
 :manual:`Update Operators </reference/operator/update-array/#update-operators>`
 for a complete list.
 
-Examples
-~~~~~~~~
+Sample Documents
+~~~~~~~~~~~~~~~~
 
 The following examples use a database called ``test`` and collection
 called ``pizza`` which contains documents that describe customers and
@@ -89,7 +92,7 @@ the following sample document to follow the example queries:
 .. _first-match-operator:
 
 Match the First Array Element
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+-----------------------------
 
 To perform the update on only the first array element of each document
 that matches your query document in your update operation, use the ``$``
@@ -144,7 +147,7 @@ in our update, we encounter the following error:
 .. _all-match-operator:
 
 Match All Array Elements
-~~~~~~~~~~~~~~~~~~~~~~~~
+------------------------
 
 To perform the update on all of the array elements of each document that
 matches your query document in your update operation, use the all
@@ -184,7 +187,7 @@ resemble the following:
 .. _filtered-positional-operator:
 
 Filtered Positional Operator
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+----------------------------
 
 In the previous sections, we used the ``$`` operator to match the first
 array element and the ``$[]`` operator to match all array elements. In this

source/fundamentals/crud/write-operations/insert.txt

@@ -27,8 +27,8 @@ generates a unique ``_id`` field for documents unless specified.
 The following examples use a collection called ``pizzaCollection``,
 which contains documents with the name and shape of a pizza.
 
-Insert a Document Example
-~~~~~~~~~~~~~~~~~~~~~~~~~
+Insert a Document
+~~~~~~~~~~~~~~~~~
 
 You can specify a document in a JSON object as follows:
 
@@ -56,8 +56,8 @@ You can print the number of documents inserted by accessing the
 For a runnable example, see the :doc:`insertOne() </usage-examples/insertOne>`
 usage example.
 
-Insert Multiple Documents Example
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Insert Multiple Documents
+~~~~~~~~~~~~~~~~~~~~~~~~~
 
 You can specify multiple documents in an array of JSON objects as follows:
 

source/fundamentals/crud/write-operations/upsert.txt

@@ -4,6 +4,15 @@ Insert or Update in a Single Operation
 
 .. default-domain:: mongodb
 
+.. contents:: On this page
+   :local:
+   :backlinks: none
+   :depth: 1
+   :class: singlecol
+
+Overview
+--------
+
 If your application stores and modifies data in MongoDB, you probably use
 insert and update operations. In certain workflows, you may need to choose
 between an insert and update depending on whether the document exists.
@@ -18,6 +27,9 @@ If the query filter passed to these methods does not find any matches and
 you set the ``upsert`` option to ``true``, MongoDB inserts the update
 document. Let's go through an example.
 
+Performing an Update
+--------------------
+
 Suppose your application tracks the current location of food trucks,
 storing the nearest address data in a MongoDB collection that resembles the
 following:
@@ -47,6 +59,9 @@ If a food truck named "Deli Llama" exists, the method call above updates
 the document in the collection. However, if there are no food trucks named
 "Deli Llama" in your collection, no changes are made.
 
+Performing an Upsert
+--------------------
+
 Consider the case in which you want to add information about the food
 truck even if it does not currently exist in your collection. Rather than
 first querying whether it exists to determine whether we need to insert or