ReactJS-The Beginner Master Class
  • React In the Beginning
    • Lesson 1 - Demo: Build a Simple React App - Fast
    • Lesson 2 - HTML Review
    • Lesson 3 - CSS Review
    • Lesson 4 - Modern JavaScript (JSX) Patterns
    • Lesson 5 - Set up Dev Environment
    • Hands-on Practice
  • React Fundamentals
    • Lesson 1 - Understanding Old vs New Way of Building Web Apps - SPAs
    • Lesson 2 - Motivation for Using React as the Solution to Vanilla JS
    • Lesson 3 - What is ReactJS - How it Works
    • React Code Along from Scratch
    • Lesson 4 - Create and Run a React Project with Vite - Full Overview
    • Lesson 5 - Create Hook by State Management in React
    • Lesson 6 - React Project File and Folder Walkthrough
    • Lesson 7 - JSX and How React Treats the DOM & JSX Compilation(by Babeljs) - Overview
    • Lesson 8 - Understanding the Main Files - App.jsx and main.jsx
    • Lesson 9 - Props and One-Way Data Flow - Overview
    • Lesson 10 - Google Bookshelf App - Ver 1.0
    • Hands-on Practice I
    • Hands-on Practice II
  • React State and Styling
    • Lesson 1 - Pulling Book Data from a Different Data File
    • Lesson 2 - Overview of How State Works in React
    • Lesson 3 - RandomQuote App
    • Lesson 4 - Lifting State Up - React Pattern Overview
    • Hands-On - Simple Counter
  • Forms and Interactivity - Grocery List App
    • Lesson 1 - Setup a Simple Form and Input
    • Lesson 2 - Build Form Profile App Using Multi-input Form Data
    • Hands-on : Build a Grocery List App
  • Connecting to the Backend - Consuming APIs - UseEffect Hook
    • Lesson 1 - Connecting to the Back End - Understanding Side Effects, Hooks and useEffect - Overview
    • Lesson 2 - Fetching Data from the Backend the Right Way with useEffect Hook
    • Lesson 3 - Setting Up Loading State
    • Hands-on :Use Dependency Array and Adding Values that Control Side Effects
  • Solo Project 1
  • RESTful APIs :Build a BookSearch App -Ver 2.0
    • Lesson 1: Build and test RESTful APIs with Postman
    • Lesson 2 - BookShelf App Structure
    • Lesson 3 - Create NavBar.jsx Component
    • Lesson 4 - Create Footer Component
    • Lesson 5 - Create BookList.jsx Component
    • Lesson 6 - Create BookCard.jsx Component
    • Lesson 7 - Creating Custom Hooks - useBooks and api-client
    • Lesson 8 - Controlling Network Activities in React with AbortController
    • Lesson 9 - Show Book Details in a Modal - Working
    • Lesson 10 - Bookshelf App Summary
  • Multi-Page Applications (MPAs)
    • Build a Multi-Page React Application
    • Multi-Page React Application
    • Hands-on Practice
  • Backend Frameworks-NEXT.JS
    • Migrating from React to Next.js
    • Lesson 1: Key Concepts of NodeJS and Express for Backend Web Development
    • Lesson 2: How to set up a new Next.js project
    • Lesson 3: How to create Layouts and Pages
    • Hands-on Practice 1
    • Hands on Practice 2
      • New Project & Folder Structure
      • File-Based Routing
      • Server vs Client Components & Router Hooks
      • Start On The Navbar
      • Navbar Links, Dropdowns & React Icons
      • Active Links & Conditional Rendering
      • Homepage Components
      • Properties Page
      • Property Card Dynamic Data
      • Home Property Listings
      • Custom Not Found & Loading Pages
  • Git and GitHubs
    • Git Installation
    • Git Commands
    • GitHub Repository
    • Hands-on Practice
  • Database in Application
    • React Supabase CRUD
    • Hands-on: Note Taking App
  • NoSQL Database
    • Installing MongoDB Community Edition
    • System Env Path Setting
    • How to use MongoDB Shell
    • How to Connect and Use Mongosh in VS Code via MongoDB Extension
    • MongoDB Guide
  • Solo Project 2
  • Deployment and Web Hosting
    • Lesson 1. React+Vite+TS+Shadcn Project
    • Lesson 2. Deploying a React Vite App to Vercel from Vercel CLI
    • Lesson 3 Connecting to GitHub Repo and Automate Deployment
  • Solo Project 3
  • Final Term Project
    • Level 1 Team Project
    • Level 1 Team Project
    • Level 1 Team Project
    • Level 1 Team Project
    • Level 2 Team Project
    • Level 2 Team Project
    • Level 3 Team Project
    • Level 3 Team Project
Powered by GitBook
On this page
  • Database & Collection Creation, Document Operations & Queries
  • 1. Install and Start MongoDB
  • 2. Create a Database
  • 3. Create a Collection
  • 4. Insert Documents
  • 5. Find (Retrieve) Documents
  • 6. Update Documents
  • 7. Delete Documents
  • 8. Sorting & Limiting Results
  • 9. Comparison Operators
  • 10. Logical Operators
  • 11. Indexes for Performance
  • 12. Drop a Collection or Database
  • Example Document & Data Types
  • Conclusion
  1. NoSQL Database

