目录

MongoDB - 增删改查及聚合操作

一. 数据库操作(database)

  1.         Mysql       MongoDB
  2. 数据表      table       Collections
  3. 数据行      row         Documents
  4. 数据列      字段        Field

1. 创建及查看库

  1. 1. 有则使用这个数据库没有则创建
  3. 	use DATABASE_NAME
  5. 2. 查看当前选择的数据库, 默认是test
  7. 	db
  9. 3. 查看数据库，默认有admin、local和"test"，如果数据库生成但是没有集合（下面会讲）所以此时只有逻辑数据库产生并没有真正意义上的物理数据，这样看不到查询结果
  11. 	show dbs

2. 删除库

  1. use database_name #先切换到要删的库下
  3. db.dropDatabase() #删除当前库

二. 集合collectionc=操作(相当于SQL数据库中的表table)

1、增

  1. use db1#选择所在数据库
  2. #方式一：
  3. db.table1.insert({'a':1})#当第一个文档插入时，集合就会被创建并包含该文档
  4. #方式二：
  5. db.table2#创建一个空集合

2、查

  1. show collections
  2. show tables#两者等价

3、删

  1. db.table1.drop()
  3. #集合没有改的操作

三. 文件操作

1.增(insert)

  1. user0={
  2.     "_id":1,
  3.     "name":"alex",
  4.     "age":10,
  5.     'hobbies':['music','read','dancing'],
  6.     'addr':{
  7.         'country':'China',
  8.         'city':'weifang'
  9.     }
  10. }
  12. user1={
  13.     "_id":2,
  14.     "name":"wupeiqi",
  15.     "age":20,
  16.     'hobbies':['music','read','run'],
  17.     'addr':{
  18.         'country':'China',
  19.         'city':'hebei'
  20.     }
  21. }
  23. db.table1.insert(user0)	# 增加一个
  25. db.table1.insertMany([user0, user1])	# 增加多个

2.删(delect,remove)

  1. #1、删除符合条件的第一个文档
  2. db.user.deleteOne({ 'age': 8 })#第一个包含有 'age': 8的文档
  4. #2、删除符合条件的全部
  5. db.user.deleteMany( {'addr.country': 'China'} ) #只要有内嵌文档，且内容含有country': 'China'的全都删除
  6. db.user.deleteMany({"_id":{"$gte":3}})#删除id大于等于3的所有
  8. #3、删除全部
  9. db.user.deleteMany({}) #等于是清空该集合（表）

3.改(update)

1.简单修改

  1. db.user.update({}, {$set:{}})	# 默认修改第一条
  3. db.user.updateOne({age:99}, {$set:{"name":"JW8"}})	# 默认修改第一条, 官方推荐.
  5. db.user.updateMany({age:99}, {$set:{"name":"JW8"}})	# 更新所有符合条件的数据

2.加减操作: $inc

  1. #增加和减少$inc
  2. #年龄都+1
  3. db.user.update(
  4.     {},
  5.     {"$inc":{"age":1}},
  6.     {"multi":true}
  7. )
  8. #年龄都-10
  9. db.user.update(
  10.     {},
  11.     {"$inc":{"age":-10}},
  12.     {"multi":true}
  13. )

3.添加删除数组内元祖$push $pop $pull

$push的功能是往现有数组内添加元素

  1. #1、为名字为武大郎的人添加一个爱好read
  2. db.user.update({"name":"武大郎"},{"$push":{"hobbies":"read"}})
  4. #2、为名字为武大郎的人一次添加多个爱好tea，dancing
  5. db.user.update({"name":"武大郎"},{"$push":{
  6.     "hobbies":{"$each":["tea","dancing"]}
  7. }})

$pop的功能是按照位置只能从头或从尾即两端删元素，类似于队列。1代表尾，-1代表头

  1. #1、{"$pop":{"key":1}} 从数组末尾删除一个元素
  3. db.user.update({"name":"武大郎"},{"$pop":{
  4.     "hobbies":1}
  5. })
  7. #2、{"$pop":{"key":-1}} 从头部删除
  8. db.user.update({"name":"武大郎"},{"$pop":{
  9.     "hobbies":-1}
  10. })

$pull可以自定义条件删除

  1. db.user.update({'addr.country':"China"},{"$pull":{
  2.     "hobbies":"read"}
  3. },
  4. {
  5.     "multi":true
  6. }
  7. )

