MongoDB详解（二）

一、MongoDB之CRUD

1、获取帮助

db.help //数据库帮助信息

    db.dropdatabase()
    db.getName()
    db.stats()
    db.serverStatus() //server状态
    db.getCollectionNames() //所有的集合

db.col.help //col是collection的名字，collection帮助信息
sh.help //sharding帮助
rs.help //副本集帮助
help admin
help connect //db连接帮助
help keys //快捷键帮助
help misc //编码信息
help mr //mapreduce

2、显示类命令

show dbs //查看所有的数据库
show collections //查看当前db的collections(类似RDBMS的表)
show users //当前db的用户
show profile //查看最新system.profile entries
show logs //查看最近的日志名称
show log [name] //查看最近的内存log的段，默认是'global'

3、MongoDB的CRUD：

create,read,update,delete
JSON-link style.
"_id" 相当于MySQL的主键。文档之间可以相互引用。
多个文档组合成一个collections，组合具有相似功能的文档。
MongoDB数据存储在collections，collection像MySQL的表，但是schema free、支持全文索引

4、DB的创建与删除

use DATABASE_NAME //如果数据库不存在，则创建数据库，否则切换到指定数据库。
db 命令验证当前在用的db
show dbs //查看所有db

db.testdb.insert({"name":"firsttime"}) //第一次创建的db，使用show dbs看不到，插入一条数据后就可以看到了
> use test
switched to db test
> db.dropDatabase() //删除数据库
{ "dropped" : "test", "ok" : 1 }
> show dbs
admin   0.000GB
col     0.000GB
config  0.000GB
local   0.000GB

> show collections
col
coll
> db.coll.drop()  //删除collections 
true
> show collections  //使用show tables也可以的
col

5、集合的创建与删除

db.createCollection(name, options)
name: 要创建的集合名称
options: 可选参数, 指定有关内存大小及索引的选项

options 可以是如下参数：
图1：

在插入文档时，MongoDB 首先检查固定集合的 size 字段，然后检查 max 字段。

> db.createCollection("col1")
{ "ok" : 1 }
> show collections
col1

> db.createCollection("col2",{ capped:true,autoIndexId:true,size:6142800,max:10000})
{
    "note" : "the autoIndexId option is deprecated and will be removed in a future release",
    "ok" : 1
}

在 MongoDB 中，你不需要创建集合。当你插入一些文档时，MongoDB 会自动创建集合。

> db.col2.insert({"name":"testcoll"})
WriteResult({ "nInserted" : 1 })
> show collections
col2

db.collection.drop() //删除
show tables //也可以看到collections

6、插入文档(insert)

所有存储在集合中的数据都是BSON格式。
BSON是一种类json的一种二进制形式的存储格式,简称Binary JSON。

db.COLLECTION_NAME.insert(document)
db.col.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})

//如果当前db中没有col这个集合，MongoDB将会创建该集合并插入文档
db.col.find() //db.col.find().pretty()这样显示更好看点

{ "_id" : ObjectId("5adca2da0ea27e685086ab8c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "MongoDB中文网", "url" : "http://www.mongodb.org.cn", "tags" : [ "mongodb", "database", "NoSQL" ], "likes" : 100 }

通过自定义变量的方式进行插入

document=({title:'hello world',
    description:'world is so beautiful',
    by: 'Mine',
    url: 'http://localhost.com',
    tags: ['mongodb','database','nosql','newsql'],
    likes: 100
});
{
    "title" : "hello world",
    "description" : "world is so beautiful",
    "by" : "Mine",
    "url" : "http://localhost.com",
    "tags" : [
        "mongodb",
        "database",
        "nosql",
        "newsql"
    ],
    "likes" : 100
}

db.col.insert(document)
WriteResult({ "nInserted" : 1 })
插入文档你也可以使用 db.col.save(document) 命令。如果不指定 _id 字段 save() 方法类似于 insert() 方法。如果指定 _id 字段，则会更新该 _id 的数据。

3.2 版本后还有以下几种语法可用于插入文档:
db.collection.insertOne():向指定集合中插入一条文档数据
db.collection.insertMany():向指定集合中插入多条文档数据
插入单条数据

var document = db.collection.insertOne({"a": 3})  //插入collection这个"表"并且赋值给变量document
document
{
    "acknowledged" : true,
    "insertedId" : ObjectId("571a218011a82a1d94c02333")  //
}
db.collection.find() //验证是否插入

插入多条数据
注：db.collection.insertMany([{"b": 3}, {'c': 4}]) //插入记录
var res = db.collection.insertMany([{"b": 3}, {'c': 4}]) //插入并赋值给变量

res
{
    "acknowledged" : true,
    "insertedIds" : [
        ObjectId("571a22a911a82a1d94c02337"),
        ObjectId("571a22a911a82a1d94c02338")
    ]
}

注：{}是一个document,[]里面可以有多个document。

7、更新文档(update)

语法格式：

db.collection.update(
   ,
   ,
   {
     upsert: ,
     multi: ,
     writeConcern: 
   }
)

query : update的查询条件，类似sql update查询内where后面的。
update : update的对象和一些更新的操作符（如$,$inc...）等，也可以理解为sql update查询内set后面的
upsert : 可选，这个参数的意思是，如果不存在update的记录，是否插入objNew,true为插入，默认是false，不插入。
multi : 可选，mongodb 默认是false,只更新找到的第一条记录，如果这个参数为true,就把按条件查出来多条记录全部更新。
writeConcern :可选，抛出异常的级别

异常级别：
WriteConcern.NONE:没有异常抛出
WriteConcern.NORMAL:仅抛出网络错误异常，没有服务器错误异常
WriteConcern.SAFE:抛出网络错误异常、服务器错误异常；并等待服务器完成写操作。
WriteConcern.MAJORITY: 抛出网络错误异常、服务器错误异常；并等待一个主服务器完成写操作。
WriteConcern.FSYNC_SAFE: 抛出网络错误异常、服务器错误异常；写操作等待服务器将数据刷新到磁盘。
WriteConcern.JOURNAL_SAFE:抛出网络错误异常、服务器错误异常；写操作等待服务器提交到磁盘的日志文件。
WriteConcern.REPLICAS_SAFE:抛出网络错误异常、服务器错误异常；等待至少2台服务器完成写操作。

插入数据：
db.stu.insert({name:'xiaohong',ip:'127.0.0.1',age:'25',seletest:'ziqiangbuxi',love:'basketball'})
db.stu.insert({name:'xiaoming',ip:'127.0.0.2',age:'23',seletest:'love self',love:'tee'})
db.stu.insert({name:'xiaogang',ip:'127.0.0.3',age:'24',love:'pingpong'})
db.stu.insert({"name" : "xiaohong", "ip" : "127.0.0.5", "age" : "24", "love" : "xiaohong2"})
db.stu.insert({name:"xiaoqiang",ip:"127.0.0.5",age:"26",love:"xiaohong2"})

basketball爱好改为diaoyu //下面两种方式都可以的

> db.stu.update({'love':'basketball'},{$set:{'love':'diaoyu'}})
> db.stu.update({'name':'xiaohong'},{$set:{'love':'diaoxiaoyu'}})
以上语句只会修改第一条发现的文档，如果你要修改多条相同的文档，则需要设置 multi 参数为 true。

示例:25岁的love都改为“tee"
> db.stu.update({'age':'24'},{$set:{'lovee':'tee'}},{multi:true}) //没有这个字段会自动添加

save() 方法更新文档

db.collection.save(
   ,
   {
     writeConcern: 
   }
)

document : 文档数据。
writeConcern :可选，抛出异常的级别。

> db.stu.find().pretty()
...
{
    "_id" : ObjectId("5aed3b6887388e6d32e3c726"),
    "name" : "xiaoqiang",
    "ip" : "127.0.0.5",
    "age" : "26",
    "love" : "xiaohong2"
}
...
> db.stu.save({
... "_id" : ObjectId("5aed3b6887388e6d32e3c726"),
... "name" : "xiaoqiang",
... "ip" : "127.0.0.5",
... "age" : "26",
... "love" : "selfcontrol"})
> db.stu.find().pretty()

{
    "_id" : ObjectId("5aed3b6887388e6d32e3c726"),
    "name" : "xiaoqiang",
    "ip" : "127.0.0.5",
    "age" : "26",
    "love" : "selfcontrol"
}

更多的参考案例：
只更新第一条记录：db.stu.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } );
全部更新：db.stu.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true ); //upsert为false,multi为false，存在才会更新，更新所有满足条件并且存在该字段的
只添加第一条：db.stu.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false ); //
全部添加加进去: db.stu.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true );
全部更新：db.stu.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true );
只更新第一条记录：db.stu.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false );

db.collection.updateOne() 向指定集合更新单个文档
db.collection.updateMany() 向指定集合更新多个文档

use stu
db.stu_col1.insert( [
{"name":"abc","age":"25","status":"zxc"},
{"name":"dec","age":"19","status":"qwe"},
{"name":"asd","age":"30","status":"nmn"},
] )

