MongoDB的数组和对象类型

在MongoDB中可以添加数组和对象类型，这其实就对应了关系数据库中OneToMany和ManyToOne的类型，先来看如下一条数据：

db.topic.insertOne(
{
        title:'MongoDB学习指南',
        tags:['java','程序设计','数据库','NOSql'],
        content:'MongoDB学习之道,MongoDB是一个流行的NoSql数据库',
        comments:[
            {
               user:'jake',
               content:'Good Text'
            },
            {
               user:'Leon',
               content:'Ok!!'
            }
        ],
        author:{
            name:'konghao',
            mail:'ynkonghao@gmail.com'
        }
    }
);

以上这条语句插入了一个topic的collection，在这个collection插入了一个文档，这个文档中有title，tags，conent，comments和author几个信息，我们可以发现，对应MongoDB而言，除了添加基本数据类型之外还可以添加数组类型，tags数据就是一个数组类型，里面有四个值，而且author是一个对象类型。comments是一个数组，数组中的值又是一个对象。这就是MongoDB（文档型数据库）的特点，如果使用的是关系型数据库，需要在数据库中加入多张表来进行存储，之后通过join来查询，而使用文档型的数据库对于这种结构优势明显，数据库的设计问题将会在后面的章节详细探讨。

此时可以通过.来导航查询想要的信息

>db.topic.find({"author.name":"konghao"}) ##查询作者的名字叫konghao的用户
{
        "_id" : ObjectId("5a12e8cb15ec7ee2ec16bbbb"),
        "title" : "MongoDB学习指南",
        "tags" : [
                "java",
                "程序设计",
                "数据库",
                "NOSql"
        ],
        "content" : "MongoDB学习之道,MongoDB是一个流行的NoSql数据库",
        "comments" : [
                {
                        "user" : "jake",
                        "content" : "Good Text"
                },
                {
                        "user" : "Leon",
                        "content" : "Ok!!"
                }
        ],
        "author" : {
                "name" : "konghao",
                "mail" : "ynkonghao@gmail.com"
        }
}

我们还可以利用javascript shell来查询对象中的数组信息

> var d = db.topic.findOne(); ##将topic中的第一个条数据存储到变量d中
> d.comments.length ##获取comments的长度
2
> d.comments ##显示所有的comments
[
        {
                "user" : "jake",
                "content" : "Good Text"
        },
        {
                "user" : "Leon",
                "content" : "Ok!!"
        }
]

MongoDB的批量插入操作

首先是关于主键的操作，如果添加数据的时候不添加任何主键，会自动生成一个主键，这个主键并不像关系数据库中的自动递增（这是为了分布式考虑的），而是使用"时间戳+机器编号+进程编号+序列号"来生成的，这就可以保证每个id都是唯一的。id为5a0ed29a0149542ec19d4dd8，可以这样分解:5a0ed29a 014954 2ec1 9d4dd8 首先前四个字节(5a0ed29a)表示时间戳，014954表示机器号，2ec1表示进程编号，最后的9d4dd8表示序列号。

我们也可以手动指定id，使用_id来指定

> db.user.insertOne({_id:"user001",name:"foobar"}) ##插入一条数据，id是自己指定
{ "acknowledged" : true, "insertedId" : "user001" }
> db.user.find({name:"foobar"}) ##找到id为自己指定的数据
{ "_id" : "user001", "name" : "foobar" }

通过db.collection.insertMany()可以批量插入数据，MongoDB的批量插入效率比较高，它执行的操作非常少，它首先会查询批量插入的文档中是否包含有 _ id, 如果包含有，就验证_id是否已经存在，当发现所有的id都不存在，就直接存储，此时不会做其他的检查，这样就保证了插入的效率，当然这种也会存在一些问题，就是可能存在不合理的空数据存在。

db.user.insertMany([
...     {username:"foo",nickname:"FOO",password:"123"},
...     {username:"bar",nickname:"BAR",password:"111"},
...     {username:"hello",nickname:"HELLO",password:"123"}
... ]
... )
{
        "acknowledged" : true,
        "insertedIds" : [
                ObjectId("5a12fcf46533217cfe3d4090"),
                ObjectId("5a12fcf46533217cfe3d4091"),
                ObjectId("5a12fcf46533217cfe3d4092")
        ]
}

MongoDB的删除操作

删除操作上一讲已经介绍了，在3.2版本之前可以通过db.colletion.remove()来删除，在3.2之后提供db.collection.deleteOne()来删除一个数据和db.collection.deleteMany()来完成批量删除。在新版本中要进行删除操作，需要加入过滤条件，如果要删除所有的信息使用db.collection.deleteMany({})即可删除所有数据。