4.避免重复添加 $addToSet

即多个相同元素要求插入时只插入一条

  1. db.urls.insert({"_id":1,"urls":[]})
  3. db.urls.update(
  4.      {"_id":1},
  5.      {
  6.     "$addToSet":{
  7.         "urls":{
  8.         "$each":[
  9.             'http://www.baidu.com',
  10.             'http://www.baidu.com',
  11.             'http://www.xxxx.com'
  12.             ]
  13.             }
  14.         }
  15.     }
  16. )

5.限制大小,排序

  1. #1、了解：限制大小"$slice"，只留最后n个
  3. db.user.update({"_id":5},{
  4.     "$push":{"hobbies":{
  5.         "$each":["read",'music','dancing'],
  6.         "$slice":-2
  7.     }
  8.     }
  9. })
  11. #2、了解：排序The $sort element value must be either 1 or -1"
  12. db.user.update({"_id":5},{
  13.     "$push":{"hobbies":{
  14.         "$each":["read",'music','dancing'],
  15.         "$slice":-1,
  16.         "$sort":-1
  17.     }
  18.     }
  19. })
  21. #注意：不能只将"$slice"或者"$sort"与"$push"配合使用，且必须使用"$each"

4.查

1.简单用法

  1. db.user.find({})	# 查询所有符合条件的数据
  2. db.th.findOne({})	# 查询符合条件的第一条数据	
  4. db.th.findOne({name:2})	# 查询name字段 == 2 的数据
  5. db.stu.find({name:"辉哥",age:99})	# 并列条件 name与age 同时满足的

2.比较运算：=，!= ('$ne') ，> ('$gt') ，< ('$lt') ，>= ('$gte') ，<= ('$lte')

  1. =，!= ('$ne') ，> ('$gt') ，< ('$lt') ，>= ('$gte') ，<= ('$lte')
  2. #1、select * from db1.user where id = 3
  3. db.user.find({"_id":3})
  5. #2、select * from db1.user where id != 3
  6. db.user.find({"_id":{"$ne":3}})
  8. #3、select * from db1.user where id > 3
  9. db.user.find({"_id":{"$gt":3}})
  11. #4、select * from db1.user where age < 3
  12. db.user.find({"age":{"$lt":3}})
  14. #5、select * from db1.user where id >= 3
  15. db.user.find({"_id":{"$gte":3}})
  17. #6、select * from db1.user where id <= 3
  18. db.user.find({"_id":{"$lte":3}})

3.逻辑运算：MongoDB中字典内用逗号分隔多个条件是and关系，或者直接用$and，$o，r$not（与或非）

  1. #逻辑运算:$and,$or,$not
  2. #1 select * from db1.user where id >=3 and id <=4;
  3. db.user.find({"_id":{"$gte":3,"$lte":4}})
  5. #2 select * from db1.user where id >=3 and id <=4 and age >=40;
  6. db.user.find({
  7.     "_id":{"$gte":3,"$lte":4},
  8.     "age":{"$gte":40}
  9. })
  11. db.user.find({"$and":[
  12. {"_id":{"$gte":3,"$lte":4}},
  13. {"age":{"$gte":40}}
  14. ]})
  16. #3 select * from db1.user where id >=0 and id <=1 or id >=4 or name = "yuanhao";
  17. db.user.find({"$or":[
  18. {"_id":{"$lte":1,"$gte":0}},
  19. {"_id":{"$gte":4}},
  20. {"name":"yuanhao"}
  21. ]})
  23. #4 select * from db1.user where id % 2 = 1;
  24. db.user.find({"_id":{"$mod":[2,1]}})
  26. db.user.find({
  27.     "_id":{"$not":{"$mod":[2,1]}}
  28. })

4.成员运算：成员运算无非in和not in，MongoDB中形式为$in ， $nin

  1. #1、select * from db1.user where age in (20,30,31);
  2. db.user.find({"age":{"$in":[20,30,31]}})
  4. #2、select * from db1.user where name not in ('alex','yuanhao');
  5. db.user.find({"name":{"$nin":['Stefan','Damon']}})

