MongoDB入门指南 - CSDN文库

需积分: 9 83 浏览量更新于2024-07-26 收藏 204KB PDF 举报

"《the little mongodb book》是一本关于MongoDB的著作，由Karl Seguin撰写，并遵循Attribution-NonCommercial 3.0 Unported许可协议，允许非商业性的复制、分发、修改和展示，但需归功于作者。这本书涵盖了MongoDB的基本概念、操作和使用技巧。Karl Seguin是.NET和Ruby开发的专家，对MongoDB有深入的贡献，包括对C# MongoDB库NoRM的核心贡献，以及创建了交互式教程mongly和MongoWeb Admin。他的免费服务mogade.com也是基于MongoDB运行的。读者可以在http://openmymind.net找到他的博客，或通过@karlseguin关注他的推特。此外，作者特别感谢Perry Neal提供的帮助。最新的书本源代码可能在发布时有所更新。" 在《the little mongodb book》中，你将了解到MongoDB的基础知识，这是一款流行的开源、文档型数据库系统，以NoSQL数据库的形式提供服务。MongoDB以其灵活性、高性能和易于扩展性而著称，尤其适合处理大量结构化和半结构化数据。以下是一些关键知识点： 1. **文档数据库**：MongoDB使用JSON格式的文档来存储数据，这种格式便于理解和处理，尤其是对于处理复杂数据结构。 2. **集合与数据库**：在MongoDB中，数据以集合（类似于关系数据库中的表）的形式存储在数据库中。集合不需预先定义模式，可以动态适应不断变化的数据结构。 3. **查询语言**：MongoDB提供了强大的查询语言，允许用户以灵活的方式检索、更新和操作数据。 4. **索引**：为了提高查询性能，MongoDB支持创建索引，包括单字段、复合字段和唯一索引。 5. **副本集与分片**：MongoDB支持副本集来实现高可用性和数据冗余，以及分片以实现水平扩展，处理大数据量。 6. **聚合框架**：MongoDB的聚合框架允许对数据进行复杂的分析和处理，如计算统计信息、分组和管道操作。 7. **GridFS**：用于存储和检索大型文件的内置解决方案，将大文件分割成多个小块存储在MongoDB中。 8. **C#驱动程序NoRM**：Karl Seguin是NoRM的贡献者之一，这个驱动程序允许.NET开发者轻松地与MongoDB交互。 9. **MongoDB Web Admin**：一个管理工具，提供图形界面来监控和管理MongoDB实例，包括查看统计信息、运行查询等。 10. **交互式教程mongly**：这是一个实践性的学习工具，帮助开发者熟悉MongoDB的使用和操作。通过阅读《the little mongodb book》，开发者不仅能够掌握MongoDB的基本操作，还能了解如何在实际项目中应用这些知识，从而更好地利用MongoDB的优势来处理现代应用程序的需求。

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 much 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 cursor,

which we can do things to, such as counting or skipping ahead, without 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.

You might be wondering, 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

6

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 because 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 method to switch databases, 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 argu-

ment. Internally MongoDB uses a binary serialized JSON format. Externally, this means that

we use JSON a lot, as is the case with our parameters. If we execute db.getCollectionNames

() now, we'll actually see two collections: unicorns and system.indexes. system.indexes

is created once per database and contains the information on our databases index.

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 an

ObjectId for you. Most of the time you'll probably want to let MongoDB generate it for you.

By default, the _id field is indexed - which explains why the system.indexes collection was

created. You can look at system.indexes:

db.system.indexes.find()

7

剩余32页未读，继续阅读

春哥撩编程

粉丝: 52
资源: 9

最新资源