mongodb 应用

mongodb 应用


use test
db.foo.insert({"bar":"baz"})

show dbs
show collections

db.foo.fine()
db.foo.remove() /删除foo下的文档

db.mailing.list.insert{"opt-out":true, "name":"richy"}
db.mailing.list.remove({"opt-out": true})


修改文档
db.users.insert({"name":"joe","friends":32, "enemies":2})
db.users.find()

var joe = db.users.findOne({"name":"joe"});
joe.relationships = {"friends": joe.friends, "enemies":joe.enemies};
joe.username = joe.name;
delete joe.friends;
delete joe.enemies;
db.users.update({"name":"joe"}, joe);
db.users.find()


修改器
$inc:
db.analytics.insert({"url":"www.example.com", "pageviews":52})
db.analytics.update({"url":"www.example.com"}, {"$inc":{"pageviews":1}})
db.analytics.find()

---------------$set and $unset:--------增加字段/拆除字段---------

db.users.update( {"_id" : ObjectId("4fa8910f4a74b84f6e789007")}, {"$set":{"favorite book": "war and peace"}})

db.users.update( {"_id" : ObjectId("4fa8910f4a74b84f6e789007")}, {"$set":{"favorite book": "green eggs and ham"}})

db.users.update( {"_id" : ObjectId("4fa8910f4a74b84f6e789007")}, {"$set":{"favorite book": ["cat's cradld", "foundation trilogy", "ender's game"]}})

db.users.update( {"_id" : ObjectId("4fa8910f4a74b84f6e789007")}, {"$unset":{"favorite book": 1}})


------------------增加数值-----------------------

db.games.insert({"game":"pinball", "user":"joe"})

db.games.update({"game":"pinball", "user":"joe"},{"$inc":{"score":50}})

db.games.update({"game":"pinball", "user":"joe"},{"$inc":{"score":10000}})


-----------------$push---------追加数组---------------

db.blog.posts.insert({"title":"A blog post", "content":"..."})

db.blog.posts.update({"title":"A blog post"},{"$push":{"comments":{"name":"joe","email":"joe@example.com","content":"nice post."}}})

db.blog.posts.update({"title":"A blog post"},{"$push":{"comments":{"name":"joe","email":"joe@example.com","content":"nice post."}}})

db.blog.posts.find()


-------------条件更新---------$ne---------------

db.papers.insert({"authors cited","..."})

db.papers.update({"authors cited":"..."},{"$set":{"authors cited":[]}})

db.papers.update({"authors cited":{"$ne": "Richie"}}, {$push:{"authors cited":"Richie"}})


---------------------$addToSet----------避免重复追加数组-------

{ "_id" : ObjectId("4fa8910f4a74b84f6e789007"), "name" : "joe", "relationships" : { "friends" : 32, "enemies" : 2 }, "username" : "joe" }

db.users.update({ "_id" : ObjectId("4fa8910f4a74b84f6e789007")},{"$set":{"emails":["joe@example.com","joe@gmail.com", "joe@yahoo.com"]}})

db.users.update({ "_id" : ObjectId("4fa8910f4a74b84f6e789007")},{"$addToSet":{"emails":"joe@hotmail.com"}})

db.users.update({ "_id" : ObjectId("4fa8910f4a74b84f6e789007")},{"$addToSet":{"emails":{"$each":["aa@tom.com","bb@tom.com","aa@tom.com"]}}})



--------------------删除-------------------

db.lists.insert({"todo":["dishes","laundry", "dry cleaning"]})

db.lists.update({}, {"$pull":{"todo":"laundry"}})

db.lists.find()


--------------------$定位---------------------

db.blog.posts.update({"comments.name":"joe"},{"$set":{"comments.$.name":"jim"}})



---------------------save shell -------------

db.foo.insert({"num":"0"})

var x=db.foo.findOne()
x.num=42
db.foo.save(x)

db.foo.update({"_id":x._id},x)



-----------------查看执行结果----------------

db.runCommand({getLastError:1})


-----------------查看进程---------------------

ps = db.runCommand({"findAndModify" : "processes"},{"query":{"status":"READY"}},{"query":{"status":"READY"}},{"sort":{"priority":-1}},{"update":{"$set":{"status":"RUNNING"}}})

update / remove

--------------条件查询---------------------


"$lt"    "$lte"    "$gt"    "$gte"

db.user.find({"age":{"$gte":18, "$lte":30}})

start= new Date("01/01/2007")

db.users.find({"registered":{"$lt":start}})

db.users.find({"username":{"$ne":"joe"}})


$in   $or

db.user.find({"ticket_no":{"$nin":[725,542,390]}})

db.user.find("$or":[{"ticket_no":725},{"winner":true}])


$mod $not

null

$exists； 没有$eq操作符，用一个元素的$in代替

db.c.find({"y":{"$in":[null], "$exists":true}})


正则表达式：
db.users.insert({"name":"Joe","friends":15, "enemies":8})
db.users.insert({"name":"Joey","friends":1, "enemies":0})
db.users.insert({"name":"joeyy","friends":4, "enemies":76})

db.users.find({"name":/joe/i})
db.users.find({"name":/joey?/i})


正则表达式匹配自身：
db.foo.insert({"bar":/baz/})
db.foo.find({"bar":/baz/})


查询数组
db.food.insert({"fruit":["apple","banana","peach"]})

db.food.find({"fruit":"banana"})

$all