5.正则：正则定义在/ /内

  1. # MongoDB: /正则表达/i
  3. #1、select * from db1.user where name regexp '^j.*?(g|n)$';
  4. db.user.find({'name':/^j.*?(g|n)$/i})#匹配规则：j开头、g或n结尾，不区分大小写

6.查看指定字段：0表示不显示1表示显示

  1. #1、select name,age from db1.user where id=3;
  2. db.user.find({'_id':3},{'_id':0,'name':1,'age':1})
  4. #2、select name,age from db1.user where name regexp "^jin.*?(g|n)$";
  5. db.user.find({
  6.     "name":/^jin.*?(g|n)$/i
  7. },
  8. {
  9.     "_id":0,
  10.     "name":1,
  11.     "age":1
  12. }
  13. )

7.对数组的查询：

  1. #查询数组相关
  2. #查hobbies中有dancing的人
  3. db.user.find({
  4.     "hobbies":"dancing"
  5. })
  6. #查看既有dancing爱好又有tea爱好的人
  7. db.user.find({
  8.     "hobbies":{"$all":["dancing","tea"]}
  9. })
  10. #查看第2个爱好为dancing的人
  11. db.user.find({
  12.     "hobbies.2":"dancing"
  13. })
  14. #查看所有人的第2个到第3个爱好
  15. db.user.find(
  16. {},
  17. {
  18.     "_id":0,
  19.     "name":0,
  20.     "age":0,
  21.     "addr":0,
  22.     "hobbies":{"$slice":[1,2]},
  23. }
  24. )
  26. #查看所有人最后两个爱好，第一个{}表示查询条件为所有，第二个是显示条件
  27. db.user.find(
  28. {},
  29. {
  30.     "_id":0,
  31.     "name":0,
  32.     "age":0,
  33.     "addr":0,
  34.     "hobbies":{"$slice":-2},
  35. }
  36. )
  38. #查询子文档有"country":"China"的人
  39. db.user.find(
  40. {
  41.     "addr.country":"China"
  42. }
  43. )

8.对查询结果进行排序：sort() 1代表升序、-1代表降序

  1. db.user.find().sort({"name":1,})
  2. db.user.find().sort({"age":-1,'_id':1})

9.分页：limit表示取多少个document，skip代表跳过几个document

  1. #这样就做到了分页的效果
  2. db.user.find().limit(2).skip(0)#前两个
  3. db.user.find().limit(2).skip(2)#第三个和第四个
  4. db.user.find().limit(2).skip(4)#第五个和第六个

10.获取数量：count()

  1. #查询年龄大于30的人数
  2. #方式一：
  3. db.user.count({'age':{"$gt":30}}) 
  5. #方式二：
  6. db.user.find({'age':{"$gt":30}}).count()

11.其他

  1. #1、查找所有
  2. db.user.find() #等同于db.user.find({})
  3. db.user.find().pretty()
  4. #2、去重
  5. db.user.find().distinct()
  7. #3、{'key':null} 匹配key的值为null或者没有这个key
  8. db.t2.insert({'a':10,'b':111})
  9. db.t2.insert({'a':20})
  10. db.t2.insert({'b':null})
  11. db.t2.find({"b":null})#得到的是b这个key的值为null和没有b这个key的文档
  12. { "_id" : ObjectId("5a5cc2a7c1b4645aad959e5a"), "a" : 20 }
  13. { "_id" : ObjectId("5a5cc2a8c1b4645aad959e5b"), "b" : null }

四. 聚合操作

我们在查询时肯定会用到聚合，在MongoDB中聚合为aggregate，聚合函数主要用到$match $group $avg $project $concat

