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.
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.
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.
use <databaseName>
Example:
> 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:
use <databaseName>
db.dropDatabase()
Dropping a collection:
db.<collectionName>.drop()
Example of dropping a database:
> use myDatabase
switched to db myDatabase
> db.dropDatabase()
{ "dropped": "myDatabase", "ok": 1 }
Example of dropping a collection:
> 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.
db.createCollection(<name>, options)
Example:
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.
show collections
Example
> 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:
db.<collectionName>.insertOne({ <documentData> })
Syntax for inserting multiple documents:
db.<collectionName>.insertMany([ { <document1Data> }, { <document2Data> }, ... ])
Example of inserting a single document:
db.myCollection.insertOne({ name: "John", age: 30, city: "New York" })
Example of inserting multiple documents:
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.
db.<collectionName>.find()
Example
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.
db.<collectionName>.find().pretty()
Example:
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.
db.<collectionName>.find(<query>)
Example:
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.
db.<collectionName>.find().sort(<sortCriteria>)
Example:
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.
db.<collectionName>.countDocuments(<query>)
Example:
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.
db.<collectionName>.find().limit(<limitValue>)
Example:
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.
db.<collectionName>.find(<query>).sort(<sortCriteria>).limit(<limitValue>)
Example:
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.
db.<collectionName>.findOne(<query>)
Example:
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.
db.collection.find().forEach( <function> )
Example:
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.
db.<collectionName>.find(<query>, { field1: 1, field2: 1, ... })
Example:
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:
db.<collectionName>.updateOne(<filter>, <update>, <options>)
Syntax for updating multiple documents:
db.<collectionName>.updateMany(<filter>, <update>, <options>)
Example of updating a single document:
db.myCollection.updateOne({ name: "John" }, { $set: { age: 35 } })
Example of updating multiple documents:
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.
db.<collectionName>.updateMany(<filter>, { $rename: { <oldFieldName>: <newFieldName> } })
Example:
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:
db.<collectionName>.deleteOne(<filter>)
Syntax for deleting multiple documents:
db.<collectionName>.deleteMany(<filter>)
Example of deleting a single document:
db.myCollection.deleteOne({ name: "John" })
Example of deleting multiple documents:
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.
db.collectionName.find({ fieldName: { $elemMatch: { <queryCondition> } } })
Example:
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.
db.collectionName.createIndex({ fieldName: 1 })
Example:
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:
db.collectionName.createIndex({ fieldName: "text" })
Syntax for text search:
db.collectionName.find({ $text: { $search: "searchQuery" } })
Example:
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:
db.collectionName.find({ fieldName: { $gt: value } })
Syntax for greater than or equal to:
db.collectionName.find({ fieldName: { $gte: value } })
Syntax for less than:
db.collectionName.find({ fieldName: { $lt: value } })
Syntax for less than or equal to:
db.collectionName.find({ fieldName: { $lte: value } })
Example:
// 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! 😊
Top comments (0)