MongoDB Course Built for AI-Paired Learning

This chapter focuses on Relational against document databases, When a document model fits, Databases, collections and documents and the practice needed to use these concepts confidently in real projects.

• Relational against document databases
• When a document model fits
• Databases, collections and documents
• BSON and its data types
• ObjectId and document identity
• Installing MongoDB locally
• MongoDB Atlas and managed clusters
• Connecting with the shell
• MongoDB Compass for exploration
• Connection strings and options
• Creating and dropping databases
• Creating and dropping collections
• Capped collections
• Inserting a single document
• Inserting many documents
• Reading documents with find
• findOne and its behaviour
• Counting documents
• Deleting documents
• Document size limits
• Naming conventions
• Exploring a sample dataset

This chapter focuses on Query filter syntax, Comparison operators, Logical operators: and, or, not, nor and the practice needed to use these concepts confidently in real projects.

• Query filter syntax
• Comparison operators
• Logical operators: and, or, not, nor
• Element operators: exists and type
• Evaluation operators: regex and expr
• Querying nested fields with dot notation
• Querying arrays by value
• The all operator
• The elemMatch operator
• Array size queries
• Projections and field selection
• Excluding fields
• Projecting array slices
• Sorting results
• Limit and skip
• Cursor behaviour and batching
• Cursor methods in the driver
• Distinct values
• Case-insensitive searches
• Range queries on dates
• Query performance intuition
• Common query mistakes

This chapter focuses on updateOne and updateMany, The set operator, unset and rename and the practice needed to use these concepts confidently in real projects.

• updateOne and updateMany
• The set operator
• unset and rename
• inc, mul, min and max
• currentDate and timestamps
• Array update operators: push and pull
• addToSet and its semantics
• pop and pullAll
• The positional operator
• The filtered positional operator
• Array filters
• Upserts and their pitfalls
• replaceOne against updateOne
• findOneAndUpdate and returning documents
• Bulk write operations
• Ordered against unordered bulk writes
• Delete operations and cascading logic
• Write concerns explained
• Journaling and durability
• Read concerns and consistency
• Retryable writes
• Handling duplicate key errors

This chapter focuses on Modelling for access patterns, Embedding documents, Referencing documents and the practice needed to use these concepts confidently in real projects.

• Modelling for access patterns
• Embedding documents
• Referencing documents
• Choosing between embed and reference
• One-to-one relationships
• One-to-few relationships
• One-to-many relationships
• One-to-squillions and the outlier pattern
• Many-to-many modelling
• Denormalisation and duplication trade-offs
• Keeping duplicated data consistent
• The bucket pattern for time series
• The computed pattern
• The subset pattern
• The extended reference pattern
• The attribute pattern
• The polymorphic pattern
• Schema versioning
• Schema validation rules
• JSON Schema in MongoDB
• Migrating documents in place
• Reviewing a schema against real queries

This chapter focuses on What an aggregation pipeline is, The match stage, The project stage and the practice needed to use these concepts confidently in real projects.

• What an aggregation pipeline is
• The match stage
• The project stage
• The group stage and accumulators
• sum, avg, min, max and count
• push and addToSet accumulators
• The sort stage
• skip and limit in pipelines
• The unwind stage
• Preserving null and empty arrays
• The lookup stage for joins
• Pipelines inside lookup
• The addFields and set stages
• The replaceRoot stage
• The facet stage
• The bucket and bucketAuto stages
• The count stage
• The merge and out stages
• Expression operators overview
• Conditional expressions: cond and switch
• Date and string expression operators
• Optimising pipeline order

This chapter focuses on Why indexes matter, The default id index, Single field indexes and the practice needed to use these concepts confidently in real projects.

• Why indexes matter
• The default id index
• Single field indexes
• Compound indexes
• The ESR rule for index design
• Index prefixes and reuse
• Multikey indexes on arrays
• Text indexes and text search
• Wildcard indexes
• Geospatial indexes
• Hashed indexes
• Unique indexes
• Partial indexes
• Sparse indexes
• TTL indexes for expiring data
• Index build strategies
• The explain method
• Reading an execution plan
• Covered queries
• Index intersection
• Identifying slow queries
• Index maintenance cost

This chapter focuses on Atomicity at the document level, When multi-document transactions are needed, Sessions and their lifecycle and the practice needed to use these concepts confidently in real projects.

• Atomicity at the document level
• When multi-document transactions are needed
• Sessions and their lifecycle
• Starting and committing a transaction
• Aborting and rolling back
• The convenient transaction API
• Transaction limits and timeouts
• Read and write concerns in transactions
• Snapshot isolation
• Retrying transient transaction errors
• Performance cost of transactions
• Designing to avoid transactions
• Two-phase commit patterns
• Idempotent operations
• Optimistic concurrency with versions
• Causal consistency
• Read preferences
• Stale reads from secondaries
• Change streams
• Reacting to changes in an application
• Resume tokens and reliability
• Event-driven patterns with change streams

This chapter focuses on The MongoDB Node driver basics, Connection management in an application, Connection pooling and sizing and the practice needed to use these concepts confidently in real projects.

• The MongoDB Node driver basics
• Connection management in an application
• Connection pooling and sizing
• What Mongoose adds
• Defining a schema
• Schema types and options
• Default values and required fields
• Built-in and custom validators
• Models and documents
• CRUD with Mongoose models
• Query helpers and chaining
• Lean queries for performance
• Virtuals
• Instance and static methods
• Pre and post middleware hooks
• Population and reference resolution
• Nested population
• Discriminators for polymorphism
• Transactions with Mongoose
• Indexes declared in schemas
• Typing Mongoose models in TypeScript
• Testing code that uses Mongoose

This chapter focuses on Authentication and users, Role-based access control, Built-in and custom roles and the practice needed to use these concepts confidently in real projects.

• Authentication and users
• Role-based access control
• Built-in and custom roles
• Network access and IP allow lists
• TLS connections
• Encryption at rest
• Field-level encryption
• Auditing access
• Backups and restore strategies
• Point-in-time recovery
• mongodump and mongorestore
• Import and export tools
• Replica sets explained
• Elections and failover
• Oplog and replication lag
• Sharding concepts
• Choosing a shard key
• Chunk balancing
• Zone sharding
• Monitoring key metrics
• Capacity planning
• Common production incidents

This chapter focuses on Understanding the application domain, Listing the required access patterns, Designing the collections and the practice needed to use these concepts confidently in real projects.

• Understanding the application domain
• Listing the required access patterns
• Designing the collections
• Deciding embedding against referencing
• Writing the schema validation rules
• Seeding realistic sample data
• Implementing create operations
• Implementing read and search queries
• Implementing update flows
• Implementing delete and archive flows
• Building an aggregation report
• Adding a dashboard aggregation
• Designing the index set
• Verifying with explain plans
• Adding transactions where needed
• Adding change stream reactions
• Handling errors and retries
• Load testing the queries
• Tuning based on results
• Documenting the data model
• Reviewing security settings
• Final review and walkthrough