Step 1: Install the msi Installer

Right-click the Windows installer, select Run as Administrator, and follow the instructions to install MongoDB.

Step 2: Create a Data Directory

Create \data\db directory in C:\ to store MongoDB data. Directory looks like “C:\data\db”.

Step 3: Start the MongoDB Server

Open the command prompt and navigate to the MongoDB installation folder. Issue the following command to start the MongoDB server, as shown in Figure 1-3.

mongod.exe

You should get a message that states “Waiting for connection on port 27017.”

Step 4: Start the MongoDB Client

Open another command prompt and navigate to the MongoDB installation folder. Issue the following command to start the MongoDB client, as shown in Figure 1-4.

mongo.exe

We can see the mongo shell.

This confirms, we have installed MongoDB on windows.

Step 1: Extract the tarball

Step 2: Create a Data Directory

Create a /data/db directory as shown in Recipe 1-1.

Step 3: Start the MongoDB Server

Step 4: Start the MongoDB Client

Step 1: Install the MongoDB Compass msi Installer

Right-click the MongoDB Compass Windows installer, select Run as Administrator, and follow the instructions to install MongoDB Compass. Figure 1-5 shows the MongoDB Compass GUI.

Step 2: Start the MongoDB Server

You should see a message that states “Waiting for connection on port 27017.”

Step 3: Connect MongoDB Compass with MongoDB Server

Click the New Connection tab. Enter the required details, as shown in Figure 1-6.

Click Connect to connect to the MongoDB Server as shown in Figure 1-7.

We have now connected MongoDB Compass to the MongoDB server.

Step 1: Create a database

This shows that you are working in the mydb database, so you know we have created a database by that name.

Step 1: Drop a Database

We have thus dropped the database named mydb.

Step 1: Display a List of Databases

We can now see the list of databases.

Step 1: Display the Version of MongoDB

We can see that the version of MongoDB is 4.0.2.

Step 1: Display a List of Commands

We can now see the list of MongoDB commands.

In next chapter, we discuss how to perform CRUD operations using MongoDB query language.

Step 1: Create a Collection

We can now see the collection named person.

Step 1: Create a Capped Collection

Here, size denotes the maximum size of the collection in bytes and max denotes the maximum number of documents allowed.

Step 2: Query a Capped Collection

We can see the results are now in the reverse order.

Step 3: Insert a Document into a Full Capped Collection

Notice that the first document is overwritten by the third document, as the maximum number of documents allowed in the student capped collection is two.

Step 1: Insert a Single Document

insertOne() returns a document that contains the newly inserted document’s _id.

If you don’t specify an _id field, MongoDB generates an _id field with an ObjectId value. The _id field act as the primary key.

Step 2: Insert Multiple Documents

Pass an array of documents to the insertMany() method to insert multiple documents.

Step 1: Select All Documents in a collection

You need to pass an empty document as a query parameter to the find() method.

Step 2: Specify Equality Conditions

To specify an equality condition, you need to use <field>:<value> expressions in the query to filter documents.

Step 3: Specify Conditions Using Query Operator

Step 4: Specify AND Conditions

Step 5: Specify OR Conditions

You can use $or in a compound query to join each clause with a logical or conjunction.

The operator $or selects the documents from the collection that match at least one of the selected conditions.

Step 1: Update a Single Document

MongoDB provides modify operators to modify field values such as $set.

Step 2: Update Multiple Documents

Here, the modifiedCount is 2, which indicates that the preceding command modified two documents in the student collection.

Step 3: Replace a Document

You can replace the entire content of a document except the _id field by passing an entirely new document as the second argument to db.collection.replaceOne() as shown here.

Step 1: Delete Only One Document That Matches a Condition

Step 2: Delete All Documents That Match a Condition

Step 3: Delete All Documents from a Collection

Step 1: Match an Embedded or Nested Document

To perform an equality match on the embedded document, you need to specify the exact match document in the <value> document, including the field order.

