MongoDB语言命令

MongoDB shell

1、MongoDB用文档的形式存储数据，BSON的数据格式。
2、MongoDB与传统数据库相比，集合相当于表，文档相当于记录，不需要提前定义好数据模型。
3、MongoDB的写操作的原子性限制在文档级别，单个文档不能超过16MB。
4、shell的使用 启动shell的命令 mongosh --port 端口号

注意：mongoDB shell中命令是区分大小写
cls 清屏
1、切换数据库，如果该数据库不存在会新建该数据
use database_name
2、显示所有的数据库，注意：如果某数据不存在集合，是看不到的
show dbs
3、创建集合
db.createCollection(“c1”)
4、显示当前数据库
db
5、删除当前数据库
db.dropDatabase()
6、显示当前数据的所有集合
show collections
7、使用insert函数增加一条文档，如果集合不存在，同时会创建集合
db.collection_name.insertOne({name:“tom”,age:20})
8、删除指定的集合
db.collection_name.drop()
9、插入包含数组元素的文档
db.class1.insertOne({name:“joe”,scores:[80,78,90]})
10、查看指定集合中所有的文档
db.collection_name.find()等同于db.collection_name.find({})
11、根据指定的条件进行查询
db.collection_name.find({_id:1})
12、完全替换整个文档
db.collection_name.update({_id:2},{name:“tom1”})
13、修改指定字段需要借助KaTeX parse error: Expected '}', got 'EOF' at end of input: …pdate({_id:4},{set:{name:“tom1”}})
14、删除指定的文档
db.class1.deleteOne({_id:1});
15、加载js文件，注意编码
test.js
dbservice=connect(“localhost:27017”)//连接数据库
db=dbservice.getSiblingDB(“test0226”)//选择数据库
db.class1.drop()//删除集合
for(i=0;i<100;i++){
db.class1.insertOne({name:“tom”,age:20})//插入文档
}
var cursor=db.class1.find()//查询所有文档
while(cursor.hasNext()){
printjson(cursor.toArray())//迭代输出
}

命令行方式加载 mongosh d:/demo/test.js 可选参数–quiet（启动时不显示冗余的信息）
mongo shell方式加载 load(“d:/demo/test.js”)

MongoDB数据类型

查询的语法：find({field:value})
db.stu.insertOne({name:“zhangsan”})
db.stu.insertOne({name:“lisi”,age:null})
db.stu.find({age:null})会把不存在age字段和age为null的文档都查询到
查询name的value值为string类型的文档
db.stu.find({name:{$type:2}})

插入32位整型数据
db.stu.insertOne({_id:1,name:“tom”,age:NumberInt(20)})
插入64位整型数据
db.stu.insertOne({_id:2,name:“tom”,age:NumberLong(21)})
查询姓名包含tom的文档
db.stu.find({name:/tom/})
查询姓李的学生的文档
db.stu.find({name:/^李/})
每一条文档默认存在一个字段_id，服务器生成ObjectId类型

插入Date类型
db.stu.insertOne({name:“Tom”,inputDate:Date()})
var c1=Date(); //返回一个字符串（string），没有getDate等日期对象方法，内容为当前时间
var c2= new Date(); //返回一日期对象，可以调用toString()转换成字符串

插入时间戳类型
获取当前时间的时间戳：var a=Date.parse(new Date())
db.stu.insertOne({name:“张六”,age:21,grade:90,ts:a})

ObjectId() mongodb shell内建的用于创建ObjectId对象的函数
getTimestamp() 提取前四个字节的时间戳，返回值是date类型
valueOf() 用于取得ObjectId16进制字符串的表示
x=ObjectId()
x.getTimestamp()
x.valueOf()

在描述复杂的数据类型，可以选择内嵌文档（嵌套文档），或者用引用文档
内嵌文档：非扁平化设计，阅读自然，更新方便，针对一条文档加锁就可以了

子文档小，更新不是很频繁的时候，建议内嵌文档
子文档大，经常变化，建议引用文档

数据插入

