DOCS-484, DOCS-382, DOCS-281 Update operators ref docs and redirect compact command

Author: kay-kim

source/reference/operator/all.txt

@@ -8,11 +8,11 @@ $all
 
    *Syntax*: ``{ field: { $all: [ <value> , <value1> ... ] }``
 
-   :operator:`$all` selects the documents where the ``field`` is an
-   array and contains all items (e.g. ``<value>``, ``<value1>``, etc.)
+   :operator:`$all` selects the documents where the ``field`` holds an
+   array and contains all elements (e.g. ``<value>``, ``<value1>``, etc.)
    in the array.
 
-   For example:
+   Consider the following example:
 
    .. code-block:: javascript
 
@@ -22,24 +22,25 @@ $all
    where the ``tags`` field contains an array with the elements,
    ``appliances``, ``school``, and ``technology``. 
 
-   Therefore, the above query will match documents in the
-   ``inventory`` collection that have a ``tags`` that hold *either* of
-   the following arrays: 
+   Therefore, the above query will match documents in the ``inventory``
+   collection that have a ``tags`` field that hold *either* of the
+   following arrays:
 
    .. code-block:: javascript
 
       [ "school", "book", "bag", "headphone", "appliances" ]
       [ "appliances", "school", "book" ]
 
-   :operator:`$all` exists describe and specify arrays in MongoDB
-   queries. you may use :operator:`$all`  to select against a
-   non-array ``field``, as in the following example: 
+   The :operator:`$all` operator exists to describe and specify arrays
+   in MongoDB queries. However, you may use the :operator:`$all`
+   operator to select against a non-array ``field``, as in the
+   following example:
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $all: [ 50 ] } } )
 
-    **However**, use the following form to express the same query: 
+   **However**, use the following form to express the same query: 
 
    .. code-block:: javascript
 

source/reference/operator/and.txt

@@ -24,9 +24,9 @@ $and
    This query will select all documents in the ``inventory``
    collection where:
 
-   - ``price`` equals ``1.99`` **and** 
-   - ``qty`` is less than ``20`` **and**
-   - ``sale`` is ``true``.
+   - ``price`` field value equals ``1.99`` **and** 
+   - ``qty`` field value is less than ``20`` **and**
+   - ``sale`` field value is equal to ``true``.
 
    MongoDB provides an implicit ``AND`` operation when specifying a
    comma separated list of expressions. For example, you may write the
@@ -36,25 +36,23 @@ $and
 
       db.inventory.find( { price: 1.99, qty: { $lt: 20 } , sale: true } )
 
-   For queries that require an ``AND`` operation on the value of a
-   single field, you *must* use the :operator:`$and` operator. For
-   example: 
+   If, however, a query requires an ``AND`` operation on the same
+   field, you *must* use the :operator:`$and` operator as in the
+   following example:
 
    .. code-block:: javascript
 
       db.inventory.update( { $and: [ { price: { $ne: 1.99 } }, { price: { $exists: true } } ] }, { $set: { qty: 15 } } )
 
    This :method:`update() <db.collection.update()>` operation will set
-   the value of the ``qty`` field in documents where the value of the
-   ``price`` field: 
+   the value of the ``qty`` field in documents where: 
 
-   -  does not equal ``1.99`` **and** 
-   -  exists.
+   -  the ``price`` field value does not equal ``1.99`` **and** 
+   -  the ``price`` field exists.
 
    .. seealso:: 
 
       :method:`find() <db.collection.find()>`, :method:`update()
       <db.collection.update()>`, :operator:`$ne`, :operator:`$exists`,
       :operator:`$set`.
-
-    
+      

source/reference/operator/exists.txt

@@ -13,20 +13,21 @@ $exists
    ``exists``. For SQL ``exists``, refer to the :operator:`$in`
    operator.
 
-   For example, you would query:
+   Consider the following example:
 
    .. code-block:: javascript
 
       db.inventory.find( { $and: [ { qty: { $exists: true } }, { qty: { $nin: [ 5, 15 ] } } ] } )
 
-   to select all documents in ``inventory`` where ``qty`` exists *and* does
-   not equal either ``5`` nor ``15``.
+   This query will select all documents in the ``inventory`` collection
+   where the ``qty`` field exists *and* its value does not equal either
+   ``5`` nor ``15``.
 
    The above query used the :operator:`$and` operator because the query
-   performs an ``AND`` operation on the value of a single field and is
+   performs an ``AND`` operation on the value of the same field and is
    not specific to the :operator:`$exists` operator.
 
    .. seealso:: 
 
       :method:`find() <db.collection.find()>`, :operator:`$and`,
-      :operator:`$nin``, :operator:`$in``.
+      :operator:`$nin`, :operator:`$in`.

source/reference/operator/gt.txt

@@ -8,28 +8,30 @@ $gt
 
    *Syntax*: ``{field: {$gt: value} }``
 
