DOCSP-19887 update db collection.insert pt1 v5.1 (#75) (#81)

* DOCSP-19887-update-insert-examples-pt1

* Add more pages

* Update indent format

Author: Dave

source/core/2dsphere.txt

@@ -117,21 +117,18 @@ documents that store location data as :ref:`GeoJSON Point
 
 .. code-block:: javascript
 
-   db.places.insert(
+   db.places.insertMany( [
       {
          loc : { type: "Point", coordinates: [ -73.97, 40.77 ] },
          name: "Central Park",
          category : "Parks"
-      }
-   )
-
-   db.places.insert(
+      },
       {
          loc : { type: "Point", coordinates: [ -73.88, 40.78 ] },
          name: "La Guardia Airport",
          category : "Airport"
       }
-   )
+   ] )
 
 Create a ``2dsphere`` Index
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~

source/core/index-case-insensitive.txt

@@ -85,9 +85,11 @@ To use the index, queries must specify the same collation.
 
 .. code-block:: javascript
 
-   db.fruit.insert( [ { type: "apple" },
-                      { type: "Apple" },
-                      { type: "APPLE" } ] )
+   db.fruit.insertMany( [
+      { type: "apple" },
+      { type: "Apple" },
+      { type: "APPLE" }
+   ] )
 
    db.fruit.find( { type: "apple" } ) // does not use index, finds one result
 
@@ -120,9 +122,11 @@ Insert a small collection of names:
 
 .. code-block:: javascript
 
-   db.names.insert( [ { first_name: "Betsy" },
-                      { first_name: "BETSY"},
-                      { first_name: "betsy"} ] )
+   db.names.insertMany( [
+      { first_name: "Betsy" },
+      { first_name: "BETSY"},
+      { first_name: "betsy"}
+   ] )
 
 Queries on this collection use the specified collation by default,
 and if possible use the index as well.

source/core/index-partial.txt

@@ -267,17 +267,21 @@ fields are greater than ``21``:
 
 .. code-block:: javascript
 
-   db.users.insert( { username: "david", age: 27 } )
-   db.users.insert( { username: "amanda", age: 25 } )
-   db.users.insert( { username: "rajiv", age: 32 } )
+   db.users.insertMany( [
+      { username: "david", age: 27 },
+      { username: "amanda", age: 25 },
+      { username: "rajiv", age: 32 }
+   ] )
 
 However, the following documents with duplicate usernames are allowed
 since the unique constraint only applies to documents with ``age``
 greater than or equal to 21.
 
 .. code-block:: javascript
 
-   db.users.insert( { username: "david", age: 20 } )
-   db.users.insert( { username: "amanda" } )
-   db.users.insert( { username: "rajiv", age: null } )
+   db.users.insertMany( [
+      { username: "david", age: 20 },
+      { username: "amanda" },
+      { username: "rajiv", age: null }
+   ] )
 

source/core/index-sparse.txt

@@ -231,16 +231,21 @@ index permits the following :doc:`insert operations
 
 .. code-block:: javascript
 
-   db.scores.insert( { "userid": "AAAAAAA", "score": 43 } )
-   db.scores.insert( { "userid": "BBBBBBB", "score": 34 } )
-   db.scores.insert( { "userid": "CCCCCCC" } )
-   db.scores.insert( { "userid": "DDDDDDD" } )
+   db.scores.insertMany( [
+      { "userid": "AAAAAAA", "score": 43 },
+      { "userid": "BBBBBBB", "score": 34 },
+      { "userid": "CCCCCCC" },
+      { "userid": "DDDDDDD" }
+   ] )
 
 However, the index *would not permit* the addition of the following
 documents since documents already exists with ``score`` value of ``82``
 and ``90``:
 
 .. code-block:: javascript
 
-   db.scores.insert( { "userid": "AAAAAAA", "score": 82 } )
-   db.scores.insert( { "userid": "BBBBBBB", "score": 90 } )
+   db.scores.insertMany( [
+      { "userid": "AAAAAAA", "score": 82 },
+      { "userid": "BBBBBBB", "score": 90 }
+   ] )
+

source/core/index-unique.txt

@@ -93,8 +93,10 @@ the collection since the index enforces uniqueness for the
 
 .. code-block:: javascript
 
-   db.collection.insert( { _id: 2, a: [ { loc: "A" }, { qty: 5 } ] } )
-   db.collection.insert( { _id: 3, a: [ { loc: "A", qty: 10 } ] } )
+   db.collection.insertMany( [
+      { _id: 2, a: [ { loc: "A" }, { qty: 5 } ] },
+      { _id: 3, a: [ { loc: "A", qty: 10 } ] }
+   ] )
 
 .. seealso::
 
@@ -168,7 +170,7 @@ value of ``{ "a.loc": "B", "a.qty": null }``.
 
 .. code-block:: javascript
 
-   db.collection.insert( { _id: 4, a: [ { loc: "B" }, { loc: "B" } ] } )
+   db.collection.insertOne( { _id: 4, a: [ { loc: "B" }, { loc: "B" } ] } )
 
 .. _unique-index-and-missing-field:
 
@@ -194,15 +196,15 @@ field ``x``:
 
 .. code-block:: javascript
 
-   db.collection.insert( { y: 1 } )
+   db.collection.insertOne( { y: 1 } )
 
 However, the unique index errors on the insertion of a document without
 the field ``x`` if the collection already contains a document missing
 the field ``x``:
 
 .. code-block:: javascript
 
-   db.collection.insert( { z: 1 } )
+   db.collection.insertOne( { z: 1 } )
 
 The operation fails to insert the document because of the violation of
 the unique constraint on the value of the field ``x``:

source/core/replica-set-write-concern.txt

@@ -68,15 +68,18 @@ prevent rollbacks, see :ref:`rollback-avoid`.
 Verify Write Operations to Replica Sets
 ---------------------------------------
 
-The following operation includes the ``writeConcern`` option to 
-the :method:`~db.collection.insert()` method. The operation specifies
-:writeconcern:`"majority"` write concern and a 5 second timeout using 
-the :ref:`wc-wtimeout` write concern parameter so that the operation 
-does not block indefinitely.
+The following operation includes the ``writeConcern`` option for
+the :method:`~db.collection.insertOne()` method. The operation
+specifies:
+- the :writeconcern:`"majority"` write concern, and
+- a 5 second timeout.
+
+The :ref:`wc-wtimeout` write concern parameter ensures that the
+operation does not block indefinitely.
 
 .. code-block:: javascript
 
-   db.products.insert(
+   db.products.insertOne(
       { item: "envelopes", qty : 100, type: "Clasp" },
       { writeConcern: { w: "majority" , wtimeout: 5000 } }
    )

source/core/retryable-writes.txt

@@ -102,47 +102,38 @@ cannot be :writeconcern:`{w: 0} <\<number\>>`.
      - Descriptions
 
    * - | :method:`db.collection.insertOne()`
-       | :method:`db.collection.insert()`
        | :method:`db.collection.insertMany()`
-
      - Insert operations.
 
    * - | :method:`db.collection.updateOne()`
        | :method:`db.collection.replaceOne()`
        | :method:`db.collection.update()` where ``multi`` is ``false``
-
      - Single-document update operations. [#duplicate-key-update]_
 
    * - | :method:`db.collection.deleteOne()`
        | :method:`db.collection.remove()` where ``justOne`` is ``true``
-
      - Single document delete operations.
 
    * - | :method:`db.collection.findAndModify()`
        | :method:`db.collection.findOneAndDelete()`
        | :method:`db.collection.findOneAndReplace()`
        | :method:`db.collection.findOneAndUpdate()`
-
      - ``findAndModify`` operations. All ``findAndModify`` operations
        are single document operations.
 
    * - :method:`db.collection.bulkWrite()` with the following write
        operations:
 
        - :ref:`bulkwrite-write-operations-insertOne`
-
        - :ref:`updateOne <bulkwrite-write-operations-updateOneMany>`
-
        - :ref:`bulkwrite-write-operations-replaceOne`
-
        - :ref:`deleteOne <bulkwrite-write-operations-deleteOneMany>`
 
      - Bulk write operations that only consist of the single-document
        write operations. A retryable bulk operation can include any
        combination of the specified write operations but cannot include
        any multi-document write operations, such as ``updateMany``.
 
-
    * - :method:`Bulk <Bulk()>` operations for:
 
        - :method:`Bulk.find.removeOne()`

source/core/schema-validation.txt

@@ -342,7 +342,7 @@ For example, the following insert operation violates the validation rule:
 
 .. code-block:: javascript
 
-   db.contacts2.insert( { name: "Amanda", status: "Updated" } )
+   db.contacts2.insertOne( { name: "Amanda", status: "Updated" } )
 
 However, since the ``validationAction`` is ``warn`` only, MongoDB only
 logs the validation violation message and allows the operation to

source/core/transactions-in-applications.txt

@@ -476,8 +476,14 @@ transactions:
    :copyable: false
 
    // Create collections:
-   db.getSiblingDB("mydb1").foo.insert( {abc: 0}, { writeConcern: { w: "majority", wtimeout: 2000 } } );
-   db.getSiblingDB("mydb2").bar.insert( {xyz: 0}, { writeConcern: { w: "majority", wtimeout: 2000 } } );
+   db.getSiblingDB("mydb1").foo.insertOne(
+       {abc: 0},
+       { writeConcern: { w: "majority", wtimeout: 2000 } }
+   )
+   db.getSiblingDB("mydb2").bar.insertOne(
+      {xyz: 0},
+      { writeConcern: { w: "majority", wtimeout: 2000 } }
+   )
 
    // Start a session.
    session = db.getMongo().startSession( { readPreference: { mode: "primary" } } );

source/core/transactions-operations.txt

@@ -124,27 +124,19 @@ operations against a :red:`non-existing` collection:
    * - | :method:`db.collection.findAndModify()` with ``upsert: true``
        | :method:`db.collection.findOneAndReplace()` with ``upsert: true``
        | :method:`db.collection.findOneAndUpdate()` with ``upsert: true``
-
      - :dbcommand:`findAndModify` with ``upsert: true``
 
-
    * - | :method:`db.collection.insertMany()`
        | :method:`db.collection.insertOne()`
-       | :method:`db.collection.insert()`
-
      - :dbcommand:`insert`
 
    * - | :method:`db.collection.updateOne()` with ``upsert: true``
        | :method:`db.collection.updateMany()` with ``upsert: true``
        | :method:`db.collection.replaceOne()` with ``upsert: true``
-       | :method:`db.collection.update()` with ``upsert: true``
-
      - :dbcommand:`update` with ``upsert: true``
 
-
    * - | :method:`db.collection.bulkWrite()`  with insert or ``upsert:true`` operations
        | Various :doc:`/reference/method/js-bulk` with insert or ``upsert:true`` operations
-
      - 
 
 For other CRUD operations allowed in transactions, see