db.class1.drop()
一：添加文档
1、语法：db.collection.insertOne({document})
2、插入1条文档
db.class1.insertOne({name:“tom”})
3、插入1条复杂文档
db.class1.insertOne({_id:0,name:“tom”,age:20})
4、插入变量
var doc1={name:“tom”,address:{provice:“hebei”,city:“shijiazhuang”}}
db.class1.insertOne(doc1)
5、插入多条文档，注意[]的使用
db.class1.insertMany([{name:“tom”},{name:“jerry”}])
6、有序插入文档
db.class1.insertMany([{_id:1,name:“tom”,age:20},{_id:2,name:“jerry”,age:21}])
db.class1.insertMany([{_id:1,name:“tom”,age:20},{_id:3,name:“jerry”,age:21}],{ordered:false})
除了出错记录，其他记录继续插入
db.class1.insertMany([{_id:1,name:“tom”,age:20},{_id:4,name:“jerry”,age:21}],{ordered:true})
如果出错，一条记录都不插入，保持原子性，默认为true
7、写安全级别设置
db.products.insertOne(
{ item: “envelopes”, qty : 100, type: “Clasp” },
{ writeConcern: { w: 0, wtimeout: 5000 } }
)
db.products.insertOne(
{ item: “envelopes”, qty : 100, type: “Clasp” },
{ writeConcern: { w: 1, wtimeout: 5000 } }
)

db.products.insertOne(
{ item: “envelopes”, qty : 100, type: “Clasp” },
{ writeConcern: { w: 1, j:true,wtimeout: 5000 } }
)
非确认式写入：无法保证数据的正确性
优点：写入速度快，效率高，更新操作不会被阻塞
缺点：无法保证是否真的插入数据，会出现插入无效数据（重复_id）
确认式写入：保证了数据正确性，无法保证数据的安全性，
因为返回结果针对的是内存是否写入成功，无法保证持久化
日志写入：可以保证持久化，保证数据恢复
复制集写入：保证复制集写入成功

数据查询

for(i=0;i<10;i++){
db.c1.insertOne({_id:i,name:"user"+i,age:20+i})
}


1、复合条件的查询，一般用,分割
db.c1.find({_id:1,name:"user1"})
2、字段映射
db.c1.find({},{name:1})
db.c1.find({},{_id:0,name:1})
db.c1.find({},{name:0})
db.c1.find({},{name:0,age:1}) //错误

options选项
//查询前三条文档，从第一条开始
db.c1.find({},{},{limit:3})或者
db.c1.find().limit(3)
//从第六条开始显示
db.c1.find({},{},{skip:5})
db.c1.find().skip( 5 )
查询第3-5条的文档
db.c1.find({},{},{skip:2,limit:3})等价于db.c1.find().limit(3).skip(2)

按照id倒序排序
db.c1.find({},{},{sort:{_id:-1}})

3、查询操作符的使用
1）比较查询操作符  $e  $ne $gt $lt $in $nin 语法{field:{operator:value}}
$in $nin 的值是数组
db.c1.find({age:20})等价于db.c1.find({age:{$eq:20}})
查询年龄大于等于20岁的文档
db.c1.find({age:{$gte:20}})
查询23到25之间的文档
db.c1.find({age:{$in:[23,24,25]}})等价于$gte  $lte
db.c1.find({age:{$gte:23,$lte:25}})

2）逻辑操作符 
$and（多个条件都满足） $or（至少满足一个条件） $nor（多个条件都不满足）的值都是数组，
$not  值是一个表达式
$and有显示和隐式 
db.c1.find({_id:1,name:"qq"})
等价于db.c1.find({$and:[{_id:1},{name:"qq"}]})
查询age等于23或者age等于27的文档
 db.c1.find({$or:[{age:23},{age:27}]})

查询age小于23或者age 大于27的文档
 db.c1.find({$or:[{age:{$lt:23}},{age:{$gt:27}}]})//正确

db.c1.find({age:{$not:{$gte:23,$lte:27}}})
 //这种方式会把age 为null的都显示出来
$not操作符的值需要包含操作符

查询23<=age<=27的文档
db.c1.find({$and:[{age:{$gte:23}},{age:{$lte:27}}]})
db.c1.find({$nor:[{age:{$lt:23}},{age:{$gt:27}}]})

 某些时候只能用显式$and:[{$or:[{}]},{$or:[{}]}]