Step 2: Query on a Nested Field

We can use dot notation to query a field of the embedded document.

Step 1: Match an Array

To specify an equality condition on an array, you need to specify the exact array to match in the <value> of the query document {<field>:<value>}.

Step 2: Query an Array for an Element

Step 3: Specify Query Operators

Step 4: Query an Array with Compound Filter Conditions on the Array Elements

Here, one element of the scores array can satisfy the greater than 20 condition and another element can satisfy the less than 24 condition, or a single element can satisfy both the conditions.

Step 5: Using the $elemMatch operator

Step 6: Query an Array Element by Index Position

Use dot notation to query an array element by its index position.

Step 7: Using the $size Operator

You can use the $size operator to query an array by number of elements.

Step 8: Using the $push Operator

You can use the $push operator to add a value to an array.

Step 9: Using the $addToSet Operator

You can use the $addToSet operator to add a value to an array. $addToSet adds a value to an array only if a value is not present. If a value is present, it does not do anything.

Step 10: Using the $pop Operator

You can use the $pop operator to remove the first or last element of an array.

Step 1: Query for a Document Nested in an Array

Step 2: Query for a Field Embedded in an Array of Documents

Step 3: Array Index to Query for a Field in the Embedded Document

Step 1: Return the Specified Fields and the _id Field Only

You can project the required fields by setting the <field> value to 1 in the projection document.

Step 2: Suppress the _id Field

You can suppress the _id field by setting its exclusion <field> to 0 in the projection document.

Step 3: Exclude More Than One Field

You can exclude fields by setting <field> to 0 in the projection document.

Step 4: Return a Specific Field in an Embedded Document

You can use dot notation to refer to the embedded field and set the <field> to 1 in the projection document.

Step 1: Equality Filter

Here, it returns both the documents.

Step 2: Type Check

Step 3: Existence Check

You can use the $exist operator to check for the existence of a field.

Step 1: Establishing a Connection and Creating a Collection

Step 2: Insert a Document

Step 3: Query a Document

Step 4: Update a Document

Step 5: Delete a Document

Step 1: One-to-One Relationships

With this data model, we can retrieve complete student information with one query.

Step 2: One-to-Many Relationships

This data model allows us to retrieve complete student information with one query.

Step 1: One-to-Many Relationships

Here, the publisher document is embedded inside the book document, which leads to repetition of the publisher data model.

Step 2: Query Document References

Step 1: Tree Structure with Parent References

The parent references pattern stores each tree node in a document; in addition to the tree node, the document stores the _id of the node’s parent.

The tree structure of this author collection is shown in Figure 3-3.

Step 2: Tree Structure with Child References

The child references pattern stores each tree node in a document; in addition to the tree node, the document stores in an array the _id value(s) of the node’s children.

Child references are a good choice to work with tree storage when there are no subtree operations.

Step 3: Tree Structure with an Array of Ancestors

The array of ancestors pattern stores each tree node in a document; in addition to the tree node, the document stores in an array the _id value(s) of the node’s ancestors or path.

The array of ancestors field stores the ancestors field and reference to the immediate parent.

This pattern provides an efficient solution to find all descendants and the ancestors of a node. The array of ancestors pattern is a good choice for working with subtrees.

Step 1: Aggregation Pipeline

In the preceding example, the value of the variable is accessed by using the $ sign.

Step 1: Map-Reduce

To filter on status:"A" and then group it on custID and compute the sum of amount, use the following map-reduce function.

Step 1: Single-Purpose Aggregation Operations

Step 1: Converting SQL Aggregation Operations to MongoDB

Now, let’s find the count of records from the orders colletion.

Step 1: Create an Index

Here, the parameter value “1” indicates that empId field values will be stored in ascending order.

Step 1: Multikey Index

Multikey indexes are useful to create an index for a field that holds an array value. MongoDB creates an index key for each element in the array.

Step 2: Text Indexes

