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)
}

数据删除

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}})

数据更新

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"}})

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 }
      } }
   ] )

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等为停止词，此类频率很高的词默认没有建立索引

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，查看该角色具体可以执行什么操作