非关系型数据库MongoDB学习笔记

MongoDB学习笔记   --周灿

创建数据库

use “databasename”

查看数据库

show dbs

给指定数据库添加集合和插入记录

db.集合名.insert（{}）

显示数据库中的文档

show collections

显示文件中的所有内容

db.文件名.find（）

显示文件中的第一条内容

db.文件名.findOne（）

更新文档数据

db.文件名.update({name:"can"},{$set:{name:"dys",age:22}})

删除文档中的数据

db.文件名.remove({name:”can”})

删除数据集

db.文件名.drop（）

删除数据库

db.dropDatabase()

查看帮助

help

帮助文档

http://api.mongodb.org/js/3.0.4/index.html

内嵌文件

db.文件名.insert（{name：“gg”，child：{name：“hh”}}）

插入时的id可自定义

db.文件名.insert（{id：“001”，name：“hao”，age：33}）

批量插入文档

For(var i=0;i<10;i++){

db.文件名.insert({name:i})

}

save与insert的不同

save遇见相同的id相当于更新操作，insert遇见相同的id会报错

删除集合中的所有数据

db.文件名.remove（）

删除集合中指定的数据

db.文件名.remove（{name：dys}）

强制更新

db.文件名.update（{查询器}，{更新器}）

查询更新完后如果发现有主键冲突则停止更新

查出来就更新查不出来就插入

db.文件名.update（{查询器}，{更新器}，true）

查出来只更新第一条 也可以批量更新方法

db.文件名.update（{查询器}，{$set：更新器}，false，true）

自加修改器

{age:28},{$inc:{age:1}}自加1

删掉键age

{age:29},{$unset:{age:1}}

插入数组

db.book.update({_id:1},{$push:{book:"js"}})

批量插入数组

db.book.update({_id:1},{$pushAll:{book:["jds","fjdk"]}})

存在不操作不存在就插进去这与push不同

db.book.update({_id:1},{$addToSet:{book:"jds"}})

删除数组中的第一个值

db.book.update({_id:1},{$pop:{book:-1}})

删除数组中的最后一个值

db.book.update({_id:1},{$pop:{book:1}})

删除指定值

db.book.update({_id:1
4000
},{$pull:{book:"js"}})

批量删除指定的值

db.book.update({_id:1},{$pullAll:{book:["jds","fjdk"]}})

数组中的匹配插入

db.book.update({"book.type":"js"},{$set:{"book.$.author":"zhoucan"}})

批量数组更新

db.book.update({name:"book"},{$addToSet:{book:{$each:[{type:"db",name:"mongo"}]}}})

runCommand可以执行mongodb的特殊函数和findAndModify特殊函数结合使用

db.runCommand({ "findAndModify":"book" ,"query":{"name":"zhou"},"update":{"$set":{"id":"1"}},"new":true})

<<

<e<=

>>

>e>=

&ne!=

db.文件名.find({条件}，{键指定})

按条件查找

db.book.find({age:{$gte:25,$lte:50}},{_id:0,name:1,age:1})

包含查询

db.book.find({name:{$in:["zhoucan","zoua"]}},{_id:0,name:1,age:1})

不包含查询

db.book.find({name:{$nin:["zhoucan","zoua"]}},{_id:0,name:1,age:1})

或条件查询

db.book.find({$or:[{age:{$gt:40}},{age:{$lt:30}}]},{_id:0,name:1,age:1})

按条件更新

db.book.update({$or:[{age:{$gt:40}},{age:{$lt:30}}]},{$set:{sex:"M"}},false,true)

在条件空查询

db.book.find({sex:{$in:[null]}},{_id:1,name:1})

正则表达式匹配

db.book.find({name:/zh/i},{_id:1,name:1})

$not的使用

db.book.find({name:{$not:/zh/i}},{_id:1,name:1})

$not和$nin不同nin只能在集合的数组上而not可以在任意位置

数组$all查询

db.book.find({sex:{$all:["M"]}},{_id:1,name:1})

数组索引查询

db.book.find({"book.1":"sh"})

按数组大小查询

db.book.find({book:{$size:3}})

使用size时候不能与别的比大小一起使用所以要用的时候先为要用的增加一个size再操作

db.book.update({},{$set:{size:1}},false,true)

db.book.update({name:"zoua"},{$push:{book:"boo"},$inc:{size:1}})

db.book.find({size:{$gt:2}})

游标查询数量

 var book=db.book.find({name:"zoua"})

