Skip to main content
Mapagam

57 SECTIONS · 616 TOPICS

Mongodb Roadmap

  1. Installing and Configuring MongoDB

    1. 1. Installing MongoDB Community Server
    2. Example: macOS install and start
    3. 2. Installing MongoDB Enterprise Edition
    4. 3. Setting Up mongod Configuration File
    5. Example: /etc/mongod.conf (YAML)
    6. 4. Configuring Network Bindings
    7. 5. Setting Up Storage Options
    8. 6. Configuring Logging Options
    9. 7. Setting Up Security Options
    10. 8. Using mongod Command-Line Options
    11. 9. Connecting with mongosh Shell
    12. 10. Setting Up Environment Variables
    13. 11. Configuring Memory Settings
    14. 12. Running MongoDB as a Service

  2. Understanding MongoDB Connection Strings

    1. 1. Understanding Connection String URI (mongodb://)
    2. 2. Connecting to Local Instance
    3. 3. Connecting to Remote Server
    4. 4. Using Authentication in Connection String
    5. 5. Setting Database in Connection String
    6. 6. Configuring Connection Pool Options
    7. 7. Using SRV Connection String (mongodb+srv://)
    8. 8. Setting TLS/SSL Options
    9. 9. Configuring Connection Timeout
    10. 10. Setting Socket Timeout
    11. 11. Handling Connection Pooling Behavior
    12. 12. Managing Connection Lifecycle
    13. Example: Node.js driver lifecycle

  3. Understanding BSON Data Types

    1. 1. Understanding Document Structure
    2. 2. Working with String Type
    3. 3. Working with Number Types
    4. 4. Working with Boolean Type
    5. 5. Working with Date Type
    6. 6. Working with ObjectId Type
    7. 7. Working with Arrays
    8. 8. Working with Embedded Documents
    9. 9. Working with Null and Undefined Values
    10. 10. Working with Binary Data
    11. 11. Understanding Regular Expression Type
    12. 12. Understanding Timestamp Type

  4. Working with Databases and Collections

    1. 1. Creating Database
    2. 2. Listing Databases
    3. 3. Dropping Database
    4. 4. Creating Collection
    5. 5. Listing Collections
    6. 6. Dropping Collection
    7. 7. Renaming Collection
    8. 8. Getting Collection Stats
    9. 9. Creating Capped Collection
    10. 10. Validating Collection
    11. 11. Understanding Collection Options
    12. 12. Using Namespace Limits

  5. Working with Capped Collections

    1. 1. Creating Capped Collection
    2. 2. Setting Maximum Size
    3. 3. Setting Maximum Document Count
    4. 4. Understanding FIFO Behavior
    5. 5. Using Tailable Cursors with Capped Collections
    6. 6. Converting Regular to Capped
    7. 7. Understanding Capped Collection Limitations
    8. 8. Using Capped Collections for Logging
    9. 9. Querying Capped Collections
    10. 10. Monitoring Capped Collection Size

  6. Inserting Documents

    1. 1. Inserting Single Document
    2. Example: Insert with explicit _id
    3. 2. Inserting Multiple Documents
    4. 3. Using Ordered Inserts
    5. 4. Handling Insert Errors
    6. 5. Setting Write Concern
    7. 6. Using _id Field
    8. 7. Inserting with Upsert
    9. 8. Using Bulk Write Operations
    10. 9. Handling Duplicate Key Errors
    11. 10. Inserting Nested Documents
    12. 11. Using Retryable Writes

  7. Querying Documents

    1. 1. Finding All Documents
    2. 2. Finding Single Document
    3. 3. Querying with Equality Conditions
    4. 4. Using Comparison Operators
    5. 5. Querying Arrays
    6. 6. Querying Embedded Documents
    7. 7. Using Logical Operators
    8. 8. Using $in and $nin Operators
    9. 9. Checking Field Existence ($exists)
    10. 10. Using Regular Expressions
    11. 11. Querying Null Values
    12. 12. Using $expr for Expression Queries
    13. 13. Using $type for Type Checking

  8. Working with Cursors

    1. 1. Understanding Cursor Behavior
    2. 2. Iterating Cursor Results
    3. 3. Converting Cursor to Array
    4. 4. Counting Cursor Results
    5. 5. Setting Cursor Limit
    6. 6. Skipping Cursor Results
    7. Example: Range-based pagination
    8. 7. Sorting Cursor Results
    9. 8. Setting Batch Size
    10. 9. Using Tailable Cursors
    11. 10. Using noCursorTimeout Option
    12. 11. Closing Cursors
    13. 12. Understanding Cursor Expiration

  9. Working with Projection

    1. 1. Including Fields
    2. 2. Excluding Fields
    3. 3. Projecting Array Elements
    4. 4. Using $elemMatch in Projection
    5. 5. Projecting Positional Elements ($)
    6. 6. Excluding _id Field
    7. 7. Using $meta for Text Search Scores
    8. 8. Projecting Nested Fields
    9. 9. Understanding Projection Limitations
    10. 10. Using Projection for Performance

  10. Updating Documents

    1. 1. Updating Single Document (updateOne())
    2. 2. Updating Multiple Documents (updateMany())
    3. 3. Replacing Document
    4. 4. Using $set Operator
    5. 5. Using $unset to Remove Fields
    6. 6. Incrementing Values ($inc)
    7. 7. Multiplying Values ($mul)
    8. 8. Renaming Fields ($rename)
    9. 9. Using $min and $max Operators
    10. 10. Setting on Insert ($setOnInsert)
    11. 11. Using $currentDate Operator
    12. 12. Using findOneAndUpdate()
    13. 13. Using findOneAndReplace()
    14. 14. Handling Upsert Operations

  11. Updating Arrays

    1. 1. Adding to Arrays
    2. 2. Adding Multiple Items
    3. 3. Removing Items
    4. 4. Removing First or Last
    5. 5. Adding Unique Items
    6. 6. Updating Array Elements by Position ($)
    7. 7. Updating All Array Elements ($[])
    8. 8. Using Filtered Positional Operator ($[identifier])
    9. 9. Slicing Arrays
    10. 10. Sorting Array Elements
    11. 11. Limiting Array Size
    12. 12. Using $pullAll to Remove Multiple

  12. Deleting Documents

    1. 1. Deleting Single Document
    2. 2. Deleting Multiple Documents
    3. 3. Using findOneAndDelete()
    4. 4. Deleting with Filter Criteria
    5. 5. Handling Delete Results
    6. 6. Setting Write Concern for Deletes
    7. 7. Using Bulk Delete Operations
    8. 8. Deleting All Documents
    9. 9. Using TTL Indexes for Automatic Deletion
    10. 10. Implementing Soft Deletes

  13. Working with Bulk Operations

    1. 1. Using bulkWrite() Method
    2. 2. Performing insertOne in Bulk
    3. 3. Performing updateOne in Bulk
    4. 4. Performing updateMany in Bulk
    5. 5. Performing deleteOne in Bulk
    6. 6. Performing deleteMany in Bulk
    7. 7. Performing replaceOne in Bulk
    8. 8. Using Ordered Bulk Operations
    9. 9. Using Unordered Bulk Operations
    10. 10. Handling Bulk Write Errors
    11. 11. Optimizing Bulk Performance
    12. 12. Using Bulk Operations with Sessions

  14. Working with Single-Field Indexes

    1. 1. Creating Single Field Index
    2. 2. Creating Ascending Index
    3. 3. Creating Descending Index
    4. 4. Listing Indexes
    5. 5. Dropping Index
    6. 6. Dropping All Indexes
    7. 7. Setting Unique Constraint
    8. 8. Setting Sparse Index
    9. 9. Setting Index Name
    10. 10. Creating Background Index
    11. 11. Using Index Hints
    12. 12. Analyzing Index Usage

  15. Working with Compound Indexes

    1. 1. Creating Compound Index
    2. 2. Understanding Index Order
    3. 3. Using Prefix Queries
    4. 4. Understanding Sort Direction Optimization
    5. 5. Optimizing Compound Index for Queries
    6. 6. Setting Index Options
    7. 7. Understanding Covered Queries
    8. 8. Analyzing Compound Index Performance
    9. 9. Using Compound Index for Sorting
    10. 10. Avoiding Index Intersection

  16. Working with Multikey Indexes

    1. 1. Creating Multikey Index
    2. 2. Understanding Multikey Behavior
    3. 3. Indexing Array of Scalars
    4. 4. Indexing Array of Documents
    5. 5. Understanding Multikey Limitations
    6. 6. Using Compound Multikey Indexes
    7. 7. Avoiding Multiple Multikey Fields
    8. 8. Analyzing Multikey Index Usage

  17. Working with Text Indexes

    1. 1. Creating Text Index
    2. 2. Creating Compound Text Index
    3. 3. Setting Text Index Weights
    4. 4. Setting Default Language
    5. 5. Using Language Override
    6. 6. Creating Wildcard Text Index
    7. 7. Dropping Text Index
    8. 8. Understanding Text Index Limitations

  18. Working with Geospatial Indexes

    1. 1. Creating 2dsphere Index
    2. 2. Creating 2d Index
    3. 3. Understanding Index Differences
    4. 4. Indexing GeoJSON Objects
    5. 5. Setting Coordinate Precision
    6. 6. Creating Compound Geospatial Index
    7. 7. Understanding Geospatial Index Limits
    8. 8. Optimizing Geospatial Queries

  19. Working with Specialized Indexes

    1. 1. Creating Hashed Index
    2. 2. Creating Wildcard Index
    3. 3. Creating TTL Index
    4. 4. Creating Partial Index
    5. 5. Creating Case-Insensitive Index
    6. 6. Creating Hidden Index
    7. 7. Unhiding Index
    8. 8. Understanding Specialized Index Use Cases
    9. 9. Choosing Right Index Type

  20. Working with TTL Indexes

    1. 1. Creating TTL Index
    2. 2. Setting Expiration Time
    3. 3. Understanding TTL Monitor Thread
    4. 4. Using Date Fields for Expiration
    5. 5. Modifying TTL Index
    6. 6. Removing TTL Behavior
    7. 7. Monitoring TTL Deletions
    8. 8. Understanding TTL Limitations
    9. 9. Using TTL with Partial Indexes
    10. 10. Implementing Data Retention Policies

  21. Working with Data Modeling

    1. 1. Understanding Document Model
    2. 2. Modeling One-to-One Relationships
    3. 3. Modeling One-to-Many Relationships (embedded)
    4. 4. Modeling One-to-Many Relationships
    5. 5. Modeling Many-to-Many Relationships
    6. 6. Using Embedded Documents
    7. 7. Using References with $lookup
    8. 8. Choosing Embedding vs Referencing
    9. 9. Handling Large Documents
    10. 10. Understanding Schema Flexibility

  22. Implementing Schema Design Patterns

    1. 1. Using Attribute Pattern
    2. 2. Using Bucket Pattern
    3. 3. Using Computed Pattern
    4. 4. Using Document Versioning Pattern
    5. 5. Using Extended Reference Pattern
    6. 6. Using Outlier Pattern
    7. 7. Using Polymorphic Pattern
    8. 8. Using Subset Pattern
    9. 9. Using Tree Patterns
    10. 10. Using Schema Versioning Pattern

  23. Validating Document Schema

    1. 1. Creating Schema Validation Rules
    2. 2. Using JSON Schema Validation
    3. 3. Setting Validation Level
    4. 4. Setting Validation Action
    5. 5. Using Query Expression Validation
    6. 6. Validating Required Fields
    7. 7. Validating Data Types
    8. 8. Setting Min/Max Values
    9. 9. Using Pattern Matching
    10. 10. Validating Array Items
    11. 11. Updating Validation Rules
    12. 12. Bypassing Validation

  24. Using Aggregation Framework

    1. 1. Understanding Pipeline Stages
    2. 2. Matching Documents
    3. 3. Projecting Fields
    4. 4. Grouping Documents
    5. 5. Sorting Results
    6. 6. Limiting Results
    7. 7. Skipping Results
    8. 8. Unwinding Arrays
    9. 9. Looking Up from Collections
    10. 10. Adding Computed Fields
    11. 11. Replacing Root
    12. 12. Counting Documents

  25. Using Advanced Aggregation Stages

    1. 1. Filtering Arrays in Documents
    2. 2. Using $facet for Multi-Pipeline
    3. 3. Using $bucket for Categorization
    4. 4. Using $bucketAuto for Auto-Bucketing
    5. 5. Using $graphLookup for Recursive Queries
    6. 6. Using $sample for Random Documents
    7. 7. Using $out to Output Collection
    8. 8. Using $merge to Merge Collections
    9. 9. Using $redact for Access Control
    10. 10. Using $unionWith to Combine Collections
    11. 11. Using $densify for Missing Data
    12. 12. Using $fill for Null Values

  26. Using Aggregation Operators

    1. 1. Using Arithmetic Operators
    2. 2. Using Comparison Operators
    3. 3. Using String Operators
    4. 4. Using Array Operators
    5. 5. Using Date Operators
    6. 6. Using Conditional Operators
    7. 7. Using Accumulator Operators
    8. 8. Using Type Conversion
    9. 9. Using Set Operators
    10. 10. Using Object Operators
    11. 11. Using Window Operators

  27. Working with Text Search

    1. 1. Creating Text Index
    2. 2. Performing Text Search
    3. 3. Using Search Phrases
    4. 4. Excluding Terms
    5. 5. Setting Text Search Language
    6. 6. Sorting by Text Score ($meta: "textScore")
    7. 7. Using Case-Sensitive Search
    8. 8. Using Diacritic-Sensitive Search
    9. 9. Combining Text Search with Other Queries
    10. 10. Understanding Text Index Limitations
    11. 11. Using Text Search with Aggregation

  28. Working with Geospatial Queries

    1. 1. Storing GeoJSON Objects
    2. 2. Storing Legacy Coordinates
    3. 3. Using $near for Proximity Queries
    4. 4. Using $nearSphere for Spherical Distance
    5. 5. Using $geoWithin for Boundary Queries
    6. 6. Using $geoIntersects for Intersection
    7. 7. Using $centerSphere for Circular Regions
    8. 8. Using $box for Rectangular Regions
    9. 9. Using $polygon for Custom Shapes
    10. 10. Calculating Distances
    11. 11. Understanding Geospatial Query Limitations

  29. Working with MongoDB Views

    1. 1. Creating Views
    2. 2. Querying Views
    3. 3. Using Aggregation Pipelines in Views
    4. 4. Dropping Views
    5. 5. Listing Views
    6. 6. Understanding View Limitations
    7. 7. Modifying View Definition
    8. 8. Using Views for Security
    9. 9. Materializing View Results
    10. 10. Creating On-Demand Materialized Views

  30. Working with Time Series Collections

    1. 1. Creating Time Series Collection
    2. 2. Setting Time Field
    3. 3. Setting Meta Field
    4. 4. Configuring Granularity
    5. 5. Inserting Time Series Data
    6. 6. Querying Time Series Data
    7. 7. Using Aggregation with Time Series
    8. 8. Setting Expiration
    9. 9. Understanding Bucketing Behavior
    10. 10. Optimizing Time Series Performance
    11. 11. Creating Secondary Indexes on Time Series

  31. Working with GridFS

    1. 1. Understanding GridFS Architecture
    2. 2. Uploading Files
    3. 3. Downloading Files
    4. 4. Listing Files
    5. 5. Deleting Files
    6. 6. Using GridFS with Language Drivers
    7. 7. Setting Chunk Size
    8. 8. Querying GridFS Files Collection
    9. 9. Storing Metadata with Files
    10. 10. Handling Large File Storage
    11. 11. Using GridFS for Binary Data

  32. Working with Collations

    1. 1. Understanding Collation Options
    2. 2. Setting Collection-Level Collation
    3. 3. Using Query-Level Collation
    4. 4. Setting Index Collation
    5. 5. Configuring Case Sensitivity
    6. 6. Using Diacritic Sensitivity
    7. 7. Using Numeric Ordering
    8. 8. Setting Alternate Handling
    9. 9. Configuring Normalization
    10. 10. Using Locale-Specific Sorting

  33. Configuring Read Preferences

    1. 1. Setting Read Preference
    2. 2. Using primaryPreferred Mode
    3. 3. Using secondaryPreferred Mode
    4. 4. Using nearest Mode
    5. 5. Using Read Preference Tags
    6. 6. Setting maxStalenessSeconds
    7. 7. Understanding Read Preference Behavior
    8. 8. Using Read Preference with Transactions
    9. 9. Configuring Read Preference in Connection String
    10. 10. Handling Read Preference Failover

  34. Configuring Read Concerns

    1. 1. Using local Read Concern
    2. 2. Using available Read Concern
    3. 3. Using majority Read Concern
    4. 4. Using linearizable Read Concern
    5. 5. Using snapshot Read Concern
    6. 6. Understanding Read Concern Levels
    7. 7. Setting Read Concern in Operations
    8. 8. Combining Read Concern with Read Preference
    9. 9. Using Read Concern with Transactions
    10. 10. Understanding Read Concern Performance

  35. Configuring Write Concerns

    1. 1. Setting Write Concern
    2. 2. Using Acknowledged Writes
    3. 3. Using Majority Writes
    4. 4. Using Journaled Writes
    5. 5. Setting Write Timeout
    6. 6. Using Unacknowledged Writes
    7. 7. Using Custom Write Concern
    8. 8. Understanding Write Concern Performance
    9. 9. Configuring Default Write Concern
    10. 10. Handling Write Concern Errors

  36. Working with Sessions

    1. 1. Starting Session
    2. 2. Using Session with Operations
    3. 3. Setting Session Options
    4. 4. Understanding Causal Consistency
    5. 5. Implementing Read Your Writes
    6. 6. Implementing Monotonic Reads
    7. 7. Ending Session
    8. 8. Using Session with Transactions
    9. 9. Handling Session Timeout
    10. 10. Understanding Session Lifecycle

  37. Working with Transactions

    1. 1. Starting Transaction
    2. 2. Committing Transaction
    3. 3. Aborting Transaction
    4. 4. Using Transaction Options
    5. 5. Handling Transaction Errors
    6. 6. Implementing Retry Logic
    7. 7. Using Multi-Document Transactions
    8. 8. Understanding Transaction Limitations
    9. 9. Setting Transaction Timeout
    10. 10. Using Callback API for Transactions
    11. 11. Understanding Transaction Performance

  38. Working with Change Streams

    1. 1. Opening Change Stream
    2. 2. Filtering Change Events
    3. 3. Understanding Change Event Structure
    4. 4. Resuming Change Stream
    5. 5. Using Full Document Option
    6. 6. Using Full Document Before Change
    7. 7. Watching Specific Operations
    8. 8. Setting Start Time
    9. 9. Handling Change Stream Errors
    10. 10. Using Change Streams with Aggregation
    11. 11. Monitoring Database/Collection Changes

  39. Working with Replication

    1. 1. Understanding Replica Set Architecture
    2. 2. Initiating Replica Set
    3. 3. Adding Replica Members
    4. 4. Removing Replica Members
    5. 5. Configuring Priority
    6. 6. Setting Up Arbiter
    7. 7. Using Hidden Members
    8. 8. Configuring Delayed Members
    9. 9. Checking Replica Status
    10. 10. Forcing Election
    11. 11. Understanding Oplog
    12. 12. Setting Oplog Size

  40. Working with Sharding

    1. 1. Understanding Sharded Cluster Architecture
    2. 2. Setting Up Config Servers
    3. 3. Setting Up mongos Query Routers
    4. 4. Enabling Sharding
    5. 5. Choosing Shard Key
    6. 6. Sharding Collection
    7. 7. Using Hashed Shard Key
    8. 8. Using Ranged Shard Key
    9. 9. Using Compound Shard Key
    10. 10. Adding Shards
    11. 11. Removing Shards
    12. 12. Understanding Chunk Management

  41. Optimizing Sharded Clusters

    1. 1. Understanding Balancer Process
    2. 2. Starting and Stopping Balancer
    3. 3. Configuring Balancer Window
    4. 4. Understanding Chunk Migration
    5. 5. Splitting Chunks Manually
    6. 6. Moving Chunks
    7. 7. Checking Shard Status
    8. 8. Monitoring Shard Distribution
    9. 9. Avoiding Jumbo Chunks
    10. 10. Understanding Broadcast vs Targeted Queries

  42. Implementing MongoDB Security

    1. 1. Enabling Authentication
    2. 2. Creating User Accounts
    3. 3. Using Built-in Roles
    4. 4. Creating Custom Roles
    5. 5. Granting Roles
    6. 6. Revoking Roles
    7. 7. Using SCRAM Authentication
    8. 8. Using x.509 Certificate Authentication
    9. 9. Using LDAP Authentication
    10. 10. Configuring Kerberos Authentication
    11. 11. Implementing Role-Based Access Control

  43. Configuring Network Security

    1. 1. Enabling TLS/SSL
    2. 2. Configuring TLS Certificates
    3. 3. Setting Client TLS Options
    4. 4. Using IP Whitelisting
    5. 5. Configuring Firewall Rules
    6. 6. Setting Up SSH Tunneling
    7. 7. Using VPC Peering
    8. 8. Implementing Private Endpoints
    9. 9. Configuring Network Compression
    10. 10. Understanding Network Security Best Practices

  44. Working with Encryption

    1. 1. Using Encryption at Rest
    2. 2. Configuring KMIP for Key Management
    3. 3. Understanding Client-Side Field Encryption
    4. 4. Creating Data Encryption Keys
    5. 5. Encrypting Specific Fields
    6. 6. Decrypting Encrypted Fields
    7. 7. Using Automatic Encryption
    8. 8. Using Explicit Encryption
    9. 9. Rotating Encryption Keys
    10. 10. Configuring Queryable Encryption

  45. Working with Auditing

    1. 1. Enabling Audit Log
    2. 2. Configuring Audit Filters
    3. 3. Auditing Authentication Events
    4. 4. Auditing Authorization Events
    5. 5. Auditing DDL Operations
    6. 6. Auditing DML Operations
    7. 7. Auditing Administrative Actions
    8. 8. Using Audit Log File
    9. 9. Understanding Audit Event Structure
    10. 10. Analyzing Audit Logs

  46. Working with Backup Strategies

    1. 1. Using mongodump for Backup
    2. 2. Using mongorestore for Restore
    3. 3. Backing Up Specific Database
    4. 4. Backing Up Specific Collection
    5. 5. Using --oplog for Point-in-Time Recovery
    6. 6. Restoring with --oplogReplay
    7. 7. Creating Filesystem Snapshots
    8. 8. Using Cloud Backup Solutions
    9. 9. Backing Up Replica Sets
    10. 10. Backing Up Sharded Clusters
    11. 11. Implementing Backup Schedules
    12. 12. Testing Backup Restoration

  47. Working with Data Import and Export

    1. 1. Using mongoimport for JSON/CSV
    2. 2. Using mongoexport for JSON/CSV
    3. 3. Importing from JSON File
    4. 4. Exporting to JSON Format
    5. 5. Importing from CSV File
    6. 6. Exporting to CSV Format
    7. 7. Setting Import Field Types
    8. 8. Using Query for Selective Export
    9. 9. Handling Large Data Imports
    10. 10. Using --drop for Clean Import

  48. Optimizing Query Performance

    1. 1. Analyzing Query Performance
    2. 2. Understanding Explain Plans
    3. 3. Using Covered Queries
    4. 4. Avoiding Collection Scans
    5. 5. Optimizing Index Selection
    6. 6. Using Index Intersection
    7. 7. Understanding Query Selectivity
    8. 8. Optimizing Sort Operations
    9. 9. Using Projection to Reduce Data
    10. 10. Implementing Query Caching Strategies
    11. 11. Understanding Query Targeting

  49. Working with Database Profiler

    1. 1. Enabling Database Profiler
    2. 2. Setting Profiling Level
    3. 3. Setting Slow Operation Threshold
    4. 4. Querying system.profile Collection
    5. 5. Analyzing Slow Queries
    6. 6. Understanding Profile Document Structure
    7. 7. Using Profile for Index Optimization
    8. 8. Filtering Profile Results
    9. 9. Disabling Profiler
    10. 10. Managing Profile Collection Size

  50. Working with Monitoring Tools

    1. 1. Using db.serverStatus() Command
    2. 2. Monitoring with mongostat Utility
    3. 3. Monitoring with mongotop Utility
    4. 4. Checking Current Operations
    5. 5. Killing Operations
    6. 6. Monitoring Replication Lag
    7. 7. Checking Lock Statistics
    8. 8. Monitoring Memory Usage
    9. 9. Checking Connection Metrics
    10. 10. Using Free Monitoring

  51. Working with Storage Engines

    1. 1. Understanding WiredTiger Engine
    2. 2. Configuring WiredTiger Cache
    3. 3. Using Compression Options
    4. 4. Configuring Journal Commits
    5. 5. Understanding Document-Level Locking
    6. 6. Using In-Memory Storage Engine
    7. 7. Configuring Storage Engine Options
    8. 8. Monitoring Storage Metrics
    9. 9. Understanding Checkpoints
    10. 10. Optimizing Storage Performance

  52. Using Database Commands

    1. 1. Running Admin Commands
    2. 2. Running Database Commands
    3. 3. Using listDatabases Command
    4. 4. Using listCollections Command
    5. 5. Using serverStatus Command
    6. 6. Using replSetGetStatus Command
    7. 7. Using dbStats Command
    8. 8. Using collStats Command
    9. 9. Using compact Command
    10. 10. Using buildInfo Command
    11. 11. Using connectionStatus Command

  53. Handling Errors and Debugging

    1. 1. Understanding Error Codes
    2. 2. Handling Duplicate Key Errors
    3. 3. Handling Write Concern Errors
    4. 4. Debugging with explain() Method
    5. 5. Using Verbose Logging
    6. 6. Checking Server Logs
    7. 7. Using mongod Diagnostic Data
    8. 8. Handling Connection Errors
    9. 9. Debugging Replication Issues
    10. 10. Using Diagnostic Commands
    11. 11. Understanding Error Handling Best Practices

  54. Using MongoDB Shell Tools

    1. 1. Using mongosh Interactive Shell
    2. 2. Connecting with mongosh
    3. 3. Using mongosh Helper Methods
    4. 4. Running Scripts with mongosh
    5. 5. Using mongosh REPL Features
    6. 6. Configuring mongosh Settings
    7. 7. Using mongosh Editor Mode
    8. 8. Accessing MongoDB Logs in mongosh
    9. 9. Using Tab Completion in mongosh
    10. 10. Exiting mongosh

  55. Using MongoDB Command-Line Tools

    1. 1. Using mongodump Utility
    2. 2. Using mongorestore Utility
    3. 3. Using mongoexport Utility
    4. 4. Using mongoimport Utility
    5. 5. Using mongostat for Real-Time Monitoring
    6. 6. Using mongotop for Read/Write Activity
    7. 7. Using mongofiles for GridFS Operations
    8. 8. Using bsondump for BSON Conversion
    9. 9. Using mongoreplay for Traffic Recording
    10. 10. Understanding Tool Authentication Options

  56. Using MongoDB Atlas Features

    1. 1. Creating Atlas Cluster
    2. 2. Configuring Cluster Tier
    3. 3. Setting Up Database Users
    4. 4. Configuring Network Access
    5. 5. Using Atlas Search
    6. 6. Creating Atlas Search Indexes
    7. 7. Using Atlas Data Lake
    8. 8. Configuring Atlas Alerts
    9. 9. Using Atlas Performance Advisor
    10. 10. Implementing Atlas Backup

  57. Using Atlas Search

    1. 1. Creating Search Index
    2. 2. Using $search Aggregation Stage
    3. 3. Implementing Text Search
    4. 4. Using Autocomplete
    5. 5. Using Fuzzy Matching
    6. 6. Using Wildcards
    7. 7. Implementing Faceted Search
    8. 8. Using Highlighting
    9. 9. Scoring and Ranking Results
    10. 10. Using Compound Queries
    11. 11. Configuring Custom Analyzers