MongoDB Tutorial

Introduction to MongoDB

// Introduction to MongoDB
// MongoDB is a NoSQL database that uses JSON-like documents.
// It is schema-less, making it easy to handle changing data structures.

// Example Document in MongoDB
{
"_id": ObjectId("507f1f77bcf86cd799439011"),
"name": "John Doe",
"age": 29,
"address": {
"street": "123 Main St",
"city": "New York"
},
"interests": ["coding", "music"]
}

MongoDB is a type of NoSQL database, meaning it doesn't use tables and rows like traditional databases. Instead, it stores data in documents similar to JSON, which makes it flexible and easy to work with.

NoSQL Databases

// NoSQL Databases Overview
// They handle large volumes of unstructured data.
// Types of NoSQL databases include:

// 1. Document-based (e.g., MongoDB)
// 2. Key-value (e.g., Redis)
// 3. Column-family (e.g., Cassandra)
// 4. Graph (e.g., Neo4j)

NoSQL databases are great for handling unstructured or changing data. Unlike traditional databases, they don't require a fixed structure, making them ideal for big data and fast-changing web applications.

Advantages over RDBMS

// Advantages of MongoDB over SQL Databases:
// - Schema-less: No need for a fixed structure.
// - Horizontally Scalable: Easy to handle large data by adding servers.
// - High Performance: Faster for complex data.
// - Flexible Data Storage: Store hierarchical data easily.

MongoDB and other NoSQL databases offer several benefits over traditional SQL databases: they don't need a set structure, can handle huge data sets more easily, and can store complex data efficiently.

MongoDB Data Types

// Common MongoDB Data Types
// 1. String: Text data.
// 2. Number: Integers and floating-point numbers.
// 3. Boolean: True or false.
// 4. Array: List of values.
// 5. Object: Embedded document.
// 6. Date: Date and time.

// Example Document with Data Types
{
"username": "alice",
"age": 30,
"isMember": true,
"tags": ["admin", "user"],
"contact": { "email": "alice@example.com" },
"joined_at": ISODate("2024-11-16T12:00:00Z")
}

MongoDB supports multiple data types like strings, numbers, booleans, arrays, and even nested documents. This makes it versatile for storing all kinds of data.

Install MongoDB

// Steps to Install MongoDB:
// 1. Download the installer from the MongoDB website.
// 2. Follow the installation instructions for your OS.
// 3. Start the MongoDB server:

// On Windows: 
mongod

// On Mac/Linux: 
sudo systemctl start mongod

// Verify Installation
mongo --version

To install MongoDB, download it from the official site and follow the installation instructions. Start the MongoDB server using the command line and verify the installation.

MongoDB Data Modeling

// Data Modeling in MongoDB:
// Use Embedding or Referencing to structure data.

// Embedding Example: Store related data together
{
"author": "John",
"articles": [
{ "title": "Learning MongoDB", "views": 100 },
{ "title": "NoSQL Basics", "views": 150 }
]
}

// Referencing Example: Link separate documents
{
"author": "Jane",
"article_id": ObjectId("507f1f77bcf86cd799439012")
}

// Separate Article Document
{
"_id": ObjectId("507f1f77bcf86cd799439012"),
"title": "Advanced MongoDB",
"views": 200
}

MongoDB allows you to structure your data using Embedding (storing related data in a single document) or Referencing (linking data across documents), depending on your needs.

MongoDB Operators

Query & Projection Operator

// Query Operators Examples
// $gt, $lt: Greater than, Less than
// $in: Matches any value in an array
// $and, $or: Combines conditions

// Find all users older than 25
db.users.find({ "age": { "$gt": 25 } })

// Find users aged 20 or 30
db.users.find({ "age": { "$in": [20, 30] } })

// Projection Example: Show only 'name' and 'age'
db.users.find({ "age": { "$gt": 25 } }, { "name": 1, "age": 1, "_id": 0 })

Query operators are used to search and filter documents in MongoDB. For example, you can use $gt for "greater than," $lt for "less than," or $in to match any value within an array. Projections allow you to specify which fields to return in the result.

MongoDB Update Operator

// Update Operators Examples
// $set: Update or add a field
// $inc: Increment a value
// $unset: Remove a field

// Update a user's age to 35
db.users.updateOne({ "name": "John" }, { "$set": { "age": 35 } })

// Increment all user ages by 1
db.users.updateMany({}, { "$inc": { "age": 1 } })