设我们的数据库中有这样的数据

  1. from pymongo import MongoClient
  2. import datetime
  4. client=MongoClient('mongodb://root:123@localhost:27017')
  5. table=client['db1']['emp']
  6. # table.drop()
  8. l=[
  9. ('武大郎','male',18,'20170301','烧饼检察官',7300.33,401,1),
  10. ('武松','male',78,'20150302','公务员',1000000.31,401,1),
  11. ('宋江','male',81,'20130305','公务员',8300,401,1),
  12. ('林冲','male',73,'20140701','公务员',3500,401,1),
  13. ('柴进','male',28,'20121101','公务员',2100,401,1),
  14. ('卢俊义','female',18,'20110211','公务员',9000,401,1),
  15. ('高俅','male',18,'19000301','公务员',30000,401,1),
  16. ('鲁智深','male',48,'20101111','公务员',10000,401,1),
  18. ('史进','female',48,'20150311','打手',3000.13,402,2),
  19. ('李逵','female',38,'20101101','打手',2000.35,402,2),
  20. ('周通','female',18,'20110312','打手',1000.37,402,2),
  21. ('石秀','female',18,'20160513','打手',3000.29,402,2),
  22. ('李忠','female',28,'20170127','打手',4000.33,402,2),
  24. ('吴用','male',28,'20160311','文人',10000.13,403,3),
  25. ('萧让','male',18,'19970312','文人',20000,403,3),
  26. ('安道全','female',18,'20130311','文人',19000,403,3),
  27. ('公孙胜','male',18,'20150411','文人',18000,403,3),
  28. ('朱贵','female',18,'20140512','文人',17000,403,3)
  29. ]
  31. for n,item in enumerate(l):
  32.     d={
  33.         "_id":n,
  34.         'name':item[0],
  35.         'sex':item[1],
  36.         'age':item[2],
  37.         'hire_date':datetime.datetime.strptime(item[3],'%Y%m%d'),
  38.         'post':item[4],
  39.         'salary':item[5]
  40.     }
  41.     table.save(d)

$match和 $group：相当于sql语句中的where和group by

  1. {"$match":{"字段":"条件"}},可以使用任何常用查询操作符$gt,$lt,$in等
  3. #例1、select * from db1.emp where post='公务员';
  4. db.emp.aggregate({"$match":{"post":"公务员"}})
  6. #例2、select * from db1.emp where id > 3 group by post;
  7. db.emp.aggregate(
  8.     {"$match":{"_id":{"$gt":3}}},
  9.     {"$group":{"_id":"$post",'avg_salary':{"$avg":"$salary"}}}
  10. )
  12. #例3、select * from db1.emp where id > 3 group by post having avg(salary) > 10000;
  13. db.emp.aggregate(
  14.     {"$match":{"_id":{"$gt":3}}},
  15.     {"$group":{"_id":"$post",'avg_salary':{"$avg":"$salary"}}},
  16.     {"$match":{"avg_salary":{"$gt":10000}}}
  17. )

$group具体

  1. {"$group":{"_id":分组字段,"新的字段名":聚合操作符}}
  3. #1、将分组字段传给$group函数的_id字段即可
  4. {"$group":{"_id":"$sex"}} #按照性别分组
  5. {"$group":{"_id":"$post"}} #按照职位分组
  6. {"$group":{"_id":{"state":"$state","city":"$city"}}} #按照多个字段分组，比如按照州市分组
  8. #2、分组后聚合得结果,类似于sql中聚合函数的聚合操作符：$sum、$avg、$max、$min、$first、$last
  9. #例1：select post,max(salary) from db1.emp group by post;
  10. db.emp.aggregate({"$group":{"_id":"$post","max_salary":{"$max":"$salary"}}})
  12. #例2：取每个部门最大薪资与最低薪资
  13. db.emp.aggregate({"$group":{"_id":"$post","max_salary":{"$max":"$salary"},"min_salary":{"$min":"$salary"}}})
  15. #例3：如果字段是排序后的，那么$first,$last会很有用,比用$max和$min效率高
  16. db.emp.aggregate({"$group":{"_id":"$post","first_id":{"$first":"$_id"}}})
  18. #例4：求每个部门的总工资
  19. db.emp.aggregate({"$group":{"_id":"$post","count":{"$sum":"$salary"}}})
  21. #例5：求每个部门的人数
  22. db.emp.aggregate({"$group":{"_id":"$post","count":{"$sum":1}}})
  24. #3、数组操作符
  25. {"$addToSet":expr}#不重复
  26. {"$push":expr}#重复
  28. #例：查询岗位名以及各岗位内的员工姓名:select post,group_concat(name) from db1.emp group by post;
  29. db.emp.aggregate({"$group":{"_id":"$post","names":{"$push":"$name"}}})
  30. db.emp.aggregate({"$group":{"_id":"$post","names":{"$addToSet":"$name"}}})