查找名字为user2或者名字为user5并且age小于23或者age 大于27的文档
db.c1.find({$and:[{$or:[{name:"user2"},{name:"user5"}]},{$or:[{age:{$lt:23}},{age:{$gt:27}}]}]})

元素操作符
db.c1.find({major:{$exists:true}})
查询存在字段major的文档
db.c1.find({age:{$type:1}})
查询age的值是double类型的文档

$where 参数是js字符串，用于同一条文档，字段之间的比较
db.fruit.insertOne({apple:10,pear:20})
db.fruit.insertOne({apple:10,pear:10})
db.fruit.find({$where:"this.apple==this.pear"})
db.fruit.find({$where:"this.apple>this.pear"})
内嵌文档的查询
1）完整的子文档的匹配，内容和顺序都必须一致
db.class1.find({address:{
provice:"Hebei",
city:"shijiazhuang"
}})
2)子文档某个字段的匹配方式，注意""
db.class1.find({"address.provice":"Hebei"})

数组查询
db.query_array.insertMany([{_id:5,name:"xiaoli",age:20,scores:[95,98,99]},
                       {_id:6,name:"xiaoli",age:20,scores:[95,99]},
     {_id:7,name:"xiaoli",age:20,scores:[95,99,98]}
                       ])
1）
数组元素存储基本数据类型
查询数组scores包含100的文档
db.query_array.find({scores:100}})
查询数组scores包含小于60的文档
db.query_array.find({scores:{$lt:60}})

涉及到位置索引（数组.索引位置）
查询数组scores第二个值小于90的文档
db.query_array.find({"scores.1":{$lt:90}})



2）数组查询操作符
$all 参数是数组 用于查询数组字段包含指定的所有元素的文档
db.query_array.find()
db.query_array.find({scores:{$all:[98,90]}})
$elemMatch 数组元素一个值同时满足的多条件查询
查询有一个分数是大于95小于99的文档
db.query_array.find({scores:{$elemMatch:{$gt:95,$lt:99}}})
查询数组元素有大于95，有元素小于99，不限制同一个元素的文档
db.query_array.find({scores:{$gt:95,$lt:99}})
查询数组长度为3的文档
db.query_array.find({scores:{$size:3}})

$elemMatch专门查询数组Field中元素是否满足指定的条件
用于字段的映射
db.query_array.find({},{scores:{$elemMatch:{$gt:95,$lt:99}}})
$显示满足条件的第一个数组元素：注意：查询条件必须是数组
db.query_ar ray.find({},{"scores.$":1}) 错误
db.query_array.find({scores:{$gt:90}},{"scores.$":1})正确

slice  参数有两种情况，整数，正数，从头开始，负数从尾部开始 返回指定数组的元素
 $slice的参数是含有2 个元素的数组，分别是起始位置，元素个数
$slice 用于映射
db.query_array.find({},{scores:{$slice:2}})//显示数组的前2个元素
db.query_array.find({},{scores:{$slice:[-2,2]}})//从倒数第2个数开始，显示2个元素
db.query_array.find({},{scores:{$slice:[-3,1]}})//从倒数第3个数开始，显示1个元素


db.array_em.insertMany([
{_id:1,scores:[{cours:"chinese",grade:90},{cours:"math",grade:95}]},
{_id:2,scores:[{cours:"chinese",grade:92},{cours:"math",grade:90}]}
])
查询任意一门课程的成绩大于90
db.array_em.find({"scores.grade":{$gt:90}})

查询第二门课程成绩大于90的文档
db.array_em.find({"scores.1.grade":{$gt:90}})
查询scores数组元素满足课程为语文，成绩大于90的文档
db.array_em.find({scores:{$elemMatch:{cours:"chinese",grade:{$gt:90}}}})

db.array_em.find({scores:{cours:"chinese",grade:{$gt:90}}})
查询为空