// Remove the 'address' field from a document
db.users.updateOne({ "name": "Jane" }, { "$unset": { "address": "" } })

Update operators modify existing documents. Use $set to change a field's value, $inc to increase a numeric value, or $unset to remove a field.

Aggregation Pipeline Stages

// Aggregation Pipeline Example
// Pipeline stages: $match, $group, $sort

// Group users by age and count them
db.users.aggregate([
{ "$match": { "age": { "$gt": 20 } } },
{ "$group": { "_id": "$age", "count": { "$sum": 1 } } },
{ "$sort": { "count": -1 } }
])

The aggregation framework processes data through stages. Each stage transforms the data. Common stages include $match for filtering, $group for grouping data, and $sort for ordering results.

MongoDB limit()

// Limit Example
// Show only the first 5 users
db.users.find({}).limit(5)

The limit() function restricts the number of documents returned by a query. This is useful when you only want to preview a small portion of the data.

MongoDB sort()

// Sort Example
// Sort users by age in descending order
db.users.find({}).sort({ "age": -1 })

// Sort users by name alphabetically
db.users.find({}).sort({ "name": 1 })

The sort() function is used to arrange documents based on field values. Use 1 for ascending order and -1 for descending order.

Query Modifiers

// Query Modifiers Examples
// skip(): Skip a certain number of documents
// sort(): Sort documents
// limit(): Limit the number of documents returned

// Skip the first 10 users and get the next 5, sorted by name
db.users.find({}).skip(10).limit(5).sort({ "name": 1 })

Query modifiers like skip(), limit(), and sort() allow for refined searches. They can be combined to paginate results, order them, and more.

Database Commands

Database Commands

// Common Database Commands
// show dbs: Lists all databases
// use <database>: Switch to a specific database
// db.dropDatabase(): Deletes the current database

// List all databases
show dbs

// Switch to 'myDatabase'
use myDatabase

// Delete the current database
db.dropDatabase()

Database commands allow you to manage databases in MongoDB. Commands like show dbs list all databases, use <database> switches to a specific database, and db.dropDatabase() deletes the current database.

Aggregation Commands

// Aggregation Commands Examples
// $match: Filters documents
// $group: Groups documents by a specified field
// $project: Reshapes documents

// Count users by age
db.users.aggregate([
{ "$match": { "age": { "$gte": 18 } } },
{ "$group": { "_id": "$age", "total": { "$sum": 1 } } },
{ "$project": { "age": "$_id", "total": 1, "_id": 0 } }
])

Aggregation commands process data records and return computed results. Key stages include $match (filtering), $group (grouping data), and $project (reshaping documents).

Geospatial Commands

// Geospatial Commands Examples
// $geoWithin: Finds documents within a specified geometry
// $near: Finds documents near a point

// Find locations within a specific area
db.places.find({
"location": {
"$geoWithin": {
"$centerSphere": [[-73.97, 40.77], 10 / 3963.2] // radius in miles
}
}
})

// Find the closest places to a given point
db.places.find({
"location": {
"$near": {
"$geometry": {
          "type": "Point",
          "coordinates": [-73.97, 40.77]
},
"$maxDistance": 5000 // distance in meters
}
}
})

Geospatial commands handle data related to geographic locations. Examples include $geoWithin for finding documents within a geometry and $near for searching nearby points.

Query & Write Operation Commands

// Query & Write Operation Examples
// find(): Fetches documents
// insertOne(), insertMany(): Insert documents
// updateOne(), updateMany(): Update documents
// deleteOne(), deleteMany(): Delete documents

// Find all users with age greater than 30
db.users.find({ "age": { "$gt": 30 } })

// Insert a new user
db.users.insertOne({ "name": "Alice", "age": 25 })

// Update the age of a specific user
db.users.updateOne({ "name": "Alice" }, { "$set": { "age": 26 } })

// Delete all users aged below 20
db.users.deleteMany({ "age": { "$lt": 20 } })

Query and write commands are essential for interacting with MongoDB. Use find() for fetching data, insertOne() or insertMany() for inserting, updateOne() or updateMany() for updating, and deleteOne() or deleteMany() for removing data.

Query Plan Cache Commands

// Query Plan Cache Commands Examples
// db.collection.getIndexes(): List indexes for a collection
// db.collection.explain(): Get query execution details
// db.collection.dropIndexes(): Drop all indexes on a collection

// Get indexes of the 'users' collection
db.users.getIndexes()