$project：用于投射，即设定该键值对是否保留。1为保留，0为不保留，可对原有键值对做操作后增加自定义表达式

  1. {"$project":{"要保留的字段名":1,"要去掉的字段名":0,"新增的字段名":"表达式"}}
  3. #select name,post,(age+1) as new_age from db1.emp;
  4. db.emp.aggregate(
  5.     {"$project":{
  6.         "name":1,
  7.         "post":1,
  8.         "new_age":{"$add":["$age",1]}
  9.         }
  10. })

更多自定义表达式

  1. #1、表达式之数学表达式
  2. {"$add":[expr1,expr2,...,exprN]} #相加
  3. {"$subtract":[expr1,expr2]} #第一个减第二个
  4. {"$multiply":[expr1,expr2,...,exprN]} #相乘
  5. {"$divide":[expr1,expr2]} #第一个表达式除以第二个表达式的商作为结果
  6. {"$mod":[expr1,expr2]} #第一个表达式除以第二个表达式得到的余数作为结果
  8. #2、表达式之日期表达式:$year,$month,$week,$dayOfMonth,$dayOfWeek,$dayOfYear,$hour,$minute,$second
  9. #例如：select name,date_format("%Y") as hire_year from db1.emp
  10. db.emp.aggregate(
  11.     {"$project":{"name":1,"hire_year":{"$year":"$hire_date"}}}
  12. )
  14. #例如查看每个员工的工作多长时间
  15. db.emp.aggregate(
  16.     {"$project":{"name":1,"hire_period":{
  17.         "$subtract":[
  18.             {"$year":new Date()},
  19.             {"$year":"$hire_date"}
  20.         ]
  21.     }}}
  22. )
  24. #3、字符串表达式
  25. {"$substr":[字符串/$值为字符串的字段名,起始位置,截取几个字节]}
  26. {"$concat":[expr1,expr2,...,exprN]} #指定的表达式或字符串连接在一起返回,只支持字符串拼接
  27. {"$toLower":expr}
  28. {"$toUpper":expr}
  30. db.emp.aggregate( {"$project":{"NAME":{"$toUpper":"$name"}}})
  32. #4、逻辑表达式
  33. $and
  34. $or
  35. $not

排序：$sort、限制：$limit、跳过：$skip

  1. {"$sort":{"字段名":1,"字段名":-1}} #1升序，-1降序
  2. {"$limit":n}
  3. {"$skip":n} #跳过多少个文档
  5. #例1、取平均工资最高的前两个部门
  6. db.emp.aggregate(
  7. {
  8.     "$group":{"_id":"$post","平均工资":{"$avg":"$salary"}}
  9. },
  10. {
  11.     "$sort":{"平均工资":-1}
  12. },
  13. {
  14.     "$limit":2
  15. }
  16. )
  17. #例2、
  18. db.emp.aggregate(
  19. {
  20.     "$group":{"_id":"$post","平均工资":{"$avg":"$salary"}}
  21. },
  22. {
  23.     "$sort":{"平均工资":-1}
  24. },
  25. {
  26.     "$limit":2
  27. },
  28. {
  29.     "$skip":1
  30. }
  31. )

随机选取n个：$sample

  1. #集合users包含的文档如下
  2. { "_id" : 1, "name" : "dave123", "q1" : true, "q2" : true }
  3. { "_id" : 2, "name" : "dave2", "q1" : false, "q2" : false  }
  4. { "_id" : 3, "name" : "ahn", "q1" : true, "q2" : true  }
  5. { "_id" : 4, "name" : "li", "q1" : true, "q2" : false  }
  6. { "_id" : 5, "name" : "annT", "q1" : false, "q2" : true  }
  7. { "_id" : 6, "name" : "li", "q1" : true, "q2" : true  }
  8. { "_id" : 7, "name" : "ty", "q1" : false, "q2" : true  }
  10. #下述操作时从users集合中随机选取3个文档
  11. db.users.aggregate(
  12.    [ { $sample: { size: 3 } } ]
  13. )