模糊查询 
1)$regex与正则表达式区别
2) i（忽略大小写） s(忽略.的原意，单行匹配) m（多行匹配，换行符）
x（忽略pattern转义字符及注释）
db.query_regex.insertMany([
{type : "Abc123",description : "Single line description." },
{type : "abc789",description : "First line\nSecond line"},
{type: "xyz456",description : "Many spaces before     line"},
{type: "xyz789",description : "Multiple\nline description"}
])

模糊查询

db.query_regex.find({type:{ $regex:/^ABC/i}})
db.query_regex.find({description:{ $regex: /^S/, $options: 'm' }});
db.query_regex.find({description:{ $regex: /^S/}});

db.query_regex.find({description:{$regex: /m.*line/, $options: 'is' }});
db.query_regex.find({description:{$regex: /m.*line/, $options: 'i' }});

var pattern = "abc #category code\n123 #item number\n"
db.query_regex.find({type:{$regex:pattern,$options:"xi"}})

db.query_regex.find({type:{$regex:/abc  123/,$options: 'xi'}});
db.query_regex.find({type:{$regex:/abc  123/,$options: 'i'}});

cursor.js中代码
dbservice=connect("localhost:27017")
db=dbservice.getSiblingDB("test")
db.query_cursor.drop()

for(i=0;i<100;i++){
db.query_cursor.insert({index:i,text:"hello,mongodb"})
}

/* var mycursor = db.query_cursor.find();
while(mycursor.hasNext()) {

    printjson(mycursor.next());
    var left = mycursor.objsLeftInBatch();
    print("Left in bash:",left);
} */