// Explain a query (details about execution)
db.users.explain("executionStats").find({ "age": { "$gt": 25 } })

// Drop all indexes on 'users' collection
db.users.dropIndexes()

Query Plan Cache Commands provide insights into query performance. Use getIndexes() to list indexes, explain() to understand query execution, and dropIndexes() to remove all indexes from a collection.

Authentication Commands

// Authentication Commands Examples
// db.auth(): Authenticate a user in the shell
// db.createUser(): Create a new user with roles

// Authenticate a user
db.auth("adminUser", "securePassword")

// Create a new user with readWrite access to the 'sales' database
db.createUser({
user: "salesUser",
pwd: "salesPass123",
roles: [ { role: "readWrite", db: "sales" } ]
})

Authentication commands handle user authentication in MongoDB. Use db.auth() to authenticate and db.createUser() to create a new user with specific roles.

User Management Commands

// User Management Commands Examples
// db.getUsers(): List all users in the database
// db.dropUser(): Delete a user from the database

// List all users in the current database
db.getUsers()

// Delete a user named 'salesUser'
db.dropUser("salesUser")

User Management commands allow you to manage database users. Use db.getUsers() to list all users and db.dropUser() to delete a user from the database.

Role Management Commands

// Role Management Commands Examples
// db.createRole(): Create a custom role
// db.getRole(): Get details of a specific role
// db.dropRole(): Delete a custom role

// Create a custom role with read-only access
db.createRole({
role: "readOnlyRole",
privileges: [
{ resource: { db: "sales", collection: "" }, actions: [ "find" ] }
],
roles: []
})

// Get details of a role
db.getRole("readOnlyRole")

// Delete the 'readOnlyRole'
db.dropRole("readOnlyRole")

Role Management commands create, view, and delete custom roles. Use db.createRole() to define a new role, db.getRole() to view a role, and db.dropRole() to remove it.

Replication Commands

// Replication Commands Examples
// rs.initiate(): Initialize a replica set
// rs.status(): Check the status of the replica set
// rs.add(): Add a new member to the replica set

// Initialize a new replica set
rs.initiate()

// Check the status of the replica set
rs.status()

// Add a new member to the replica set
rs.add("mongodb-node2:27017")

Replication commands are used to manage replica sets for redundancy and high availability. Use rs.initiate() to set up a replica, rs.status() to check its status, and rs.add() to add a member.

Sharding Commands

// Sharding Commands Examples
// sh.enableSharding(): Enable sharding for a database
// sh.shardCollection(): Shard a specific collection
// sh.status(): View the status of the sharded cluster

// Enable sharding for the 'myDatabase'
sh.enableSharding("myDatabase")

// Shard the 'orders' collection by the 'orderId' field
sh.shardCollection("myDatabase.orders", { "orderId": 1 })

// View the sharding status
sh.status()

Sharding commands manage horizontal scaling in MongoDB. Use sh.enableSharding() to enable sharding on a database, sh.shardCollection() to shard a collection, and sh.status() to check the sharding status.

Session Commands

// Session Commands Examples
// startSession(): Start a new session
// withTransaction(): Perform operations within a transaction
// endSession(): End the session

// Start a new session
let session = db.getMongo().startSession()

// Use a transaction within the session
session.startTransaction()
try {
db.orders.insertOne({ "item": "Laptop", "quantity": 1 })
db.customers.updateOne(
{ "customerId": "12345" },
{ "$set": { "orderStatus": "Processing" } }
)
session.commitTransaction()
} catch (e) {
session.abortTransaction()
} finally {
session.endSession()
}

Session commands handle multi-document transactions in MongoDB. Use startSession() to begin a session, withTransaction() to execute transactions, and endSession() to close the session.

Database

Create Database

// Create Database Example
// In MongoDB, a database is created automatically when you insert data into a collection.

// Switch to or create a database called 'myNewDatabase'
use myNewDatabase

// Create a collection named 'customers' to confirm the database creation
db.customers.insertOne({ name: "John Doe", email: "john@example.com" })

// The database 'myNewDatabase' is now created and contains the 'customers' collection.

In MongoDB, databases are not explicitly created with a single command. Instead, a database is created automatically when you switch to a database that doesn't exist (using use <databaseName>) and insert data into a collection.

Drop Database

// Drop Database Example
// To delete a database in MongoDB, you use the 'db.dropDatabase()' command.

// Switch to the database you want to drop
use myNewDatabase

// Drop the currently selected database
db.dropDatabase()

