1.MySQL

A map of the MySQL notes: architecture, storage engines, indexing, transactions, replication, diagnostics, and performance work.

A practical guide to reading MySQL execution plans: access type, chosen indexes, row estimates, join order, covering access, filesort, temporary work, and EXPLAIN ANALYZE.

MySQL binlog-based replication, relay logs, replication lag, parallel apply, semi-sync, GTID/position waiting, and stale-read trade-offs.

A measurement-first SQL tuning workflow covering slow-query identification, execution plans, indexing, query rewrites, pagination, and joins.

A version-aware checklist for installation, initialization, security, durability, memory, and observability.

Logical rewrites, cost-based physical planning, access paths, join ordering, statistics, optimizer trace, and execution-plan selection.

The storage-engine abstraction and why InnoDB is the normal transactional choice.

MySQL and InnoDB locking from global/metadata locks to record, gap, and next-key locks, plus how access paths determine lock scope.

InnoDB primary and secondary B+ tree indexes, composite indexes, covering indexes, leftmost prefixes, selectivity, range scans, and index-design trade-offs.

B+tree organization, clustered and secondary indexes, page locality, and lookup complexity.

How database files, redo/binlog, tablespaces, filesystem caches, and fsync interact.

Page-based B+tree storage, records, free space, page splits, and locality.

Choosing numeric, temporal, string, binary, JSON, and exact-value types from semantics and access patterns.

MySQL server-level change logging for replication and point-in-time recovery, including statement/row formats, durability policy, and its distinction from InnoDB redo.

The path from a client connection through parsing, optimization, execution, and the storage-engine interface.

Client authentication, sessions, connection pools, limits, timeouts, and protocol lifecycle.

Cardinality and distribution statistics used for cost-based query-plan selection.

Full scans, index scans, range access, point lookup, ref access, and plan-dependent row retrieval.

Capturing expensive statements for plan analysis and workload prioritization.

Historical per-query profiling and modern alternatives for diagnosing query execution.

Purpose of mysql, information_schema, performance_schema, and sys metadata/diagnostic schemas.

Lexing, parsing, semantic resolution, and the boundary between parsing and optimization.

Executing an optimizer-selected plan through iterators/operators and storage-engine row access.

A symptom-first workflow for latency, CPU, I/O, locks, connections, replication, and query-plan regressions.

Benchmarking database throughput, latency, concurrency, and saturation with realistic datasets and transactions.

Operational trade-offs of managed MySQL: HA, backups, monitoring, scaling, limits, and provider-specific behavior.

Caching InnoDB data and index pages, dirty-page management, eviction, and working-set behavior.

Evidence-driven tuning across schema, SQL, indexes, memory, concurrency, I/O, and architecture.

Capturing MySQL changes from the binary log for downstream synchronization and event pipelines.

How InnoDB caches data and index pages, tracks free/dirty/cached pages, evicts cold pages, and decouples logical writes from data-file flushing.

How InnoDB uses transaction IDs, undo-based row versions, and Read Views so readers can observe consistent historical versions without blocking writers.

InnoDB write-ahead logging, redo buffering, fsync policy, group commit, crash recovery, and the relationship between redo log and binlog.

How undo records support transaction rollback and MVCC version reconstruction, and why long transactions delay undo purge.

InnoDB transaction boundaries, ACID mechanisms, isolation levels, consistent reads, locking reads, MVCC, redo, and undo.

Logical and physical storage of InnoDB pages across system, file-per-table, undo, and temporary tablespaces.

How InnoDB clustered indexes differ from MyISAM's separate data and index storage.

Transactional MySQL storage with clustered indexes, MVCC, redo/undo, locking, and buffer-pool caching.

Writing dirty buffer-pool pages and redo state to durable storage under checkpoints and background pressure.