-   :operator:`$gt` selects those documents where the ``field`` is greater
-   than (i.e. ``>``) the specified ``value``.
+   :operator:`$gt` selects those documents where the value of the
+   ``field`` is greater than (i.e. ``>``) the specified ``value``.
 
-   For example, you would query:
+   Consider the following example:
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $gt: 20 } } )
 
-   to select all documents in ``inventory`` where ``qty`` is greater than
-   ``20``.
+   This query will select all documents in the ``inventory`` collection
+   where the ``qty`` field value is greater than ``20``.
 
-   You may use the :operator:`$lt` operator to select fields from
-   embedded documents. For example, you would query:
+   Consider the following example which uses the :operator:`$gt`
+   operator with a field from an embedded document:
 
    .. code-block:: javascript
 
       db.inventory.update( { "carrier.fee": { $gt: 2 } }, { $set: { price: 9.99 } } )
 
-   to update a single document in ``inventory`` where the field ``fee``
-   from the embedded document ``carrier`` is greater than ``2``.
-   				
+   This :method:`update() <db.collection.update()>` operation will set
+   the value of the ``price`` field in the documents that contain the
+   embedded document ``carrier`` whose ``fee`` field value is
+   greater than ``2``.
+      				
    .. seealso:: 
 
       :method:`find() <db.collection.find()>`, :method:`update()

source/reference/operator/gte.txt

@@ -8,27 +8,30 @@ $gte
 
    *Syntax*: ``{field: {$gte: value} }``
 
-   :operator:`$gte` selects the documents where the ``field`` is
-   greater than or equal to (i.e. ``>=``) a specified value
-   (e.g. ``value``.) Consider the following example: 
+   :operator:`$gte` selects the documents where the value of the
+   ``field`` is greater than or equal to (i.e. ``>=``) a specified
+   value (e.g. ``value``.)
+   
+   Consider the following example: 
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $gte: 20 } } )
 
    This query would select all documents in ``inventory`` where
-   ``qty`` is greater than or equal to ``20``.
+   the ``qty`` field value is greater than or equal to ``20``.
 
-   You may use the :operator:`$gte` operator to select fields from
-   embedded documents, as in the following example:
+   Consider the following example which uses the :operator:`$gte`
+   operator with a field from an embedded document:
 
    .. code-block:: javascript
 
       db.inventory.update( { "carrier.fee": { $gte: 2 } }, { $set: { price: 9.99 } } )
 
    This :method:`update() <db.collection.update()>` operation will set
-   the value of the ``price`` field where the ``fee`` field in the
-   document embedded in the ``carrier`` field is greater than ``2``.
+   the value of the ``price`` field that contain the embedded document
+   ``carrier`` whose``fee`` field value is greater than or equal to
+   ``2``.
 
    .. seealso::
 

source/reference/operator/in.txt

@@ -8,38 +8,38 @@ $in
 
    *Syntax*: ``{ field: { $in: [<value1>, <value2>, ... <valueN> ] } }``
 
-   :operator:`$in` selects the documents where the ``field`` equals any
-   value in the specified array (e.g. ``<value1>``, <value2>``, etc.)
+   :operator:`$in` selects the documents where the ``field`` value
+   equals any value in the specified array (e.g. ``<value1>``,
+   ``<value2>``, etc.)
+   
    Consider the following example: 
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $in: [ 5, 15 ] } } )
 
-   This query will select to select all documents in ``inventory``
-   where ``qty`` is either ``5`` or ``15``.  Although you can express
-   this query using the :operator:`$or` operator, prefer
-   :operator:`$in` in favor of :operator:`$or` when performing
-   equality checks on a single field.
+   This query will select to select all documents in the ``inventory``
+   collection where the ``qty`` field value is either ``5`` or
+   ``15``. Although you can express this query using the
+   :operator:`$or` operator, choose the :operator:`$in` operator rather
+   than the :operator:`$or` operator when performing equality checks on
+   the same field.
 
-   If the field holds an array, then the following expression is true
-   *if* any element specified with the :operator:`$in` expression is
-   in the array.
-
-   .. code-block:: javascript
+   If the ``field`` holds an array, then the :operator:`$in` operator
+   selects the documents whose ``field`` holds an array that contains
+   at least one element that matches a value in the specified array
+   (e.g. ``<value1>``, ``<value2>``, etc.)
 
-      { field: { $in: [ array ] } }
-
    Consider the following example:
 
    .. code-block:: javascript
 
       db.inventory.update( { tags: { $in: ["appliances", "school"] } }, { $set: { sale:true } } )
 
    This :method:`update() <db.collection.update()>` operation will set
-   the value of ``sale`` in the ``inventory`` collection where at
-   least one element of the ``tags`` array matches an element in the
-   array ``["appliances", "school"]``.
+   the ``sale`` field value in the ``inventory`` collection where the
+   ``tags`` field holds an array with at least one element matching an
+   element in the array ``["appliances", "school"]``.
 
    .. seealso:: 
 

source/reference/operator/lt.txt

@@ -8,27 +8,29 @@ $lt
 
    *Syntax*: ``{field: {$lt: value} }``
 
-   :operator:`$lt` selects the documents where the ``field`` is less
-   than (i.e. ``<``) the specified ``value``.
+   :operator:`$lt` selects the documents where the value of the
+   ``field`` is less than (i.e. ``<``) the specified ``value``.
 
-   For example, you would query:
+   Consider the following example:
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $lt: 20 } } )
 
-   to select all documents in ``inventory`` where ``qty`` is less than
-   ``20``.
+   This query will select all documents in the ``inventory`` collection
+   where the ``qty`` field value is less than ``20``.
+
+   Consider the following example which uses the :operator:`$lt`
+   operator with a field from an embedded document:
 
-   You may use the :operator:`$lt` operator to select fields from
-   embedded documents. For example, you would query:
-   	
    .. code-block:: javascript
 
       db.inventory.update( { "carrier.fee": { $lt: 20 } }, { $set: { price: 9.99 } } )
-	
-   to update a single document in ``inventory`` where the field ``fee``
-   from the embedded document ``carrier`` is less than ``20``.
+
+   This :method:`update() <db.collection.update()>` operation will set
+   the ``price`` field value in the documents that contain the
+   embedded document ``carrier`` whose ``fee`` field value is less
+   than ``20``.
 
    .. seealso::
 

source/reference/operator/lte.txt

@@ -8,29 +8,31 @@ $lte
 
    *Syntax*: ``{ field: { $lte: value} }``
 
-   :operator:`$lte` selects the documents where the ``field`` is less
-   than or equal to (i.e. ``<=``) the specified ``value``.
+   :operator:`$lte` selects the documents where the value of the
+   ``field`` is less than or equal to (i.e. ``<=``) the specified
+   ``value``.
 
-   For example, you would query:
+   Consider the following example:
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $lte: 20 } } )
-   
-   to select all documents in ``inventory`` where ``qty`` is less than or
-   equal to ``20``.
 
-   You may use the :operator:`$lt` operator to select fields from
-   embedded documents. For example, you would query:
+   This query will select all documents in the ``inventory`` collection
+   where the ``qty`` field value is less than or equal to ``20``.
+
+   Consider the following example which uses the :operator:`$lt`
+   operator with a field from an embedded document:
 
    .. code-block:: javascript
 
       db.inventory.update( { "carrier.fee": { $lte: 5 } }, { $set: { price: 9.99 } } )
-	
-   to update a single document in ``inventory`` where the field ``fee``
-   from the embedded document ``carrier`` is less than or equal to
-   ``2``.
-			
+		
+   This :method:`update() <db.collection.update()>` operation will set
+   the ``price`` field value in the documents that contain the embedded
+   document ``carrier`` whose ``fee`` field value is less than or equal
+   to ``5``.
+   	
    .. seealso::
 
       method:`find() <db.collection.find()>`, :method:`update()

