MongoDB入门指南：免费下载学习宝典

需积分: 1 201 浏览量更新于2024-07-19 收藏 187KB PDF 举报

"The Little MongoDB Book" 是一本面向初学者的优质IT入门书籍，它以简洁的方式介绍了MongoDB，这是一种流行的分布式文档型数据库系统。这本书遵循Creative Commons Attribution-NonCommercial 3.0 Unported 许可证，这意味着读者可以免费下载、复制、修改和展示该书，但必须注明作者卡尔·塞古因，并且不能用于商业用途。卡尔·塞古因是一位多才多艺的开发者，拥有.NET和Ruby开发经验，他在开源项目中有积极贡献，包括C# MongoDB库NoRM，他还编写了互动教程mongly和MongoWebAdmin工具。作为MongoDB领域的专家，卡尔对MongoDB的C#驱动程序做出了关键性贡献，他注意到游戏开发者的需求，创立了mogade.com，这个平台就依赖于MongoDB来提供服务。此外，他还撰写了"The Little Redis Book"，进一步展示了他在数据库技术上的广博知识。他的博客可以在http://openmymind.net上找到，而他在Twitter上通过[@karlseguin](http://twitter.com/karlseguin)分享他的见解和最新动态。在本书的创作过程中，卡尔特别感谢Perry Neal提供了宝贵的审阅和支持，这体现了作者在分享知识的同时也注重与同行的合作和交流。《The Little MongoDB Book》不仅是一本技术指南，也是对MongoDB技术深入浅出的讲解，适合那些希望入门MongoDB或者提升技能的读者。阅读这本书，读者将能够掌握MongoDB的基本概念、数据模型设计、查询操作以及如何在实际项目中应用这一强大的数据库系统。

As an example for Windows users, if you extracted the downloaded file to c:\mongodb\ and you created c:\mongodb\

data\ then within c:\mongodb\bin\mongodb.config you would specify dbpath=c:\mongodb\data\. You could then

launch mongod from a command prompt via c:\mongodb\bin\mongod --config c:\mongodb\bin\mongodb.config.

Feel free to add the bin folder to your path to make all of this less verbose. MacOSX and Linux users can follow almost

identical directions. The only thing you should have to change are the paths.

Hopefully you now have MongoDB up and running. If you get an error, read the output carefully - the server is quite

good at explaining what’s wrong.

You can now launch mongo (without the d) which will connect a shell to your running server. Try entering db.version()

to make sure everything’s working as it should. Hopefully you’ll see the version number you installed.

Chapter 4

Chapter 1 - The Basics

We begin our journey by getting to know the basic mechanics of working with MongoDB. Obviously this is core to

understanding MongoDB, but it should also help us answer higher-level questions about where MongoDB fits.

To get started, there are six simple concepts we need to understand.

1. MongoDB has the same concept of a database with which you are likely already familiar (or a schema for you

Oracle folks). Within a MongoDB instance you can have zero or more databases, each acting as high-level

containers for everything else.

2. A database can have zero or more collections. A collection shares enough in common with a traditional table

that you can safely think of the two as the same thing.

3. Collections are made up of zero or more documents. Again, a document can safely be thought of as a row.

4. A document is made up of one or more fields, which you can probably guess are a lot like columns.

5. Indexes in MongoDB function mostly like their RDBMS counterparts.

6. Cursors are different than the other five concepts but they are important enough, and often overlooked, that

I think they are worthy of their own discussion. The important thing to understand about cursors is that when

you ask MongoDB for data, it returns a pointer to the result set called a cursor, which we can do things to, such

as counting or skipping ahead, before actually pulling down data.

To recap, MongoDB is made up of databases which contain collections. A collection is made up of documents.

Each document is made up of fields. Collections can be indexed, which improves lookup and sorting performance.

Finally, when we get data from MongoDB we do so through a cursor whose actual execution is delayed until necessary.

Why use new terminology (collection vs. table, document vs. row and field vs. column)? Is it just to make things more

complicated? The truth is that while these concepts are similar to their relational database counterparts, they are not

identical. The core difference comes from the fact that relational databases define columns at the table level whereas

a document-oriented database defines its fields at the document level. That is to say that each document within a

collection can have its own unique set of fields. As such, a collection is a dumbed down container in comparison

to a table, while a document has a lot more information than a row.

Although this is important to understand, don’t worry if things aren’t yet clear. It won’t take more than a couple of

inserts to see what this truly means. Ultimately, the point is that a collection isn’t strict about what goes in it (it’s

schema-less). Fields are tracked with each individual document. The benefits and drawbacks of this will be explored

in a future chapter.

Let’s get hands-on. If you don’t have it running already, go ahead and start the mongod server as well as a mongo

shell. The shell runs JavaScript. There are some global commands you can execute, like help or exit. Commands

that you execute against the current database are executed against the db object, such as db.help() or db.stats().

Commands that you execute against a specific collection, which is what we’ll be doing a lot of, are executed against

the db.COLLECTION_NAME object, such as db.unicorns.help() or db.unicorns.count().

Go ahead and enter db.help(), you’ll get a list of commands that you can execute against the db object.

A small side note: Because this is a JavaScript shell, if you execute a method and omit the parentheses (), you’ll

see the method body rather than executing the method. I only mention it so that the first time you do it and get a

response that starts with function (...){ you won’t be surprised. For example, if you enter db.help (without the

parentheses), you’ll see the internal implementation of the help method.

First we’ll use the global use helper to switch databases, so go ahead and enter use learn. It doesn’t matter that the

database doesn’t really exist yet. The first collection that we create will also create the actual learn database. Now

that you are inside a database, you can start issuing database commands, like db.getCollectionNames(). If you do

so, you should get an empty array ([ ]). Since collections are schema-less, we don’t explicitly need to create them.

We can simply insert a document into a new collection. To do so, use the insert command, supplying it with the

document to insert:

db.unicorns.insert({name: 'Aurora',

gender: 'f', weight: 450})

The above line is executing insert against the unicorns collection, passing it a single parameter. Internally MongoDB

uses a binary serialized JSON format called BSON. Externally, this means that we use JSON a lot, as is the case with

our parameters. If we execute db.getCollectionNames() now, we’ll see a unicorns collection.

You can now use the find command against unicorns to return a list of documents:

db.unicorns.find()

Notice that, in addition to the data you specified, there’s an _id field. Every document must have a unique _id field.

You can either generate one yourself or let MongoDB generate a value for you which has the type ObjectId. Most of

the time you’ll probably want to let MongoDB generate it for you. By default, the _id field is indexed. You can verify

this through the getIndexes command:

db.unicorns.getIndexes()

What you’re seeing is the name of the index, the database and collection it was created against and the fields included

in the index.

Now, back to our discussion about schema-less collections. Insert a totally different document into unicorns, such as:

db.unicorns.insert({name: 'Leto',

剩余65页未读，继续阅读

Scape1989

粉丝: 25
资源: 22

MongoDB入门指南：免费下载学习宝典

The Little MongoDB Book 中文版.pdf

The Little MongoDB Book，非常经典的一本书

The Little MongoDB Book

the little mongodb book

the-little-mongodb-book-cn:The Little MongoDB Book 中文版

MongoDB入门指南：The Little MongoDB Book中文版解析

安卓java读取网页源码-the-little-mongodb-book:来自@justinyhuang的the-little-mongodb

The-Little-MongoDB-Book-rus:MongoDB 小书

The Little Redis Book.pdf

the little redis book.pdf

最新资源