MongoDB高级

# 关系（多个文档之间在逻辑上的相互联系）
1:1 (1对1)
1: N (1对多)
N: 1 (多对1)
N: N (多对多)

# $in（user和address）
address
{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "name": "Tom Hanks",
   "contact": "987654321",
   "dob": "01-01-1991"
}
{
   "_id":ObjectId("52ffc4a5d85242602e000000"),
   "building": "22 A, Indiana Apt",
   "pincode": 123456,
   "city": "Los Angeles",
   "state": "California"
}
user
{
   "_id":ObjectId("52ffc33cd85242f436000001"),
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin",
   "address_ids": [
      ObjectId("52ffc33cd85242f436000001"),
      ObjectId("52ffc4a5d85242602e000000")
   ]
}
var result = db.user.findOne({"name":"Tom Benzamin"},{"address_ids":1});
db.address.find({"_id":{"$in":result["address_ids"]}});

# DBRefs
{ $ref : , $id : , $db :  }
user insert
{
   "_id":ObjectId("53402597d852426020000003"),
   "address": {
   "$ref": "address",
   "$id": ObjectId("52ffc4a5d85242602e000000"),
   "$db": "data"},
   "contact": "987654321",
   "dob": "01-01-1991",
   "name": "Tom Benzamin"
}
user find
var user = db.user.findOne({"name":"Tom Benzamin"})
var dbRef = user.address
# 4.0 db[dbRef.$ref].findOne({"_id":ObjectId(dbRef.$id)})
db[dbRef.$ref].findOne({"_id":(dbRef.$id)}) 

# 原子操作(原子操作常用命令)
$set 用来指定一个键并更新键值，若键不存在并创建
{ $set : { field : value } }
$unset 用来删除一个键
{ $unset : { field : 1} }
$inc 可以对文档的某个值为数字型（只能为满足要求的数字）的键进行增减的操作
{ $inc : { field : value } }
$push value追加到field中，field是数组类型，若field不存在，会新增一个数组类型并添加
{ $push : { field : value } }
$pushAll 一次可以追加多个值到一个数组字段内
{ $pushAll : { field : value_array } }
$pull 从数组field内删除一个等于value值
{ $pull : { field : _value } }
$addToSet 增加一个值到数组内，而且只有当这个值不在数组内才增加
{ $addToSet : { field : _value } }
$pop 删除数组的第一个或最后一个元素
{ $pop : { field : 1 } }
$rename 修改字段名称
{ $rename : { old_field_name : new_field_name } }
$bit 位操作，integer类型
{$bit : { field : {and : 5}}}

# 覆盖索引查询
db.user.ensureIndex({age:1,name:1}) 创建联合索引
db.user.find({age:11},{name:1,_id:0}) 索引覆盖

# 查询分析 explain() 和 hint()
# 创建8千条数据
for(var index=0; index<8000; index++) {
var name = Math.random().toString(36).substr(2);
var age = Math.ceil(Math.random()*100);
db.user.insert({name:name,age:age});
}
explain()分析查询是否走索引
hint()指定强制走索引 

# ObjectId（12字节 BSON 类型数据）
前4个字节表示时间戳
接下来的3个字节是机器标识码
紧接的2个字节由进程id组成（PID）
最后3个字节是随机数

myObjectId = ObjectId("5349b4ddd2781d08c09890f4")
ObjectId("5349b4ddd2781d08c09890f4").getTimestamp()
new ObjectId().str

# Map Reduce命令
db.collection.mapReduce(
   function() {emit(key,value);},
   function(key,values) {return reduceFunction},
   {
      out: collection,
      query: document,
      sort: document,
      limit: number
   }
).find();
Map 函数调用 emit(key, value), 遍历 collection 中所有的记录, 将 key 与 value 传递给 Reduce 函数进行处理
map 映射函数 (生成键值对序列, 作为 reduce 函数参数)
reduce 统计函数，reduce函数的任务就是将key-values变成key-value，也就是把values数组变成一个单一的值value
out 统计结果存放集合 (不指定则使用临时集合,在客户端断开后自动删除)
query 一个筛选条件，只有满足条件的文档才会调用map函数 （query limit sort可以随意组合）
sort 和limit结合的sort排序参数（也是在发往map函数前给文档排序），可以优化分组机制
limit发往map函数的文档数量的上限（要是没有limit，单独使用sort的用处不大）
# result分析
{
        "result" : "post_total",
        "timeMillis" : 23,
        "counts" : {
                "input" : 5,
                "emit" : 5,
                "reduce" : 1,
                "output" : 2
        },
        "ok" : 1
}
result：储存结果的collection的名字,这是个临时集合，MapReduce的连接关闭后自动就被删除了
timeMillis：执行花费的时间，毫秒为单位
input：满足条件被发送到map函数的文档个数
emit：在map函数中emit被调用的次数，也就是所有集合中的数据总量
ouput：结果集合中的文档个数（count对调试非常有帮助）
ok：是否成功，成功为1
err：如果失败，这里可以有失败原因，不过从经验上来看，原因比较模糊，作用不大

# 案例
db.user.insert({name:"tom",age:11});
db.user.insert({name:"tom",age:13});
db.user.insert({name:"oo",age:12});
db.user.mapReduce(
   function() {emit(this.name, this.age);},
   function(key,values) {return Array.sum(values)},
   {
      out: "total",
      query: {age: {$gt: 10}},
   }
).find();

# 全文检索
db.user.ensureIndex({field:"text"})
db.user.find({$text:{$search:"title"}})
db.user.getIndexes()
db.user.dropIndex("field_text")

db.user.ensureIndex({name:"text"})
db.user.find({$text:{$search:"rock"}})
db.user.dropIndex("name_text")

# 正则
db.user.find({name:{$regex:"oO"}})
db.user.find({name:{$regex:"oO",$options:"$i"}})

# 工具推荐
Navicat for MongoDB

# GridFS
存储超过16M的文件 其实就是文件分块 files存储源信息 chunks存储具体的小分块

# 固定集合（Capped Collections）
性能出色且有着固定大小的集合，对于大小固定，我们可以想象其就像一个环形队列，当集合空间用完后，再插入的元素就会覆盖最初始的头部的元素
db.createCollection("cappedLogCollection",{capped:true,size:10000})
db.createCollection("cappedLogCollection",{capped:true,size:10000,max:1000})
size 是整个集合空间大小，单位为【KB】
max 是集合文档个数上线，单位是【个】
db.cappedLogCollection.isCapped()
db.runCommand({"convertToCapped":"posts",size:10000})

# 自动增长
db.createCollection("counter")
db.counter.insert({lastUpdateId:0,id:"id"});

function getNextSequenceValue(sequenceName){
	var sequenceDocument = db.counter.findAndModify({
query:{id: sequenceName },
update: {$inc:{lastUpdateId:1}},"new":true
});
	return sequenceDocument.lastUpdateId;
}
db.user.insert({"_id":getNextSequenceValue("id"),name:"tom",age:11})