MongoDB权威指南：从基础到大数据应用 - CSDN文库

3星 · 超过75%的资源需积分: 9 114 浏览量更新于2024-07-23 收藏 3.85MB PDF 举报

"Apress.The.Definitive.Guide.to.MongoDB.2nd.Edition.Dec.2013" 这本书是MongoDB的权威指南第二版，旨在深入介绍MongoDB的基础特性和开发方法。MongoDB是一种流行的NoSQL数据库系统，以其灵活性、高性能和易扩展性而闻名。书中覆盖了从安装到高级特性的全面内容，适合数据库新手和有经验的开发者学习。第一部分：MongoDB基础这部分从MongoDB的简介开始，让读者理解它是什么以及为什么选择它。接下来的章节指导读者如何安装MongoDB，确保读者能够顺利设置和运行数据库环境。在数据模型章节中，介绍了MongoDB的核心数据结构，如文档、集合和数据库。此外，还详细讲解了如何操作数据，包括插入、查询、更新和删除等基本操作。第二部分：使用MongoDB开发这一部分主要针对开发人员，探讨了如何在PHP和Python这两种流行的语言中与MongoDB集成。通过实例展示了如何在这些语言中建立连接、执行查询以及处理数据。同时，还深入介绍了更复杂的查询技术，帮助开发者实现高效的数据检索。第三部分：高级MongoDB与大数据这部分涵盖了数据库管理，包括监控、备份、恢复等关键任务，以及优化MongoDB性能的方法。复制章节讲解了MongoDB的高可用性方案，确保数据的安全性和一致性。最后，介绍了分片（Sharding）技术，这是MongoDB处理大数据和横向扩展的关键特性，有助于在大规模部署中保持性能。书中的附录和索引为读者提供了额外的参考资源，便于快速查找特定信息。作者在序言中分享了自己的数据库学习历程，强调了MongoDB在当今大数据时代的重要性。这本书是全面了解和掌握MongoDB的宝贵资料，不仅适合初学者入门，也适合已经有一定经验的开发者深入学习和提升。通过阅读此书，读者将能够充分利用MongoDB的潜力，进行高效的数据存储和处理。

CHAPTER 1 ■ INTRODUCTION TO MONGODB

13

Profiling Queries

A built-in profiling tool lets you see how MongoDB works out which documents to return. This is useful because,

in many cases, a query can be easily improved simply by adding an index. If you have a complicated query, and

you’re not really sure why it’s running so slowly, then the query profiler can provide you with extremely valuable

information. Again, you’ll learn more about the MongoDB Profiler in Chapter 10.

Updating Information In-Place

When a database updates a row (or in the case of MongoDB, a document), it has a couple of choices about how to do

it. Many databases choose the multi-version concurrency control (MVCC) approach, which allows multiple users to

see different versions of the data. This approach is useful because it ensures that the data won’t be changed partway

through by another program during a given transaction.

The downside to this approach is that the database needs to track multiple copies of the data. For example,

CouchDB provides very strong versioning, but this comes at the cost of writing the data out in its entirety. While this

ensures that the data is stored in a robust fashion, it also increases complexity and reduces performance.

MongoDB, on the other hand, updates information in-place. This means that (in contrast to CouchDB) MongoDB

can update the data wherever it happens to be. This typically means that no extra space needs to be allocated, and the

indexes can be left untouched.

Another benefit of this method is that MongoDB performs lazy writes. Writing to and from memory is very fast, but

writing to disk is thousands of times slower. This means that you want to limit reading and writing from the disk as much

as possible. This isn’t possible in CouchDB, because that program ensures that each document is quickly written to disk.

While this approach guarantees that the data is written safely to disk, it also impacts performance significantly.

MongoDB only writes to disk when it has to, which is usually once every second or so. This means that if a value

is being updated many times a second—a not uncommon scenario if you’re using a value as a page counter or for live

statistics—then the value will only be written once, rather than the thousands of times that CouchDB would require.

This approach makes MongoDB much faster, but, again, it comes with a tradeoff. CouchDB may be slower, but it

does guarantee that data is stored safely on the disk. MongoDB makes no such guarantee, and this is why a traditional

RDBMS is probably a better solution for managing critical data such as billing or accounts receivable.

Storing Binary Data

GridFS is MongoDB’s solution to storing binary data in the database. BSON supports saving up to 4MB of binary data

in a document, and this may well be enough for your needs. For example, if you want to store a profile picture or a sound

clip, then 4MB might be more space than you need. On the other hand, if you want to store movie clips, high-quality

