Essential Concepts | MongoDB | Part 1
Tags: webdev, node, mongodb, database
Published: 2024-07-03 14:48:34

##Basics
###SQL vs NoSQL,Documents and Collections, Data Types

**SQL vs NoSQL**

1. SQL (Structured Query Language): Traditional relational databases like MySQL, PostgreSQL. They use tables to store data, and data is structured in rows and columns.Example: A table Users with columns id, name, email.

2. NoSQL (Not Only SQL): More flexible data models like document databases (MongoDB), key-value stores, wide-column stores, etc.Example: A collection Users where each user is a JSON-like document.

###Documents and Collections

**Document:** A record in a NoSQL database, typically stored in a JSON-like format.

**Example:** 
```
{
  "id": 1,
  "name": "John Doe",
  "email": "john.doe@example.com"
}
```
**Collection:** A group of documents, similar to a table in SQL.

**Example:** A collection Users containing documents like the one above.

###Data Types###

**String:** "John Doe"
**Number:** 25
**Boolean:** true
**Array:** ["reading", "traveling"]
**Object:** {"street": "123 Main St", "city": "Anytown"}

###Methods###

**insert()**
**Example:**
Insert a new user into the Users 
```
collection.db.Users.insert({ name: "Alice", email: "alice@example.com" });
```
**find()**
**Example:** Find all users in the Users 
```
collection.db.Users.find();
```
**update()**
**Example:** Update the email of a user with name "Alice".
```
db.Users.update({ name: "Alice" }, { $set: { email: "newalice@example.com" } });
```
**deleteOne()**
**Example:** Delete a user with name "Alice".
```
db.Users.deleteOne({ name: "Alice" });
```
**bulkWrite()**
**Example:** Perform multiple operations in a single call.
```
db.Users.bulkWrite([
  { insertOne: { document: { name: "Bob", email: "bob@example.com" } } },
  { updateOne: { filter: { name: "John Doe" }, update: { $set: { email: "newjohn@example.com" } } } },
  { deleteOne: { filter: { name: "Alice" } } }
]);
```
###Comparison Operators###

**$eq (Equal To)**
**Example:** Find users with name "John Doe".
```
db.Users.find({ name: { $eq: "John Doe" } });
```
**$gt (Greater Than)**
**Example:** Find users older than 25.
```
db.Users.find({ age: { $gt: 25 } });
```
**$lt (Less Than)**
**Example:** Find users younger than 25.
```
db.Users.find({ age: { $lt: 25 } });
```
**$lte (Less Than or Equal To)**
**Example:** Find users aged 25 or younger.
```
db.Users.find({ age: { $lte: 25 } });
```
**$gte (Greater Than or Equal To)**
**Example:** Find users aged 25 or older.
```
db.Users.find({ age: { $gte: 25 } });
```
**$ne (Not Equal To)**
**Example:** Find users not named "John Doe".
```
db.Users.find({ name: { $ne: "John Doe" } });
```
###Logical Operators
**$and**
**Example:** Find users named "John Doe" who are older than 25.
```
db.Users.find({ $and: [ { name: "John Doe" }, { age: { $gt: 25 } } ] });
```
**$or**
**Example:** Find users named "John Doe" or younger than 25.
```
db.Users.find({ $or: [ { name: "John Doe" }, { age: { $lt: 25 } } ] });
```
**$not**
**Example:** Find users not named "John Doe".
```
db.Users.find({ name: { $not: { $eq: "John Doe" } } });
```
**$nor**
**Example:** Find users neither named "John Doe" nor older than 25.
```
db.Users.find({ $nor: [ { name: "John Doe" }, { age: { $gt: 25 } } ] });
```

###Array Operators 
**$in**
**Example:** Find users whose names are either "John Doe" or "Alice".
```
db.Users.find({ name: { $in: ["John Doe", "Alice"] } });
```
**$nin**
**Example:** Find users whose names are neither "John Doe" nor "Alice".
```
db.Users.find({ name: { $nin: ["John Doe", "Alice"] } });
```
**$all**
**Example:** Find users who have both "reading" and "traveling" in their hobbies.
```
db.Users.find({ hobbies: { $all: ["reading", "traveling"] } });
```
**$elemMatch**
**Example:** Find users who have an address in "New York".
```
db.Users.find({ addresses: { $elemMatch: { city: "New York" } } });
```
**$size**
**Example:** Find users who have exactly 2 hobbies.
```
db.Users.find({ hobbies: { $size: 2 } });
```
##Element Operators
**$exists**
**Example:** Find users who have an email address.
```
db.Users.find({ email: { $exists: true } });
```
**$type**
**Example:** Find users whose age is a number.
```
db.Users.find({ age: { $type: "number" } });
```
**$regex**
**Example:** Find users whose email ends with "example.com".
```
db.Users.find({ email: { $regex: /example\.com$/ } });
```

###Projection Operators
**$project**
**Example:** Include only the name and email fields.
```
db.Users.find({}, { name: 1, email: 1 });
```
**$include and $exclude**
**Example:** Exclude the age field.
```
db.Users.find({}, { age: 0 });
```
**$slice**
**Example:** Limit the array to the first 3 elements.
```
db.Users.find({}, { hobbies: { $slice: 3 } });
```

###Indexes
**Single Field**
**Example:** Create an index on the email field.
```
db.Users.createIndex({ email: 1 });
```
**Compound**
**Example:** Create a compound index on name and email.
```
db.Users.createIndex({ name: 1, email: 1 });
```
**Text**
**Example:** Create a text index on the description field.
```
db.Users.createIndex({ description: "text" });
```

These concepts and examples provide a comprehensive overview of MongoDB operations, queries, aggregation, transactions, and security measures. If you need more details or have specific scenarios to explore, feel free to ask!



Happy Coding 🧑‍💻

**Connect with Me 🙋🏻: [LinkedIn](https://www.linkedin.com/in/aakash-kumar-182a11262?utm_source=share&utm_campaign=share_via&utm_content=profile&utm_medium=android_app)**