var array = db.query_cursor.find().toArray()
if (array.length > 10)
{
var obj = array[95];
printjson(obj)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

数据删除

for(i=0;i<=10;i++){
db.class1.insertOne({_id:i,name:"aa"})
}
1、删除集合中的第一条文档
db.class1.deleteOne({})
2、删除符合条件的第一条文档
db.class1.deleteOne({name:"aa"})
db.class1.deleteOne({_id:{$gt:8}})
3、删除符合条件的所有文档
db.class1.deleteMany({name:"aa"})
4、删除所有文档
db.class1.deleteMany({})
5、指定写入策略
db.class1.deleteOne({name:"aa"},{writeConcern:{w:1}})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

数据更新

db.class1.drop()
db.goods.insertOne({_id:1,name:"牛奶",price:20})
db.goods.insertOne({_id:2,name:"苹果",price:30})
db.goods.insertOne({_id:3,name:"桔子",price:40})

db.goods.updateOne({},{$inc:{price:10}})
db.goods.updateMany({},{$inc:{price:10}})

upsert参数
db.goods.updateOne({_id:4},{$set:{name:"香蕉"}})
db.goods.updateOne({_id:4},{$set:{name:"香蕉"}},{upsert:true})

upsert为true时，没有满足条件的文档时，会插入一条新的文档，默认为false
当有满足条件的文档或者查询条件为空时，不会插入

replaceOne()方法
db.goods.replaceOne({_id:4},{name:"鸡蛋",total:100})
条件为空时，替换第一条文档，替换时id不变


掌握八种操作符的使用
$set $unset $rename $inc 
$mul $currentDate $min $max
{multi:true}
需要对键值加"" 的情形：子文档的指定字段进行修改



1、修改指定的字段值{$set:{field:newValue}}，

db.c1.updateOne({_id:1},{$set:{name:"tom"}})
2、使用$set如果没有字段，就会添加字段
db.c1.updateOne({_id:1},{$set:{sex:1}})

3、删除指定字段{$unset:{field:newValue}}，
db.c1.updateOne({_id:1},{$unset:{name:""}})
4、修改字段{$rename:{field:"newFiled"}}
db.c1.updateOne({_id:1},{$rename:{name:"newname"}})
5、$inc 修改指定的字段值 +-数值，加5块钱
db.c1.updateOne({_id:1},{$inc:{age:5}})
6、$mul 修改指定的字段值 *数值，整型或浮点型
db.c1.updateOne({_id:1},{$mul:{age:0.9}})
7、多条记录同时做更新，需要用updateMany
db.c1.updateOne({},{$inc:{age:5}})只对第一条进行修改
db.c1.updateMany({},{$inc:{age:5}})
8、$min给定的值小于字段的原先的值，就会被修改
 $max给定的值大于字段的原先的值，就会被修改
db.c1.updateOne({_id:1},{$min:{age:10}})
db.c1.updateOne({_id:1},{$max:{age:100}})


9、$currentDate的用法，修改日期
格式：$currentDate:{field:<typeSpecification>}
<typeSpecification>可以是一个boolean true类型设置当前字段是日期Date类型
或者为一个文档{$type:"timestamp"}或{$type:"date"}

db.c1.updateOne({_id:1},{$currentDate:{time1:true,time2:{$type:"timestamp"}}})
10、修改内嵌文档
db.c1.insertOne({_id:11,name:"tom",address:{provice:"hebei",city:"shijiazhuang"}})
替换子文档
db.c1.updateOne({_id:11},{$set:{address:{provice:"jiangsu",city:"changsha"}}})
修改子文档的字段的值，用.连接，注意加""
db.c1.updateOne({_id:11},{$set:{"address.provice":"hunan"}})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

MongoDb数组更新和时间序列

1、数组元素的操作符和修改器的使用
$  $push  $pop $addToSet $pull $pullAll
1) $
db.c2.insertOne({_id:1,scores:[30,40,50]})
db.c2.insertOne({_id:2,scores:[]})
db.c2.insertOne({_id:3,scores:[20,30,50]})
db.c2.insertOne({_id:4,scores:[20,30,40,50,60]})
db.c2.updateOne({scores:30},{$set:{"scores.$":33}})
db.c2.updateMany({scores:30},{$set:{"scores.$":33}})
2)$push    {$push:{array:value}} 向数组末尾追加一个元素
db.c2.updateOne({_id:1},{$push:{scores:60}})
3）$pop   {$pop:{array:-1|1}  -1从头部删除,1从尾部删除
db.c2.updateOne({_id:1},{$pop:{scores:-1}})
db.c2.updateOne({_id:1},{$pop:{scores:1}})
4）$addToSet    {$addToSet:{array:value}} 向数组末尾追加一个元素，如果已经存在同样的元素，不会添加
db.c2.updateOne({_id:1},{$addToSet :{scores:50}})
5）$pull 删除指定的一个元素  {$pull:{array:value}} 
db.c2.updateOne({_id:3},{$pull:{scores:30}})
6）$pullAll 删除多个元素 参数是数组 {$pullAll:{array:[v1,v2,v3,----]}}
db.c2.updateOne({_id:4},{$pullAll:{scores:[30,40,50]}})
7)修改器的使用$each $slice $position $sort与push结合使用
$each用于添加多个元素
{$push:{array:{$each:[v1,v2,v3，-----]}}}
db.c2.updateOne({_id:1},{$push:{scores:{$each:[1,2,3,4,5]}}})
$slice:用于数组中添加元素后，取子集的个数
{$push:{array:{$each:[v1,v2,v3，-----],$slice:n}}}
db.c2.updateOne({_id:1},{$push:{scores:{$each:[11,12,13,14,15],$slice:2}}})
$slice的值取0：清空数组 正数：从头部开始取子集  负数：从尾部开始取子集

$position向数组指定的位置追加元素(从0开始计算)
{$push:{array:{$each:[v1,v2,v3，-----],$position:n}}}
db.c2.updateOne({_id:1},{$push:{scores:{$each:[11,12,13,14,15],$position:1}}})
$sort更新后，对数组中的元素进行排序
简单的数组元素 {$push:{array:{$each:[v1,v2,v3，-----],$sort:-1|1}}}
db.c2.updateOne({_id:1},{$push:{scores:{$each:[11,12,13,14,15],$sort:1}}})
db.c2.insert({_id:5,scores:[{"科目":"数学","成绩":50},{"科目":"语文","成绩":60},{"科目":"英语","成绩":40}]})
复杂的数组元素{$push:{array:{$each:[v1,v2,v3，-----],$sort:{filed:-1|1}}}}
db.c2.updateOne({_id:5},{$push:{scores:{$each:[{"科目":"数学1","成绩":20},{"科目":"语文1","成绩":70}],$sort:{"成绩":-1}}}})