// The database 'myNewDatabase' is now deleted.

To remove a database in MongoDB, use the db.dropDatabase() command. Ensure you switch to the correct database with use <databaseName> before running the drop command.

Collection

Create Collection

    // Create Collection Example
    // To create a collection in MongoDB, you use the 'db.createCollection()' command.

    // Switch to your database
    use myNewDatabase

    // Create a new collection called 'products'
    db.createCollection('products')

    // Verify that the collection is created by showing all collections
    show collections
  

To create a collection in MongoDB, you can use the db.createCollection() method. However, collections are also created automatically when you insert a document into them. If you want explicit control, use this method to create a collection before inserting data.

Drop Collection

// Drop Collection Example
// To drop (delete) a collection in MongoDB, use the 'db.collection.drop()' method.

// Switch to your database
use myNewDatabase

// Drop the 'products' collection
db.products.drop()

// Verify that the collection is deleted by showing all collections
show collections

To drop a collection in MongoDB, use the db.collection.drop() method. This will permanently delete the collection and all of its data, so be cautious before running this command.

CRUD: Documents

Insert Documents

// Insert Document Example
// Insert a single document into the 'products' collection
db.products.insertOne({
name: "Laptop",
brand: "BrandX",
price: 1200,
inStock: true
})

// Insert multiple documents into the 'products' collection
db.products.insertMany([
{ name: "Phone", brand: "BrandY", price: 800, inStock: true },
{ name: "Tablet", brand: "BrandZ", price: 600, inStock: false }
])

You can insert documents into MongoDB using insertOne() for a single document or insertMany() for multiple documents. These methods insert data into the specified collection.

Update Documents

// Update Document Example
// Update a single document's price in the 'products' collection
db.products.updateOne(
{ name: "Laptop" }, // Condition
{ $set: { price: 1300 } } // Update operation
)

// Update multiple documents' inStock status
db.products.updateMany(
{ inStock: false }, // Condition
{ $set: { inStock: true } } // Update operation
)

Use updateOne() to update a single document or updateMany() to update multiple documents that match the specified condition. The $set operator is used to specify the fields that you want to update.

Delete Documents

// Delete Document Example
// Delete a single document from the 'products' collection
db.products.deleteOne({ name: "Phone" })

// Delete multiple documents
db.products.deleteMany({ inStock: false })

To delete documents, use deleteOne() to delete a single document and deleteMany() to delete multiple documents that meet the specified condition.

Query Documents

// Query Documents Example
// Find all documents in the 'products' collection
db.products.find({})

// Find a document with specific condition
db.products.find({ brand: "BrandX" })

// Find documents with conditions and limit the result
db.products.find({ price: { $gt: 500 } }).limit(2)

You can query documents using the find() method. You can specify conditions, like filtering by price, and you can also limit the results using .limit().

SQL to MongoDB Mapping

// SQL to MongoDB Mapping
// SQL: SELECT * FROM products WHERE price > 500 LIMIT 5;
// MongoDB equivalent:
db.products.find({ price: { $gt: 500 } }).limit(5)

In SQL, a query like SELECT * FROM products WHERE price > 500 LIMIT 5; is equivalent to the MongoDB query db.products.find({ price: { $gt: 500 } }).limit(5).

MongoDB Text Search

// MongoDB Text Search Example
// First, create a text index on a field
db.products.createIndex({ name: "text" })

// Then, use the $text operator for text search
db.products.find({ $text: { $search: "Laptop" } })

MongoDB provides a full-text search feature. You need to create a text index on the field you want to search (e.g., name), and then you can use the $text operator to search for specific keywords within that field.

MongoDB Shell

MongoDB Shell

// MongoDB Shell Basics

// Connect to MongoDB
// Open the shell and type the following command to connect to your MongoDB server
$ mongo

// Switch to a database (if it doesn't exist, MongoDB creates it when you insert data)
> use myDatabase

// Show all available databases
> show databases

// Show all collections in the current database
> show collections

The MongoDB shell allows you to interact with the database directly. It provides commands like show databases, use <dbName>, and show collections to navigate between databases and collections.

Shell Collection Methods

// Shell Collection Methods Example

// Insert a document into a collection
db.products.insertOne({
name: "Laptop",
price: 1200,
brand: "BrandX"
})

// Find a document in the collection
db.products.find({ name: "Laptop" })

// Update a document in the collection
db.products.updateOne(
{ name: "Laptop" },
{ $set: { price: 1100 } }
)