> db.user.deleteMany({}) ##删除所有数据
{ "acknowledged" : true, "deletedCount" : 6 }
> db.user.find()
>

接下来我们看一下批量删除的速度问题，首先批量添加一些数据

for(int i=0;i<1000000;i++) {
  Document d = new Document("name", "foo")
  .append("no", i);
  collection.insertOne(d);
}

以上代码通过java代码插入了一百万条数据，之后我们来进行一下删除操作，使用deleteMany({})来删除

> use demo
switched to db demo
> db.user.count()
1000000
> db.user.deleteMany({})
{ "acknowledged" : true, "deletedCount" : 1000000 }
>

100W条数据花去了18.35秒的时间，这个操作并不会删除索引，所以时间较长，可以使用db.collection.drop()来完全删除collection，效率就会高很多，这样就需要重新创建索引，而且不能使用其他条件。

> db.user.count()
1000000
> db.user.drop()
true

这次删除仅仅花了0.1秒的时间，所以如果希望全部删除一个collection，使用drop显然效率要高得多。

MongoDB的更新操作

MongoDB的更新方式比较多，首先介绍基于shell的方式，这种方式是把数据先读出来，之后以对象的方式完成修改。这种方式一般用在修改较大的情况下。

db.user.insertOne({
    name:"foo",
    nickname:"bar",
    friends:12,
    enemies:2
})

我们希望修改为

db.user.insertOne({
    username:"foo",
    nickname:"bar",
    relations:{
        friends:12,
        enemies:2
    }
})

这种使用shell的替换方式比较方便

var u = db.user.findOne({name:"foo"}) ##查询对象存储到u中
u.relations = {friends:u.friends,enemies:u.enemies} ##设置relations的值
u.username = u.name ##修改name为username
delete u.friends ##删除friends
delete u.enemies ##删除enemies
delete u.name ##删除name
db.user.update({name:"foo"},u) ##替换对象
db.user.findOne({username:"foo"}) ##查询看看结果
{
        "_id" : ObjectId("5a155e7156d8db3756cafce3"),
        "nickname" : "bar",
        "relations" : {
                "friends" : 12,
                "enemies" : 2
        },
        "username" : "foo"
}

这就是替换的方式，它是基于一种编程的思想来进行，使用这种方式要进行单个对象的复杂修改比较适用。

接着介绍基于修改器的方法，这种方式使用比较广泛，它的主要思路就是通过$符号来进行修改这些操作，首先使用inc可以对数据进行增加和减少，这个操作只能针对数字类型，小数或者整数

> db.topic.insertOne({title:"first",visites:107})##添加一条数据
> db.topic.update({title:"first"},{$inc:{visites:1}})##修改参观次数增加1
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.topic.findOne({title:"first"})##查询
{
        "_id" : ObjectId("5a15608556d8db3756cafce5"),
        "title" : "first",
        "visites" : 108
}
> db.topic.update({title:"first"},{$inc:{visites:-3}})##将数字修改了减少3
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.topic.findOne({title:"first"})
{
        "_id" : ObjectId("5a15608556d8db3756cafce5"),
        "title" : "first",
        "visites" : 105
}
>

使用set可以完成特定需求的修改，这是非常常用的一种方式

> db.author.findOne()##原数据
{
        "_id" : ObjectId("5a162f8956d8db3756cafce7"),
        "name" : "foo",
        "age" : 20,
        "gender" : "male",
        "intro" : "student"
}
> db.author.update({name:"foo"},{$set:{intro:"teacher"}})##使用$set进行修改
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })

set不仅仅可以修改变量，还可以修改数据类型，下面将intro修改为数组类型

 db.author.update({name:"foo"},{$set:{intro:["teacher","programmer"]}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.author.findOne()
{
        "_id" : ObjectId("5a162f8956d8db3756cafce7"),
        "name" : "foo",
        "age" : 20,
        "gender" : "male",
        "intro" : [
                "teacher",
                "programmer"
        ]
}

使用unset可以删除一个键，由于操作的时候都要通过写键值对，所以，可以在要删除的字段后随便写个值即可，一下代码写了一个1

> db.author.update({name:"foo"},{$unset:{intro:1}})##删除intro属性
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.author.findOne()
{
        "_id" : ObjectId("5a162f8956d8db3756cafce7"),
        "name" : "foo",
        "age" : 20,
        "gender" : "male"
}

使用set还可以修改关联类型的值

> db.topic.findOne() ##修改前的数据
{
        "_id" : ObjectId("5a12e8cb15ec7ee2ec16bbbb"),
        "title" : "MongoDB学习指南",
        "content" : "MongoDB学习之道,MongoDB是一个流行的NoSql数据库",
        "author" : {
                "name" : "konghao",
                "mail" : "ynkonghao@gmail.com"
        }
}
> db.topic.update(
    {"author.name":"konghao"},
    {$set:{"author.mail":"konghao@gmail.com"}}
)##修改关联类型author
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.topic.findOne()##修改后的数据
{
        "_id" : ObjectId("5a12e8cb15ec7ee2ec16bbbb"),
        "title" : "MongoDB学习指南",
        "content" : "MongoDB学习之道,MongoDB是一个流行的NoSql数据库",
        "author" : {
                "name" : "konghao",
                "mail" : "konghao@gmail.com"
        }
}

更新操作除了针对基本数据外还可以更新数组信息,使用push可以完成数组的插入，会在最后一条插入，如果没有这个key，会自动创建一条数据插入

db.posts.findOne()
{
        "_id" : ObjectId("5a1656e656d8db3756cafce8"),
        "title" : "a blog",
        "content" : "...",
        "author" : "foo"
}
> db.posts.update({title:"a blog"},
    {$push:{comments:{name:"leon",email:"leon.email.com",content:"leon replay"}}})
    ##插入了一条comments的回复，此时没有comments。所以创建了一个数组类型的key出来
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.posts.findOne()##查询结果
{
        "_id" : ObjectId("5a1656e656d8db3756cafce8"),
        "title" : "a blog",
        "content" : "...",
        "author" : "foo",
        "comments" : [
                {
                        "name" : "leon",
                        "email" : "leon.email.com",
                        "content" : "leon replay"
                }
        ]
}

使用addToSet可以向一个数组中添加元素，但这个有一个限定条件就是，如果已经存在就不添加，这是非常好用的方法。

> db.users.findOne() ##原始数据
{
        "_id" : ObjectId("5a1659a756d8db3756cafce9"),
        "name" : "foo",
        "age" : 12,
        "email" : [
                "foo@example.com",
                "foo@163.com"
        ]
}
> db.users.update({name:"foo"},{$addToSet:{email:"foo@qq.com"}})##添加了一个email信息
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.update({name:"foo"},{$addToSet:{email:"foo@gmail.com"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.findOne()##添加完成之后多了两条email的数据
{
        "_id" : ObjectId("5a1659a756d8db3756cafce9"),
        "name" : "foo",
        "age" : 12,
        "email" : [
                "foo@example.com",
                "foo@163.com",
                "foo@qq.com",
                "foo@gmail.com"
        ]
}
> db.users.update({name:"foo"},{$addToSet:{email:"foo@gmail.com"}})##继续添加一条已经存在的信息
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 0 })
> db.users.findOne()##并没有添加成功
{
        "_id" : ObjectId("5a1659a756d8db3756cafce9"),
        "name" : "foo",
        "age" : 12,
        "email" : [
                "foo@example.com",
                "foo@163.com",
                "foo@qq.com",
                "foo@gmail.com"
        ]
}
>

使用each可以添加一个数组，此时如果配合addToSet会非常方便，此时只会添加不存在的数据，以上一例的数据为蓝本

db.users.update(
    {name:"foo"},
    {$addToSet:{email:{$each:["foo@qq.com","foo@sohu.com"]}}}
)##在email中的添加qq和sohu的邮箱，由于qq已经存在，所以不会添加，只会添加sohu的邮箱
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.findOne()
{
        "_id" : ObjectId("5a165d5f56d8db3756cafcea"),
        "name" : "foo",
        "age" : 12,
        "email" : [
                "foo@example.com",
                "foo@163.com",
                "foo@gmail.com",
                "foo@qq.com",
                "foo@sohu.com"
        ]
}

通过pop可以删除数组中的元素，可以指定从哪一个位置删除。'{$pop:{xxx:1}}'表示删除xx这个数组的最后一个元素，使用xxx:-1表示删除第一个元素。

> db.users.findOne()##原始数据
{
        "_id" : ObjectId("5a165d5f56d8db3756cafcea"),
        "email" : [
                "foo@example.com",
                "foo@163.com",
                "foo@gmail.com",
                "foo@qq.com",
                "foo@sohu.com"
        ]
}
> db.users.update({name:"foo"},{$pop:{email:1}})##删除email最后一个位置元素，sohu会被删除
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.findOne()
{
        "_id" : ObjectId("5a165d5f56d8db3756cafcea"),
        "email" : [
                "foo@example.com",
                "foo@163.com",
                "foo@gmail.com",
                "foo@qq.com"
        ]
}
>db.users.update({name:"foo"},{$pop:{email:-1}})#使用-1删除第一个元素
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.findOne()
{
        "_id" : ObjectId("5a165d5f56d8db3756cafcea"),
        "name" : "foo",
        "age" : 12,
        "email" : [
                "foo@163.com",
                "foo@gmail.com",
                "foo@qq.com"
        ]
}

对于update方法而言，第一个参数是条件，第二个参数是具体的修改信息，它还有第三个参数，是一个布尔类型的值，如果为true，表示修改操作，如果没有找到条件，会自动创建需要修改的数据，默认是false。先看看如下实例

> db.statistics.update({url:"/blog"},{$inc:{visites:1}}) ##增加/blog地址的访问次数
WriteResult({ "nMatched" : 0, "nUpserted" : 0, "nModified" : 0 }) ##由于没有数据，所以不会更新
> db.statistics.findOne()##没有更新
null
> db.statistics.update({url:"/blog"},{$inc:{visites:1}},true)##设置第三个参数为true，会自动添加
WriteResult({
        "nMatched" : 0,
        "nUpserted" : 1,
        "nModified" : 0,
        "_id" : ObjectId("5a16ea57d76cb43bc7d5de15")
})
> db.statistics.findOne()##添加了一条数据
{
        "_id" : ObjectId("5a16ea57d76cb43bc7d5de15"),
        "url" : "/blog",
        "visites" : 1
}

已上操作非常方便，因为这个操作是原子性的，如果我们使用shell来更新，需要先取出对象，之后判断，如果存在执行更新，不存在执行添加，这个操作的步骤较多而且不是原子性。不仅效率不高，而且如果更新到某一个部分抛出异常就会出现数据不统一操作。

接下来介绍save这个shell脚本，也非常的实用，它会检查数据是否存在，如果存在就更新，如果不存在就插入，这也是比较实用的操作。

> db.users.findOne()##原始数据
{
        "_id" : ObjectId("5a165d5f56d8db3756cafcea"),
        "name" : "foo",
        "age" : 33,
        "email" : [
                "foo@163.com",
                "foo@gmail.com",
                "foo@qq.com"
        ]
}
> var foo=db.users.findOne({name:"foo"})
> foo.age = 44##修改age为44，age存在会执行修改
44
> foo.num = 33##num不存在会自动添加这个属性
33
> db.users.save(foo)##执行save方法
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
> db.users.find({name:"foo"}).pretty()
{
        "_id" : ObjectId("5a165d5f56d8db3756cafcea"),
        "name" : "foo",
        "age" : 44,##修改的变量
        "email" : [
                "foo@163.com",
                "foo@gmail.com",
                "foo@qq.com"
        ],
        "num" : 33 ##新添加的
}
>

最后来实际测试一下更新的效率问题，这里将会测试inc，set和push三个方法

long start = new Date().getTime();
for(int i=0;i<100000;i++) {
  collection.updateOne(gte("num",1),inc("num",1));//使用java完成更新
}
long end = new Date().getTime();
System.out.println((end-start)/1000);

插入了10W条数据，最后的时间是13秒左右，差不多每秒7000多条，对于一个台个人电脑而言效率还算不错，接着测试set操作。

long start = new Date().getTime();
for(int i=0;i<100000;i++) {
  collection.updateOne(eq("name","leon"),set("num",i));//使用java完成修改
}
long end = new Date().getTime();
System.out.println((end-start)/1000);

同样操作10W条数据，我们发现时间16秒左右，稍微慢一点点，这说明只要在文档结构不做调整的情况下，set的速度也是非常理想的。最后来测试push操作，push仅仅操作1W条数数据

long start = new Date().getTime();
for(int i=0;i<10000;i++) {
  collection.updateOne(eq("name","Ada"),push("nums",i));
}
long end = new Date().getTime();
System.out.println((end-start)/1000);

时间约为25秒左右，我们发现，push操作的效率比较的低，所以需要注意push的瓶颈问题，必要时可以将数组拿出来放到一个单独的集合中。

这一部分详细的探讨了MongoDB的写操作，并且介绍了多数非常常用的方法，下一部分将会详细的探讨查询相关的操作。