更新单个文档
> db.stu_col1.updateOne({"name":"abc"},{$set:{"age":"28"}})
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
> db.stu_col1.find()
{ "_id" : ObjectId("59c8ba673b92ae498a5716af"), "name" : "abc", "age" : "28", "status" : "zxc" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b0"), "name" : "dec", "age" : "19", "status" : "qwe" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b1"), "name" : "asd", "age" : "30", "status" : "nmn" }
>

更新多个文档
> db.stu_col1.updateMany({"age":{$gt:"10"}},{$set:{"status":"xyz"}})
{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
> db.stu_col1.find()
{ "_id" : ObjectId("59c8ba673b92ae498a5716af"), "name" : "abc", "age" : "28", "status" : "xyz" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b0"), "name" : "dec", "age" : "19", "status" : "xyz" }
{ "_id" : ObjectId("59c8ba673b92ae498a5716b1"), "name" : "asd", "age" : "30", "status" : "xyz" }
>

update常用的操作：

$inc:增大指定字段的值：db.collection.update({field:value},{$inc:{field1:amount}}})  //"field:value"是query内容，amount是调整大小
$rename:更改字段名：{$rename:{:,:,...}}
$set:修改字段的值为新的值：db.collection.update({field:value1},{$set:{field1:value2}})
$unset:db.collection.update({field:value1},{$unset:{field1:" "}})

name为“wolf"的index增加2：
test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }
test_set:PRIMARY> db.testCon.update({"name":"wolf"},{$inc:{"index":2}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 7 }

更新name为jack的url和name字段名分别为extra和huaming：
test_set:PRIMARY> db.testCon.insert({"name":"jack","index":"15","url":"www.jack.com"})
test_set:PRIMARY> db.testCon.update({"name":"jack"},{$rename:{'url':'extra','name':'huaming'}})
{ "_id" : ObjectId("5aee8e31a8232742f456fffa"), "index" : "15", "extra" : "www.jack.com", "huaming" : "jack" }

删除index为15的“huaming”字段：
{ "_id" : ObjectId("5aee8e31a8232742f456fffa"), "index" : "15", "extra" : "www.jack.com", "huaming" : "jack" }
test_set:PRIMARY> db.testCon.update({"index":"15"},{$unset:{"huaming":"jack"}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })
test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aee8e31a8232742f456fffa"), "index" : "15", "extra" : "www.jack.com" }

8、删除文档(remove)

remove的基本语法：

db.collection.remove(
   ,
   
)

2.6版本之后的新语法：

db.collection.remove(
   ,
   {
     justOne: ,
     writeConcern: 
   }
)

query :（可选）删除的文档的条件。
justOne : （可选）如果设为 true 或 1，则只删除一个文档。
writeConcern :（可选）抛出异常的级别。

> db.testcol.find({acknowledged:true})  //remove的时候尽量先find，key和value可以不加" "
{ "_id" : ObjectId("5aed244587388e6d32e3c71d"), "acknowledged" : true, "insertedIds" : [ ObjectId("5aed242487388e6d32e3c71b"), ObjectId("5aed242487388e6d32e3c71c") ] }
> db.testcol.remove({acknowledged:true})
WriteResult({ "nRemoved" : 1 })

>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1) //只删除第一条找到的记录
>db.col.remove({}) //删除所有数据

remove() 方法已经过时了，现在官方推荐使用 deleteOne() 和 deleteMany() 方法。
> db.testcol.deleteMany({d:{$gt:10}})
{ "acknowledged" : true, "deletedCount" : 2 }
> db.testcol.deleteOne({d:{$gt:12}})
{ "acknowledged" : true, "deletedCount" : 1 }
db.testcol.deleteMany({})
{ "acknowledged" : true, "deletedCount" : 5 }

二、查询文档

1、查询文档

db.collection.find(query, projection)
query ：可选，使用查询操作符指定查询条件
projection ：可选，使用投影操作符指定返回的键。查询时返回文档中所有键值，只需省略该参数即可（默认省略）。
除了 find() 方法之外，还有一个 findOne() 方法，它只返回一个文档。

MongoDB 与 RDBMS Where 语句比较
图2

2、and条件：

>db.col.find({key1:value1, key2:value2}).pretty()
> db.stu_col1.find({"age":{$gt:"20"},"name":"abc"})

> db.stu_col1.find()
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c728"), "name" : "dec", "age" : "19", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd", "age" : "30", "status" : "xyz" }

错误的两种写法
> db.stu_col1.find({status:xyz})  //这样是不行的
2018-05-05T15:11:32.374+0800 E QUERY    [thread1] ReferenceError: xyz is not defined :
@(shell):1:19
> db.stu_col1.find({"status":xyz})
2018-05-05T15:12:28.324+0800 E QUERY    [thread1] ReferenceError: xyz is not defined :
@(shell):1:19

正确的写法
> db.stu_col1.find({status:"xyz"})
> db.stu_col1.find({"status":"xyz"})  //推荐
> db.stu_col1.find({"age":{$gt:"20"}})

3、or条件：

>db.col.find(
   {
      $or: [
         {key1: value1}, {key2:value2}
      ]
   }
).pretty()
> db.stu_col1.find({$or:[{"name":"abc"},{"age":{$gt:"25"}}]}).pretty() //一样
> db.stu_col1.find({
$or:[
    {"name":"abc"},{"age":{$gt:"25"}}
    ]
}).pretty()
{
    "_id" : ObjectId("5aed469c87388e6d32e3c727"),
    "name" : "abc",
    "age" : "25",
    "status" : "xyz"
}
{
    "_id" : ObjectId("5aed469c87388e6d32e3c729"),
    "name" : "asd",
    "age" : "30",
    "status" : "xyz"
}

and和or联用：

> db.stu_col1.find()
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c728"), "name" : "dec", "age" : "19", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd", "age" : "30", "status" : "xyz" }
> db.stu_col1.find({"age":{$gte:"25"},$or:[{"name":"abc"},{"name":"age"}]})
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }

4、projection操作：

db.collection.find(query, projection)

_id 键默认返回，需要主动指定 _id:0 才会隐藏

两种模式不可混用（因为这样的话无法推断其他键是否应返回）

db.collection.find(query, {title: 1, by: 0}) //错误,只能全1或全0。除了在inclusion模式时可以指定_id为0
db.collection.find(query, {_id:0, title: 1, by: 1}) // 正确

> db.stu_col1.find({"age":{$gt:"20"}}) //默认返回所有
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd", "age" : "30", "status" : "xyz" }

db.collection.find(query, {title: 1, by: 1}) // inclusion模式 指定返回的键，不返回其他键
db.collection.find(query, {title: 0, by: 0}) // exclusion模式 指定不返回的键,返回其他键
> db.stu_col1.find({"age":{$gt:"20"}},{title:1,by:1}) //只返回"_id"
{ "_id" : ObjectId("5aed469c87388e6d32e3c727") }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729") }
> db.stu_col1.find({"age":{$gt:"20"}},{title:0,by:0})
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd", "age" : "30", "status" : "xyz" }

> db.stu_col1.find({"age":{$gt:"20"}},{name:1,title:1,by:1}) //显示name和_id字段
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd" }
> db.stu_col1.find({"age":{$gt:"20"}},{_id:0,title:0,by:0})  //不显示_id字段
{ "name" : "abc", "age" : "25", "status" : "xyz" }
{ "name" : "asd", "age" : "30", "status" : "xyz" }

> db.stu_col1.find({},{_id:0,title:0,by:0})  //query的内容可以用{} 填充
{ "name" : "abc", "age" : "25", "status" : "xyz" }
{ "name" : "dec", "age" : "19", "status" : "xyz" }
{ "name" : "asd", "age" : "30", "status" : "xyz" }

5、not和nor

not表达式:"{field:{$not:{}}}"
nor表达式:"{field:{$nor:[ {expression-1}, {expression-2},....]}}"

查找index不大于1(小于等于1)的值

test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }
test_set:PRIMARY> db.testCon.find({"index":{$not:{$gt:1}}})
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
查找name不是以"J"开头的
test_set:PRIMARY> db.testCon.find({name:{$not:/^J.*/}})  //注意"/^J.*/"不加“ ”
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }
$not操作符不支持$regex正则表达式操作，使用//或者你的驱动接口代替

index为2和name为"Joe"的并集在全集中取反
test_set:PRIMARY> db.testCon.find({$nor:[{"index":2},{"name":"Joe"}]})
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }
{ "_id" : ObjectId("5aee73a0a8232742f456fff8"), "name" : "tom", "index" : 12 }

6、条件操作符

(>) 大于 - $gt
(<) 小于 - $lt
(>=) 大于等于 - $gte
(<= ) 小于等于 - $lte
in 在指定范围内
nin 不在指定范围内

$gt -------- greater than  >
$gte --------- gt equal  >=
$lt -------- less than  <
$lte --------- lt equal  <=
$ne ----------- not equal  !=
$eq  --------  equal  =

组合使用：
> db.stu_col1.find({"age":{$gt:"20",$lt:"30"}},{_id:0,title:0,by:0}) //20-30之间的
{ "name" : "abc", "age" : "25", "status" : "xyz" }
> db.stu_col1.find({$or:[{"age":{$gt:"25"}},{"age":{$lt:"20"}}]})  //小于20或者大于25的
> db.stu_col1.find({$or:[{"age":{$gt:"25"}},{"age":{$lt:"20"}}]},{_id:0,title:0,by:0})
in用法
test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }
test_set:PRIMARY> db.testCon.find({"index":{$in:[1,2,3]}})
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }
test_set:PRIMARY> db.testCon.find({"index":{$nin:[1,2,3]}})
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }
test_set:PRIMARY> db.testCon.find({"name":{$nin:["wolf","tom"]}})
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }

