DOCSP-20008 updates for update pt4 v5.2 (#119)

* DOCSP-20008 updates for update pt4

* Add files

* Fix multi

* Add pull files

* Staging fixes

* Review updates

Author: Dave

source/reference/operator/update/currentDate.txt

@@ -86,7 +86,7 @@ After the operation, you can query the collection to verify the update:
 
 .. code-block:: javascript
 
-   db.customers.find().pretty()
+   db.customers.find()
 
 The updated document would resemble:
 
@@ -160,6 +160,5 @@ The query should return the following document:
 
    - :method:`db.collection.updateOne()`
    - :method:`db.collection.updateMany()`
-   - :method:`db.collection.update()`
    - :method:`db.collection.findAndModify()`
    - :method:`db.collection.findOneAndUpdate()`

source/reference/operator/update/min.txt

@@ -47,11 +47,11 @@ Examples
 Use ``$min`` to Compare Numbers
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Consider the following document in the collection ``scores``:
+Create the ``scores`` collection:
 
 .. code-block:: javascript
 
-   { _id: 1, highScore: 800, lowScore: 200 }
+   db.scores.insertOne( { _id: 1, highScore: 800, lowScore: 200 } )
 
 The ``lowScore`` for the document currently has the value
 ``200``. The following operation uses :update:`$min` to compare
@@ -60,7 +60,7 @@ The ``lowScore`` for the document currently has the value
 
 .. code-block:: javascript
 
-   db.scores.update( { _id: 1 }, { $min: { lowScore: 150 } } )
+   db.scores.updateOne( { _id: 1 }, { $min: { lowScore: 150 } } )
 
 The ``scores`` collection now contains the following modified document:
 
@@ -73,7 +73,7 @@ field ``lowScore``, i.e ``150``, is less than ``250``:
 
 .. code-block:: javascript
 
-   db.scores.update( { _id: 1 }, { $min: { lowScore: 250 } } )
+   db.scores.updateOne( { _id: 1 }, { $min: { lowScore: 250 } } )
 
 The document remains unchanged in the ``scores`` collection:
 
@@ -84,16 +84,18 @@ The document remains unchanged in the ``scores`` collection:
 Use ``$min`` to Compare Dates
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Consider the following document in the collection ``tags``:
+Create the ``tags`` collection:
 
 .. code-block:: javascript
 
-   {
-     _id: 1,
-     desc: "crafts",
-     dateEntered: ISODate("2013-10-01T05:00:00Z"),
-     dateExpired: ISODate("2013-10-01T16:38:16Z")
-   }
+   db.tags.insertOne(
+      {
+        _id: 1,
+        desc: "crafts",
+        dateEntered: ISODate("2013-10-01T05:00:00Z"),
+        dateExpired: ISODate("2013-10-01T16:38:16Z")
+      }
+   )
 
 The following operation compares the current value of the
 ``dateEntered`` field, i.e. ``ISODate("2013-10-01T05:00:00Z")``,
@@ -102,7 +104,7 @@ whether to update the field:
 
 .. code-block:: javascript
 
-   db.tags.update(
+   db.tags.updateOne(
       { _id: 1 },
       { $min: { dateEntered: new Date("2013-09-25") } }
    )
@@ -121,5 +123,6 @@ The operation updates the ``dateEntered`` field:
 
 .. seealso::
 
-   - :method:`db.collection.update()`
+   - :method:`db.collection.updateMany()`
    - :method:`db.collection.findAndModify()`
+

source/reference/operator/update/position.txt

@@ -69,18 +69,18 @@ Examples
 Add Elements at the Start of the Array
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Consider a collection ``students`` that contains the following document:
+Create the ``students`` collection:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "scores" : [ 100 ] }
+   db.students.insertOne( { "_id" : 1, "scores" : [ 100 ] } )
 
 The following operation updates the ``scores`` field to add the
 elements ``50``, ``60`` and ``70`` to the beginning of the array:
 
 .. code-block:: javascript
 
-   db.students.update(
+   db.students.updateOne(
       { _id: 1 },
       {
         $push: {
@@ -101,19 +101,19 @@ The operation results in the following updated document:
 Add Elements to the Middle of the Array
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Consider a collection ``students`` that contains the following document:
+Add a document to the ``students`` collection:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "scores" : [  50,  60,  70,  100 ] }
+   db.students.insertOne( { "_id" : 2, "scores" : [  50,  60,  70,  100 ] } )
 
 The following operation updates the ``scores`` field to add the
 elements ``20`` and ``30`` at the array index of ``2``:
 
 .. code-block:: javascript
 
-   db.students.update(
-      { _id: 1 },
+   db.students.updateOne(
+      { _id: 2 },
       {
         $push: {
            scores: {
@@ -128,24 +128,23 @@ The operation results in the following updated document:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "scores" : [  50,  60,  20,  30,  70,  100 ] }
+   { "_id" : 2, "scores" : [  50,  60,  20,  30,  70,  100 ] }
 
 Use a Negative Index to Add Elements to the Array
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-.. versionchanged:: 3.6
+:update:`$position` can accept a negative array index value to indicate
+the position starting from the end, counting from (but not including)
+the last element of the array. For example, ``-1`` indicates the
+position just before the last element in the array.
 
-   :update:`$position` can accept a negative array index value to
-   indicate the position starting from the end, counting from (but not
-   including) the last element of the array. For example, ``-1``
-   indicates the position just before the last element in the array.
-
-Consider a collection ``students`` that contains the following document:
+Add the following document to the ``students`` collection:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "scores" : [  50,  60,  20,  30,  70,  100 ] }
-
+   db.students.insertOne(
+      { "_id" : 3, "scores" : [  50,  60,  20,  30,  70,  100 ] }
+   )
 
 The following operation specifies ``-2`` for the :update:`$position` to
 add ``90`` at the position two places before the last element, and then
@@ -159,8 +158,8 @@ add ``90`` at the position two places before the last element, and then
 
 .. code-block:: javascript
 
-   db.students.update(
-      { _id: 1 },
+   db.students.updateOne(
+      { _id: 3 },
       {
         $push: {
            scores: {
@@ -175,4 +174,5 @@ The operation results in the following updated document:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "scores" : [ 50, 60, 20, 30, 90, 80, 70, 100 ] }
+   { "_id" : 3, "scores" : [ 50, 60, 20, 30, 90, 80, 70, 100 ] }
+

source/reference/operator/update/positional-all.txt

@@ -24,14 +24,14 @@ Definition
 
       { <update operator>: { "<array>.$[]" : value } }
 
-   Use in update operations, e.g. :method:`db.collection.update()` and
-   :method:`db.collection.findAndModify()`, to modify all array
+   Use in update operations, e.g. :method:`db.collection.updateOne()`
+   and :method:`db.collection.findAndModify()`, to modify all array
    elements for the document or documents that match the query
    condition. For example:
 
    .. code-block:: javascript
 
-      db.collection.updateMany(
+      db.collection.updateOne(
          { <query conditions> },
          { <update operator>: { "<array>.$[]" : value } }
       )
@@ -57,7 +57,7 @@ array field:
 
 .. code-block:: javascript 
 
-   db.collection.update(
+   db.collection.updateOne(
       { myArray: [ 5, 8 ] },
       { $set: { "myArray.$[]": 10 } },
       { upsert: true }
@@ -79,23 +79,23 @@ documents were found to update:
 
 .. code-block:: javascript 
 
-   db.collection.update(
-      { myArray: 5 },
+   db.emptyCollection.updateOne(
+      { },
       { $set: { "myArray.$[]": 10 } },
       { upsert: true }
    )
-   
-   db.collection.update(
-      { },
+
+   db.emptyCollection.updateOne(
+      { myArray: 5 },
       { $set: { "myArray.$[]": 10 } },
       { upsert: true }
    )
 
 Nested Arrays
 ~~~~~~~~~~~~~
 
-The ``$[]`` operator can be used for queries which
-traverse more than one array and nested arrays.
+The ``$[]`` operator can be used for queries that traverse more than
+one array and nested arrays.
 
 For an example, see :ref:`position-nested-arrays`.
 
@@ -107,28 +107,29 @@ Examples
 Update All Elements in an Array
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Consider a collection ``students`` with the following documents:
+Create the ``students`` collection:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "grades" : [ 85, 82, 80 ] }
-   { "_id" : 2, "grades" : [ 88, 90, 92 ] }
-   { "_id" : 3, "grades" : [ 85, 100, 90 ] }
+   db.students.insertMany( [
+      { "_id" : 1, "grades" : [ 85, 82, 80 ] },
+      { "_id" : 2, "grades" : [ 88, 90, 92 ] },
+      { "_id" : 3, "grades" : [ 85, 100, 90 ] }
+   ] )
 
 To increment all elements in the ``grades`` array by ``10`` for all
 documents in the collection, use the all positional :update:`$[]`
 operator:
 
 .. code-block:: javascript
 
-   db.students.update(
+   db.students.updateMany(
       { },
       { $inc: { "grades.$[]": 10 } },
-      { multi: true }
    )
 
-The all positional :update:`$[]` operator acts as a
-placeholder for all elements in the array field.
+The all positional :update:`$[]` operator acts as a placeholder for all
+elements in the array field.
 
 After the operation, the ``students`` collection contains the following
 documents:
@@ -143,48 +144,49 @@ Update All Documents in an Array
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 The :update:`$[]` positional operator facilitates updates to arrays
-that contain embedded documents. To access the fields
-in the embedded documents, use the :ref:`dot notation
-<document-dot-notation>` on the :update:`$[]` operator.
+that contain embedded documents. To access the fields in the embedded
+documents, use the :ref:`dot notation <document-dot-notation>` with the
+:update:`$[]` operator.
 
 .. code-block:: javascript
 
-   db.collection.update(
+   db.collection.updateOne(
       { <query selector> },
       { <update operator>: { "array.$[].field" : value } }
    )
 
 
-Consider a collection ``students2`` with the following documents:
+Create the ``students2`` collection:
 
 .. code-block:: javascript
 
-   {
-      "_id" : 1,
-      "grades" : [
-         { "grade" : 80, "mean" : 75, "std" : 8 },
-         { "grade" : 85, "mean" : 90, "std" : 6 },
-         { "grade" : 85, "mean" : 85, "std" : 8 }
-      ]
-   }
-   {
-      "_id" : 2,
-      "grades" : [
-         { "grade" : 90, "mean" : 75, "std" : 8 },
-         { "grade" : 87, "mean" : 90, "std" : 5 },
-         { "grade" : 85, "mean" : 85, "std" : 6 }
-      ]
-   }
+   db.students2.insertMany( [
+      {
+         "_id" : 1,
+         "grades" : [
+            { "grade" : 80, "mean" : 75, "std" : 8 },
+            { "grade" : 85, "mean" : 90, "std" : 6 },
+            { "grade" : 85, "mean" : 85, "std" : 8 }
+         ]
+      },
+      {
+         "_id" : 2,
+         "grades" : [
+            { "grade" : 90, "mean" : 75, "std" : 8 },
+            { "grade" : 87, "mean" : 90, "std" : 5 },
+            { "grade" : 85, "mean" : 85, "std" : 6 }
+         ]
+      }
+   ] )
 
 To modify the value of the ``std`` field for all elements in the
 ``grades`` array, use the positional :update:`$[]` operator:
 
 .. code-block:: javascript
 
-   db.students2.update(
+   db.students2.updateMany(
       { },
       { $inc: { "grades.$[].std" : -2 } },
-      { multi: true }
    )
 
 After the operation, the collection has the following documents:
@@ -211,24 +213,25 @@ After the operation, the collection has the following documents:
 Update Arrays Specified Using a Negation Query Operator
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Consider a collection ``results`` with the following documents:
+Create the ``results`` collection:
 
 .. code-block:: javascript
 
-   { "_id" : 1, "grades" : [ 85, 82, 80 ] }
-   { "_id" : 2, "grades" : [ 88, 90, 92 ] }
-   { "_id" : 3, "grades" : [ 85, 100, 90 ] }
+   db.results.insertMany( [
+      { "_id" : 1, "grades" : [ 85, 82, 80 ] },
+      { "_id" : 2, "grades" : [ 88, 90, 92 ] },
+      { "_id" : 3, "grades" : [ 85, 100, 90 ] }
+   ] )
 
 To increment all elements in the ``grades`` array by ``10`` for all
 documents **except** those with the value ``100`` in the ``grades``
 array, use the all positional :update:`$[]` operator:
 
 .. code-block:: javascript
 
-   db.results.update(
+   db.results.updateMany(
       { "grades" : { $ne: 100 } },
       { $inc: { "grades.$[]": 10 } },
-      { multi: true }
    )
 
 The all positional :update:`$[]` operator acts as a
@@ -275,7 +278,7 @@ nested ``grades.questions`` array, regardless of ``type``:
    db.students3.updateMany(
       {},
       { $inc: { "grades.$[].questions.$[score]": 2 } },
-      { arrayFilters: [  { "score": { $gte: 8 } } ], multi: true} 
+      { arrayFilters: [  { "score": { $gte: 8 } } ] } 
    )
 
 The updated documents look like this: