MongoDB 4.0 : MongoDB Developer & Admin Course

Learn how to design and deploy a high-performance MongoDB 4.0 database by mastering aggregation, indexing, document models and structure, and essential administration concepts.

Explore the fundamentals of NoSQL databases, contrasting relational systems with document, key-value, and column-store models, and learn how NoSQL enables scalable, highly available, distributed data management.

Explore MongoDB basics by examining collections and documents with no predefined schema, where fields are created on the fly and documents differ.

Explore MongoDB 4.0 features like ad hoc queries, indexing any field, replication with slave copies for reads, automatic sharding and load balancing, and the aggregation framework for scalable performance.

Discover the advantages of MongoDB: document-oriented model, flexible schema, and file system storage; offers load balancing and favorable comparison to relational databases as data scales.

Explore the differences between MySQL and MongoDB, comparing relational database management system concepts, query language, stored procedures, scalability, and speed.

Compare Cassandra and MongoDB, highlighting Cassandra's high performance, distributed architecture, automatic scaling, and availability, alongside MongoDB's document-oriented model and cross-platform features.

The lecture contrasts CouchDB and MongoDB by examining how collections and documents are managed, how updates occur, and how availability and strongly consistent behavior are addressed.

Compare Redis and MongoDB, highlighting in-memory data structures, fast performance, and scalable architecture, with features like sets, lists, bitmaps, partial indexes, and hyperloglog, plus automated failure detection and backup.

MongoDB offers real-time data with flexible, schema-less documents, supports ad hoc queries and indexing for performance, and uses replica sets and load balancing across multiple instances to ensure availability.

Download and install MongoDB on Windows, choose a 64-bit package, optionally install MongoDB Compass, configure environment variables, create a data/db directory, and start the mongod server and mongo shell.

Configure the mongo shell's interactive prompt by defining JavaScript functions and variables to display operation counts, host, database, uptime, and document counts, enabling dynamic, informative prompts during sessions.

Explore how to access the Mongo shell help, view databases and collections, and use common shell methods and dot notation to query and manipulate data.

Explore the MongoDB shell quick reference, mastering mongod command line options, basic JavaScript operations, and core commands like show dbs, show collections, use, insert, update, delete, and index creation.

Learn how relational databases map to MongoDB by converting tables to collections, rows to documents, and columns to fields, with automatic _id keys and dynamic schemas.

Explore MongoDB 4.0 datatypes, from binary encoded values and object ids to strings, numbers, nulls, and embedded documents, with language drivers supporting JavaScript and other types.

Learn how MongoDB auto-creates databases and collections when you insert data, and that a database appears in show dbs only after a document exists, then drop it.

Explore how MongoDB handles collections, including explicitly creating a collection with options (name, size, indexing, max documents), automatic creation on document insert, and how to list or drop collections.

Explain how documents in a collection use a dynamic schema with embedded documents and multiple data types, and highlight the _id primary key, immutable and unique.

Explore how MongoDB compares values across numeric and string types, apply language-specific string comparison rules, and use ascending or descending sort orders with missing fields and date objects.

Insert single or multiple documents into a MongoDB collection using various input methods, assign an object id when needed, and verify results with find.

Query documents in a collection using find with multi-field conditions and indexes, apply equality and range operators, use or with $or, and retrieve via findOne, limit, or aggregation pipeline.

Query embedded and nested documents in MongoDB using dot notation to match inner fields with exact values, and explore equality and range conditions on embedded data.

Master querying arrays in MongoDB 4.0 by matching exact and at least one element, using dot notation to access nested fields, and composing compound conditions across documents in the collection.

Explore querying an array of embedded documents in MongoDB 4.0 by using dot notation to apply conditions on embedded fields, such as quantity thresholds within in-stock items.

Explore how to use projection in MongoDB 4.0 with the find method to include or exclude fields, control nested documents with dot notation, and apply $slice for embedded documents.

Learn how to query for null or missing fields in MongoDB 4.0 using the find method, including equality, not equal, and existence checks on the item field.

Learn how to iterate a Mongo shell cursor by constructing a find query, reading documents with next or print, and using batch size and index access to manage results efficiently.

Master updating and replacing documents in MongoDB with update, update many, and replace, using $set and current date to update lastModified while preserving the immutable _id and upsert behavior.

Explore deleting documents in MongoDB using delete one, delete many, and deleting all with an empty filter; learn how operation status, index preservation, and write-acknowledgment levels matter.

Explore bulk write operations in MongoDB, performing inserts, updates, deletes, and replaces with the bulkWrite method. Learn the difference between ordered and unordered execution and how each affects processing.

Review retryable writes in MongoDB 4.0, detailing replica set requirements, transactions, and document-level locking, plus how abort and commit operations behave across single and bulk writes.

Explore text search in MongoDB by building text indexes, executing search queries, and using the aggregation pipeline to rank results by relevance across multiple languages.

Explore geospatial queries in MongoDB by storing coordinates, using embedded or legacy field structures, and building specialized indexes to locate documents by proximity to a point, including in aggregation pipelines.

Explore geospatial queries in MongoDB 4.0 by using an index to find restaurants within a specified distance of a point in New York City, inspecting neighborhoods and restaurants datasets.

Explore atomicity in MongoDB, from single-document writes to multi-document transactions for cross-document consistency. Learn design tips like denormalized schemas and unique indexes to enforce data integrity.

Explore how MongoDB manages read isolation, consistency, and recency across single and multi-document operations, including read uncommitted to serializable guarantees and consistent sessions with majority acknowledged writes.

Explore how MongoDB distributes writes across replica sets and shards, and how reads can target secondaries or the primary. Understand read preferences, monotonic reads, and session guarantees for consistent results.

Explore how linearizable reads work in MongoDB 4.0 using findAndModify to guarantee durable, up-to-date data when reading, including exact-match queries on a unique index and a dummy field increment.

Analyze how the query optimizer generates candidate plans, caches the winning plan, and uses it to speed subsequent queries, while indexes and collection scans shape plan choice.

Improve query performance by using indexes to reduce the amount of data that queries must process, enabling selective queries and avoiding full collection scans.

Explore techniques for evaluating operational performance in MongoDB, using the profiler, execution statistics, and explain plans to analyze queries, write operations, and index choices.

Create indexes to support queries and boost performance. Use compound indexes and index hints to guide the query optimizer, apply projections to fetch only needed fields, and limit results.

Explain how write performance hinges on indexes, as inserts or removes update index entries. Note that document growth and storage engine behavior, plus hardware factors, affect write throughput.

Explore how MongoDB explain results reveal how the query optimizer selects a winning plan, including stage details, index usage, projections, and execution statistics.

Analyze query performance using execution stats and explain plans to compare index usage against collection scans, focusing on keys examined and documents scanned for efficiency.

Learn how tailable cursors in MongoDB 4.0 keep the cursor open to stream new documents, using the last indexed value to track progress and fetch updates.

Explore the MongoDB aggregation pipeline, an alternative to map-reduce, a multistage data processing framework that transforms documents through pipeline stages and expressions, with index-aware optimization.

Explore MongoDB 4.0 aggregation pipeline with a zip code dataset, using group, sum, and sort to compute state totals and city details.

Explore MongoDB 4.0 aggregation techniques using reference data in a sports club example, including project, unwind, group, and sum operations to analyze monthly joins and popular likes for membership insights.

Explore map reduce in MongoDB 4.0, learning how map and reduce operations condense large data into aggregated results using JavaScript map functions and a finalize function while operating on collections.

Explain how map reduce runs on sharded collections, using input and output collections, dispatching jobs to shards, and performing postprocessing to distribute results.

Describe map reduce concurrency in MongoDB, detailing reads from input, map and reduce execution, temporary and output collections, and a global write log governing processing.

Explore map reduce on the orders and audios collections, mapping customer ids to prices to sum by key, and finalizing results to compute averages for filtered orders and items.

Demonstrate incremental map-reduce on a growing sessions dataset using a map function, reduce, and finalize, outputting to a separate collection and then merging new results into the existing one.

Troubleshoot the map function in MongoDB by defining a map to emit customer id and price, verify key-value pairs, and apply it to documents from the orders collection.

Explore troubleshooting the MongoDB reduce function in map-reduce, ensuring the reduce output type matches the map emission, preserving order-independence, and validating sums across sample key-value documents.

Explore the MongoDB aggregation pipeline, featuring stages like group, match, and project, and learn how aggregation commands produce, modify, and incrementally derive documents from collections.

Learn about user-defined and system variables in aggregation expressions, how to access them with double dollar signs, and use dot notation for object fields.

Map SQL concepts to MongoDB aggregation, using group by, having, match, and limit to model funding data for the latest project.

Explore how MongoDB 4.0 supports flexible document schemas by choosing between embedded denormalized documents and normalized references, balancing performance, data retrieval, and transactional options.

Learn schema validation in MongoDB, including json schema validation, validation levels strict and moderate, and validation actions error and warn during updates and inserts.

Learn how to design data models in MongoDB by choosing embedded documents for denormalized, one-to-many relationships to improve performance, and using references in normalized data models for many-to-many scenarios.

Explore how operational factors and data models influence MongoDB performance, including embedding versus referencing, single-document versus multi-document operations, sharding strategies, indexing, and storage considerations.

Explore MongoDB 4.0 tree structures, including parent and child references, nested set, and materialized paths, with queries for ancestors and descendants and indexing patterns.

Learn how to model data for atomic operations in MongoDB, including single-document updates and multi-document transactions introduced in version 4.0, and embedding available copies and checkout details to ensure atomicity.

explore modeling data for keyword search in MongoDB 4.0 by storing keywords in an array and indexing them, and discuss text index limitations and indexing tradeoffs.

Explore approaches to modeling monetary data in MongoDB 4.0, comparing numeric and non-numeric models, and learn to use decimal types, scale factors, and application transformations for exact currency precision.

Store dates in UTC by default and convert local times to UTC for consistent reporting. Reconstruct local time using time zone offsets in application logic and display ISO dates.

Explore cross-document linking in MongoDB with manual references, DBRefs, dollar lookups, and graph lookups for joins, and learn when to store data in one or multiple collections.

Explore single field indexes in MongoDB, including ascending and descending indexes, embedded field and embedded document indexing with dot notation, and building indexes in the background for large collections.

Learn how to create compound indexes that span multiple fields, control sort order, and support prefix queries, while understanding the 32-field limit and hashed field restrictions.

Explore MongoDB multikey indexes, which create an index key for each array element or embedded document, enabling efficient queries and sorting, while noting no compound multikey indexes.

Master multikey index bounds in MongoDB 4.0, learning how to dissect and compound index bones for multi-predicate queries, including embedded documents and dollar elian match.

Explore how to create and use text indexes in MongoDB 4.0 to power text search across string fields, including single and compound indexes, weights, and language options.

Learn how to specify a default language for a text index and build multilingual text indexes, including per-document language overrides via a language field and embedded documents.

Specify a custom name for a text index to avoid default names that exceed length limits, using the name option in createIndex and later drop or list via getIndexes.

Learn to control search results with weights in MongoDB text indexes by assigning different weights to content, keywords, and about fields to influence ranking.

Limit the number of index entries scanned by using a compound index that combines department with a text index on description. Use $text search with equality on preceding keys.

Explore how the 2d fed index in mongodb 4.0 supports queries on geometries stored as dual json objects or legacy coordinates, including 2d sphere indexes, versioning, and shard key considerations.

Explore MongoDB 4.0 2d indexes for legacy coordinate fields and planar geospatial queries. Learn to create a 2d index and set location range and precision, with multiple indexes.

Learn how geo haystack indexes in MongoDB optimize proximity queries by bucketing documents near a location, using a location field and a second field with bucket size and sparse options.

Explore hashed indexes in MongoDB 4.0, using a hashing function to compute value hashes for index keys, enabling hash-based shard keys, partitioning data across the cluster, and randomized data distribution.

Explore ttl indexes that automatically remove documents after a defined period by indexing a date field, expiring after seconds or clock time, via a background thread on primary.

Learn how unique indexes enforce uniqueness in MongoDB by applying single-field and compound indexes, handling existing data, nulls, and partial filters, with practical examples.

Partial indexes index a subset of documents using a filter expression, lowering storage use and reducing index creation and maintenance costs while enabling queries on indexed predicates.

Learn how to create case-insensitive indexes in MongoDB 4.0 using collations, specify locale and strength, and ensure queries use the same collation for correct results and performance.

Explore sparse indexes in MongoDB, which index only documents containing the indexed field, contrast with non-sparse behavior, and learn to use partial indexes, hints, and unique sparse options.

Learn how index builds on a populated collection block operations by default, and how enabling background builds keeps the database available. Monitor progress and understand replica set implications.

Learn how MongoDB uses index intersection to fulfill queries by combining multiple indexes, including prefix and compound indexes, and understand limitations when a query does not align with index prefixes.

View and manage indexes across a database by listing indexes on collections with db.collection.getIndexes, then remove specific indexes with dropIndex and dropIndexes, leaving the default _id index.

Analyze indexing strategies for MongoDB by balancing query types and memory, and design single or compound indexes with prefixes to optimize reads, sorts, and production performance.

Explore the WiredTiger storage engine, its in-memory and on-disk data management, and how it supports multiple engines, concurrency control, checkpoints, journaling, compression, and memory usage.

Learn to change a standalone MongoDB to wiredTiger by exporting data with mongodump, creating a new data directory, starting the wiredTiger instance, and restoring with mongorestore, binding to localhost.

Explore the MMAPv1 storage engine for MongoDB 4.0, including memory-mapped file usage, journaling for crash recovery, and how record allocations with power-of-two sizing, padding, and bagging affect fragmentation and performance.

Explore MongoDB 4.0's in-memory storage engine, a non-persistent, 64-bit feature that offers lower latency, with document-level write concurrency and no multi-document transactions.

Learn how MongoDB uses journaling and checkpoints to ensure durability, recover from the last checkpoint after a failure, and maintain data consistency with journal records.