在数组的第一个位置，添加元素，取5个元素子集，倒序存储
db.c2.updateOne({_id:1},{$push:{scores:{$each:[11,12,13,14,15],$slice:5,$position:0,$sort:-1}}})

2、findOneAndReplace()方法

db.scores.insertMany([
   { "_id" : 1, "team" : "aa", "score" : 25000 },
   { "_id" : 2, "team" : "bb", "score" : 23500 },
   { "_id" : 3, "team" : "cc", "score" : 19250 },
   { "_id" : 4, "team" : "dd", "score" : 15235 },
   { "_id" : 5, "team" : "ee", "score" : 18000 }
]);

db.scores.findOneAndReplace(
   { "score" : { $lt : 20000 } },
   { "team" : "Oo", "score" : 20000 }
)
db.scores.findOneAndReplace(
   { "score" : { $lt : 20000 } },
   { "team" : "Ob", "score" : 20000 },
   { sort: { "score" : 1 } }
)
db.scores.findOneAndReplace(
   { "score" : { $lt : 22250 } },
   { "team" : "Th", "score" : 22250 },
   { sort : { "score" : 1 }, projection: { "_id" : 0, "team" : 1 } }
)

db.scores.findOneAndReplace(
      { "score" : { $gt : 25000 } },
      { "team" : "Em", "score" : 25010 },
      { maxTimeMS: 5 }
)

  db.scores.findOneAndReplace(
      { "team" : "For" },
      { "_id" : 6019, "team" : "For" , "score" : 32000},
      {  upsert : true, returnDocument: "after" }
   )

findAndModify一次只能修改一个文档
默认 findAndModify返回的修改前文档,new：true，可以返回修改后的文档

3、findAndModify效率慢一些

db.f1.insert({name:"xiaoli",age:20,score:90})
db.f1.insert({name:"xiaoli",age:22,score:95})

db.f1.findAndModify({query:{name:"xiaoli"},sort:{age:1},update:{$inc:{score:1}},new:true,upsert:true})

db.f1.findAndModify({query:{name:"xiaoli"},sort:{age:-1},update:{$inc:{score:1}},new:true,fields:{name:1}})

db.f1.findAndModify({query:{name:"xiaoli"},sort:{age:1},remove:true})


4、bukWrite
db.pizzas.insertMany( [
   { _id: 0, type: "pepperoni", size: "small", price: 4 },
   { _id: 1, type: "cheese", size: "medium", price: 7 },
   { _id: 2, type: "vegan", size: "large", price: 8 }
] )

db.pizzas.bulkWrite( [
      { insertOne: { document: { _id: 3, type: "beef", size: "medium", price: 6 } } },
      { insertOne: { document: { _id: 4, type: "sausage", size: "large", price: 10 } } },
      { updateOne: {
         filter: { type: "cheese" },
         update: { $set: { price: 8 } }
      } },
      { deleteOne: { filter: { type: "pepperoni"} } },
      { replaceOne: {
         filter: { type: "vegan" },
         replacement: { type: "tofu", size: "small", price: 4 }
      } }
   ] )



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

MongoDB特殊索引