// Delete a document from the collection
db.products.deleteOne({ name: "Laptop" })

Collection methods in the MongoDB shell allow you to perform CRUD operations directly. You can use methods like insertOne(), find(), updateOne(), and deleteOne() to interact with data in a collection.

Cursor Methods

// Cursor Methods Example

// Find documents and use cursor methods to iterate
const cursor = db.products.find({})

// Use the forEach method to iterate over each document
cursor.forEach(doc => {
print(doc.name, doc.price);
})

// Limit the number of documents returned
db.products.find({}).limit(2)

// Skip some documents
db.products.find({}).skip(1).limit(2)

Cursor methods are used when querying data with find(). The result is a cursor that you can use to iterate through documents using methods like forEach(), or control the result set with limit() and skip().

MongoDB Database Commands

// MongoDB Database Commands Example

// Create a database (it will be created when you insert data)
> use myNewDatabase

// Show all databases
> show databases

// Drop a database
> db.dropDatabase()

MongoDB allows you to perform database operations such as switching between databases with use <dbName>, listing all databases with show databases, and dropping databases with db.dropDatabase().

Query Plan Cache Methods

// Query Plan Cache Methods Example

// View the query plan cache
db.products.explain('executionStats').find({ price: { $gt: 500 } })

// View the query plan for an index
db.products.explain('queryPlanner').find({ brand: "BrandX" })

Query plan cache methods allow you to view the query execution plans for a given query. Use explain('executionStats') or explain('queryPlanner') to understand how MongoDB is executing your queries and make performance optimizations.

Bulk Operation Methods

// Create a bulk operation object
const bulk = db.products.initializeUnorderedBulkOp();

// Insert documents in bulk
bulk.insert({ name: "Laptop", price: 1200 });
bulk.insert({ name: "Phone", price: 800 });

// Update documents in bulk
bulk.find({ name: "Phone" }).update({ $set: { price: 850 } });

// Execute the bulk operations
bulk.execute()

MongoDB supports bulk operations, allowing you to perform multiple insert, update, and delete operations at once. You can initialize a bulk operation with initializeUnorderedBulkOp(), then use methods like insert(), find().update(), and finally execute the bulk operation with execute().

Connection Methods

// Connect to a MongoDB instance using a URI
const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/myDatabase', { useNewUrlParser: true, useUnifiedTopology: true })
.then(() => console.log("Connected to MongoDB"))
.catch(err => console.log("Connection failed", err));

MongoDB can be connected to using a URI string, such as mongodb://localhost:27017/myDatabase. The mongoose.connect() method establishes the connection, and you can handle success and failure using .then() and .catch().

MongoDB Cloud

MongoDB Stitch

// Example: Using MongoDB Stitch SDK to connect to MongoDB
const stitch = require('mongodb-stitch-client');
const app = stitch.Stitch.initializeAppClient('your-app-id');

// Connect to MongoDB Stitch
app.auth.loginWithCredential(stitch.AnonymousCredential.create())
.then(() => console.log('Connected to MongoDB Stitch'))
.catch(err => console.log('Error:', err));

MongoDB Stitch is a serverless platform that allows developers to build applications by using MongoDB as the backend. You can interact with MongoDB without managing a server by using Stitch SDKs for various platforms. You can authenticate users, access data, and build functions directly within MongoDB.

MongoDB Atlas

// Example: Connecting to MongoDB Atlas using Node.js
const mongoose = require('mongoose');

const uri = 'mongodb+srv://:@cluster0.mongodb.net/test?retryWrites=true&w=majority';
mongoose.connect(uri, { useNewUrlParser: true, useUnifiedTopology: true })
.then(() => console.log('Connected to MongoDB Atlas'))
.catch(err => console.log('Error:', err));

MongoDB Atlas is a fully managed cloud database platform provided by MongoDB. It allows you to deploy, manage, and scale MongoDB clusters with minimal configuration. It comes with advanced features like automated backups, monitoring, and security, all integrated into a cloud-based dashboard.

MongoDB Cloud Manager

// Example: Managing MongoDB clusters using MongoDB Cloud Manager
// (Note: this requires using the MongoDB Cloud Manager UI to manage clusters)

MongoDB Cloud Manager is an on-premise MongoDB management tool. It allows you to deploy, manage, and monitor MongoDB clusters on your own infrastructure. Cloud Manager helps with backups, scaling, and monitoring your MongoDB database performance in real-time.

