MongoDB 4.0.10 CRUD操作(增删改查)

• 新增：当向集合插入文档时，如果没有给文档指定_id属性(可以自行指定)，则数据库会自动为文档添加一个_id，该属性用来作为文档的唯一标识，可以使用ObjectId()生成
• 一次性插入大量数据：可以先把所有数据放在一个新数组中，然后一次性插入数组

/* <collection>集合名，doc是需要插入的对象
db.<collection>.insert(doc)      向当前数据库的集合中插入一个或多个文档，doc为一个json对象或者json对象的List列表
db.<collection>.insertOne(doc)   向当前数据库的集合中 插入一个文档，doc为一个json对象
db.<collection>.insertMany(doc)  向当前数据库的集合中插入多个文档，doc为json对象的List列表
*/
// 示例如下
db.runoob.insert({title: 'MongoDB 教程', description: 'MongoDB 是一个Nosql数据库', by: '菜鸟教程', url: 'http://www.runoob.com', tags: ['mongodb', 'database', 'NoSQL'], likes: 1200 });
var doc1 = {title: 'HTML 教程', description: 'HTML编写网页', by: '菜鸟教程', url: 'http://www.runoob.com', tags: ['HTML', 'JavaScript', 'CSS'], likes: 1010 }
var doc2 = {title: 'ASP.NET 教程', description: 'ASP.NET编写网页', by: '菜鸟教程', url: 'http://www.runoob.com', tags: ['Web Froms', 'Web API', 'MVC', 'WCF'], likes: 1000 }
var doc3 = {title: 'JAVA 教程', description: 'JAVA编写网页', by: '菜鸟教程', url: 'http://www.runoob.com', tags: ['JSP', 'Spring'], likes: 1560}
db.runoob.insert([doc1,doc2,doc3]); //一次性插入多个数据
db.runoob.find()

• 删除：remove()方法不会真正的释放空间，需要继续执行db.repairDatabase()回收磁盘空间

/* db.<collection>.remove(<query>,<option>)   删除所有符合条件的文档，默认情况删除多个
option：justOne为true时，只删除一个，默认为false；writeConcern：抛出异常的级别
db.<collection>.remove({})        删除集合的所有文档，传递的是一个空参数，这是一条条删除，性能较低
db.<collection>.deleteOne()       删除一个符合条款的文档
db.<collection>.deleteMany()      删除所有的符合条件的文档
*/
db.runoob.remove({_id:ObjectId("5d352450b595146edeaac430")})
db.runoob.remove({by:"菜鸟教程"},true) //只删除一个
db.runoob.find()

• 修改

/* 如果需要修改指定属性，需要使用 修改操作符 $set:用来修改文档中的指定属性;$unset:用来删除文档中的指定属性
db.<collection>.update(<query>,<update>,<options>)  使用新对象替换符合查询条件的旧对象,当有多个符合条件的对象，默认只修改一个
<query>：查询条件，类似where语句；<update>：新文档，类似于update语句中的set，需要使用修改操作符
<options>：可选配置
    upsert：为true时，如果没有匹配到符合的文档，则进行插入，默认false；
    multi：为true时，可以一次性修改所有符合条件的文档；
    writeConcern：抛出异常的级别
可以修改可选参数配置的multi:true
db.<collection>.updateMany()     同时修改多个符合条件的文档
db.<collection>.updateOne()      修改一个符合条件的文档
db.<collection>.replaceOne()     替换一个文档
db.<collection>.save(doc)         保存文档
save()方法接受一个键值对对象作为参数，如果指定的文档已经存在于数据库中，就将其更新为指定的值，否则插入一个文档，应该是根据_id匹配
*/
db.runoob.update({title:"MongoDB 教程"},{by:"新菜鸟教程"})                     // 直接把{by:"新菜鸟教程"}替换到旧文档中了
db.runoob.update({title:"HTML 教程"},{$set:{url:"new url"},$inc:{likes:100}})    // set url="new url",likes+=100
db.runoob.update({title:"ASP.NET 教程"},{$unset:{url:""}})                    // 移除url属性
db.runoob.updateMany({by:"菜鸟教程"},{$set:{by:"新菜鸟教程"}})                  // 修改全部符合条件文档
db.runoob.update({by:"新菜鸟教程"},{$set:{by:"菜鸟教程"}},{multi:true})          // 修改全部符合条件文档
db.runoob.find()

• 查询

