Ways to improve MongoDB performance

MongoDB is a high-performance database, but in the process of using it, you may occasionally encounter some performance issues. Compared with other relational databases, such as SQL Server, MySQL, and Oracle, MongoDB is relatively new and many people are not very familiar with it. Therefore, many developers and DBAs tend to focus on functional implementation and ignore performance requirements. In fact, like SQL Server, MySQL, and Oracle, MongoDB's design adjustments, index creation, and statement optimization will have a huge impact on performance.

In order to fully explore the performance of MongoDB, the following 18 items are simply summarized. Welcome everyone to continue to summarize and improve.

(1) It is recommended to use the default value for the _id key in the document. It is prohibited to save custom values ​​in _id.

Interpretation: There is a "_id" key in every MongoDB document, which is an ObjectID object by default (the identifier includes timestamp, machine ID, process ID and counter). The speed of inserting in MongoDB is very different when specifying _id or not. Specifying _id will slow down the insertion rate.

(2) It is recommended to use short field names.

Interpretation: Unlike relational databases, each document in a MongoDB collection needs to store field names, and long field names require more storage space.

(3) MongoDB indexes can improve document query, update, delete, and sort operations, so create indexes appropriately based on business needs.

(4) Each index takes up some space and causes resource consumption for insert operations. Therefore, it is recommended that the number of indexes for each collection be kept within 5.

(5) For queries involving multiple keys, creating a composite index that includes these keys is a good solution. The key value order of the composite index is very important. Understand the leftmost prefix principle of the index.

Interpretation: For example, create a composite index {a:1,b:1,c:1} on the test collection. Execute the following seven query statements:

db.test.find({a:"hello"}) // 1
db.test.find({b:"sogo", a:"hello"}) // 2
db.test.find({a:"hello",b:"sogo",c:"666"}) // 3
db.test.find({c:"666", a:"hello"}) // 4
db.test.find({b:"sogo", c:"666"}) // 5
db.test.find({b:"sogo" }) // 6
db.test.find({c:"666"}) // 7

The above query statement may go to index 1, 2, 3, 4

The query should include the leftmost index field, in the order in which the indexes were created, regardless of the order of the query fields.

The fewest indexes cover the most queries.

(6) TTL index (time-to-live index, an index with a life cycle). Using TTL index, you can age documents that have reached a timeout period. When a document reaches the aging level, it will be deleted.

Interpretation: The index to create TTL must be of date type. A TTL index is a single-field index and cannot be a composite index. The TTL document deletion background thread removes invalid documents every 60 seconds. Fixed-length collections are not supported.

(7) When you need to create an index for a field in a collection, but a large number of documents in the collection do not contain this key value, it is recommended to create a sparse index.

Interpretation: The index is dense by default, which means that even if the index field of a document is missing, there is a corresponding relationship in the index. In a sparse index, only documents that contain the index key value will appear.

(8) When creating a text index, specify the field as text instead of 1 or -1. Each collection has only one text index, but it can index any number of fields.

Interpretation: Text search is much faster, and it is recommended to use text indexes instead of inefficient queries on multiple fields of collection documents.

(9) Use findOne to query multiple matching items in the database, and it will return the first item in the naturally sorted document set. If you need to return multiple documents, use the find method.

(10) If the query does not need to return the entire document or is only used to determine whether the key value exists, projection (mapping) can be used to limit the returned fields to reduce network traffic and client memory usage.

Interpretation: You can either explicitly specify the returned fields by setting {key:1}, or you can set {key:0} to specify the fields to be excluded.

(11) Except for prefix style queries, regular expression queries cannot use indexes and take longer to execute than most selectors, so they should be used sparingly.

(12) In aggregation operations, $ must come before match and before $group. By putting $ before the beginning of the operator, you can reduce the number of matches and the number of documents that the $group operator has to process.

(13) Modifying documents through operators usually results in better performance because there is no need to go back and forth to the server to obtain and modify the document data, and less time is spent on serializing and transmitting data.

(14) Batch Insert can reduce the number of times data is submitted to the server and improve performance. However, the BSON Size of the batch submission does not exceed 48MB.

(15) It is forbidden to retrieve too much data for sorting at one time. MongoDB currently supports sorting result sets within 32M. If sorting is required, try to limit the amount of data in the result set.

(16) Some $ operators in the query may cause poor performance, such as $ne, $, not, $exists, $nin, and $or. Try not to use them in your business.

a) $exist: Due to the loose document structure, the query must traverse every document;

b) $ne: If the negated value is the majority, the entire index will be scanned;

c) $not: may cause the query optimizer to not know which index to use, so it often degenerates into a full table scan;

d) $nin: full table scan;

e) \$If there are multiple conditions, the query will be made a certain number of times, and the result sets will be merged at the end. You should consider converting it to or: If there are multiple conditions, the query will be made a certain number of times, and the result sets will be merged at the end. You should consider converting it to $in.

(17) Fixed collections can be used to record logs, which makes data insertion faster and allows the earliest data to be eliminated when inserting data. This feature can be considered during demand analysis and design, which improves performance and eliminates the need for deletion.

Interpretation: Fixed collections need to be created explicitly, specifying the size and the number of documents. Regardless of which limit is reached first, new documents inserted into the collection will remove the oldest documents.

(18) The amount of data in the documents in the collection will affect the query performance. In order to maintain the appropriate amount, they need to be archived regularly.

Mongodb performance optimization

Database performance has a crucial impact on the overall performance of the software. The commonly used performance optimization methods for Mongodb database are:

1. Paradigmization and de-paradigmization;

2. Use of fill factor;

3. Use of indexes;

The above is all the content about how to improve MongoDB performance. Thank you for your support of 123WORDPRESS.COM.