db.food.insert({"fruit":["apple","kumquat","orange"]})
db.food.insert({"fruit":["cherry","banana","apple"]})

db.food.find({"fruit":{"$all":["apple","banana"]}})


数组精确匹配
db.food.find({"fruit":["apple","banana","peach"]})
db.food.find({"fruit":["apple","peach","banana"]})---顺序不符，不能查出

指定数组位置
db.food.find({"fruit.2":"peach"})

$size 查询指定长度的数组
db.food.find({"fruit":{"$size":3}})

$size不支持$eq,可增加size字段
db.food.update({"fruit.1":"banana"},{"$push":{"fruit":"strawberry"}})
db.food.update({"fruit.1":"banana"},{"$push":{"fruit":"strawberry"}, "$inc":{"size":1}})

不能与$addToSet同时使用


$slice 返回数组的子集合
db.food.findOne({"fruit.1":"banana"})
db.food.findOne({"fruit.1":"banana"},{"fruit":{"$slice":2}})
db.food.findOne({"fruit.1":"banana"},{"fruit":{"$slice":-2}})
db.food.findOne({"fruit.1":"banana"},{"fruit":{"$slice":[2,3]}})

查询内嵌文档
db.people.find({"name":{"first":"Joe", "last":"Schmoe"}})
db.people.find({"name.first":"Joe", "name.last":"Schmoe"})

db.blog.find({"comments":{"author":"joe","score":{"$gte":5}}})--不能直接使用
内嵌文档要求完全匹配

要正确匹配一组属性用 $elemMatch
db.blog.find({"comments":{"$elemMatch":{"author":"joe","score":{"$gte":5}}}})


$where查询
db.foo.insert({"apple":1, "banana":6, "peach":3})
db.foo.insert({"apple":8, "spinach":4, "watermelon":4})

db.foo.find({"$where":"true"})

db.foo.find({"$where":function(){
    return true;
}})

db.foo.find({"$where": function() {
    for(var current in this) {
        for( var other in this) {
            if(current != other && this[current] == this[other] ) {
                return true;
            }
        }
    }
    return false;
    }})

返回true，文档作为结果的一部分，返回false，则不然。

$where性能慢，只有在走投无路时才考虑使用。

用索引根据非$where子句进行过滤，$where子句只用于对结果进行调优。

4.5游标
for(i=0;i<100;i++) {
db.c.insert({x:i});
}

var cursor = db.c.find();

cursor.forEach(function(x){
print(x.x);
})


limit, skip, sort

db.c.find().limit(3)
db.c.find().skip(3)
db.c.find().sort({x:-1})
db.c.find().sort({username:1, age:-1})

db.c.find().sort({x:-1}).limit(10).skip(10)

略过过多结果会导致性能问题，建议尽量避免（可根据排序条件构造查询条件）


随机选取文档

db.people.insert({"name":"joe", "random":Math.random()})
db.people.insert({"name":"john", "random":Math.random()})
db.people.insert({"name":"jim", "random":Math.random()})
db.people.insert({"name":"richy", "random":Math.random()})

var random=Math.random()
result = db.people.findOne({"random":{"$gt":random}})

建立索引
db.people.ensureIndex({"name":1, "state":1,"random":1})

$maxscan
$min
$max
$hint
$explain
$snapshot


cursor=db.foo.find()

while(cursor.hasNext()){
    var doc = cursor.next();
    db.doc.save(doc);
}


多字段索引和索引名称
db.foo.ensureIndex({"a":1,"b":1,"c":-1},{"name":"alphabet"})

唯一索引和去除重复
db.people.ensureIndex({"username":1}, {"unique":true,"dropDups":true})


.hint 强制使用某个索引 --一般没这必要


修改索引
db.people.ensureIndex({"username":1}, {"background":true})

删除索引
db.runCommand({"dropIndexes":"foo", "index":"alphabet"})

删除全部索引
db.runCommand({"dropIndexes":"foo", "index":"*"})


地理空间索引
db.map.insert({"gps":[0,100]})
db.map.ensureIndex({"gps":"2d"})

定义空间索引取值范围
db.star.trek.ensureIndex({"light-years":"2d"},{"min":-1000,"max":1000})

db.map.find({"gps":{"$near":[40,-73]}}).limit(10)
db.runCommand({geoNear:"map", near:[40,-73], num:10})

$within 形状内的DOCUMENT，矩形和圆形
db.map.find({"gps":{"$within":{"$box":[[10,20],[15,30]]}}})
db.map.find({"gps":{"$within":{"$center":[[10,20],50]}}})

复合地理空间索引
db.map.ensureIndex({"location":"2d", "desc":1})
db.map.find({"location":{"$near":[-70,30]}, "desc":"coffeeshop"}).limit(1)



聚合工具
db.foo.count()

db.runCommand({"distinct":"people", "key": "age"})

group-------------------

db.runCommand({"group":{
"ns":"stocks",
"key":"day",
"initial":{"time":0},
"$reduce":function(doc,prev) {
    if(doc.time>prev.time) {
        prev.price=doc.price;
        prev.time=doc.time;
    }
}}})

"$finalize" -----------------每组最后执行一次

将函数作为分组的健，适用于各种复杂条件的分组

"$keyf"

"$keyf": function(x){return x.category.toLowerCase();}

创建固定集合
db.createCollection("my_collecion", {capped:true, size:100000,max:100});
db.runCommand({convertToCapped: "people", size:1000})
db.people.find().sort({"$natural":-1})