source/reference/operator/mod.txt

@@ -8,33 +8,35 @@ $mod
 
    *Syntax*: ``{ field: { $mod: [ divisor, remainder ]} }``
 
-   :operator:`$mod` selects the documents where the ``field`` divided
+   :operator:`$mod` selects the documents where the ``field`` value divided
    by the ``divisor`` has the specified ``remainder``.
 
-   For example, you would query:
+   Consider the following example:
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $mod: [ 4, 0 ] } } )
 
-   to select all documents in ``inventory`` where the ``qty`` modulo
-   ``4`` equals ``3``, such as documents with ``qty`` equal to ``0`` or
-   ``12``.
+   This query will select all documents in the ``inventory`` collection
+   where the ``qty`` field value modulo ``4`` equals ``3``, such as
+   documents with ``qty`` value equal to ``0`` or ``12``.
 
-   In some cases, you can query using :operator:`$mod` rather than the
-   more expensive :operator:`$where` operator.  So, you can query:
+   In some cases, you can query using the :operator:`$mod` operator
+   rather than the more expensive :operator:`$where` operator. Consider
+   the following example using the :operator:`$mod` operator:
 
    .. code-block:: javascript
 
       db.inventory.find( { qty: { $mod: [ 4, 3 ] } } )
 
-   rather than using the more expensive `$where`:
+   The above query is less expensive than the following query which
+   uses the :operator:`$where` operator:
 
    .. code-block:: javascript
 
       db.inventory.find( { $where: "this.qty % 4 == 3" } )
 
    .. seealso::
 
-      method:`find() <db.collection.find()>`, :method:`update()
+      :method:`find() <db.collection.find()>`, :method:`update()
       <db.collection.update()>`, :operator:`$set`.