while(book.hasNext()){

 obj=book.next();

print(obj.book.length)

 }

查询指定数组的内部值

db.book.find({name:"zoua"},{book:{$slice:[0,2]}})

查询最后一本书

db.book.find({name:"zoua"},{book:{$slice:-1},_id:0,name:1})

批量添加嵌套

var ob=[{

... school:"a",

... score:"a"

... },{

... school:"b",

... score:"b"

... },{

... school:"c",

... score:"c"

... }]

db.book.update({name:"zoua"},{$set:{school:ob}},false,true)

绝对匹配

db.book.find({school:{school:"a",score:"a"}})

对象.匹配

db.book.find({"school.school":"a"})

条件组查询

db.book.find({school:{$elemMatch:{school:"a",score:"a"}}})

$where查询实例

db.book.find({$where:function(){

var book = this.book;

var school = this.school;

if(this.age >20){

for(var j=0;j<school.length;j++){

 if(school[j].school=="a"){

 return true;

 }

 }

}

}})

查询前3条数据

db.book.find({},{}).limit(3)

查询第二条后面的3条数据

db.book.find({},{}).limit(3).skip(2)

升序1降序-1

db.book.find({},{}).limit(3).skip(3).sort({age:1})

快照查询后面有很多高级选项

db.book.find({$query:{name:"zoua"},$snapshot:true})

测试查询速度

var start = new Date()

db.book.find(_id:65871)

var end = new Date()

end - start

加了索引1正序-1倒序

db.book.ensureIndex({_id:1})

建立索引为索引取名

db.book.ensureIndex({name:-1},{name:"bookname"})

建立独立索引 建立后不能插入与索引相同的值

db.book.ensureIndex({name:1},{unique:true,name:"fuck"})

如果原来有相同的值 就这样建立

db.book.ensureIndex({name:-1},{unique:true,dropDups:true,name:"uck"})

强制查询使用指定的索引

db.book.find({name:4}).hint({name:-1})

查看本次查询用的什么索引和状态信息

db.book.find({name:4}).explain()

后台创建索引

db.book.ensureIndex({name:1},{background:true})

批量删除索引

db.runCommand({dropIndexes:"book",index:"*"})

建立2d数据

> for(var i=0;i<200;i=i+5){

... db.book.insert({_id:i,git:{x:i,y:i}})

... }

建立2d索引

db.book.ensureIndex({git:"2d"},{min:-1,max:201})

查询离50，50最近的3个点

db.book.find({git:{$near:[50,50]}}).limit(3)

查询一个方形内的点

db.book.find({git:{$within:{$box:[[50,50],[100,100]]}}},{git:1,_id:0})

查询圆形内的点

db.book.find({git:{$within:{$center:[[50,50],50]}}},{git:1,_id:0})

查询有多少个

db.book.find().count()

去除重复的内容显示

db.runCommand({distinct:"book",key:"_id"}).values

group分组：....

命令执行器

db.runCommand({drop:”book”})

访问api

http://localhost:28017/_commands

查看服务器的版本信息和操作系统

db.runCommand({buildinfo:1})

查询执行集合的详细信息

db.runCommand({collStats:"book"})

创建一个固定集合

db.runCommand("mycoll",{size:100,capped:true,max:10})

将普通集合转化成固定集合

db.runCommand({convertToCapped:"book",size:1000000})

反向排序

db.book.find().sort({$natural:-1})

文件系统 增加删除个文件

eval的使用教程10

导出集合

mongoexport -d csdn -c book -o d:/book.json

导入集合

mongoimport --db csdn --collection book --file d:/book.json

导出数据库

mongodump --host 127.0.0.1:27017 -d csdn -o d:/

导入数据库

mongorestore --host 127.0.0.1:27017 -d csdn -directoryperdb d:/csdn

添加用户

db.addUser(“gg”,”12”)

开启auth认证后
--auth（服务器）

只有启用用户db.auth(“gg”,”12’)才能访问

显示用户

db.system.users.find()

主从服务器的配置 从服务器自动备份 以防主服务器down
教程13

服务器的副本集是为了 更加友好的备份  主从读写分离 对于大的数据集有用教程14

分片 空间不够 教程15

 

Java；

 

import java.net.UnknownHostException;

import java.util.List;

import java.util.Set;

 

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.DBObject;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

import com.mongodb.util.JSON;

