The Definitive Guide To MongoDB Mongo DB

• Contents at a Glance
• Contents
• About the Authors
• About the Technical Reviewer
• About the Contributor
• Acknowledgments
• Introduction
• Chapter 1: Introduction to MongoDB
  • Reviewing the MongoDB Philosophy
    • Using the Right Tool for the Right Job
    • Lacking Innate Support for Transactions
    • JSON and MongoDB
    • Adopting a Nonrelational Approach
    • Opting for Performance vs. Features
    • Running the Database Anywhere
  • Fitting Everything Together
    • Generating or Creating a Key
    • Using Keys and Values
    • Implementing Collections
    • Understanding Databases
  • Reviewing the Feature List
    • WiredTiger
    • Using Document-Oriented Storage (BSON)
    • Supporting Dynamic Queries
    • Indexing Your Documents
    • Leveraging Geospatial Indexes
    • Profiling Queries
    • Updating Information In Place (Memory Mapped Database Only)
    • Storing Binary Data
    • Replicating Data
    • Implementing Sharding
    • Using Map and Reduce Functions
    • The Aggregation Framework
  • Getting Help
    • Visiting the Website
    • Cutting and Pasting MongoDB Code
    • Finding Solutions on Google Groups
    • Finding Solutions on Stack Overflow
    • Leveraging the JIRA Tracking System
    • Chatting with the MongoDB Developers
  • Summary
• Chapter 2: Installing MongoDB
  • Choosing Your Version
    • Understanding the Version Numbers
  • Installing MongoDB on Your System
    • Installing MongoDB under Linux
      • Installing MongoDB through the Repositories
      • Installing MongoDB Manually
    • Installing MongoDB under Windows
  • Running MongoDB
    • Prerequisites
    • Surveying the Installation Layout
    • Using the MongoDB Shell
  • Installing Additional Drivers
    • Installing the PHP Driver
      • Getting MongoDB for PHP
      • Installing the PHP Driver on Unix-Based Platforms Automatically
      • Installing the PHP Driver on Unix-Based Platforms Manually
      • Installing the PHP Driver on Windows
    • Confirming That Your PHP Installation Works
      • Connecting to and Disconnecting from the PHP Driver
    • Installing the Python Driver
      • Installing PyMongo under Linux
        • Installing PyMongo Automatically
        • Installing PyMongo Manually
      • Installing PyMongo under Windows
    • Confirming That Your PyMongo Installation Works
  • Summary
• Chapter 3: The Data Model
  • Designing the Database
    • Drilling Down on Collections
    • Using Documents
      • Embedding vs. Referencing Information in Documents
    • Creating the _id Field
  • Building Indexes
    • Impacting Performance with Indexes
  • Implementing Geospatial Indexing
    • Querying Geospatial Information
  • Pluggable Storage Engines
  • Using MongoDB in the Real World
  • Summary
• Chapter 4: Working with Data
  • Navigating Your Databases
    • Viewing Available Databases and Collections
  • Inserting Data into Collections
  • Querying for Data
    • Using the Dot Notation
    • Using the Sort, Limit, and Skip Functions
    • Working with Capped Collections, Natural Order, and $natural
    • Retrieving a Single Document
    • Using the Aggregation Commands
      • Returning the Number of Documents with count( )
      • Retrieving Unique Values with distinct( )
      • Grouping Your Results
    • Working with Conditional Operators
      • Performing Greater-Than and Less-Than Comparisons
      • Retrieving All Documents but Those Specified
      • Specifying an Array of Matches
      • Finding a Value Not in an Array
      • Matching All Attributes in a Document
      • Searching for Multiple Expressions in a Document
      • Retrieving a Document with $slice
      • Searching for Odd/Even Integers
      • Filtering Results with $size
      • Returning a Specific Field Object
      • Matching Results Based on the BSON Type
      • Matching an Entire Array
      • Using the $not Metaoperator
      • Specifying Additional Query Expressions
    • Leveraging Regular Expressions
  • Updating Data
    • Updating with update()
    • Implementing an Upsert with the save() Command
    • Updating Information Automatically
      • Incrementing a Value with $inc
      • Setting a Field’s Value
      • Deleting a Specified Field
      • Appending a Value to a Specified Field
      • Specifying Multiple Values in an Array
      • Adding Data to an Array with $addToSet
    • Removing Elements from an Array
      • Removing Each Occurrence of a Specified Value
      • Removing Multiple Elements from an Array
    • Specifying the Position of a Matched Array
    • Atomic Operations
      • Using the Update-If-Current Method
    • Modifying and Returning a Document Atomically
  • Processing Data in Bulk
    • Executing Bulk Operations
    • Evaluating the Output
  • Renaming a Collection
  • Deleting Data
  • Referencing a Database
    • Referencing Data Manually
    • Referencing Data with DBRef
  • Implementing Index-Related Functions
    • Surveying Index-Related Commands
      • Forcing a Specified Index to Query Data
      • Constraining Query Matches
  • Summary