MongoDB provides text indexes to support text search queries on string content. You can create a text index on a field that takes as its value a string or an array of string elements.

This command creates a text index for the field post_text.

Step 3: Hashed Indexes

The size of the indexes can be reduced with the help of hashed indexes. Hashed indexes store the hashes of the values of the indexed field. Hashed indexes support sharding using hashed shard keys. In hashed-based sharding, a hashed index of a field is used as the shard key to partition data across the sharded cluster. We discuss sharding in Chapter 5.

Hashed indexes do not support multikey indexes.

Step 4: 2dsphere Index

The 2dsphere index is useful to return queries on geospatial data.

Step 1: TTL Indexes

Time to Live (TTL) indexes are single-field indexes that are used to remove documents from a collection after a certain amount of time. Data expiration is useful for certain types of information such as logs, machine-generated data, and so on.

Step 2: Unique Indexes

A unique index ensures that the indexed fields do not contain any duplicate values. By default, MongoDB creates a unique index on the _id field.

Step 3: Partial Indexes

Partial indexes are useful when you want to index the documents in a collection that meet a specific filter condition. The filter condition could be specified using any operators. For example, db.person.find( { age: { $gt: 15 } } ) can be used to find the documents that have an age greater than 15 in the person collection. Partial indexes reduce storage requirements and performance costs because they store only a subset of the documents.

Use the db.collection.createIndex() method with the partialFilterExpression option to create a partial index.

Step 4: Sparse Indexes

Sparse indexes store entries only for the documents that have the indexed field, even if it contains null values. A sparse index skips any documents that do not have the indexed field. The index is considered sparse because it does not include all the documents of a collection.

Step 1: Create an Index to Support Your Queries

Creating the right index to support the queries increases the query execution performance and results in great performance.

Step 2: Using an Index to Sort the Query Results

Sort operations use indexes for better performance. Indexes determine the sort order by fetching the documents based on the ordering in the index.

Step 1: Three-Member Replica Set

Next, start three mongod instances as shown here (see Figures 5-2, 5-4, and 5-6).

start mongod --bind_ip hostname --dbpath c:\mongodb\repset\rs1 --port 20001 --replSet myrs

Refer to Figure 5-3 for a mongod instance that is waiting for connection on port 20001.

Refer to Figure 5-5 for a mongod instance that is waiting for connection on port 20002.

Refer Figure 5-7 for a mongod instance that is waiting for connection on port 20002.

Figure 5-8 shows the mongo shell that is running on port 20001.

Here, the mongod instance running on port 20001 becomes primary.

The output Error: error: { ........... } shows that we are getting an error message because we are trying to read data from the secondary node.

In the preceding output, WriteCommandError { ........... } shows that we are getting an error message because we can’t perform write operations in a secondary node. We can perform write operations only in the primary node.

All the secondary nodes replicate the primary’s log and apply their operations to ensure the secondary’s data set reflects the primary’s data set, as shown in Figure 5-9.

Step 2: Auto Failover—High Availability

Kill the primary running on port 20001 and press Enter in the mongo shell running on ports 20002 and 20003 (Figure 5-10). Any one of the secondary nodes can become primary now.

When a primary does not communicate with other members in the replica set for a configured period (10 seconds by default), an eligible secondary node calls for an election to nominate itself as the new primary and resume its normal operation (Figure 5-11).

Step 1: Sharded Cluster

First, create data directories for three shards as shown here.

Next, start the shards as shown here.

Figure 5-12 shows the execution of commands.

Figure 5-13 shows the execution of commands.

Figure 5-14 shows the execution of commands.

Figure 5-16 is the snapshot for reference.

Figure 5-17 is a snapshot for reference to start config servers.

Now it is time to perform sharding. Here, we are going to use one query router, one config server, and three shards.

This shows that user data is distributed to shard1 and shard2.

Step 1: Multidocument Transactions

We can see the modifications from inside the transaction.