public class Delo {

public static void main(String[] args){

try {

Mongo mongo = new Mongo("127.0.0.1:27017");

System.out.println(mongo);

List<String> dbname = mongo.getDatabaseNames();

for(String name:dbname){

System.out.println(name);

}

DB db = mongo.getDB("csdn");

Set<String> collname = db.getCollectionNames();

for(String name:collname){

System.out.println(name);

}

DBCollection bo = db.getCollection("book");

DBCursor cur = bo.find();

while(cur.hasNext()){

DBObject obj = cur.next();

System.out.println(obj.get("git"));

}

System.out.println(cur.count());

System.out.println(JSON.serialize(cur));

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MongoException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}

 

import java.net.UnknownHostException;

import java.util.ArrayList;

import java.util.List;

 

import javax.swing.plaf.basic.BasicOptionPaneUI;

 

import org.bson.types.ObjectId;

 

import com.mongodb.*;

 

public class Caozuo {

static Mongo connection = null;

static DB db = null;

 

public Caozuo(String dataBaseName) {

try {

connection = new Mongo("127.0.0.1:27017");

db = connection.getDB(dataBaseName);

} catch (UnknownHostException e) {

// TODO Auto-generated catch block

e.printStackTrace();

} catch (MongoException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

 

}

 

public static void main(String[] args) {

Caozuo caozuo = new Caozuo("csdn");

/*

 * caozuo.createCollection("person"); //单个插入
DBObject dbs = new

 * BasicDBObject(); dbs.put("name", "zhoucan"); dbs.put("age", 22);

 * List<String> book = new ArrayList<String>(); book.add("js");

 * book.add("mongo"); dbs.put("book", book);

 * caozuo.insert(dbs,"person");

 */

/* // 批量插入

List<DBObject> dbo = new ArrayList<DBObject>();

DBObject dys = new BasicDBObject("name", "dys");

DBObject dy = new BasicDBObject("name", "dy");

dbo.add(dys);

dbo.add(dy);

caozuo.insertBatch(dbo, "person");*/

//删除数据

caozuo.deleteById("55a1dda7e273245d0f4f6654","person");

//条件删除

/*DBObject dy = new BasicDBObject();

dy.put("name", "dy");

caozuo.deletebo(dy,"person");*/

//更新操作

/*DBObject update = new BasicDBObject();

update.put("$set", new BasicDBObject("email","12@qq.com"));

caozuo.update(new BasicDBObject("name","zhou"),update,false,true,"person");*/

//查询

/* DBObject keys = new BasicDBObject();

keys.put("_id", false);

keys.put("name", true);

keys.put("age", true);

DBCursor cur = caozuo.find(null,keys,"person");

while(cur.hasNext()){

DBObject object = cur.next();

System.out.println(object.get("name"));

}*/

//分页

DBObject keys = new BasicDBObject();

keys.put("_id", false);

keys.put("name", true);

keys.put("age", true);

DBCursor cur = caozuo.find(null,keys,1,1,"person");

while(cur.hasNext()){

DBObject object = cur.next();

System.out.println(object.get("name"));

}

connection.close();

}

public DBCursor find(DBObject ref,DBObject keys,int start,int limit,String collName){

DBCursor cur = find(ref,keys,collName);//调用下面的

return cur.limit(limit).skip(start);

}

public DBCursor find(DBObject ref,DBObject keys,String collName){

DBCollection coll = db.getCollection(collName);

DBCursor cur = coll.find(ref,keys);

return cur;

}

public void update(DBObject find,DBObject update,boolean upset,boolean multi,String collName){

DBCollection coll = db.getCollection(collName);

coll.update(find, update,upset,multi);

}

public void deletebo(DBObject find,String collName){

DBCollection coll = db.getCollection(collName);

coll.remove(find);

}

public void deleteById(String id,String collName){

DBCollection coll = db.getCollection(collName);

coll.remove(new BasicDBObject("_id",new ObjectId(id)));//如果id是对象就new object(id)

}

 

public void createCollection(String collName) {

DBObject dbs = new BasicDBObject();

db.createCollection(collName, dbs);

 

}

 

public void insert(DBObject dbs, String collName) {

DBCollection coll = db.getCollection(collName);

coll.insert(dbs);

}

public void insertBatch(List<DBObject> dbo,String collName){

DBCollection coll = db.getCollection(collName);

coll.insert(dbo);

}

 

}

 未经许可  可随机转载  说明出处    http://blog.csdn.net/dystryudutu   谢谢