-
Notifications
You must be signed in to change notification settings - Fork 1.7k
/
optimize-query-performance-with-indexes-and-projections.txt
116 lines (81 loc) · 4.02 KB
/
optimize-query-performance-with-indexes-and-projections.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
==========================
Optimize Query Performance
==========================
.. default-domain:: mongodb
.. contents:: On this page
:local:
:backlinks: none
:depth: 1
:class: singlecol
Create Indexes to Support Queries
---------------------------------
For commonly issued queries, create :doc:`indexes </indexes>`. If a
query searches multiple fields, create a :ref:`compound index
<index-type-compound>`. Scanning an index is much faster than scanning a
collection. The indexes structures are smaller than the documents
reference, and store references in order.
.. example:: If you have a ``posts`` collection containing blog posts,
and if you regularly issue a query that sorts on the ``author_name``
field, then you can optimize the query by creating an index on the
``author_name`` field:
.. code-block:: javascript
db.posts.createIndex( { author_name : 1 } )
Indexes also improve efficiency on queries that routinely sort on a
given field.
.. example:: If you regularly issue a query that sorts on the
``timestamp`` field, then you can optimize the query by creating an
index on the ``timestamp`` field:
Creating this index:
.. code-block:: javascript
db.posts.createIndex( { timestamp : 1 } )
Optimizes this query:
.. code-block:: javascript
db.posts.find().sort( { timestamp : -1 } )
Because MongoDB can read indexes in both ascending and descending
order, the direction of a single-key index does not matter.
Indexes support queries, update operations, and some phases of the
:ref:`aggregation pipeline
<aggregation-pipeline-operators-and-performance>`.
.. include:: /includes/fact-bindata-storage-optimization.rst
Limit the Number of Query Results to Reduce Network Demand
----------------------------------------------------------
MongoDB :term:`cursors <cursor>` return results in groups of multiple
documents. If you know the number of results you want, you can reduce
the demand on network resources by issuing the :method:`~cursor.limit()`
method.
This is typically used in conjunction with sort operations. For example,
if you need only 10 results from your query to the ``posts``
collection, you would issue the following command:
.. code-block:: javascript
db.posts.find().sort( { timestamp : -1 } ).limit(10)
For more information on limiting results, see :method:`~cursor.limit()`
Use Projections to Return Only Necessary Data
---------------------------------------------
When you need only a subset of fields from documents, you can achieve better
performance by returning only the fields you need:
For example, if in your query to the ``posts`` collection, you need only
the ``timestamp``, ``title``, ``author``, and ``abstract`` fields, you
would issue the following command:
.. code-block:: javascript
db.posts.find( {}, { timestamp : 1 , title : 1 , author : 1 , abstract : 1} ).sort( { timestamp : -1 } )
For more information on using projections, see
:ref:`read-operations-projection`.
Use ``$hint`` to Select a Particular Index
------------------------------------------
In most cases the :ref:`query optimizer
<read-operations-query-optimization>` selects the optimal index for a
specific operation; however, you can force MongoDB to use a specific
index using the :method:`~cursor.hint()` method. Use
:method:`~cursor.hint()` to support performance testing, or on
some queries where you must select a field or field included in
several indexes.
Use the Increment Operator to Perform Operations Server-Side
------------------------------------------------------------
Use MongoDB's :update:`$inc` operator to increment or decrement
values in documents. The operator increments the value of the field on
the server side, as an alternative to selecting a document, making
simple modifications in the client and then writing the entire
document to the server. The :update:`$inc` operator can also help
avoid race conditions, which would result when two application
instances queried for a document, manually incremented a field, and
saved the entire document back at the same time.