练习题

  1. 查询岗位名以及各岗位内的员工姓名

  2. 查询岗位名以及各岗位内包含的员工个数

  3. 查询公司内男员工和女员工的个数

  4. 查询岗位名以及各岗位的平均薪资、最高薪资、最低薪资

  5. 查询男员工与男员工的平均薪资，女员工与女员工的平均薪资

  6. 查询各岗位内包含的员工个数小于2的岗位名、岗位内包含员工名字、个数

  7. 查询各岗位平均薪资大于10000的岗位名、平均工资

  8. 查询各岗位平均薪资大于10000且小于20000的岗位名、平均工资

  9. 查询所有员工信息，先按照age升序排序，如果age相同则按照hire_date降序排序

  10. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资升序排列

  11. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资降序排列,取前1个

    1. 1. 查询岗位名以及各岗位内的员工姓名
    2. db.emp.aggregate({"$group":{"_id":"$post","names":{"$push":"$name"}}})
    4. 2. 查询岗位名以及各岗位内包含的员工个数
    5. db.emp.aggregate({"$group":{"_id":"$post","count":{"$sum":1}}})
    7. 3. 查询公司内男员工和女员工的个数
    8. db.emp.aggregate({"$group":{"_id":"$sex","count":{"$sum":1}}})
    10. 4. 查询岗位名以及各岗位的平均薪资、最高薪资、最低薪资
    11. db.emp.aggregate({"$group":{"_id":"$post","avg_salary":{"$avg":"$salary"},"max_salary":{"$max":"$salary"},"min_salary":{"$min":"$salary"}}})
    13. 5. 查询男员工与男员工的平均薪资，女员工与女员工的平均薪资
    14. db.emp.aggregate({"$group":{"_id":"$sex","avg_salary":{"$avg":"$salary"}}})
    16. 6. 查询各岗位内包含的员工个数小于2的岗位名、岗位内包含员工名字、个数
    17. db.emp.aggregate(
    18. {
    19.     "$group":{"_id":"$post","count":{"$sum":1},"names":{"$push":"$name"}}
    20. },
    21. {"$match":{"count":{"$lt":2}}},
    22. {"$project":{"_id":0,"names":1,"count":1}}
    23. )
    25. 7. 查询各岗位平均薪资大于10000的岗位名、平均工资
    26. db.emp.aggregate(
    27. {
    28.     "$group":{"_id":"$post","avg_salary":{"$avg":"$salary"}}
    29. },
    30. {"$match":{"avg_salary":{"$gt":10000}}},
    31. {"$project":{"_id":1,"avg_salary":1}}
    32. )
    34. 8. 查询各岗位平均薪资大于10000且小于20000的岗位名、平均工资
    35. db.emp.aggregate(
    36. {
    37.     "$group":{"_id":"$post","avg_salary":{"$avg":"$salary"}}
    38. },
    39. {"$match":{"avg_salary":{"$gt":10000,"$lt":20000}}},
    40. {"$project":{"_id":1,"avg_salary":1}}
    41. )
    43. 9. 查询所有员工信息，先按照age升序排序，如果age相同则按照hire_date降序排序
    44. db.emp.aggregate(
    45. {"$sort":{"age":1,"hire_date":-1}}
    46. )
    48. 10. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资升序排列
    49. db.emp.aggregate(
    50. {
    51.     "$group":{"_id":"$post","avg_salary":{"$avg":"$salary"}}
    52. },
    53. {"$match":{"avg_salary":{"$gt":10000}}},
    54. {"$sort":{"avg_salary":1}}
    55. )
    57. 11. 查询各岗位平均薪资大于10000的岗位名、平均工资,结果按平均薪资降序排列,取前1个
    58. db.emp.aggregate(
    59. {
    60.     "$group":{"_id":"$post","avg_salary":{"$avg":"$salary"}}
    61. },
    62. {"$match":{"avg_salary":{"$gt":10000}}},
    63. {"$sort":{"avg_salary":-1}},
    64. {"$limit":1},
    65. {"$project":{"date":new Date,"平均工资":"$avg_salary","_id":0}}
    66. )