/* 传递的参数是筛选条件 {字段名：字段值} 等同 where 字段名=字段值
db.<collection>.find(query, projection)          查询集合中所有符合条件的文档,返回一个数组
db.<collection>.findOne(query, projection)       查询集合中所有符合元素的第一个文档，返回一个对象
db.<collection>.find(query, projection).count()  返回集合中所有符合元素的文档的数量，返回一个数字
db.<collection>.find(query, projection).pretty() 查询集合中所有符合条件的文档,格式化显示
query：查询条件；projection：使用投影操作符指定显示的字段
*/
db.runoob.find()               //select * from runoob
db.runoob.find({})             //select * from runoob
db.runoob.find({_id:ObjectId("5d352450b595146edeaac430")})     // select * from runoob where _id=ObjectId("5d352450b595146edeaac430")
db.runoob.find({by:"菜鸟教程",title:"MongoDB 教程"})             // select * from runoob where by="菜鸟教程" and title="MongoDB 教程"
db.runoob.findOne({by:"菜鸟教程"})　　　　　　　　　　　　　　　　　　// select TOP 1 * from runoob where by="菜鸟教程"
db.runoob.findOne({title:"MongoDB 教程"})._id　　　　　　　　　　　// 返回一个值=(select _id from runoob where title="MongoDB 教程")
db.runoob.find({}).count()                                     // select COUNT(1) from runoob
//select title from runoob where title="HTML 教程" {title:1,_id:0} 1代表显示，0代表不显示
db.runoob.find({title:"HTML 教程"},{title:1,_id:0})

db.runoob.distinct("tags",{by:"菜鸟教程"})     // 查找by="菜鸟教程"的tags属性组合为一个数组，且去重
db.runoob.find({"key.chl":values})            // 查找子文档属性key下的chl属性为values的文档

• Update()：修改新值使用的修改修饰符

$inc            　　// 增加
$rename            // 重命名某一列
$serOnInsert    　　// 当upsert为true时，并进行insert操作时，可以补充的字段
$set            　　// 用来修改文档中的指定属性
$unset             // 用来删除文档中的指定属性
db.runoob.update({title:"HTML 教程"},{$set:{url:"new url"},$inc:{likes:100}})    　　// set url="new url",likes+=100
db.runoob.update({title:"ASP.NET 教程"},{$rename:{url:"newurl"}})                   // 重命名某一列，将url列改为newurl
// 如果没有符合条件的文档，则直接插入该文档
db.runoob.update({title:"CSS 教程"},{$set:{description:"CSS learn"},$setOnInsert:{by:"菜鸟教程"}},{upsert:true})
db.runoob.updateMany({by:"菜鸟教程"},{$set:{by:"新菜鸟教程"}})                   　　// 修改全部符合条件文档
db.runoob.update({title:"ASP.NET 教程"},{$unset:{url:""}})                        // 移除url属性
$addToSet       // 在既有数组上添加元素，格式为 {$addToSet:{key:value}}，key为数组类型的属性
$pop            // 删除数组的第一个元素或最后一个元素，格式为 {$pop:{key:1/-1}}，key为数组类型的属性；为1时删除第一个元素，为-1时删除最后一个元素
$pullAll        // 从数组中删除多个值，格式为 {$pullAll:{key:[value1,value2...]}}
$pull           // 从数组中删除符合查询条件的文档，格式为 {$pull:{key:<query>}}
$push           // 在数组中添加一个元素，对于简单数组，格式为 {$push:{key:add_value}}；对于对象数组，格式为 {$push:{key:{field:add_value}}}
$each           // 在数组添加多个元素，格式为 {key:{$each:[value1,value2...]}}，{$push:{key:{$each:[value1,value2...]}}}，$push和$addToSet的限制符
$slice          // 用于限制更新后的数组长度，格式为 {key:{$slice:<num>}}，$push的限制符
$sort           // 用来将数组中的文档重新排序，$push的限制符
$bit            // 对整数值执行按位与和或元素，格式为 {$bit:{key:{and:<int>}}}，使用and、or、XOR

• 查询表达式
• 条件操作符：$gt：>大于；$lt：<小于；$gte：>=大于等于；$lte：<=小于等于；$ne：!=不等于；$eq：=等于；$in：in；$nin：not in；$all：指数组所有单元匹配；$size：判断数组类型的属性长度；$elemMatch：判断数组类型属性或者判断子文档数组中的字段
• 逻辑操作符：$or：or或者；$and：and；$not：not；$nor：指所有的列举条件都不应成功则为真；
• 元素运算符：$exists：某列存在则为真；$mod：满足某求余条件则为真；$type：匹配字段的数据类型，并返回结果
• limit()方法：接受一个数字参数，该参数指定从MongoDB中读取的记录条数
• skip()方法：来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数
• sort()方法：通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而 -1 是用于降序排列
• JS运算符：$where：js表达式为真则为真；$regex：正则表达式匹配为真则为真

