玩转MongoDB 从入门到实战 (it-ebooks)（Z-Library）

【One-Line Pitch】 A practical, operations-oriented introduction to MongoDB that walks you from core document concepts through aggregation, replication, sharding, and transactions, with an emphasis on how these features behave in real production deployments. Best suited for developers and DBAs who already know basic databases and want a grounded, hands-on path into MongoDB. 【Book Arc】 - **Opening (~0%–13%)**: Frames MongoDB's position between Memcached and relational databases, maps relational concepts (tables, rows, joins) onto collections, documents, and embedding, and gets you running a first instance, replica set, and shard cluster. - **Early (~13%–33%)**: Core CRUD and query mechanics — find operators, update operators including array modifiers and upsert, delete/drop semantics — plus the aggregation framework's pipeline/stage model and its SQL equivalents. - **Middle (~33%–58%)**: Replica sets in depth: member roles (Primary, Secondary, Hidden, Delayed, Arbiter), connection strategies, ReadPreference, WriteConcern, ReadConcern trade-offs, and the Raft-based failover and sync internals. - **Late (~58%–75%)**: Sharding architecture — Mongos routing, Config Servers, shard key selection, and how data distribution and cluster operations are managed. - **Ending (~75%–100%)**: ChangeStreams, multi-document transactions, and two best-practice chapters consolidating production guidance. 【Key Takeaways】 - **MongoDB sits deliberately between key-value stores and RDBMSs** (Opening): it borrows scalability and performance from the former and feature richness from the latter, which explains many of its design choices later in the book. - **The relational-to-document mapping is the mental model to internalize first** (Opening): tables become collections, rows become documents, joins become embedding or `$lookup`, and multi-record ACID transactions become multi-document transactions. - **Aggregation is a pipeline, not a single query** (Early): each stage transforms documents and feeds the next, and the framework deliberately offers only left outer joins because full joins conflict with distributed, denormalized storage. - **Replica sets are the default production shape for mid-sized workloads** (Middle): three-node sets provide availability, read scaling via Secondaries, and rolling maintenance, with Raft-based elections typically resolving failures within about 15 seconds. - **Consistency is a dial, not a constant** (Middle): ReadPreference, WriteConcern, and ReadConcern let you trade latency against rollback safety, and higher ReadConcern levels buy stronger guarantees at the cost of slower reads. - **Oplog is the connective tissue of the system** (Middle): it drives both full and incremental sync and underpins ChangeStreams, so its sizing and retention policy matter operationally. - **Sharding solves scale but demands careful shard key choice** (Late): Mongos routes by shard key, Config Servers hold metadata, and each shard is itself a replica set, so there is no single point of failure by design. - **Transactions and ChangeStreams close the gap with relational expectations** (Ending): multi-document ACID transactions and change-event streams address the two most common objections to adopting MongoDB. 【Reading Tips】 - Deep-read the Opening and Early sections even if you know SQL well — the concept mapping and aggregation pipeline are the vocabulary the rest of the book assumes. - Treat the Middle chapters on ReadPreference/WriteConcern/ReadConcern as the highest-value material; skim the command syntax and focus on the trade-off tables and reasoning. - Skim the installation and cluster-setup walkthroughs on a first pass, then return to them when you actually stand up an environment. - For the sharding and transaction chapters, read for architecture and constraints rather than memorizing commands; the excerpts emphasize design rationale over exhaustive syntax. - Keep the best-practice chapters for last and read them as a checklist against your own deployment. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first two-thirds of the book in detail; the sharding, ChangeStreams, transaction, and best-practice chapters are represented mainly by their table-of-contents entries and summary material, so specifics from those sections are not fully reflected here.