MongoDB入门指南：文档导向的NoSQL数据库

4星 · 超过85%的资源需积分: 0 174 浏览量更新于2024-07-25 2 收藏 202KB PDF 举报

《The Little MongoDB Book》是一本专注于MongoDB的NoSQL文档导向数据库技术的实用指南。该书遵循Creative Commons Attribution-NonCommercial 3.0 Unported 许可协议，这意味着读者可以免费地复制、分发、修改或展示这本书，但必须注明作者Karl Seguin，并且不能用于商业用途。Karl Seguin本身是一位经验丰富的开发者，他在.NET和Ruby开发领域有深厚造诣，同时也是一位活跃的开源项目贡献者，特别是对C# MongoDB库NoRM做出了重要贡献。他撰写了互动教程mongly，还开发了MongoWeb Admin工具。此外，他还通过mogade.com为休闲游戏开发者提供免费服务，这个平台的背后是MongoDB的支持。 Karl Seguin的个人博客位于http://openmymind.net，他在Twitter上的用户名是@karlseguin。在编写这本书的过程中，Perry Neal提供了宝贵的协助，无论是专业意见还是热情支持，他的贡献对于本书的完成至关重要。至于最新版本，读者可以在官方渠道获取到《The Little MongoDB Book》的最新源代码和更新信息，确保始终了解和掌握最新的MongoDB技术知识。这本小书深入浅出地介绍了MongoDB的基本概念、数据模型设计、CRUD操作、查询优化以及与C#等语言的集成，适合初学者和开发者快速上手MongoDB，同时也能满足有一定经验的技术人员在实际项目中的参考需求。通过阅读这本书，读者不仅能学习到MongoDB的核心原理，还能了解到如何在实际场景中灵活运用这一强大的NoSQL数据库系统。

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

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()

剩余32页未读，继续阅读

技术笔记本

粉丝: 121
资源: 22

MongoDB入门指南：文档导向的NoSQL数据库

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

MongoDB入门指南

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

The.Little.Mongo.DB.Schema.Design.Book151739402

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

The Little MongoDB Book

the little mongodb book

The Little MongoDB Book 中文版.pdf

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

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

最新资源