audio clips, or even files that are several hundred megabytes in size, then MongoDB has you covered here, too.

GridFS works by storing the information about the file (called metadata) in the files collection. The data itself is

broken down into pieces called chunks that are stored in the chunks collection. This approach makes storing data both

easy and scalable; it also makes range operations (such as retrieving specific parts of a file) much easier to use.

Generally speaking, you would use GridFS through your programming language’s MongoDB driver, so it’s

unlikely you’d ever have to get your hands dirty at such a low level. As with everything else in MongoDB, GridFS is

designed for both speed and scalability. This means you can be confident that MongoDB will be up to the task if you

want to work with large data files.

Replicating Data

When we talked about the guiding principles behind MongoDB, we mentioned that RDBMS databases offer certain

guarantees for data storage that are not available in MongoDB. These guarantees weren’t implemented for a handful

of reasons. First, these features would slow the database down. Second, they would greatly increase the complexity of

the program. Third, it was felt that the most common failure on a server would be hardware, which would render the

data unusable anyway, even if the data were safely saved to disk.

CHAPTER 1 ■ INTRODUCTION TO MONGODB

14

Of course, none of this means that data safety isn’t important. MongoDB wouldn’t be of much use if you couldn’t

count on being able to access the data when you need it. Initially, MongoDB provided a safety net with a feature called

master-slave replication, in which only one database is active for writing at any given time, an approach that is also

fairly common in the RDBMS world. This feature has since been replaced with replica sets, and basic master-slave

replication has been deprecated and should no longer be used.

Replica sets have one primary server (similar to a master), which handles all the write requests from clients.

Because there is only one primary server in a given set, it can guarantee that all writes are handled properly. When a

write occurs it is logged in the primary’s ‘oplog’.

The oplog is replicated by the secondary servers (of which there can be many) and used to bring themselves up

to date with the master. Should the master fail at any given time, one of the secondaries will become the primary and

take over responsibility for handling client write requests.

Implementing Sharding

For those involved with large-scale deployments, auto-sharding will probably prove one of MongoDB’s most

significant and oft-used features.

In an auto-sharding scenario, MongoDB takes care of all the data splitting and recombination for you. It makes

sure the data goes to the right server and that queries are run and combined in the most efficient manner possible.

In fact, from a developer’s point of view, there is no difference between talking to a MongoDB database with a

hundred shards and talking to a single MongoDB server. This feature is not yet production-ready; when it is,

however, it will push MongoDB’s scalability through the roof.

In the meantime, if you’re just starting out or you’re building your first MongoDB-based website, then you’ll

probably find that a single instance of MongoDB is sufficient for your needs. If you end up building the next Facebook

or Amazon, however, you will be glad that you built your site on a technology that can scale so limitlessly. Sharding is

the topic of Chapter 12 of this book.

Using Map and Reduce Functions

For many people, hearing the term MapReduce sends shivers down their spines. At the other extreme, many RDBMS

advocates scoff at the complexity of map and reduce functions. It’s scary for some because these functions require a

completely different way of thinking about finding and sorting your data, and many professional programmers have

trouble getting their heads around the concepts that underpin map and reduce functions. That said, these functions

provide an extremely powerful way to query data. In fact, CouchDB supports only this approach, which is one reason

it has such a high learning curve.

MongoDB doesn’t require that you use map and reduce functions. In fact, MongoDB relies on a simple querying

syntax that is more akin to what you see in MySQL. However, MongoDB does make these functions available for those

who want them. The map and reduce functions are written in JavaScript and run on the server. The job of the map

function is to find all the documents that meet a certain criteria. These results are then passed to the reduce function,

which processes the data. The reduce function doesn’t usually return a collection of documents; rather, it returns a

new document that contains the information derived. As a general rule, if you would normally use GROUP BY in SQL,

then the map and reduce functions are probably the right tools for the job in MongoDB.

Note ■ You should not think of MongoDB’s map and reduce functions as poor imitations of the approach adopted by

CouchDB. If you so desired, you could use MongoDB’s map and reduce functions for everything in lieu of MongoDB’s

innate query support.

CHAPTER 1 ■ INTRODUCTION TO MONGODB

15

The All-New Aggregation Framework

MapReduce is a very powerful tool, but it has one major drawback; it’s not exactly easy to use. Many database

systems are used for reporting, and SQL databases in particular make this very easy. If you want to group results

or find the maximum and average, then it’s very simple to express that idea and get the result you’re looking for.

Unfortunately, it’s not quite so simple to do that in MapReduce, and you effectively have to do all the wiring up

yourself. This can often mean that an otherwise simple task is unnecessary challenging.