7、元素查询type,exists,mod

type:
{field:{$type:}}
$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。
图3：

> db.stu_col1.find({"age":{$type:2}})  
> db.stu_col1.find({"age":{$type:2}},{_id:0,title:0,by:0})
{ "name" : "abc", "age" : "25", "status" : "xyz" }
{ "name" : "dec", "age" : "19", "status" : "xyz" }
{ "name" : "asd", "age" : "30", "status" : "xyz" }

exists:

{field:{$exists:}} //指定boolean的值为true返回指定字段的文档，“false"返回不存在指定的文档
test_set:PRIMARY> db.testCon.insert({"name":"baidu","url":"www.baidu.com"})
test_set:PRIMARY> db.testCon.find({url:{$exists:true}})
{ "_id" : ObjectId("5aee8966a8232742f456fff9"), "name" : "baidu", "url" : "www.baidu.com" }
{ "_id" : ObjectId("5aee8966a8232742f456fff9"), "name" : "baidu", "url" : "www.baidu.com" }
test_set:PRIMARY> db.testCon.find({url:{$exists:0}})
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }
{ "_id" : ObjectId("5aee73a0a8232742f456fff8"), "name" : "tom", "index" : 12 }
test_set:PRIMARY> db.testCon.find({url:{$exists:1}})
{ "_id" : ObjectId("5aee8966a8232742f456fff9"), "name" : "baidu", "url" : "www.baidu.com" }

注：其中boolean可以是0和1，或者true和false

mod:
{field:{$mod:[divisor,remainder]}} //取模运算
取出index对2取模余1的内容
test_set:PRIMARY> db.testCon.find({index:{$mod:[2,1]}})
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aee6f5fa8232742f456fff7"), "name" : "wolf", "index" : 5 }

8、limit和skip用法

>db.COLLECTION_NAME.find().limit(NUMBER)
> db.stu_col1.find().limit(1)
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }

> db.stu_col1.find({},{"_id":0,"title":0,"by":0})
{ "name" : "abc", "age" : "25", "status" : "xyz" }
{ "name" : "dec", "age" : "19", "status" : "xyz" }
{ "name" : "asd", "age" : "30", "status" : "xyz" }
> db.stu_col1.find({},{"_id":0,"title":0,"by":0}).limit(1).skip(1)
{ "name" : "dec", "age" : "19", "status" : "xyz" }

三、聚合排序索引

1、排序(sort)

>db.COLLECTION_NAME.find().sort({KEY:1}) //其中 1 为升序排列，而-1是用于降序排列。
> db.stu_col1.find({},{_id:0,title:0,by:0}).sort({"age":1})
{ "name" : "dec", "age" : "19", "status" : "xyz" }
{ "name" : "abc", "age" : "25", "status" : "xyz" }
{ "name" : "asd", "age" : "30", "status" : "xyz" }
> db.stu_col1.find({},{_id:0,title:0,by:0}).sort({"age":-1})
{ "name" : "asd", "age" : "30", "status" : "xyz" }
{ "name" : "abc", "age" : "25", "status" : "xyz" }
{ "name" : "dec", "age" : "19", "status" : "xyz" }

2、索引(ensureIndex)

如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。
索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构
mongodb的索引是collection级别的，可以建立在any field或者sub-field
索引类型：
单键索引(Single field Indexes)：MongoDB默认创建的_id的索引就是单键索引。
复合索引(Compound Indexes)：在多个键上建立的索引
多键索引(MultiKey indexes)：如果在一个数组上面创建索引，MongoDB会自己决定，是否要把这个索引建成多键索引。
地理空间索引(Geospatial Indexes and Queries)：
全文索引(Text Indexes):
哈希索引(hash indexes):

2.1、单键索引：

db.users.ensureIndex( { "score" : 1 } )  //单键索引 
{
    _id: ObjectId(...),
    metro: {
        city: "New York",
        state: "NY"
    },
    name: "Giant Factory"
}

db.factories.ensureIndex( { metro: 1 } )
db.factories.find( { metro: { city: "New York", state: "NY" } } ) //可以找到
db.factories.find( { metro: { state: "NY", city: "New York" } } ) //找不到，子文档的查找必须是精确匹配，包括子文档中的顺序

2.2、复合索引：

db.products.ensureIndex( { "userid": -1, "score": 1 } ) //userid是正序排列，score是逆序排列的
这个索引可以支持如下的排序
db.products.find().sort( { userid: 1, score: -1 } )；
db.products.find().sort( { userid: -1, score: 1 } )；
db.products.find().sort( { userid: 1 } )；
db.products.find().sort( { userid: -1 } )；

不能支持如下的排序：
db.products.find().sort( { userid: 1, score: 1 } )；
db.products.find().sort( { userid: -1, score: -1 } )；
db.products.find().sort( { score: 1 } )；
db.products.find().sort( { score: -1 } )；

2.3、多键索引(Multikey Index):
如果在一个数组上面创建索引，MongoDB会自己决定，是否要把这个索引建成多键索引。
{a: [1, 2], b: 1}
{a: 1, b: [1, 2]}
db.feedback.find( { "comments.text": "Please expand the olive selection." } )

多个字段创建索引

>db.stu_col1.ensureIndex({"_id":1,"name":-1})

图4：

在一个数组上面创建索引，MongoDB会自己决定，是否要把这个索引建成多键索引。

{
    "_id" : ObjectId("..."),
    "name" : "Warm Weather",
    "author" : "Steve",
    "tags" : [ "weather", "hot", "record", "april" ]
}

//在tags上创建索引，就会创建出多键索引
和

{
    "_id": ObjectId(...),
    "title": "Grocery Quality",
    "comments": [{
        author_id: ObjectId(...),
        date: Date(...),
        text: "Please expand the cheddar selection."
    }, {
        author_id: ObjectId(...),
        date: Date(...),
        text: "Please expand the mustard selection."
    }, {
        author_id: ObjectId(...),
        date: Date(...),
        text: "Please expand the olive selection."
    }]
}

创建{ "comments.text": 1 } 索引也会是多键索引，且在如下查找语句中有效：
db.feedback.find( { "comments.text": "Please expand the olive selection." } )

2.4、地理空间索引：

2dsphere 允许使用GeoJSON格式（http://www.geojson.org）指定点、线和多边形。
点可以用形如[longitude, latitude]（[经度，纬度]）的两个元素的数组表示：

{
    "name" : "New York City",
    "loc" : {
        "type" : "Point",
        "coordinates" : [50, 2]
    }
}

线可以用一个由点组成的数组来表示：

{
    "name" : "Hudson River",
    "loc" : {
        "type" : "LineString",
        "coordinates" : [[0, 1], [0, 2], [1, 2]]
    }
}

多边形是由线组成的数组来表示：

{
    "name" : "New England",
    "loc" : {
        "type" : "Polygon",
        "coordinates" : [[[0, 1], [0, 2], [1, 2], [0, 1]]]
    }
}

2dsphere 支持 Point、MultiPoint、LineString、MultiLineString、Polygon、MultiPolygon、Geometry Collection
loc 字段的名字可以是任意的，但是其中子对象是由 GeoJSON 指定的，不能改变。
在 ensureIndex 中使用 2dsphere 选项就可以创建一个地理空间索引：
db.world.ensureIndex({"loc": "2dsphere"})

可以使用多种不同的地理空间查询：交集（intersection）、包含（within）以及接近（nearness）。查询时，需要将希望查找的内容指定为形如 {"$geometry":geoJsonDesc} 的 GeoJSON 对象。
交集（intersection），使用 $geoIntersects 操作符：

var place = {
    "type" : "Polygon",
    "coordinates" : [[[0, 1], [0, 3], [50, 2], [0, 1]]]
}

db.world.find({"loc" : {"$geoIntersects" : {"$geometry" : place}}})
会查找出所有与 place 有交集的文档。
包含（within），使用 $within 或者 $geoWithin 操作符：
db.world.find({"loc" : {"$within" : {"$geometry" : place}}})

接近（nearness），使用 $near 或者 $geoNear 操作符：

var place = {
    "type" : "Point",
    "coordinates" : [0, 3]
}

db.world.find({"loc" : {"$near" : {"$geometry" : place}}})
place 必须是个点，$near 是唯一一个会对查询结果进行自动排序的地理空间操作符，$near 的返回结果是按照距离由近及远排序的。

2.5、全文索引

全文索引用于在文档中搜索文本也可以使用正则表达式来查询字符串，但是当文本块比较大的时候，正则表达式搜索会非常慢，而且无法处理语言理解的问题（如 entry 和 entries 应该算是匹配的）。
使用全文索引可以非常快地进行文本搜索，就如同内置了多种语言分词机制的支持一样。创建索引的开销都比较大，全文索引的开销更大。创建索引时，需后台或离线创建。

