
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 26-lesson course built from Sridhar Yadav's 4h 01m of YouTube playlist. 3 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by Sridhar Yadav on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Introduces the Database Internals book by Alex Petrov, outlines the streaming plan, and explains why understanding database internals benefits all engineers.
Defines OLTP, OLAP, and HTAP database categories, lists example systems for each, and explains why separate OLTP and OLAP systems are preferred at scale.
Explains how row-based storage optimizes OLTP workloads by keeping entire records together, while column-based storage optimizes OLAP by enabling column scans and compression.
Illustrates physical row layout on disk, shows why co-locating columns in a row matches page-sized I/O, and answers a viewer question on book reading order.
Demonstrates columnar layout for analytics queries, shows how repetitive values enable run-length encoding, and explains the resulting I/O and compression benefits.
Diagrams the five storage-engine components, contrasts MySQL's clustered B-tree with PostgreSQL's heap file, and explains how secondary indexes point to table data.
Compares direct page pointers and primary-key references in secondary indexes, highlighting the write-amplification and maintenance trade-offs of each approach.
Understand the trade-offs between unsorted arrays (fast writes, slow reads) and sorted arrays (fast reads via binary search, slow writes due to shifting) for database storage.
Learn how binary search trees use node pointers to enable efficient inserts and deletes without shifting data, while maintaining O(log n) search performance.
Understand how B-trees and B+trees pack multiple keys per node to match disk page sizes, keeping trees shallow and reducing disk I/O to one read per tree level.
Describe how Merkle trees use hashes of leaf nodes (files or file chunks) and parent hash concatenation to efficiently detect and synchronize changes in large file sets or single large files.
Understand the focus of Chapter 3: how to lay out B-tree nodes and other database structures on disk pages given block-based IO device interfaces.
Identify the components of a typical database page including header metadata (block ID, checksum, row count) and the storage of row data or B-tree keys and pointers within the page body.
Explain how fixed-size keys and values allow simple arithmetic offset calculations to navigate B-tree nodes loaded into memory.
Recognize the computational overhead caused by variable-length keys and values when scanning or searching within a database page.
Describe the slotted page layout where a header points to an array of fixed-size offsets/lengths that reference variable-length key-value cells packed at the page end.
Analyze how inserts into slotted pages create fragmentation gaps and require in-memory compaction to reclaim contiguous free space.
Walk through building a Merkle tree from a source directory, computing leaf hashes, concatenating child hashes for parent nodes, and using the tree to pinpoint changed files for efficient sync.