• Chapter 5: GridFS
  • Filling in Some Background
  • Working with GridFS
  • Getting Started with the Command-Line Tools
    • Using the _id Key
    • Working with Filenames
    • The File’s Length
    • Working with Chunk Sizes
    • Tracking the Upload Date
    • Hashing Your Files
  • Looking Under MongoDB’s Hood
    • Using the search Command
    • Deleting
    • Retrieving Files from MongoDB
    • Summing Up mongofiles
  • Exploiting the Power of Python
    • Connecting to the Database
    • Accessing the Words
  • Putting Files into MongoDB
  • Retrieving Files from GridFS
  • Deleting Files
  • Summary
• Chapter 6: PHP and MongoDB
  • Comparing Documents in MongoDB and PHP
  • MongoDB Classes
    • Connecting and Disconnecting
    • Inserting Data
  • Listing Your Data
    • Returning a Single Document
    • Listing All Documents
  • Using Query Operators
    • Querying for Specific Information
    • Sorting, Limiting, and Skipping Items
    • Counting the Number of Matching Results
    • Grouping Data with the Aggregation Framework
    • Specifying the Index with Hint
    • Refining Queries with Conditional Operators
      • Using the $lt, $gt, $lte, and $gte Operators
      • Finding Documents That Don’t Match a Value
      • Matching Any of Multiple Values with $in
      • Matching All Criteria in a Query with $all
      • Searching for Multiple Expressions with $or
      • Retrieving a Specified Number of Items with $slice
    • Determining Whether a Field Has a Value
    • Regular Expressions
  • Modifying Data with PHP
    • Updating via update()
    • Saving Time with Update Operators
      • Increasing the Value of a Specific Key with $inc
      • Changing the Value of a Key with $set
      • Deleting a Field with $unset
      • Renaming a Field with $rename
      • Changing the Value of a Key During Upsert with $setOnInsert
      • Appending a Value to a Specified Field with $push
      • Adding Multiple Values to a Key with $push and $each
      • Adding Data to an Array with $addToSet
      • Removing an Element from an Array with $pop
      • Removing Each Occurrence of a Value with $pull
      • Removing Each Occurrence of Multiple Elements with $pullAll
    • Upserting Data with save()
    • Modifying a Document Atomically
  • Processing Data in Bulk
    • Executing Bulk Operations
    • Evaluating the Output
  • Deleting Data
  • DBRef
    • Retrieving the Information
  • GridFS and the PHP Driver
    • Storing Files
    • Adding More Metadata to Stored Files
    • Retrieving Files
    • Deleting Data
  • Summary
• Chapter 7: Python and MongoDB
  • Working with Documents in Python
  • Using PyMongo Modules
  • Connecting and Disconnecting
  • Inserting Data
  • Finding Your Data
    • Finding a Single Document
    • Finding Multiple Documents
    • Using Dot Notation
    • Returning Fields
    • Simplifying Queries with sort(), limit(), and skip()
    • Aggregating Queries
      • Counting Items with count( )
      • Counting Unique Items with distinct( )
      • Grouping Data with the Aggregation Framework
    • Specifying an Index with hint()
    • Refining Queries with Conditional Operators
      • Using the $lt, $gt, $lte, and $gte Operators
      • Searching for Nonmatching Values with $ne
      • Specifying an Array of Matches with $in
      • Specifying Against an Array of Matches with $nin
      • Finding Documents That Match an Array’s Values
      • Specifying Multiple Expressions to Match with $or
      • Retrieving Items from an Array with $slice
    • Conducting Searches with Regular Expressions
  • Modifying the Data
    • Updating Your Data
    • Modifier Operators
      • Increasing an Integer Value with $inc
      • Changing an Existing Value with $set
      • Removing a Key/Value Field with $unset
      • Adding a Value to an Array with $push
      • Adding Multiple Values to an Array with $push and $each
      • Adding a Value to an Existing Array with $addToSet
      • Removing an Element from an Array with $pop
      • Removing a Specific Value with $pull
    • Replacing Documents with replace_one()
    • Modifying a Document Atomically
    • Putting the Parameters to Work
  • Processing Data in Bulk
    • Executing Bulk Operations
  • Deleting Data
  • Creating a Link Between Two Documents
    • Retrieving the Information
  • Summary
• Chapter 8: Advanced Queries
  • Text Search
    • Text Search Costs and Limitations
    • Using Text Search
      • Loading Text Data
      • Creating a Text Index
      • Running the Text Search Command
      • Filtering Text Queries
      • More Involved Text Searching
      • Additional Options
    • Text Indexes in Other Languages
    • Compound Indexing with Text Indexes
  • The Aggregation Framework
    • Using the $group Command
      • Using the $sum Operator
    • Using the $limit Operator
    • Using the $match Operator
    • Using the $sort Operator
    • Using the $unwind Operator
      • Using the $project Operator
    • Using the $skip Operator
    • Using the $out Operator
    • Using the $lookup Operator
  • MapReduce
    • How MapReduce Works
    • Setting Up Testing Documents
    • Working with Map Functions
    • Advanced MapReduce
    • Debugging MapReduce
  • Summary