MongoDB Guide

Database & Collection Creation, Document Operations & Queries

This lesson covers step-by-step instructions on how to create a MongoDB database, collections, and perform CRUD operations using mongosh.

1. Install and Start MongoDB

Ensure MongoDB is installed and running:

mongod --dbpath="C:\data\db"  # Windows
sudo systemctl start mongod    # Linux/macOS

Then, start the MongoDB shell at comand terminal or VSCode terminal via extension:

mongosh # at cmd 
Launch MongoDB Shell # at vsc 

2. Create a Database

MongoDB does not require explicit database creation. It automatically creates one when you insert a document.

Switch or Create a Database

use myDatabase

✔️ If myDatabase does not exist, MongoDB will create it when you insert data.


3. Create a Collection

MongoDB collections are like tables in SQL. You can create them explicitly or let MongoDB create them automatically.

Explicit Collection Creation

db.createCollection("users")

✔️ This creates an empty users collection.

Implicit Collection Creation

MongoDB automatically creates a collection when inserting a document:

db.users.insertOne({ name: "Alice", age: 30 })

4. Insert Documents

MongoDB stores data as documents in BSON format (similar to JSON).

Insert a Single Document

db.users.insertOne({ name: "Alice", age: 30, city: "New York" })

Insert Multiple Documents

db.users.insertMany([
  { name: "Bob", age: 25, city: "Los Angeles" },
  { name: "Charlie", age: 35, city: "Chicago" }
])

✔️ The _id field is automatically generated for each document.


5. Find (Retrieve) Documents

Find All Documents

db.users.find()

Pretty Print Results

db.users.find().pretty()

Find One Document

db.users.findOne({ name: "Alice" })

6. Update Documents

Update a Single Document

db.users.updateOne(
  { name: "Alice" }, 
  { $set: { age: 31, city: "San Francisco" } }
)

Update Multiple Documents

db.users.updateMany(
  { city: "Los Angeles" }, 
  { $set: { city: "San Diego" } }
)

7. Delete Documents

Delete One Document

db.users.deleteOne({ name: "Charlie" })

Delete Multiple Documents

db.users.deleteMany({ age: { $gt: 30 } })  # Deletes all users older than 30

8. Sorting & Limiting Results

Sort in Ascending Order (1)

db.users.find().sort({ age: 1 })

Sort in Descending Order (-1)

db.users.find().sort({ age: -1 })

Limit the Number of Results

db.users.find().limit(2)

9. Comparison Operators

MongoDB has SQL-like comparison operators:

Operator
Description
Example

$eq

Equal to

{ age: { $eq: 30 } }

$ne

Not equal to

{ age: { $ne: 25 } }

$gt

Greater than

{ age: { $gt: 30 } }

$lt

Less than

{ age: { $lt: 30 } }

$gte

Greater than or equal to

{ age: { $gte: 25 } }

$lte

Less than or equal to

{ age: { $lte: 40 } }

✔️ Example: Find users older than 30

db.users.find({ age: { $gt: 30 } })

10. Logical Operators

MongoDB also supports logical operators:

Operator
Description
Example

$and

Match all conditions

{ $and: [{ age: { $gt: 25 } }, { city: "San Diego" }] }

$or

Match any condition

{ $or: [{ age: 25 }, { city: "New York" }] }

$not

Negate a condition

{ age: { $not: { $gt: 30 } } }

✔️ Example: Find users older than 25 AND in "San Diego":

db.users.find({ $and: [{ age: { $gt: 25 } }, { city: "San Diego" }] })

11. Indexes for Performance

Indexes speed up queries by reducing the need for full collection scans.

Create an Index on a Field

db.users.createIndex({ name: 1 })  # Ascending index on "name"

View Existing Indexes

db.users.getIndexes()

Delete an Index

db.users.dropIndex("name_1")

12. Drop a Collection or Database

Drop a "users" Collection

db.users.drop()

Drop an Entire Database

db.dropDatabase()

Example Document & Data Types

//Json or Bson Data Type
{
  "_id": ObjectId("65af67cdef12345"),
  "name": "Alice",
  "age": 30,
  "city": "New York",
  "email": "alice@example.com",
  "isVerified": true,
  "score": 95.5,
  "hobbies": ["reading", "traveling"],
  "createdAt": ISODate("2024-01-25T10:00:00Z")
}
Data Type
Example

String

"name": "Alice"

Number

"age": 30

Boolean

"isVerified": true

Array

"hobbies": ["reading", "traveling"]

Object

"address": { "city": "New York", "zip": "10001" }

Date

"createdAt": ISODate("2024-01-25T10:00:00Z")

ObjectId

"_id": ObjectId("65af67cdef12345")


Conclusion

This guide provides an overview of how to: ✅ Create databases and collections ✅ Insert, update, delete, and query documents ✅ Use sorting, limiting, comparison, and logical operators ✅ Optimize queries with indexes

🚀 Now, you can start working efficiently with MongoDB using mongosh!

PreviousHow to Connect and Use Mongosh in VS Code via MongoDB ExtensionNextSolo Project 2

Last updated 4 months ago