{
    "_id" : ObjectId("55a0e30427c9370e525032e9"),
    "content" : "This morning I had a cup of coffee.",
    "about" : "beverage",
    "keywords" : [
        "coffee"
    ]
}
db.article.ensureIndex({"content": "text"} //创建全文索引
db.article.ensureIndex({"content": "text"}, {"default_language": "spanish"}) //指定语言
db.article.find({"$text": {"$search": "coffee"}}) //使用全文索引查询

###$ 2.6、hash索引
哈希索引可以支持相等查询，但是哈希索引不支持范围查询。您可能无法创建一个带有哈希索引键的复合索引或者对哈希索引施加唯一性的限制。但是，您可以在同一个键上同时创建一个哈希索引和一个递增/递减(例如，非哈希)的索引，这样MongoDB对于范围查询就会自动使用非哈希的索引。
db.article.ensureIndex({"a": "hashed"})

2.7、索引属性

MongDB的索引属性有以下几种：TTL索引、唯一索引和稀疏索引。
TTL索引是一种特殊索引，通过这种索引MongoDB会过一段时间后自动移除集合中的文档。
TTL索引有如下限制：
它不支持复合索引。
被索引键必须是日期类型的数据。
如果这个键存储的是一个数组，且在索引中有多个日期类型的数据(和一篇文档关联)，那么当其中最低 (比如，最早)过期阀值得到匹配时，这篇文档就会过期失效了。
TTL索引不能保证过期数据会被立刻删除。在文档过期和MongoDB从数据库中删除文档之间，可能会有延迟。
删除过期数据的后台任务每隔60秒运行一次。所以，在文档过期之后和后台任务运行或者结束之前，文档会依然存在于集合中。删除操作的持续实际取决于您的 mongod 实例的负载。
因此，在两次后台任务运行的间隔间，过期数据可能会继续留在数据库中超过60秒。在其他方面，TTL索引是普通索引，并且如果可以的话，MongoDB会使用这些索引来匹配任意查询。
db.token.ensureIndex({"lastUpdated": 1}, {"expireAfterSecs": 606024}) //token 超过24小时就会被删除掉。

> db.log_events.createIndex({"createdAt": 1},{expireAfterSeconds: 60}) //60s后到期
插入文档
> db.log_events.insert({
    "createdAt": new Date(),
    "logEvent": 2,
    "logMessage": "Success!"
})
> db.log_events.find() //时间段后查看

** 指定过期时间：**
> db.ttl.createIndex({"expireAt": 1},{expireAfterSeconds:0}) 
插入数据：
> db.ttl.insert({
    "createdAt": new Date('Mar 11, 2016 09:30:00'),
    "logEvent": 2,
    "logMessage": "Success!"
})

使用TTL时是有限制的：

-如果要索引的字段已经在其他索引中使用，不能创建TTL索引
-索引不能包含多个字段
-如果定义的字段不存在，则永不过期
-不能对capped集合创建TTL索引

唯一索引(Unique Indexes)
db.members.ensureIndex({"user_id": 1}, {unique: true}) //默认为false
唯一索引可以防止不同文档的被索引键上存储相同值，但是它不禁止同一篇文档在被索引键存储的数组里存储的元素或者内嵌文档是相同的值。在同一篇文档存储重复数据的情况下，重复的值只会被存入索引一次。

db.collection.ensureIndex({"a.b": 1 }, {unique: true})
假如在集合中没有其他的文档的 a.b 键的值是 5 ，那么唯一索引将会允许将以下文档插入集合：
db.collection.insert({a: [{b: 5}, {b: 5}]})

如果一篇文档不包含唯一索引的被索引键，那么索引默认会为该文档存储一个null值。
由于唯一性的限制，MongoDB将只允许有一篇可以不包含被索引键。如果超过一篇文档不包含被索引键或没有值，那么会抛出键重复(duplicate key)错误导致索引创建失败。可以组合使用唯一性和稀疏索引的特性来过滤那些包含null值的文档以避免这个错误。

稀疏索引(Sparse Indexes)
稀疏索引会跳过所有不包含被索引键的文档。这个索引之所以称为 “稀疏” 是因为它并不包括集合中的所有文档。与之相反，非稀疏的索引会索引每一篇文档，如果一篇文档不含被索引键则为它存储一个null值。
db.addresses.ensureIndex({"xmpp_id": 1}, {"sparse": true})
如果一个索引会导致查询或者排序的结果集是不完整的，那么MongoDB将不会使用这个索引，除非用户使用 hint() 方法来显示指定索引。例如，查询 { x: { $exists: false } } 将不会使用 x 键上的稀疏索引，除非显示的hint。
2dsphere (version 2), 2d 和 text 这些索引总是稀疏的。
只要一篇文档里有至少一个被索引键，稀疏且只包含有递增/递减索引键的复合索引就会索引这篇文档。
至于稀疏且包含有地理索引键(例如 2dsphere, 2d)以及递增/递减索引键的复合索引，只有地理索引键的存在与否能决定一篇文档是否被索引。
至于稀疏且包含了全文索引键和其他递增/递减索引键的复合索引，只有全文索引键的存在与否能决定是否索引该文档。
一个稀疏且唯一的索引，可以防止集合中的文档被索引键中出现重复值，同时也允许多个文档里不包含被索引键。

3、聚合

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。
db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)
图5：

管道：
一般用于将当前命令的输出结果作为下一个命令的参数。
MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。
表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。

    $project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。
    $match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。
    $limit：用来限制MongoDB聚合管道返回的文档数。
    $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。
    $unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。
    $group：将集合中的文档分组，可用于统计结果。
    $sort：将输入文档排序后输出。
    $geoNear：输出接近某一地理位置的有序文档。

db.getCollection('test').aggregate({"$group":{_id: 'max',max_value:{"$max":"$search_frequency"}}});

> db.stu_col1.aggregate({"$group":{_id:"max",max_value:{"$max":"$age"}}})
{ "_id" : "max", "max_value" : "30" }

> db.stu_col1.find()
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c728"), "name" : "dec", "age" : "19", "status" : "xyz" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd", "age" : "30", "status" : "xyz" }
{ "_id" : ObjectId("5aed90661a944c8f36d7b8f3"), "name" : "aaa", "age" : "128", "power" : "120" }
{ "_id" : ObjectId("5aed90c61a944c8f36d7b8f4"), "name" : "aaa", "age" : "128", "power" : "120" }
{ "_id" : ObjectId("5aed90c61a944c8f36d7b8f5"), "name" : "ggg", "age" : "120", "shuxing" : "huo" }

> db.stu_col1.aggregate({"$group":{_id: 'max',max_value:{"$max":"$age"}}});

> db.test.find()
{ "_id" : "A", "company_name" : "公司A", "search_frequency" : 212 }
{ "_id" : "B", "company_name" : "公司B", "search_frequency" : 160 }
{ "_id" : "C", "company_name" : "公司C", "search_frequency" : 553 }

> db.test.aggregate({"$group":{_id: 'min',min_value:{"$min":"$search_frequency"}}});
{ "_id" : "min", "min_value" : 160 }
> db.test.aggregate({"$group":{_id: 'max',max_value:{"$max":"$search_frequency"}}});
{ "_id" : "max", "max_value" : 553 }
> db.test.aggregate({"$group":{_id: 'sum',sum_value:{"$sum":"$search_frequency"}}});
{ "_id" : "sum", "sum_value" : 925 }
> db.test.aggregate({"$group":{_id: 'avg',avg_value:{"$avg":"$search_frequency"}}});
{ "_id" : "avg", "avg_value" : 308.3333333333333 }