In response to this, MongoDB Inc (previously 10gen) added the aggregation framework. It is pipeline-based,

and allows you to take individual pieces of a query and string them together in order to get the result you’re looking

for. This maintains the benefits of MongoDB’s document oriented design while still providing high performance.

So if you need all the power of MapReduce, you still have it at your beck and call. If you just want to do some basic

statistics and number crunching, you’re going to love the new aggregation framework. You'll learn more about the

aggregation framework and its commands in Chapters 4 and 6.

Getting Help

MongoDB has a great community, and the core developers are very active and easily approachable, and they

typically go to great lengths to help other members of the community. MongoDB is easy to use and comes with great

documentation; however, it’s still nice to know that you’re not alone, and help is available, should you need it.

Visiting the Website

The first place to look for updated information or help is on the MongoDB website (www://mongodb.org). This site

is updated regularly and contains all the latest MongoDB goodness. On this site, you can find drivers, tutorials,

examples, frequently asked questions, and much more.

Chatting with the MongoDB Developers

The MongoDB developers hang out on Internet Relay Chat (IRC) at #MongoDB on the Freenode network

(www.freenode.net). MongoDB’s developers are based in New York, but they are often found chatting in this channel

well into the night. Of course, the developers do need to sleep at some point (coffee only works for so long!); fortunately,

there are also many knowledgeable MongoDB users from around the world who are ready to help out. Many people

who visit the #MongoDB channel aren’t experts; however, the general atmosphere is so friendly that they stick around

anyway. Please feel free to join #MongoDB channel and chat with people there—you may find some great hints and tips.

If you’re really stuck, you’ll probably be able to quickly get back on track.

Cutting and Pasting MongoDB Code

Pastie (http://pastie.org) is not strictly a MongoDB site; however, it is something you will come across if you float

about in #MongoDB for any length of time. The Pastie site basically lets you cut and paste (hence the name) some output

or program code, and then put it online for others to view. In IRC, pasting multiple lines of text can be messy or hard

to read. If you need to post a fair bit of text (such as three lines or more), then you should visit http://pastie.org,

paste in your content, and then paste the link to your new page into the channel.

Finding Solutions on Google Groups

MongoDB also has a Google group called mongodb-user (http://groups.google.com/group/mongodb-user).

This group is a great place to ask questions or search for answers. You can also interact with the group via e-mail.

Unlike IRC, which is very transient, the Google group is a great long-term resource. If you really want to get involved

with the MongoDB community, joining the group is a great way to start.

17

Chapter 2

Installing MongoDB

In Chapter 1, you got a taste of what MongoDB can do for you. In this chapter, you will learn how to install and expand

MongoDB to do even more, enabling you to use it in combination with your favorite programming language.

MongoDB is a cross-platform database, and you can find a significant list of available packages to download from

the MongoDB website (www.mongodb.org). The wealth of available versions might make it difficult to decide which

version is the right one for you. The right choice for you probably depends on the operating system your server uses,

the kind of processor in your server, and whether you prefer a stable release or would like to take a dive into a version that

is still in development but offers exciting new features. Perhaps you’d like to install both a stable and a forward-looking

version of the database. It’s also possible you’re not entirely sure which version you should choose yet. In any case,

read on!

Choosing Your Version

When you look at the Download section on the MongoDB website, you will see a rather straightforward overview of

the packages available for download. The first thing you need to pay attention to is the operating system you are going

to run the MongoDB software on. Currently, there are precompiled packages available for Windows, various flavors of

the Linux operating system, Mac OS, and Solaris.

Note ■ An important thing to remember here is the difference between the 32-bit release and the 64-bit release of

the product. The 32-bit and 64-bit versions of the database currently have the same functionality, with one exception:

the 32-bit release is limited to a total dataset size of approximately 2GB per server. The 64-bit version does not carry this

restriction, however, so it’s generally preferred over the 32-bit version for production environments. Also, the differences

between these versions are subject to change.

You will also need to pay attention to the version of the MongoDB software itself: there are production releases,

previous releases, and development releases. The production release indicates that it’s the most recent stable version

available. When a newer and generally improved or enhanced version is released, the prior most recent stable version

will be made available as a previous release. This designation means the release is stable and reliable, but it usually

has fewer features available in it. Finally, there’s the development release. This release is generally referred to as the

unstable version. This version is still in development, and it will include many changes, including significant new

features. Although it has not been fully developed and tested yet, the developers of MongoDB have made it available

to the public to test or otherwise try out.

剩余318页未读，继续阅读

nspforever

粉丝: 0
资源: 1

最新资源