Because the transactions are not committed, we cannot see modifications outside the transaction .

Step 1: Isolation Test Between Two Concurrent Transactions

Here, the transactions are isolated, and each transaction shows the modification that it has made itself.

Step 1: Transactions with Write Conflicts

Here, MongoDB detects a write conflict immediately, even though the transactions are not yet committed.

Step 1: Discard Data Changes

Here, the data changes are discarded.

Step 1: To Display the Log File Content and Set the Log Level

We cannot filter the log messages in the console.

MongoDB has several logging levels, which can be set using the db.setLogLevel function.

MongoDB echoes back the previous configuration before the new setting was applied. At the top, you can see the default level, which indicates that any components that are not set will log at this level. Here, it will override only the query component. The -1 verbosity indicates that it inherits the default level from its parent.

Here, the query level is set to 2.

This query will not return any results because there is no collection named demos in the test database.

You can see some additional information about the query.

Now check the end of the log file: We cannot see the extra logging information for this find query.

Use db.setLogLevel(0) to turn off the logging level.

If we do not specify the option as query or write or anything, it will be applied for all options.

The log level 5 is very detailed; levels 1 to 3 are more useful options and these are recommended unless you need all of the detailed information provided by the highest log level of 5.

Also, setting the appropriate log level helps us to improve the performance of queries by identifying the query plans logged in the log file and also by identifying the slow operations by checking the time taken to execute a query.

Database Profiler

The database profiler is used to collect information about the commands that are executed against a running mongod instance. The database profiler writes all the collected data to the system.profile capped collection in the admin database.

MongoDB also has a Performance Advisor tool that automatically monitors slow queries and suggests new indexes to improve query performance. A query is considered to be slow if it takes more than 100 milliseconds to execute.

Step 1: Enable and Configure Database Profiler

was is the key/value pair indicating the previous level of profiling.

Here, the slow operation threshold is 30 milliseconds.

That code sets the profiler to sample 53% of all slow operations.

The was field indicates the current profiling level.

This command sets the profiling level to 1, the slow operation threshold to 20 milliseconds, and it profiles only 50% of the slow operations.

Step 1: Enable and Configure Database Profiler

The database profiler logs information in the system.profile collection. You need to query system.collection to view profiling information.

These options can be used to filter or sort as in the queries that follow.

mongostat

mongostat is a monitoring utility that provides information about a mongod instance if you are working on a single mongod instance. If you are working on a shared cluster, it shows information about a mongos instance.

Step 1: mongostat Command

Issue the mongostat command by specifying the hostname and port of MongoDB server.

mongotop

mongotop provides a method to track the amount of time spent by the mongod process during reads and writes. mongotop provides statistics on a per-collection level.

Step 1: mongotop Command

db.stats()

db.stats() provides the statistics of a single database.

Step 1: db.stats() Command

db.serverStatus()

db.serverStatus() returns a document that provides statistics for the state of a database process.

Step 1: db.serverStatus() Command

Step 1: Restore Data Using mongorestore

Step 2: Restore Data Using mongorestore to Remote Instances

Specify the username and password using options --user and --password only if the remote mongod instance requires authentication.

Step 1: Using explain() to Understand the Query Plan

Observe in this output that there is no parsedQuery in the query planner, and the winning plan says that it involves the complete collection scan.

Step 2: Understanding Different Modes in explain()

The explain() method accepts queryPlanner, executionStats, or allPlansExecution as the operating mode. The default mode is queryPlanner if we don’t specify otherwise.

If the executionTimeMillis value is more, then it could be considered a slow query and we must rewrite the query to optimize the executiuon time by adding the required filters to retrieve only the required data. We could also consider using an index on keys for better performance.

MongoDB User Roles

MongoDB Admin Roles

Cluster Admin Roles

Step 1: Create a Superuser

Step 2: Authenticate a User

You will be connected to mongoshell. You can also use db.auth() to authenticate a user.