Master MongoDB: Comprehensive Cheat Sheet for Developers
Tags: mongodb, beginners, tutorial, programming
Published: 2024-03-23 14:52:06

In today's world of data, MongoDB stands out as a top choice among NoSQL databases, thanks to its incredible flexibility. But truly grasping its ins and outs requires more than just scratching the surface. 
This blog is here to help you unlock MongoDB's power, focusing on the key queries every developer needs to know. We'll cover everything from basic commands like creating and deleting databases to more advanced tasks like adding, searching, updating, and removing data. 

Join us as we dive into the essential commands that make MongoDB a breeze for developers to use effectively.

### Show All Databases
The `show dbs` command in MongoDB succinctly lists all available databases on the current MongoDB server, aiding developers and administrators in gaining a comprehensive overview of the database environment.
```javascript
show dbs
```

### Show Current Database
The `db` command in MongoDB is used to reference the current or active database within the MongoDB shell. When invoked without any parameters, it simply returns the name of the current database, providing developers and administrators with quick confirmation of the database they are currently working with.
```javascript
db
```

### Create Or Switch Database

The `use` command in MongoDB is used to create or switch to a specific database. If the specified database already exists, MongoDB will switch to that database. If the specified database does not exist, MongoDB will create it and then switch to it.
```javascript
use <databaseName>
```
Example:

```javascript
> use myDatabase
switched to db myDatabase
```

### Drop
The "drop" command in MongoDB is used to remove a specific database or collection from the MongoDB server. When dropping a database, all collections within that database are also deleted. Similarly, dropping a collection removes all documents within that collection.
Dropping a database:
```javascript
use <databaseName>
db.dropDatabase()
```
Dropping a collection:
```javascript
db.<collectionName>.drop()
```
Example of dropping a database:
```javascript
> use myDatabase
switched to db myDatabase
> db.dropDatabase()
{ "dropped": "myDatabase", "ok": 1 }
```
Example of dropping a collection:

```javascript
> db.myCollection.drop()
true
```

### Create Collection
In MongoDB, the `createCollection` command is used to explicitly create a new collection within a database. This command allows developers to specify various options for the new collection, such as setting validation rules, defining indexes, and configuring storage options.

```Javascript
db.createCollection(<name>, options)
```
Example:

```javascript
db.createCollection(
    "logs",
    {
        capped: true, // Create a capped collection
        size: 1048576, // Set the maximum size of the collection to 1 MB
        max: 1000, // Set the maximum number of documents in the collection to 1000
        timeseries: {
            timeField: "timestamp", // Define the time field for time series collection
            metaField: "meta", // Define the meta field for time series collection
            granularity: "seconds", // Set the granularity of the time series data
            bucketMaxSpanSeconds: 3600, // Set the maximum span of each bucket to 1 hour
            bucketRoundingSeconds: 60 // Round bucket boundaries to nearest minute
        },
        expireAfterSeconds: 604800, // Expire documents after 7 days
        validationLevel: "strict", // Set validation level to strict
        validationAction: "error", // Set validation action to error
        validator: {
            $jsonSchema: {
                bsonType: "object",
                required: ["message", "level"],
                properties: {
                    message: {
                        bsonType: "string",
                        description: "must be a string and is required"
                    },
                    level: {
                        enum: ["info", "warning", "error"],
                        description: "must be one of: 'info', 'warning', 'error' and is required"
                    },
                    timestamp: {
                        bsonType: "date",
                        description: "must be a date"
                    }
                }
            }
        }
    }
)

```

### Show Collections
The `show collections` command in MongoDB is used to display a list of all collections in the current database. It provides a quick overview of the collections available for querying and manipulation.

```javascript
show collections
```
Example

```javascript
> show collections
myCollection1
myCollection2
system.indexes
```

### Insert Document
To insert a document (row) into a collection in MongoDB, you can use the `insertOne()` method to insert a single document or the `insertMany()` method to insert multiple documents at once.