• Chapter 9: Database Administration
  • Using Administrative Tools
    • mongo, the MongoDB Console
    • Using Third-Party Administration Tools
  • Backing Up the MongoDB Server
    • Creating a Backup 101
    • Backing Up a Single Database
    • Backing Up a Single Collection
  • Digging Deeper into Backups
  • Restoring Individual Databases or Collections
    • Restoring a Single Database
    • Restoring a Single Collection
  • Automating Backups
    • Using a Local Datastore
    • Using a Remote (Cloud-Based) Datastore
  • Backing Up Large Databases
    • Using a Hidden Secondary Server for Backups
    • Creating Snapshots with a Journaling Filesystem
    • Disk Layout to Use with Volume Managers
  • Importing Data into MongoDB
  • Exporting Data from MongoDB
  • Securing Your Data by Restricting Access to a MongoDB Server
  • Protecting Your Server with Authentication
    • Adding an Admin User
    • Enabling Authentication
    • Authenticating in the mongo Console
    • MongoDB User Roles
    • Changing a User’s Credentials
    • Adding a Read-Only User
    • Deleting a User
    • Using Authenticated Connections in a PHP Application
  • Managing Servers
    • Starting a Server
    • Getting the Server’s Version
    • Getting the Server’s Status
    • Shutting Down a Server
  • Using MongoDB Log Files
  • Validating and Repairing Your Data
    • Repairing a Server
    • Validating a Single Collection
    • Repairing Collection Validation Faults
      • Repairing a Collection’s Indexes
    • Repairing a Collection’s Data Files
    • Compacting a Collection’s Data Files
  • Upgrading MongoDB
    • Rolling Upgrade of MongoDB
  • Monitoring MongoDB
  • Using MongoDB Cloud Manager
  • Summary
• Chapter 10: Optimization
  • Optimizing Your Server Hardware for Performance
  • Understanding MongoDB’s Storage Engines
  • Understanding MongoDB Memory Use Under MMAPv1
    • Understanding Working Set Size in MMAPv1
  • Understanding MongoDB Memory Use Under WiredTiger
    • Compression in WiredTiger
    • Choosing the Right Database Server Hardware
  • Evaluating Query Performance
    • The MongoDB Profiler
      • Enabling and Disabling the MongoDB Profiler
      • Finding Slow Queries
      • Increase the Size of Your Profile Collection
    • Analyzing a Specific Query with explain()
    • Using the Profiler and explain() to Optimize a Query
  • Managing Indexes
    • Listing Indexes
    • Creating a Simple Index
    • Creating a Compound Index
  • Three-Step Compound Indexes By A. Jesse Jiryu Davis
    • The Setup
    • Range Query
    • Equality Plus Range Query
    • Digression: How MongoDB Chooses an Index
    • Equality, Range Query, and Sort
    • Final Method
  • Specifying Index Options
    • Creating an Index in the Background with {background:true}
    • Creating an Index with a Unique Key {unique:true}
    • Creating Sparse Indexes with {sparse:true}
    • Creating Partial Indexes
    • TTL Indexes
    • Text Search Indexes
    • Dropping an Index
    • Reindexing a Collection
  • Using hint( ) to Force Using a Specific Index
  • Using Index Filters
  • Optimizing the Storage of Small Objects
  • Summary
• Chapter 11: Replication
  • Spelling Out MongoDB’s Replication Goals
    • Improving Scalability
    • Improving Durability/Reliability
    • Providing Isolation
  • Replication Fundamentals
    • What Is a Primary?
    • What Is a Secondary?
    • What Is an Arbiter ?
  • Drilling Down on the Oplog
  • Implementing a Replica Set
    • Creating a Replica Set
    • Getting a Replica Set Member Up and Running
    • Adding a Server to a Replica Set
    • Adding an Arbiter
    • Replica Set Chaining
    • Managing Replica Sets
      • Inspecting an Instance’s Status with rs.status( )
      • Forcing a New Election with rs.stepDown( )
      • Determining If a Member Is the Primary Server
    • Configuring the Options for Replica Set Members
      • Organization of the members Structure
      • Exploring the Options Available in the Settings Structure
    • Connecting to a Replica Set from Your Application
      • Setting Read Preference from Within Your Application
      • Setting Write Concern from Within Your Application
      • Using Tags for Read Preference and Write Concern
  • Read Concern
  • Summary
• Chapter 12: Sharding
  • Exploring the Need for Sharding
  • Partitioning Horizontal and Vertical Data
    • Partitioning Data Vertically
    • Partitioning Data Horizontally
  • Analyzing a Simple Sharding Scenario
  • Implementing Sharding with MongoDB
    • Setting Up a Sharding Configuration
      • Adding a New Shard to the Cluster
      • Removing a Shard from the Cluster
    • Determining How You’re Connected
    • Listing the Status of a Sharded Cluster
    • Using Replica Sets to Implement Shards
  • The Balancer
  • Hashed Shard Keys
  • Tag Sharding
  • Adding More Config Servers
  • Summary
• Index