project举例：
> db.stu_col1.aggregate({$project:{name:1,age:1}})
{ "_id" : ObjectId("5aed469c87388e6d32e3c727"), "name" : "abc", "age" : "25" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c728"), "name" : "dec", "age" : "19" }
{ "_id" : ObjectId("5aed469c87388e6d32e3c729"), "name" : "asd", "age" : "30" }
{ "_id" : ObjectId("5aed90661a944c8f36d7b8f3"), "name" : "aaa", "age" : "128" }
{ "_id" : ObjectId("5aed90c61a944c8f36d7b8f4"), "name" : "aaa", "age" : "128" }
{ "_id" : ObjectId("5aed90c61a944c8f36d7b8f5"), "name" : "ggg", "age" : "120" }
> db.stu_col1.aggregate({$project:{_id:0,name:1,age:1}}) //只显示name和age
{ "name" : "abc", "age" : "25" }
{ "name" : "dec", "age" : "19" }
{ "name" : "asd", "age" : "30" }
{ "name" : "aaa", "age" : "128" }
{ "name" : "aaa", "age" : "128" }
{ "name" : "ggg", "age" : "120" }

四、副本集

1、副本集简介

复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性，并可以保证数据的安全性。
允许从硬件故障和服务中断中恢复数据。
mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。
mongodb各个节点常见的搭配方式为：一主一从、一主多从。
主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。

图6：

2、副本集特征：

N 个节点的集群
任何节点可作为主节点
所有写入操作都在主节点上
自动故障转移
自动恢复

3、配置

副本集设置：
#mongod --port=1200 --bind_ip=127.0.0.1 --dbpath=/mongodb/db1/ --logpath=/mongodb/db1/logs/db1.log --replSet test_set --logappend --fork
#mongod --port=1201 --bind_ip=127.0.0.1 --dbpath=/mongodb/db2/ --logpath=/mongodb/db2/logs/db2.log --replSet test_set --logappend --fork
#mongod --port=1202 --bind_ip=127.0.0.1 --dbpath=/mongodb/db3/ --logpath=/mongodb/db2/logs/db3.log --replSet test_set --logappend --fork
//要先初始化副本集

> rs.initiate({"_id":"test_set",members:[{"_id":1,"host":"127.0.0.1:1200","priority":9},{"_id":2,"host":"127.0.0.1:1201","priority":3},{"_id":3,"host":"127.0.0.1:1202","arbiterOnly":true}] })
{
    "ok" : 1,
    "operationTime" : Timestamp(1525528450, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1525528450, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

"_id": 副本集的名称
"members": 副本集的服务器列表
"_id": 服务器的唯一ID
"host": 服务器主机
"priority": 是优先级，默认为1，优先级0为被动节点，不能成为活跃节点。优先级不位0则按照有大到小选出活跃节点。
"arbiterOnly": 仲裁节点，只参与投票，不接收数据，也不能成为活跃节点。

test_set:PRIMARY> rs.status()
{
    "set" : "test_set",
    "date" : ISODate("2018-05-05T13:54:34.161Z"),
    "myState" : 1,
    "term" : NumberLong(1),
    "heartbeatIntervalMillis" : NumberLong(2000),
    "optimes" : {
        "lastCommittedOpTime" : {
            "ts" : Timestamp(1525528464, 1),
            "t" : NumberLong(1)
        },
        "readConcernMajorityOpTime" : {
            "ts" : Timestamp(1525528464, 1),
            "t" : NumberLong(1)
        },
        "appliedOpTime" : {
            "ts" : Timestamp(1525528464, 1),
            "t" : NumberLong(1)
        },
        "durableOpTime" : {
            "ts" : Timestamp(1525528464, 1),
            "t" : NumberLong(1)
        }
    },
    "members" : [
        {
            "_id" : 1,
            "name" : "127.0.0.1:1200",
            "health" : 1,
            "state" : 1,
            "stateStr" : "PRIMARY",
            "uptime" : 232,
            "optime" : {
                "ts" : Timestamp(1525528464, 1),
                "t" : NumberLong(1)
            },
            "optimeDate" : ISODate("2018-05-05T13:54:24Z"),
            "infoMessage" : "could not find member to sync from",
            "electionTime" : Timestamp(1525528461, 1),
            "electionDate" : ISODate("2018-05-05T13:54:21Z"),
            "configVersion" : 1,
            "self" : true
        },
        {
            "_id" : 2,
            "name" : "127.0.0.1:1201",
            "health" : 1,
            "state" : 2,
            "stateStr" : "SECONDARY",
            "uptime" : 23,
            "optime" : {
                "ts" : Timestamp(1525528464, 1),
                "t" : NumberLong(1)
            },
            "optimeDurable" : {
                "ts" : Timestamp(1525528464, 1),
                "t" : NumberLong(1)
            },
            "optimeDate" : ISODate("2018-05-05T13:54:24Z"),
            "optimeDurableDate" : ISODate("2018-05-05T13:54:24Z"),
            "lastHeartbeat" : ISODate("2018-05-05T13:54:33.563Z"),
            "lastHeartbeatRecv" : ISODate("2018-05-05T13:54:32.359Z"),
            "pingMs" : NumberLong(0),
            "syncingTo" : "127.0.0.1:1200",
            "configVersion" : 1
        },
        {
            "_id" : 3,
            "name" : "127.0.0.1:1202",
            "health" : 1,
            "state" : 7,
            "stateStr" : "ARBITER",
            "uptime" : 23,
            "lastHeartbeat" : ISODate("2018-05-05T13:54:33.562Z"),
            "lastHeartbeatRecv" : ISODate("2018-05-05T13:54:32.291Z"),
            "pingMs" : NumberLong(0),
            "configVersion" : 1
        }
    ],
    "ok" : 1,
    "operationTime" : Timestamp(1525528464, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1525528464, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

在主节点上插入数据，在从节点上查看。

test_set:PRIMARY>  for(var i=0; i<3;i++) db.testCon.insert({name:"Joe",index:i})
test_set:PRIMARY> db.testCon.find()
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }

test_set:SECONDARY> show dbs
2018-05-05T22:01:09.541+0800 E QUERY    [thread1] Error: listDatabases failed:{
    "operationTime" : Timestamp(1525528863, 1),
    "ok" : 0,
    "errmsg" : "not master and slaveOk=false",
    "code" : 13435,
    "codeName" : "NotMasterNoSlaveOk",
    "$clusterTime" : {
        "clusterTime" : Timestamp(1525528863, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
} :
_getErrorWithCode@src/mongo/shell/utils.js:25:13
Mongo.prototype.getDBs@src/mongo/shell/mongo.js:65:1
shellHelper.show@src/mongo/shell/utils.js:820:19
shellHelper@src/mongo/shell/utils.js:710:15
@(shellhelp2):1:1
test_set:SECONDARY> rs.slaveOk()
test_set:SECONDARY> show dbs
admin   0.000GB
config  0.000GB
local   0.000GB
test    0.000GB

test_set:SECONDARY> db.testCon.find()  //已经同步
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9e"), "name" : "Joe", "index" : 0 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaa9f"), "name" : "Joe", "index" : 1 }
{ "_id" : ObjectId("5aedb8b3aa48b68a53ecaaa0"), "name" : "Joe", "index" : 2 }
test_set:SECONDARY> db.testCon.insert({"name":"jan","index":"3"})  //slave节点没有insert权限的
WriteResult({ "writeError" : { "code" : 10107, "errmsg" : "not master" } })

模拟主节点故障：
kill掉对应的进程
rs.status()
"stateStr" : "(not reachable/healthy)",

重新启动后，又被恢复为"primary"因为优先级高 //如果启动失败：删除掉 db文件夹下的mongod.lock文件

增加和删除节点：

mongod --port=1203 --bind_ip=127.0.0.1 --dbpath=/mongodb/db4/ --logpath=/mongodb/db4/logs/db4.log --replSet test_set --logappend --fork
test_set:PRIMARY> rs.add("127.0.0.1:1203")  //primary中操作，"_id"自动设置为4
test_set:PRIMARY> rs.status()
{
    "set" : "test_set",
    "date" : ISODate("2018-05-05T14:13:12.848Z"),
    "myState" : 1,
    "term" : NumberLong(3),
    "heartbeatIntervalMillis" : NumberLong(2000),
    "optimes" : {
        "lastCommittedOpTime" : {
            "ts" : Timestamp(1525529585, 1),
            "t" : NumberLong(3)
        },
        "readConcernMajorityOpTime" : {
            "ts" : Timestamp(1525529585, 1),
            "t" : NumberLong(3)
        },
        "appliedOpTime" : {
            "ts" : Timestamp(1525529585, 1),
            "t" : NumberLong(3)
        },
        "durableOpTime" : {
            "ts" : Timestamp(1525529585, 1),
            "t" : NumberLong(3)
        }
    },
    "members" : [
        {
            "_id" : 1,
            "name" : "127.0.0.1:1200",
            "health" : 1,
            "state" : 1,
            "stateStr" : "PRIMARY",
            "uptime" : 340,
            "optime" : {
                "ts" : Timestamp(1525529585, 1),
                "t" : NumberLong(3)
            },
            "optimeDate" : ISODate("2018-05-05T14:13:05Z"),
            "electionTime" : Timestamp(1525529263, 1),
            "electionDate" : ISODate("2018-05-05T14:07:43Z"),
            "configVersion" : 2,
            "self" : true
        },
        {
            "_id" : 2,
            "name" : "127.0.0.1:1201",
            "health" : 1,
            "state" : 2,
            "stateStr" : "SECONDARY",
            "uptime" : 339,
            "optime" : {
                "ts" : Timestamp(1525529585, 1),
                "t" : NumberLong(3)
            },
            "optimeDurable" : {
                "ts" : Timestamp(1525529585, 1),
                "t" : NumberLong(3)
            },
            "optimeDate" : ISODate("2018-05-05T14:13:05Z"),
            "optimeDurableDate" : ISODate("2018-05-05T14:13:05Z"),
            "lastHeartbeat" : ISODate("2018-05-05T14:13:12.176Z"),
            "lastHeartbeatRecv" : ISODate("2018-05-05T14:13:12.178Z"),
            "pingMs" : NumberLong(0),
            "syncingTo" : "127.0.0.1:1200", //同步1200端口
            "configVersion" : 2
        },
        {
            "_id" : 3,
            "name" : "127.0.0.1:1202",
            "health" : 1,
            "state" : 7,
            "stateStr" : "ARBITER",
            "uptime" : 339,
            "lastHeartbeat" : ISODate("2018-05-05T14:13:12.176Z"),
            "lastHeartbeatRecv" : ISODate("2018-05-05T14:13:12.178Z"),
            "pingMs" : NumberLong(0),
            "configVersion" : 2
        },
        {
            "_id" : 4,
            "name" : "127.0.0.1:1203",
            "health" : 1,
            "state" : 2,
            "stateStr" : "SECONDARY",
            "uptime" : 24,
            "optime" : {
                "ts" : Timestamp(1525529585, 1),
                "t" : NumberLong(3)
            },
            "optimeDurable" : {
                "ts" : Timestamp(1525529585, 1),
                "t" : NumberLong(3)
            },
            "optimeDate" : ISODate("2018-05-05T14:13:05Z"),
            "optimeDurableDate" : ISODate("2018-05-05T14:13:05Z"),
            "lastHeartbeat" : ISODate("2018-05-05T14:13:12.176Z"),
            "lastHeartbeatRecv" : ISODate("2018-05-05T14:13:12.384Z"),
            "pingMs" : NumberLong(0),
            "syncingTo" : "127.0.0.1:1201", //同步1201端口，而1201同步的是1200端口
            "configVersion" : 2
        }
    ],
    "ok" : 1,
    "operationTime" : Timestamp(1525529585, 1),
    "$clusterTime" : {
        "clusterTime" : Timestamp(1525529585, 1),
        "signature" : {
            "hash" : BinData(0,"AAAAAAAAAAAAAAAAAAAAAAAAAAA="),
            "keyId" : NumberLong(0)
        }
    }
}

test_set:PRIMARY> rs.remove("127.0.0.1:1203")  //删除该节点

参考博客：
http://www.mongodb.org.cn/manual/ //中文文档
https://docs.mongodb.com/manual/ //英文官方
https://www.cnblogs.com/CraryPrimitiveMan/p/4622899.html //索引

你可能感兴趣的:(MongoDB,mongodb详解,mongodb副本集,分布式FS/DB)

ElasticSearch简单介绍 herry_liang
ES简单介绍一、相关概念1、ElasticSearch2、集群（Cluster）3、节点（Node）二、端口关系三、NOSql非关系性数据库1、元素（1）索引（2）类型2、特点四、元素的语法1、Restful请求2、索引3、ES数据类型一、相关概念1、ElasticSearch一个开源的高扩展的分布式全文搜索引擎，实时的存储、检索。扩展性较好的ES服务器。2、集群（Cluster）由一个或者多个节
极客天成签署 CCLA，携手openEuler社区共拓信创AI新天地极客天成ScaleFlash 人工智能
近日，北京极客天成科技有限公司（以下简称“极客天成”）签署CCLA（CorporateContributorLicenseAgreement企业贡献者许可协议），正式加入openEuler开源社区。极客天成以高通量分布式集群存储为先锋，围绕软件定义、智能化、安全可靠，全链RDMA构建了完全自主可控的分布式存储产品线和解决方案，主要解决用户海量数据下的高性能低时延数据读写难题，可为用户的数据中心提供
中标 | 极客天成分布式存储软件成功中标华泰证券并行文件系统软件项目极客天成ScaleFlash 分布式
2023年9月21日，北京极客天成科技有限公司分布式存储软件V3.0通过代理商成功中标华泰证券并行文件系统软件项目。华泰证券并行文件系统软件项目是服务于华泰证券量化投研的重点项目,是华泰证券能否取得可持续性竞争优势的关键所在,华泰证券多年深耕信用量化投研领域，基于大数据、人工智能、NLP等技术自主研发。汇聚各类市场数据，研发量化模型，能够高效全面地进行信用风险分析和研究。北京极客天成科技有限公司分
Leetcode--Java--316. 去除重复字母前滩卷王 Leetcode 贪心栈思想
题目描述给你一个字符串s，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证返回结果的字典序最小（要求不能打乱其他字符的相对位置）。样例描述示例1：输入：s="bcabc"输出："abc"示例2：输入：s="cbacdcbc"输出："acdb"思路贪心+单调栈思想用一个字符串来记录答案，每次判断答案的最后一个字符是否大于原串当前字符，如果大于并且该字符在原串后面还出现过，就可以不断删除。然
【分布式定时任务】XXL-JOB_2.4.1部署与实战布熬夜了后端开发数据库
部署分布式任务调度平台XXL-JOBXXL-JOB是一个轻量级分布式任务调度平台，其核心设计目标是开发迅速、学习简单、轻量级、易扩展。现已开放源代码并接入多家公司线上产品线，开箱即用。https://www.xuxueli.com/xxl-job/一数据库配置执行初始化数据库SQLxxl-job/doc/db/tables_xxl_job.sqlat2.4.1·xuxueli/xxl-job·Gi
速盾：高防 CDN 如何提高电子商务网站的性能和用户体验？速盾cdn 服务器安全 web安全
随着电子商务的迅速发展，电子商务网站的性能和用户体验成为了至关重要的因素。其中，高防CDN（内容分发网络）可以为电子商务网站提供很大的帮助，使其能够提高性能和用户体验。下面将详细介绍高防CDN如何实现这一目标。首先，高防CDN可以通过分布式缓存来加速电子商务网站的加载速度。CDN将网站的静态资源如图片、样式表等缓存在全球各地的服务器上，用户访问网站时可以从离他们最近的服务器上获取这些资源，大大减少
MySQL入门学习-如何在MySQL数据库中使用Java语言工作守护者170 java学习 MySQL学习 mysql 数据库学习
一、要在MySQL数据库中使用Java语言工作，可以使用Java的JDBC（JavaDatabaseConnectivity）API。JDBC是一种用于执行SQL语句的JavaAPI，它允许Java程序与各种关系型数据库进行交互。以下是一个简单的示例，展示了如何使用JDBC连接到MySQL数据库并执行SQL查询：importjava.sql.Connection;importjava.sql.Dr
JavaScript 中的深拷贝新宠：structuredClone() 函数详解芭拉拉小魔仙 js javascript 开发语言 ecmascript
在JavaScript中，处理对象拷贝时，我们经常会遇到浅拷贝（shallowcopy）和深拷贝（deepcopy）的概念。浅拷贝只复制对象的第一层属性，如果属性值是引用类型（如对象、数组等），则只复制引用而不复制对象本身，这可能会导致原始数据被意外修改。而深拷贝则递归地复制对象及其所有子属性，确保原始数据和拷贝数据完全独立。传统上，JavaScript没有内置直接进行深拷贝的函数，开发者通常需要
《区块链：重塑经济与世界》 simple涯
《区块链：重塑经济与世界》：我们生活在一个奔腾的年代，苹果重塑手机，谷歌战胜李世石，特斯拉重新定义汽车。科技不断重塑着我们的经济、生活和世界。一种全新的金融网络、分布式数据库技术从底层蓬勃而出，将重塑整个金融和经济，可能会让比尔•盖茨的预言“你们传统银行如果不改变，就是21世纪要灭绝的恐龙”应验。这个技术就是区块链。区块链的诞生颇具传奇色彩，而它引发的一系列产物：数字货币、智能合约、分布式治理等更
Qt 中 QDir 常用函数详解威桑 QT qt C++
在Qt框架中，QDir类提供了强大的功能来处理目录和文件路径。无论是导航文件系统、过滤文件，还是获取路径的详细信息，QDir都为开发者提供了一系列便捷的函数。我们详细探讨一些常用的QDir函数，包括absoluteFilePath、absolutePath、canonicalPath、dirName、entryInfoList和entryList。1.QStringabsoluteFilePath
scrapy学习笔记0827 github_czy scrapy 学习笔记
1.总之先启动先安装scrapy，pipinstallscrapy创建scrapy项目，生成的项目结构应该如图所示，scrapystartprojectexample选择需要爬取的页面并分析，这里选定的页面是Allproducts|BookstoScrape-Sandbox一个供给爬虫学者练手的网站，我们需要爬取上面的书籍信息，解析我们需要的内容在那一段html标签里可以使用浏览器自带的开发者工具
mysql磁盘io高是什么造成_FAQ | 是什么导致MySQL数据库服务器磁盘I/O高（本文章来自知数堂）... 天接云涛 mysql磁盘io高是什么造成
0、导读有个MySQL服务器的磁盘I/O总有过高报警，怎么回事？本文约1500字，阅读时间约10分钟。1、问题我的朋友小明，TA有个MySQL服务器最近总是报告磁盘I/O非常高，想着我这有免费的不用白不用的企业技术服务(TA自己这么想的)，就找我帮忙给把把脉。作为一个经验丰富(踩坑不断)的DBA，出现这种问题，一般来说，磁盘I/O很高无非是下面几个原因引起：磁盘子系统设备性能差，或采用ext2/e
Python | Leetcode Python题解之第384题打乱数组 Mopes__ 分享 Python Leetcode 题解
题目：题解：classSolution:def__init__(self,nums:List[int]):self.nums=numsself.original=nums.copy()defreset(self)->List[int]:self.nums=self.original.copy()returnself.numsdefshuffle(self)->List[int]:foriinran
商务英语中，in the process 是什么意思？ Lisa_Wang_China
WeareintheprocessofsigningLIA’swithanumberofoperators.释义：我们正在与多家运营商签署当地的实施协议。赏析一：intheprocessof“在此过程中;与此同时”例如：We'reintheprocessofsellingourhouse.我们正在出售自家的住宅。There'sstillonemorestepintheprocess.还差一道工序。
Google 插件推荐 50 个 zjx-kimi google
以下是一些推荐的GoogleChrome插件，它们在2024年被认为可以显著提升工作效率和浏览体验：AdblockPlus-广告拦截工具，帮助您屏蔽网页上的烦人广告。Tampermonkey-油猴脚本管理器，功能强大的用户脚本管理器。OneTab-将无数Tab合并在一个页面，节省内存并提高浏览效率。Infinity新标签页(Pro)-美化Chrome的标签页，提供自定义导航页面。Grammarly
【详解】线段树 CH_Vaniteux 详解数据结构线段树
线段树详解By岩之痕目录：一：综述二：原理三：递归实现四：非递归原理五：非递归实现六：线段树解题模型七：扫描线八：可持久化(主席树)九：练习题一：综述假设有编号从1到n的n个点，每个点都存了一些信息，用[L,R]表示下标从L到R的这些点。线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是O(log2(n)).线段树的原理，就是，将[1,n]分解成若干特定的子区间(数量
ModBus RTU、ModBus ASCII、ModBus TCP，它们有什么区别？哄娃睡觉 stm32
ModBus是一种通信协议，用于连接自动化设备（如PLC、温度控制器等）和计算机。它被广泛应用于工业控制系统，支持多种通信方式，包括ModBusRTU、ModBusASCII和ModBusTCP3种模式。Modbus是一种应用层协议，它定义了与基础网络无关的数据单元（ADU），可以在以太网（TCP/IP）或串行链路上（RS232、RS485等）进行通信（以太网ADU和串行ADU略有不同）。在串行链
SpringMVC--Converter（类型转换器）详解吴声子夜歌 SpringMVC SpringMVC Converter
SpringMVCConverterSpringMVC框架的Converter是一个可以将一种数据类型转换成另一种数据类型的接口，这里S表示源类型，T表示目标类型。开发者在实际应用中使用框架内置的类型转换器基本上就够了，但有时需要编写具有特定功能的类型转换器。内置的类型转换器在SpringMVC框架中，对于常用的数据类型，开发者无须创建自己的类型转换器，因为SpringMVC框架有许多内置的类型转
openwrt 21.02 开启ntfs-3g自动挂载2T以上移动硬盘 FoxMale007 未整理随笔 openwrt ntfs-3g U盘移动硬盘 NAS
初始状态：openwrt21.02原始版本需求：需要自动挂载移动硬盘，作为简单NAS使用遇到问题：1)按照网上教程mount命令不识别uuid参数，发现少安装了一个包:mount-utils2)不想用最新的ntfs工具，使用旧的ntfs-3g兼容性更好，而且挂载2T以上移动硬盘必须使用ntfs-3g。但是问题是，开启了使用UUID挂载点后，死活挂载不上。最后发现是最新openwrt源码里有个BUG
adb remount Now reboot your device for settings to take effect sun007700 adb
remountof/systemfailed:Read-onlyfilesystem原因及解决_nowrebootyourdeviceforsettingstotakeeffect-CSDN博客$adbremountDisablingverityfor/systemDisablingverityfor/system_extDisablingverityfor/vendorNowrebootyour
Node.js总结会飛的魚， node.js
文章目录node的知识点1.node的外层有一个函数2.node全局global3.node的事件循环4.Buffer缓冲器5.简单文件的读写6.流式文件的读写7.原生服务器8.mysql数据库语句9.mysql数据库的连接10.mogodb数据库连接11.express服务器12.http协议简介13.express中的request和response14.中间键的简介15.常用的第三方中间件1
如何在Web3.0应用中实现数据的安全存储？ alankuo 生成式人工智能AIGC 人工智能
在Web3.0应用中，可以通过以下几种方式实现数据的安全存储：一、分布式存储技术1.IPFS（InterPlanetaryFileSystem，星际文件系统）：-IPFS是一种去中心化的分布式文件存储系统。它将文件分割成小块，并通过哈希算法为每个块生成唯一的标识符。这些块被存储在全球各地的节点上，提高了数据的冗余性和可用性。-数据在IPFS上存储时，会被加密并分布在多个节点上，降低了单点故障的风险
Python | Leetcode Python题解之第385题迷你语法分析器 Mopes__ 分享 Python Leetcode 题解
题目：题解：classSolution:defdeserialize(self,s:str)->NestedInteger:index=0defdfs()->NestedInteger:nonlocalindexifs[index]=='[':index+=1ni=NestedInteger()whiles[index]!=']':ni.add(dfs())ifs[index]==',':inde
每日一题2024年8月30日 Gin387 算法
E-不知道叫什么名字_2023年广东工业大学腾讯杯新生程序设计竞赛(nowcoder.com)大致思路：题目要求选择连续的，男女人数相等的。题目给出男生为1，女生为0，这里猜测要把女生的0改成-1（猜测，不知道对不对）通过一些手段，前缀和+map，发现可以完美解决这个问题。#includeusingnamespacestd;typedeflonglongll;typedefdoubledb;typ
Golang | Leetcode Golang题解之第385题迷你语法分析器 __AtYou__ 经验分享 Golang Leetcode 题解
题目：题解：funcdeserialize(sstring)*NestedInteger{index:=0vardfsfunc()*NestedIntegerdfs=func()*NestedInteger{ni:=&NestedInteger{}ifs[index]=='['{index++fors[index]!=']'{ni.Add(*dfs())ifs[index]==','{index+
harmonyos鸿蒙,HarmonyOS鸿蒙入门篇丁丁TINTIN harmonyos鸿蒙
这几天鸿蒙系统起来了。开源，全场景。鸿蒙系统又是什么，官网有：HarmonyOS是一款“面向未来”、面向全场景(移动办公、运动健康、社交通信、媒体娱乐等)的分布式操作系统。在传统的单设备系统能力的基础上，HarmonyOS提出了基于同一套系统能力、适配多种终端形态的分布式理念，能够支持多种终端设备。华为开发者联盟论坛https://developer.huawei.com/consumer/鸿蒙官
SpringBoot 配置文件详解：properties 和 yml 棕豆兔＆ Spring spring boot java 后端
目录一、配置文件的作用二、配置文件的格式三、properties配置文件说明3.1properties基本语法3.2读取配置文件四、yml配置文件说明4.1yml基本语法4.2yml读取文件4.3yml使用进阶4.3.1配置对象4.3.2配置集合4.3.3配置Map一、配置文件的作用配置文件主要是为了解决硬编码带来的问题,把可能会发生改变的信息，放在一个集中的地方，当我们启动某个程序时,应用程序从
嵌入式数据库王鑫的博客886 数据库 linux 开发语言 c语言
嵌入式数据库1.关系型嵌入式数据库SQLite：特点：自给自足的、零配置的、轻量级的关系型数据库，支持SQL查询。应用：广泛应用于移动应用（如iOS和Android应用）、桌面应用（如应用程序设置和缓存）、嵌入式设备（如物联网设备）。H2：特点：Java编写的关系型数据库，支持嵌入式模式和服务器模式，支持SQL和JDBC。应用：Java应用程序中的数据存储，适用于需要嵌入式数据库的桌面应用和小型服
通过`ssh`同步`tmux`剪贴板内容 yann_qu ssh 运维 tmux xclip
通过ssh同步tmux剪贴板内容通过ssh连接远程服务器时，可以通过xclip同步tmux剪贴板内容。这需要在服务器上安装xclip，且需要在ssh远程连接时开启X11。此处附tmux剪贴板调用xclip的配置：#CopythecurrentbuffertothesystemclipboardbindC-crun-b"tmuxsave-buffer-|xclip-i-selclipboard;tm
web3.0涉及的技术 alankuo 生成式人工智能AIGC 人工智能
Web3.0的设计涉及到多种技术，以下是一些主要的技术：一、区块链技术1.分布式账本-确保数据的去中心化存储，每个节点都有完整的账本副本，提高了数据的安全性和可靠性。没有单一的控制中心，降低了数据被篡改或丢失的风险。-例如，在金融领域的应用中，分布式账本可以记录每一笔交易，保证交易的透明性和可追溯性。2.智能合约-是一种自动执行的合约，其中包含了预先定义好的规则和条款。当满足特定条件时，智能合约会
对于规范和实现，你会混淆吗？ yangshangchuan HotSpot
昨晚和朋友聊天，喝了点咖啡，由于我经常喝茶，很长时间没喝咖啡了，所以失眠了，于是起床读JVM规范，读完后在朋友圈发了一条信息： JVM Run-Time Data Areas：The Java Virtual Machine defines various run-time data areas that are used during execution of a program. So
android 网络百合不是茶网络
android的网络编程和java的一样没什么好分析的都是一些死的照着写就可以了,所以记录下来方便查找 , 服务器使用的是TomCat 服务器代码; servlet的使用需要在xml中注册 package servlet; import java.io.IOException; import java.util.Arr
[读书笔记]读法拉第传 comsci 读书笔记
1831年的时候,一年可以赚到1000英镑的人..应该很少的... 要成为一个科学家,没有足够的资金支持,很多实验都无法完成但是当钱赚够了以后....就不能够一直在商业和市场中徘徊......
随机数的产生沐刃青蛟随机数
c++中阐述随机数的方法有两种：一是产生假随机数（不管操作多少次，所产生的数都不会改变）这类随机数是使用了默认的种子值产生的，所以每次都是一样的。 //默认种子 for (int i = 0; i < 5; i++) { cout<<
PHP检测函数所在的文件名 IT独行者 PHP 函数
很简单的功能，用到PHP中的反射机制，具体使用的是ReflectionFunction类，可以获取指定函数所在PHP脚本中的具体位置。创建引用脚本。代码： [php] view plain copy // Filename: functions.php <?php&nbs
银行各系统功能简介文强chu 金融
银行各系统功能简介　业务系统核心业务系统业务功能包括：总账管理、卡系统管理、客户信息管理、额度控管、存款、贷款、资金业务、国际结算、支付结算、对外接口等清分清算系统以清算日期为准，将账务类交易、非账务类交易的手续费、代理费、网络服务费等相关费用，按费用类型计算应收、应付金额，经过清算人员确认后上送核心系统完成结算的过程国际结算系
Python学习1(pip django 安装以及第一个project) 小桔子 python django pip
最近开始学习python,要安装个pip的工具。听说这个工具很强大，安装了它，在安装第三方工具的话so easy!然后也下载了，按照别人给的教程开始安装，奶奶的怎么也安装不上！第一步：官方下载pip-1.5.6.tar.gz, https://pypi.python.org/pypi/pip easy! 第二部：解压这个压缩文件，会看到一个setup.p
php 数组 aichenglong PHP 排序数组循环多维数组
1 php中的创建数组 $product = array('tires','oil','spark');//array()实际上是语言结构而不是函数 2 如果需要创建一个升序的排列的数字保存在一个数组中，可以使用range()函数来自动创建数组 $numbers=range(1,10)//1 2 3 4 5 6 7 8 9 10 $numbers=range(1,10,
安装python2.7 AILIKES python
安装python2.7 1、下载可从 http://www.python.org/进行下载#wget https://www.python.org/ftp/python/2.7.10/Python-2.7.10.tgz 2、复制解压 #mkdir -p /opt/usr/python #cp /opt/soft/Python-2
java异常的处理探讨百合不是茶 JAVA异常
//java异常 /* 1，了解java 中的异常处理机制，有三种操作 a,声明异常 b,抛出异常 c,捕获异常 2，学会使用try-catch-finally来处理异常 3，学会如何声明异常和抛出异常 4，学会创建自己的异常 */ //2，学会使用try-catch-finally来处理异常
getElementsByName实例 bijian1013 element
实例1： <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/x
探索JUnit4扩展：Runner bijian1013 java 单元测试 JUnit
参加敏捷培训时，教练提到Junit4的Runner和Rule，于是特上网查一下，发现很多都讲的太理论，或者是举的例子实在是太牵强。多搜索了几下，搜索到两篇我觉得写的非常好的文章。文章地址：http://www.blogjava.net/jiangshachina/archive/20
[MongoDB学习笔记二]MongoDB副本集 bit1129 mongodb
1. 副本集的特性 1)一台主服务器(Primary),多台从服务器(Secondary) 2)Primary挂了之后，从服务器自动完成从它们之中选举一台服务器作为主服务器，继续工作，这就解决了单点故障，因此，在这种情况下，MongoDB集群能够继续工作 3)挂了的主服务器恢复到集群中只能以Secondary服务器的角色加入进来 2
【Spark八十一】Hive in the spark assembly bit1129 assembly
Spark SQL supports most commonly used features of HiveQL. However, different HiveQL statements are executed in different manners: 1. DDL statements (e.g. CREATE TABLE, DROP TABLE, etc.)
Nginx问题定位之监控进程异常退出 ronin47
nginx在运行过程中是否稳定，是否有异常退出过？这里总结几项平时会用到的小技巧。 1. 在error.log中查看是否有signal项，如果有，看看signal是多少。比如，这是一个异常退出的情况： $grep signal error.log 2012/12/24 16:39:56 [alert] 13661#0: worker process 13666 exited on s
No grammar constraints (DTD or XML schema).....两种解决方法 byalias xml
方法一：常用方法关闭XML验证工具栏：windows => preferences => xml => xml files => validation => Indicate when no grammar is specified:选择Ignore即可。方法二：（个人推荐）添加内容如下 <?xml version=
Netty源码学习-DefaultChannelPipeline bylijinnan netty
package com.ljn.channel; /** * ChannelPipeline采用的是Intercepting Filter 模式 * 但由于用到两个双向链表和内部类，这个模式看起来不是那么明显，需要仔细查看调用过程才发现 * * 下面对ChannelPipeline作一个模拟，只模拟关键代码： */ public class Pipeline {
MYSQL数据库常用备份及恢复语句 chicony mysql
备份MySQL数据库的命令，可以加选不同的参数选项来实现不同格式的要求。 mysqldump -h主机 -u用户名 -p密码数据库名 > 文件备份MySQL数据库为带删除表的格式，能够让该备份覆盖已有数据库而不需要手动删除原有数据库。 mysqldump -–add-drop-table -uusername -ppassword databasename > ba
小白谈谈云计算--基于Google三大论文 CrazyMizzz Google 云计算 GFS
之前在没有接触到云计算之前，只是对云计算有一点点模糊的概念，觉得这是一个很高大上的东西，似乎离我们大一的还很远。后来有机会上了一节云计算的普及课程吧，并且在之前的一周里拜读了谷歌三大论文。不敢说理解，至少囫囵吞枣啃下了一大堆看不明白的理论。现在就简单聊聊我对于云计算的了解。我先说说GFS &n
hadoop 平衡空间设置方法 daizj hadoop balancer
在hdfs-site.xml中增加设置balance的带宽，默认只有1M： <property> <name>dfs.balance.bandwidthPerSec</name> <value>10485760</value> <description&g
Eclipse程序员要掌握的常用快捷键 dcj3sjt126com 编程
判断一个人的编程水平，就看他用键盘多，还是鼠标多。用键盘一是为了输入代码（当然了，也包括注释），再有就是熟练使用快捷键。曾有人在豆瓣评《卓有成效的程序员》：“人有多大懒，才有多大闲”。之前我整理了一个程序员图书列表，目的也就是通过读书，让程序员变懒。程序员作为特殊的群体，有的人可以这么懒，懒到事情都交给机器去做，而有的人又可以那么勤奋，每天都孜孜不倦得
Android学习之路 dcj3sjt126com Android学习
转自：http://blog.csdn.net/ryantang03/article/details/6901459 以前有J2EE基础，接触JAVA也有两三年的时间了，上手Android并不困难，思维上稍微转变一下就可以很快适应。以前做的都是WEB项目，现今体验移动终端项目，让我越来越觉得移动互联网应用是未来的主宰。下面说说我学习Android的感受，我学Android首先是看MARS的视
java 遍历Map的四种方法 eksliang java HashMap java 遍历Map的四种方法
转载请出自出处： http://eksliang.iteye.com/blog/2059996 package com.ickes; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import java.util.Map.Entry; /** * 遍历Map的四种方式
【精典】数据库相关相关 gengzg 数据库
package C3P0; import java.sql.Connection; import java.sql.SQLException; import java.beans.PropertyVetoException; import com.mchange.v2.c3p0.ComboPooledDataSource; public class DBPool{
自动补全 huyana_town 自动补全
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml&quo
jquery在线预览PDF文件，打开PDF文件天梯梦 jquery
最主要的是使用到了一个jquery的插件jquery.media.js，使用这个插件就很容易实现了。核心代码 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.
ViewPager刷新单个页面的方法 lovelease android viewpager tag 刷新
使用ViewPager做滑动切换图片的效果时，如果图片是从网络下载的，那么再子线程中下载完图片时我们会使用handler通知UI线程，然后UI线程就可以调用mViewPager.getAdapter().notifyDataSetChanged()进行页面的刷新，但是viewpager不同于listview，你会发现单纯的调用notifyDataSetChanged()并不能刷新页面
利用按位取反（~）从复合枚举值里清除枚举值草料场 enum
以 C# 中的 System.Drawing.FontStyle 为例。如果需要同时有多种效果，如：“粗体”和“下划线”的效果，可以用按位或（|） FontStyle style = FontStyle.Bold | FontStyle.Underline; 如果需要去除 style 里的某一种效果，
Linux系统新手学习的11点建议刘星宇编程工作 linux 脚本
　　随着Linux应用的扩展许多朋友开始接触Linux，根据学习Windwos的经验往往有一些茫然的感觉：不知从何处开始学起。这里介绍学习Linux的一些建议。　　一、从基础开始：常常有些朋友在Linux论坛问一些问题，不过，其中大多数的问题都是很基础的。例如：为什么我使用一个命令的时候，系统告诉我找不到该目录，我要如何限制使用者的权限等问题，这些问题其实都不是很难的，只要了解了 Linu
hibernate dao层应用之HibernateDaoSupport二次封装 wangzhezichuan DAO Hibernate
/** * 方法描述:sql语句查询返回List<Class> * 方法备注: Class 只能是自定义类 * @param calzz * @param sql * @return * 创建人：王川 * 创建时间：Jul