Syntax for inserting a single document:
```javascript
db.<collectionName>.insertOne({ <documentData> })
```
Syntax for inserting multiple documents:
```javascript
db.<collectionName>.insertMany([ { <document1Data> }, { <document2Data> }, ... ])
```
Example of inserting a single document:
```javascript
db.myCollection.insertOne({ name: "John", age: 30, city: "New York" })
```
Example of inserting multiple documents:
```javascript
db.myCollection.insertMany([
    { name: "Alice", age: 25, city: "Los Angeles" },
    { name: "Bob", age: 35, city: "Chicago" },
    { name: "Emily", age: 28, city: "San Francisco" }
])
```

### Get All Rows
To retrieve all documents (rows) from a collection in MongoDB, you can use the `find()` method without any query criteria. This method returns a cursor that allows you to iterate over all documents in the collection.

```javascript
db.<collectionName>.find()
```
Example 

```javascript
db.myCollection.find()
```

### Get All Rows Formatted
To retrieve all documents (rows) from a collection in MongoDB in a formatted manner, you can use the `pretty()` method along with the `find()` method. The `pretty()` method formats the output to be more readable.

```javascript
db.<collectionName>.find().pretty()
```
Example:

```javascript
db.myCollection.find().pretty()
```

### Find Rows
To find specific documents (rows) within a collection in MongoDB, you can use the `find()` method with query criteria. This allows you to retrieve documents that match certain conditions.

```javascript
db.<collectionName>.find(<query>)
```
Example:

```javascript
db.myCollection.find({ name: "John" })
```

### Sort Rows
To sort the documents (rows) returned by a query in MongoDB, you can use the `sort()` method along with the `find()` method. This allows you to specify the field(s) by which the documents should be sorted and the sorting order.

```javascript
db.<collectionName>.find().sort(<sortCriteria>)
```
Example:

```javascript
db.myCollection.find().sort({ name: 1 })
```

### Count Rows
To count the number of documents (rows) in a collection in MongoDB, you can use the `countDocuments()` method. This method returns the count of documents that match the specified query criteria.

```javascript
db.<collectionName>.countDocuments(<query>)
```
Example:

```javascript
db.myCollection.countDocuments()
```

### Limit Rows
To limit the number of documents (rows) returned by a query in MongoDB, you can use the `limit()` method along with the `find()` method. This allows you to specify the maximum number of documents to retrieve.

```javascript
db.<collectionName>.find().limit(<limitValue>)
```
Example:

```javascript
db.myCollection.find().limit(10)
```

### Chaining
Chaining in MongoDB refers to the process of combining multiple operations or methods together in a single query. This allows you to perform various operations sequentially on the data returned by a query.

For example, you can chain methods like `find()`, `sort()`, `limit()`, and `skip()` together to create more complex queries.

```javascript
db.<collectionName>.find(<query>).sort(<sortCriteria>).limit(<limitValue>)

```
Example:

```javascript
db.myCollection.find({ status: "active" }).sort({ createdAt: -1 }).limit(10)
```

### Find One Row
To retrieve a single document (row) from a collection in MongoDB, you can use the `findOne()` method. This method returns the first document that matches the specified query criteria.

```javascript
db.<collectionName>.findOne(<query>)
```
Example:

```javascript
db.myCollection.findOne({ name: "John" })
```

### Foreach
In MongoDB, the `forEach()` method is used to iterate over the documents in a cursor returned by a query and perform a specified operation for each document.

```javascript
db.collection.find().forEach( <function> )
```
Example:

```javascript
db.myCollection.find().forEach(function(doc) {
    print("Name: " + doc.name + ", Age: " + doc.age);
})
```

### Find Specific Fields
To retrieve specific fields from documents in a collection in MongoDB, you can use the `find()` method along with projection to specify which fields you want to include or exclude in the returned documents.

```javascript
db.<collectionName>.find(<query>, { field1: 1, field2: 1, ... })
```
Example:

```javascript
db.myCollection.find({ title:'Post one' }, {
title: 1,
author: 1
})
```

### Update Row
To update one or more documents in a collection in MongoDB, you can use the `updateOne()` method to update a single document or the `updateMany()` method to update multiple documents that match the specified query criteria.
Syntax for updating a single document:
```javascript
db.<collectionName>.updateOne(<filter>, <update>, <options>)
```
Syntax for updating multiple documents:
```javascript
db.<collectionName>.updateMany(<filter>, <update>, <options>)
```
Example of updating a single document:
```javascript
db.myCollection.updateOne({ name: "John" }, { $set: { age: 35 } })
```
Example of updating multiple documents:
```javascript
db.myCollection.updateMany({ status: "active" }, { $set: { status: "inactive" } })
```