MongoDB - 增删改查及聚合操作的更多相关文章

  1. mongoDB 学习笔记纯干货（mongoose、增删改查、聚合、索引、连接、备份与恢复、监控等等）

    最后更新时间:2017-07-13 11:10:49 原始文章链接:http://www.lovebxm.com/2017/07/13/mongodb_primer/ MongoDB - 简介 官网: ...

  2. mongoDB （mongoose、增删改查、聚合、索引、连接、备份与恢复、监控等等）

    MongoDB - 简介 官网:https://www.mongodb.com/ MongoDB 是一个基于分布式文件存储的数据库,由 C++ 语言编写,旨在为 WEB 应用提供可扩展的高性能数据存储 ...

  3. C# 对MongoDB 进行增删改查的简单操作

    C# 对MongoDB 进行增删改查的简单操作   下面演示下C#操作MongoDB驱动的简单的增删改查代码 运用到的MongoDB支持的C#驱动,当前版本为1.6.0 1,连接数据库   /// & ...

  4. 【转】mongoDB 学习笔记纯干货（mongoose、增删改查、聚合、索引、连接、备份与恢复、监控等等）

    mongoDB 学习笔记纯干货(mongoose.增删改查.聚合.索引.连接.备份与恢复.监控等等) http://www.cnblogs.com/bxm0927/p/7159556.html

  5. 数据库——MongoDB增删改查

    MongoDB增删改查操作 本文包含对数据库.集合以及文档的基本增删改查操作 数据库操作 #1.增 use config #如果数据库不存在,则创建并切换到该数据库,存在则直接切换到指定数据库. #2 ...

  6. Yii2.0高级框架数据库增删改查的一些操作（转）

    yii2.0框架是PHP开发的一个比较高效率的框架,集合了作者的大量心血,下面通过用户为例给大家详解yii2.0高级框架数据库增删改查的一些操作 --------------------------- ...

  7. OracleHelper(对增删改查分页查询操作进行了面向对象的封装，对批量增删改操作的事务封装)

    公司的一个新项目使用ASP.NET MVC开发,经理让我写个OracleHelper,我从网上找了一个比较全的OracleHelper类,缺点是查询的时候返回DataSet,数据增删改要写很多代码(当 ...

  8. Yii2.0高级框架数据库增删改查的一些操作

    yii2.0框架是PHP开发的一个比较高效率的框架,集合了作者的大量心血,下面通过用户为例给大家详解yii2.0高级框架数据库增删改查的一些操作 --------------------------- ...

  9. MongoDB学习笔记,基础+增删改查+索引+聚合...

    一 基础了解 对应关系 -> https://docs.mongodb.com/manual/reference/sql-comparison/ database -> database ...

随机推荐

  1. es bulk 批量删除

    bulk [root@hadoop2 ~]# cat bulk.del.es.json {"delete":{"_index":"direct_vot ...

  2. 关于PowerDesigner导出数据库表到word文档

    关于PowerDesigner导出数据库表到word文档 一.查看全部模板: powerdesigner默觉得我们提供了非常多的模版,在工具栏中选择[Report(报告)--->Report T ...

  3. JavaScript Patterns 2.6 switch Pattern

    Principle • Aligning each case with switch(an exception to the curly braces indentation rule). • Ind ...

  4. bzoj4872

    期望dp 首先如果k=n的话,那么我们从后往前,只要看到两者的灯就关上,因为如果当前一个灯没关上,那么之后不可能关上,一个灯只能由自己倍数控制,所以这样我们就计算出了需要操作的次数,如果这个次数< ...

  5. Scala 返回多个值

    class A{ var c var d def return={ (c,d,"soyo") //以元组形式返回 }}调用: val s=new A var(a1,a2,a3)=s ...

  6. hadoop-Combiner作用用法

    文章来源http://blog.csdn.net/ipolaris/article/details/8723782 reduce的输入每个key所对应的value将是一大串1,但处理的文本很多时,这一 ...

  7. [Swift通天遁地]四、网络和线程-(2)通过BlockOperation实现线程的队列

    ★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★➤微信公众号:山青咏芝(shanqingyongzhi)➤博客园地址:山青咏芝(https://www.cnblogs. ...

  8. 修改docker-toolbox/boot2docker容器镜像

    进入虚拟机 vi /var/lib/boot2docker/profile 编辑在EXTRA_ARGS,加入 --registry-mirror=https://pee6w651.mirror.ali ...

  9. JavaScript:常用总结

    ● 语法要点 ● 引用类型 ● BOM/DOM ● 事件要点 一.语法要点 1.在声明变量时,如果省去了var关键字,那么这个变量为全局变量. 2.数据类型有5种原始类型和9种引用类型: 原始类型中: ...

  10. [ SDOI 2011 ] 打地鼠

    \(\\\) \(Description\) 给出一个\(N\times M\)的矩阵,你可以自由确定一个\(R\times C(R,C>0)\)的矩形,使得可以多个用矩形覆盖整个矩阵,覆盖的定 ...