MongoDB Ops Manager

// Example: Ops Manager provides a UI for managing clusters
// Example: Using Ops Manager's UI to configure automated backups or perform a manual cluster backup

MongoDB Ops Manager is an enterprise-level management solution for managing MongoDB clusters. It provides a unified interface to automate operational tasks like backups, upgrades, scaling, and monitoring for MongoDB instances. Ops Manager is designed for teams that manage large-scale, mission-critical MongoDB deployments.

MongoDB Tools

MongoDB Compass

// Example: Using MongoDB Compass for GUI-based management
// MongoDB Compass is a GUI tool for interacting with MongoDB
// You can use it to query data, visualize schema, and manage collections
// Below is just the basic usage as MongoDB Compass is a GUI tool

// You would install and run MongoDB Compass, then connect to your MongoDB instance.
// After connecting, you can query and manage collections directly in the Compass UI.

MongoDB Compass is the official GUI for MongoDB. It provides a graphical interface to visualize and interact with MongoDB data. With Compass, you can:

• Visualize your database schema.
• Run queries and view results.
• Analyze your data with aggregation pipelines.
• Edit, insert, and delete documents.
• View real-time performance metrics.
• And much more, all in an easy-to-use interface.

MongoDB BI Connector

// Example: Using MongoDB BI Connector to connect MongoDB with BI tools like Tableau or Power BI
// MongoDB BI Connector acts as a bridge between MongoDB and Business Intelligence (BI) tools

// You would use the MongoDB BI Connector by setting it up with your MongoDB instance
// Example query in Tableau or Power BI connected through BI Connector:

SELECT * FROM < collection_name >

The MongoDB BI (Business Intelligence) Connector is a tool that allows you to connect your MongoDB database with BI tools like Tableau, Power BI, or any other SQL-based reporting tools. It translates MongoDB’s native BSON format to the relational format (SQL), allowing BI tools to query MongoDB as if it were a traditional SQL database.

• Allows SQL-based tools to interact with MongoDB.
• You can run SQL queries against MongoDB collections.
• Makes it easier to integrate MongoDB data into reports, dashboards, and data visualizations.

Connectivity

Java MongoDB Connectivity

To connect MongoDB with Java, you'll need the MongoDB Java Driver. Here's how you can connect to MongoDB and perform basic operations.

import com.mongodb.MongoClient;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoDatabase;

public class MongoDBConnection {
    public static void main(String[] args) {
        // Connect to MongoDB
        MongoClientURI uri = new MongoClientURI("mongodb://localhost:27017");
        MongoClient mongoClient = new MongoClient(uri);

        // Connect to the database
        MongoDatabase database = mongoClient.getDatabase("myDatabase");

        // Print the database name
        System.out.println("Connected to database: " + database.getName());
    }
}
  

PHP MongoDB Connectivity

In PHP, you need the MongoDB PHP Driver to connect MongoDB to your PHP application. Here's an example:

myDatabase->myCollection;

// Insert a document
$result = $collection->insertOne(['name' => 'John', 'age' => 30]);

// Display the inserted document
echo "Inserted with Object ID '{$result->getInsertedId()}'";
?>

Python MongoDB Connectivity

In Python, you can use the PyMongo library to connect to MongoDB and perform operations.

from pymongo import MongoClient

# Connect to MongoDB
client = MongoClient('mongodb://localhost:27017/')

# Select a database and collection
db = client['myDatabase']
collection = db['myCollection']

# Insert a document
collection.insert_one({'name': 'Alice', 'age': 25})

# Find and print the inserted document
document = collection.find_one({'name': 'Alice'})
print(document)

Node.js MongoDB Connectivity

For Node.js, you will use the MongoDB Node.js Driver to interact with MongoDB.

const { MongoClient } = require('mongodb');

// Connect to MongoDB
const uri = "mongodb://localhost:27017";
const client = new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true });

async function connect() {
    try {
        // Connect to the MongoDB server
        await client.connect();
        console.log("Connected to MongoDB");

        // Select the database and collection
        const database = client.db("myDatabase");
        const collection = database.collection("myCollection");

        // Insert a document
        const result = await collection.insertOne({ name: "Bob", age: 28 });
        console.log(\`Document inserted with _id: \${result.insertedId}\`);

        // Find and print the document
        const document = await collection.findOne({ name: "Bob" });
        console.log(document);
    } finally {
        await client.close();
    }
}

connect().catch(console.error);