db.col.find({key:value})                           // 等于 {<key>:<value>} where key=value
db.col.find({key:{$lt:1000}})                      // 小于 {<key>:{$lt:<value>}} where key<1000
db.col.find({key:{$lte:1000}})                     // 小于等于 {<key>:{$lte:<value>}} where key<=1000
db.col.find({key:{$gt:1000}})                      // 大于 {<key>:{$gt:<value>}} where key>1000
db.col.find({key:{$gte:1000}})                     // 大于等于 {<key>:{$gte:<value>}} where key>=1000
db.col.find({key:{$ne:1000}})                      // 不等于 {<key>:{$ne:<value>}} where key!=1000
db.col.find({key:{$gt:40,$lt:50}})                 // where key>40 and key<50
db.col.find({key:{$in:[value1,value2...]}})        // where key in (value1, value2)
db.col.find({key:{$nin:[value1,value2...]}})       // where key not in (value1, value2)
dd.col.find({key:{$all:[value1,value2...]}})       // 匹配key中包含value1,value2...元素的文档
db.col.find({key:{$size:N}})                       // key属性为数组类型，匹配key数组长度为N的文档

db.col.find({key1:value1, key2:value2})                      // and操作 where key1=value1 and key2=value2
db.col.find({$and:[{key:{$gte:100}},{key:{$lte:500}}]})      // and操作 where key>=100 and key<=500
db.col.find({$or:[{key1: value1},{key2:value2}]})            // or操作 where key1=value1 or key2=value2
db.col.find({key1:value1,$or:[{key2:value2},{key3:value3}]}) // where key1=value1 and (k2=v2 or k3=v3)
db.col.find({key:{$not:{$in:[10,12,13]}}})                   // where key not in(10,12,13)
db.col.find({$nor:[{key1:value1}, {key2:value2},....]})      // where key1!=value1 and key2!=value2.....

db.col.find({key:/教/})      // 查询key字段包含"教"字的文档 where key like '%教%'
db.col.find({key:/^教/})     // 查询key字段以"教"字开头的文档 where key like '%教'
db.col.find({key:/教$/})     // 查询key字段以"教"字结尾的文档 where key like '教%'

db.col.find({key:{$exists:1}})            // 不为0时匹配key属性存在的文档；为0时匹配key属性不存在的文档
db.col.find({key:{$mod:[5,0]}})           // 匹配key%5=0的文档
db.col.find({key: {$type : 2}})           // 匹配key字段中数据类型为string的文档
db.col.find({key: {$type : 'string'}})    // 匹配key字段中数据类型为string的文档

db.col.find().limit(10) 　　　　　　// 取符合条件的前10条文档
db.col.find().limit(10).skip(10)  // 跳过前10条文档，取第11-20条文档
db.col.find().sort({key:1}) 　　　 //查询出的结果安装key字段升序排列
//skip(), limit(), sort()三个放在一起执行的时候，执行的顺序是先 sort(), 然后是 skip()，最后是显示的 limit()
//skip()和limit()可以用于少量数据的分页，但是对于大数据情况下，假设查询第100001条数据，这条数据的key值是：2399927
db.col.sort({key:1}).skip(100000).limit(10)  　　　　　　　　　　　//183ms，按key升序排列，跳过前100000条文档，取10条文档
db.col.find({key:{$gt:2399927}}).sort({"amount":1}).limit(10)  //53ms，取大于key的文档，排序，取10条

db.col.find({$where:'this.likes>1000'}) // 匹配col集合中的likes>1000的文档，效率低
db.col.find({key:{$regex:正则表达式}})   // 匹配key属性中符合正则表达式的文档

• 配置数据库连接错误处理 

mongo = new Mongo('localhost:27017')        　　// 连接服务器
test = mongo.getDB('test')                     // 获取数据库test
// 配置数据库连接错误处理 
// w：指定数据库错误连接写入的等级(-1 忽略网络错误、0 不要求进行写入确认、1 要求写入确认、2 要求已写入到副本集的主节点和从节点、majority 要求已经写入复制集绝大数服务器)
// wtimeout：等待时间，单位毫秒
// j：布尔值，如果为true，则写入请求将会等到日记同步完成后返回
// fsync：布尔值，如果为true，则写入请求将会等到日记fsync完成后返回
test.runCommand({getLastError:1,w:1,j:true,wtimeout:1000});    
test.auth('DEV','123456')                      // 身份验证
numcoll = test.getCollection('numbers')        // 获取集合numbers
numcoll.insert({num:30000})                    // 插入数据
result = test.runCommand({getLastError:1})
if(result.err){
    print(result.err)
}