Analiza wymagań i projektowanie schematu
Uczestnicy przełożą wymagania aplikacji na schemat MongoDB, wybierając osadzanie lub odwołania i odpowiednio stosując wzorce projektowe.
Analiza wymagań i projektowanie schematu to bezpłatna lekcja MongoDB Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej MongoDB Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs MongoDB Academy zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
The Capstone: Designing a Real Application
In this capstone lesson, you apply all the knowledge from the MongoDB track to design a production-ready application from scratch. We will build a multi-vendor e-commerce platform — a domain rich enough to exercise embedding vs referencing decisions, index planning, aggregation design, and security. The process starts with requirements analysis, which drives every schema decision that follows.
Step 1: Gather Functional Requirements
Begin by listing the application's core entities and operations. For our e-commerce platform: entities — Users, Vendors, Products, Orders, Reviews, Carts; operations — browse products by category, search by keyword, place orders, process payments, track shipping, and write reviews. Each operation maps to one or more MongoDB queries, and those queries drive schema decisions.
// Requirement analysis output (pseudocode spec)
const requirements = {
reads: [
'Get product by slug (very high frequency)',
'List products by category + sort/filter (high frequency)',
'Search products by keyword (high frequency)',
'Get order history for a user (medium frequency)',
'Get order detail (medium frequency)'
],
writes: [
'Create order (medium frequency)',
'Update order status (medium frequency)',
'Add product review (low frequency)',
'Update product inventory (high frequency)'
]
}Step 2: Identify Access Patterns
Access patterns are the specific queries your application will run. Document them precisely before designing the schema — the schema should serve the queries, not the other way around. For each pattern, record: the filter fields, sort fields, projected fields, and estimated frequency. High-frequency patterns drive indexing and embedding decisions. Low-frequency patterns can tolerate joins or aggregation pipeline overhead.
// Access pattern register
const accessPatterns = [
{
name: 'Product page',
filter: { slug: 1 },
projection: 'all except internal fields',
frequency: 'very high',
decision: 'index on slug; embed top 5 reviews'
},
{
name: 'Category listing',
filter: { categoryId: 1, price: 1 },
sort: { price: 1, createdAt: -1 },
frequency: 'high',
decision: 'compound index { categoryId, price, createdAt }'
}
]Designing the Products Collection
The product document is the most frequently read document in the system. Apply the patterns learned: Computed Pattern for pre-computed stats (avgRating, reviewCount); Subset Pattern for embedding only the top 5 reviews; Extended Reference for embedding the vendor's name and logo alongside vendorId. This eliminates joins for 95% of product page renders.
// Product document schema (simplified)
{
_id: ObjectId(),
slug: 'wireless-headphones-pro',
name: 'Wireless Headphones Pro',
categoryId: ObjectId(),
vendor: {
_id: ObjectId(), // reference for updates
name: 'AudioTech Ltd', // Extended Reference
logoUrl: '...' // Extended Reference
},
price: 149.99,
stock: 234,
avgRating: 4.3, // Computed Pattern
reviewCount: 892, // Computed Pattern
topReviews: [ /* 5 most recent */ ], // Subset Pattern
tags: ['audio', 'wireless', 'headphones'],
schema_version: 1
}Designing the Orders Collection
Orders are a classic snapshot document: they capture the state of prices and addresses at purchase time, not the current state. Embed the full shipping address (not a reference to the user's current address), the product snapshot (name, price, image at purchase time), and the vendor name. This ensures orders remain accurate even if prices change or vendors update their profiles.
// Order document schema
{
_id: ObjectId(),
userId: ObjectId(),
status: 'processing', // 'pending', 'processing', 'shipped', 'delivered', 'refunded'
createdAt: new Date(),
shippingAddress: {
name: 'Alice Smith',
street: '42 Elm St',
city: 'Istanbul',
country: 'TR'
},
items: [
{
productId: ObjectId(), // reference for linking
slug: 'wireless-...',
name: 'Wireless Headphones Pro', // snapshot
price: 149.99, // price at purchase time
quantity: 1,
imageUrl: '...'
}
],
subtotal: 149.99,
tax: 27.00,
total: 176.99
}Applying the Schema Design Decision Framework
For each relationship, apply the decision checklist: How often is it accessed together? (embed if always, reference if rarely); How often does the referenced data change? (embed if rarely, reference if frequently); Will the embedded array grow without bound? (reference if yes, embed if bounded); Is the data queried independently? (separate collection if yes, embed if always accessed via parent).
// Decision table for our e-commerce schema
const decisions = [
{ entity: 'Order items', decision: 'embed', reason: 'always fetched with order; price snapshot required' },
{ entity: 'Shipping address', decision: 'embed', reason: 'snapshot at purchase time; changes do not affect order' },
{ entity: 'Product reviews', decision: 'separate + subset', reason: 'grows unbounded; top-5 subset in product doc' },
{ entity: 'Vendor details', decision: 'extended ref', reason: 'name/logo read on every product page; changes rarely' },
{ entity: 'Category tree', decision: 'separate', reason: 'queried independently; used for breadcrumbs' }
]Schema Validation for Critical Collections
Add JSON Schema validators to the products and orders collections to prevent malformed documents from corrupting your data. Enforce required fields (price must be a positive number, status must be one of the valid enum values) and set validationAction: 'error' to reject invalid writes immediately rather than warn.
db.runCommand({
collMod: 'orders',
validator: {
$jsonSchema: {
bsonType: 'object',
required: ['userId', 'status', 'items', 'total', 'createdAt'],
properties: {
status: {
bsonType: 'string',
enum: ['pending', 'processing', 'shipped', 'delivered', 'refunded']
},
total: { bsonType: 'double', minimum: 0 },
items: { bsonType: 'array', minItems: 1 }
}
}
},
validationAction: 'error'
})Planning the Index Set
Define indexes for every high-frequency access pattern. Use the ESR rule (Equality → Sort → Range) for compound indexes. Create indexes only for queries with high frequency — unused indexes waste write performance and RAM. Document each index with its purpose so the team can prune redundant ones as access patterns evolve.
// Products collection indexes
db.products.createIndex({ slug: 1 }, { unique: true }) // product page lookup
db.products.createIndex({ categoryId: 1, price: 1, _id: 1 }) // category listing + keyset pagination
db.products.createIndex({ tags: 1 }) // tag filter
db.products.createIndex({ 'vendor._id': 1 }) // vendor store page
// Orders collection indexes
db.orders.createIndex({ userId: 1, createdAt: -1 }) // user order history
db.orders.createIndex({ status: 1, createdAt: 1 }) // fulfillment queueHandling Concurrent Inventory Updates
A critical challenge in e-commerce is preventing overselling: two users should not both be able to purchase the last item in stock. Use MongoDB's atomic findOneAndUpdate with a stock: { $gt: 0 } guard condition. The update only succeeds if stock is available, and the decrement is atomic — no race condition possible.
// Atomically reserve stock — returns null if out of stock
const product = await db.collection('products').findOneAndUpdate(
{ _id: productId, stock: { $gte: quantity } }, // guard: enough stock
{ $inc: { stock: -quantity } },
{ returnDocument: 'after', projection: { stock: 1, name: 1, price: 1 } }
)
if (!product) {
throw new Error('Insufficient stock')
}
// Proceed to create order with product snapshotAggregation Pipeline for Reporting
Design a sales summary aggregation pipeline that reports revenue by vendor for the last 30 days. This is a classic case where the aggregation pipeline replaces complex application-side computation. The pipeline matches recent orders, unwinds items, groups by vendor, and sorts by total revenue.
// Revenue by vendor, last 30 days
const since = new Date(Date.now() - 30 * 86400000)
db.orders.aggregate([
{ $match: { status: 'delivered', createdAt: { $gte: since } } },
{ $unwind: '$items' },
{
$group: {
_id: '$items.vendorId',
totalRevenue: { $sum: { $multiply: ['$items.price', '$items.quantity'] } },
orderCount: { $addToSet: '$_id' }
}
},
{ $addFields: { orderCount: { $size: '$orderCount' } } },
{ $sort: { totalRevenue: -1 } },
{ $limit: 20 }
])Testing the Schema With explain()
Before going to production, validate every critical query with explain('executionStats'). Confirm that all high-frequency queries show IXSCAN (not COLLSCAN) in the winning plan, docsExamined is close to nReturned, and totalKeysExamined is reasonable. Any query showing COLLSCAN or a high docsExamined/nReturned ratio needs an index.
// Validate the category listing query
const stats = db.products.find(
{ categoryId: ObjectId('...'), price: { $lte: 200 } }
).sort({ price: 1 }).explain('executionStats')
const plan = stats.executionStats
console.log('Stage:', plan.executionStages.inputStage.stage) // should be IXSCAN
console.log('Keys examined:', plan.totalKeysExamined) // should be small
console.log('Docs examined:', plan.totalDocsExamined) // should equal nReturned
console.log('Docs returned:', plan.nReturned)Quick Check
Test your understanding of MongoDB & NoSQL Databases concepts from this lesson.
Lesson Recap
In this lesson you learned: requirements analysis and access pattern documentation come before schema design — the schema serves the queries, not the other way around, a good product document combines Extended Reference, Computed Pattern, and Subset Pattern to eliminate joins on the hot read path, and atomic findOneAndUpdate with guard conditions prevents overselling without requiring transactions. Next up we define the index strategy and validate each index with explain().
Często zadawane pytania
Czy lekcja „Analiza wymagań i projektowanie schematu” jest bezpłatna?
Tak — pełny tekst „Analiza wymagań i projektowanie schematu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu MongoDB Academy, przejdź na CoddyKit PRO. Kurs MongoDB Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Analiza wymagań i projektowanie schematu”?
Uczestnicy przełożą wymagania aplikacji na schemat MongoDB, wybierając osadzanie lub odwołania i odpowiednio stosując wzorce projektowe. Ćwiczysz MongoDB Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć MongoDB Academy?
Nie wymagamy żadnego doświadczenia. MongoDB Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Analiza wymagań i projektowanie schematu”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji MongoDB Academy?
Tak. Każda lekcja MongoDB Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Analiza wymagań i projektowanie schematu
- Strategia indeksowania i walidacja planera zapytań
- Plan skalowania: od zestawu replik do klastra shardowanego
- Wzmacnianie zabezpieczeń i lista kontrolna środowiska produkcyjnego