2dsphere球面索引
db.index_2dsphere.find( { loc :
                { $geoIntersects :
                        { $geometry :
                            { type : "Polygon" ,
                              coordinates : [[
                                               [116.293545,39.982595], 
                                               [116.481420,39.982014], 
                                               [116.484214,39.850226], 
                                               [116.296576,39.837899],
                                               [116.293545,39.982595]
                                            ]]
                             }
                        }
                    }
                }

2d平面索引

db.index_2d.insertOne({_id:"A",position:[0.001,-0.002]})
db.index_2d.insertOne({_id:"B",position:[0.75,0.75]})
db.index_2d.insertOne({_id:"C",position:[0.5,0.5]})
db.index_2d.insertOne({_id:"D",position:[-0.5,-0.5]})

db.index_2d.createIndex({position:"2d"})

db.index_2d.find({position:{$geoWithin:{$box:[[0.25,0.25],[1.0,1.0]]}}})
db.index_2d.find({"position":{$geoWithin:{$center:[[0,0],0.75]}}})
db.index_2d.find({position:{$near:[0,0],$maxDistance:0.75}})


如果要使用全文索引进行查询，需要借助$text $search两个操作符

db.articles.insertOne({_id:1,subject:"coffee",author:"tom",views:50})
db.articles.insertOne({_id:2,subject:"Coffee Shopping",author:"tom1",views:50})
db.articles.insertOne({_id:3,subject:"Baking a cake",author:"jerry",views:50})
db.articles.insertOne({_id:4,subject:"baking",author:"joe",views:50})
db.articles.insertOne({_id:5,subject:"cream and coffee",author:"tom",views:50})
db.articles.insertOne({_id:6,subject:"coffee 1",author:"tom",views:50})
db.articles.insertOne({_id:7,subject:"coffee",author:"tom",views:50})
db.articles.insertOne({_id:8,subject:"coffee shop",author:"tom",views:50})
db.articles.insertOne({_id:9,subject:"Coffee shop",author:"tom",views:50})


db.articles.createIndex({subject:"text"})

db.articles.find({$text:{$search:"coffee"}})

db.articles.find({subject:/coffe/i}) 不使用索引
db.articles.find({$text:{$search:"coffee"}}).explain() //通过explain()函数获得，会使用索引进行查询

db.articles.find({$text:{$search:"coffee cake"}}) 
//coffee cake存在任何一种的都会查询出来，空格分隔
db.articles.find({$text:{$search:"coffee -shop"}})
//存在coffe并且不存在shop的
db.articles.find({$text:{$search:"\"a cake\""}})
//查询包含短句的，需要加转义字符""
db.articles.find({$text:{$search:"coffee",$caseSensitive:true}})
//大小写敏感

db.articles.find({$text:{$search:"a"}})//a the is等为停止词，此类频率很高的词默认没有建立索引
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61

mongoDB权限设置

权限设置 DBA


1、创建用户，创建普通用户，一般是针对哪个数据库创建，切换到哪个数据库下，也可以在其他数据库下创建
可以同时创建多个角色

db.createUser({user:"u1",pwd:"123456",roles:[{role:"read",db:"test"},{role:"readwrite",db:"student"}]})

2、权限验证生效
修改MongoDB安装目录中的配置文件 bin/mongod.cfg，重启服务
security:
  authorization: enabled
注意：authorization前面要有两个英文空格，否则会导致服务重启失败

3、验证用户登录
切换到创建用户时的数据库，再登录，否则会登录失败
db.auth("u1","123456")

4、比如想修改用户密码，在创建用户的数据库下修改，有userAdmin权限的用户才可修改
db.changeUserPassword("u1","654321")

5、删除用户（在创建用户的数据库下删除），有userAdmin权限的用户才可修改
db.dropUser("用户名")
6、授权(在创建用户的数据库下操作)，有userAdmin权限的用户才可修改
db.grantRolesToUser(“accountUser01”, [  { role: “read”,db: "stock"} ])，
数据库stock的读权限授权给用户accountUser01


开启 Profiling 功能
有两种方式可以控制 Profiling 的开关和级别，第一种是直接在启动参数里直接进行设置。
启动 MongoDB 时加上–profile=级别 即可。也可以在客户端调用 db.setProfilingLevel(级别) 命令来实时配置， Profiler 信息保存在system.profile 中。我们可以通过 db.getProfilingLevel()命令来获取当前的 Profile 级别，类似如下操作
db.setProfilingLevel(2)
开启后当前数据库下即有system.profile集合


需求：
1、针对数据库test创建用户test1，具有读写的权限
db.createUser({user:"test1",pwd:"test1",
roles: [{ role: "readWrite", db: "test"}]})
2、针对test1用户授权，使其对数据库student具有只读权限

db.grantRolesToUser(
   "test1",
   [ { role: "read", db: "student" } ],
   { w: "majority" , wtimeout: 4000 }
)



任务：1、创建管理员readWriteAnyDatabase角色，查看该角色的是否可以对任意数据进行读写
2、针对数据库test创建角色dbAdmin，查看该角色具体可以执行什么操作
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51