### Rename field
To rename a field in documents within a collection in MongoDB, you can use the `$rename` update operator along with the `updateMany()` method to update multiple documents or `updateOne()` method to update a single document.

```javascript
db.<collectionName>.updateMany(<filter>, { $rename: { <oldFieldName>: <newFieldName> } })

```
Example:

```javascript
db.myCollection.updateMany({}, { $rename: { "oldField": "newField" } })
```

### Delete row
To delete one or more documents from a collection in MongoDB, you can use the `deleteOne()` method to delete a single document or the `deleteMany()` method to delete multiple documents that match the specified query criteria.

Syntax for deleting a single document:
```javascript
db.<collectionName>.deleteOne(<filter>)
```
Syntax for deleting multiple documents:
```javascript
db.<collectionName>.deleteMany(<filter>)
```
Example of deleting a single document:
```javascript
db.myCollection.deleteOne({ name: "John" })
```
Example of deleting multiple documents:
```javascript
db.myCollection.deleteMany({ status: "inactive" })
```

### Find By Element in Array
In MongoDB, you can query documents based on elements within an array using the `$elemMatch` operator or array operators such as `$in`, `$all`, `$elemMatch`, etc., depending on your specific requirements.
```javascript
db.collectionName.find({ fieldName: { $elemMatch: { <queryCondition> } } })

```
Example:
```javascript
db.books.find({ authors: { $elemMatch: { name: "John" } } })
```

### Add Index
In MongoDB, you can add indexes to fields in your collection to improve query performance. Indexes allow MongoDB to efficiently locate documents based on the indexed fields.

To add an index to a field in MongoDB, you can use the `createIndex()` method.
```javascript
db.collectionName.createIndex({ fieldName: 1 })
```
Example:
```javascript
db.books.createIndex({ title: 1 })
```

### Text Search
In MongoDB, you can perform text searches using the `$text` operator along with the `$search` operator. Text searches allow you to search for documents that contain specific words or phrases in indexed fields.

Before performing text searches, you need to ensure that at least one field in your collection is indexed with the text index. You can create a text index using the `createIndex()` method with the `text` index type.

Syntax to create a text index:
```javascript
db.collectionName.createIndex({ fieldName: "text" })
```
Syntax for text search:
```javascript
db.collectionName.find({ $text: { $search: "searchQuery" } })
```
Example:
```javascript
db.books.find({ $text: { $search: "MongoDB" } })
```

### Greater & Less Than
In MongoDB, you can perform greater than (`$gt`), greater than or equal to (`$gte`), less than (`$lt`), and less than or equal to (`$lte`) comparisons to query documents based on numeric or date values.
Syntax for greater than:
```javascript
db.collectionName.find({ fieldName: { $gt: value } })
```
Syntax for greater than or equal to:
```javascript
db.collectionName.find({ fieldName: { $gte: value } })
```
Syntax for less than:
```javascript
db.collectionName.find({ fieldName: { $lt: value } })
```
Syntax for less than or equal to:
```javascript
db.collectionName.find({ fieldName: { $lte: value } })
```
Example:
```javascript
// Find books priced $50 or higher
db.books.find({ price: { $gte: 50 } })

// Find books priced less than $30
db.books.find({ price: { $lt: 30 } })

// Find books priced $30 or less
db.books.find({ price: { $lte: 30 } })
```

Mastering the querying methods discussed in this article is essential for efficiently retrieving data from MongoDB collections based on specific criteria.

By familiarizing yourself with these fundamental querying techniques such as finding documents by field values, performing text searches, and using comparison operators for numeric or date values, you can effectively filter and retrieve relevant information from your MongoDB databases. 🚀

I hope you found this article informative and helpful in enhancing your MongoDB querying skills! If you enjoyed it, don't hesitate to leave a comment and share your thoughts. Thank you! 😊


<a href="https://www.buymeacoffee.com/vishnusatheesh" target="_blank"><img src="https://cdn.buymeacoffee.com/buttons/v2/default-yellow.png" alt="Buy Me A Coffee" style="height: 60px !important;width: 217px !important;" ></a>