MongoDB查询-优快云博客

本文链接：https://blog.youkuaiyun.com/2403_83147124/article/details/146406310

find()相关函数

db.colls.help()

find()	查询文档，是一个游标cursor
findOne()	查询满足条件的第一个文档
findOneAndDelete()	查询满足条件的第一个文档并删除
findOneAndUpdate()	查询满足条件的第一个文档并更新
findOneAndReplace()	查询满足条件的第一个文档并替代

find()函数

在MongoDB中可以使用find()函数查询文档。

语法格式：find（{查询条件（可选）}，{指定投影的键（可选）}）

db.collection_name.find(criteria,projection)

criteria:可选，表示查询条件

projection:可选，使用投影操作符指定返回的键。1表示返回，0表示不返回，默认省略，指查询时返回文档中所有键值

在find函数中可以指定投影键。

语法格式：find（{查询条件（可选）}，{投影键名：1（显示该列）|0（不显示该键），投影键名：1|0}）

查询条件必须给定key和value，构成完整的查询条件；如果没有给定参数则表示查询所有的数据。

MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，即常规 SQL 的 AND 条件。

语法格式如下：

>db.col.find({key1:value1, key2:value2}).pretty()

pretty()函数可以使用格式化的方式显示所有文档。

findOne()函数

findOne()函数只返回满足条件的第一条数据。如果未做投影操作该方法则自带格式化功能。

语法格式：findOne（{查询条件}，{指定投影的键（可选）}）

findOneAndDelete()函数

findOneAndDelete()方法根据集合中的选择标准删除单个文档。它从集合中删除与给定过滤器查询表达式匹配的第一个文档。它包含五个参数，第一个参数是选择标准，其他参数是可选的。

参数：

第一个参数是选择标准。此参数的类型是文档。

第二个参数是可选的。

可选参数：

projection:它允许您仅选择必要的数据，而不是从文档中选择整个数据。

sort:它指定与选择标准匹配的文档的排序顺序。值1按升序排序，-1则按降序排序。

maxTimeMs:这是允许查询运行的最长时间。

collation:它指定使用归类进行操作。它允许用户为字符串比较指定language-specific规则，例如字母大写和重音符号规则。此参数的类型是文档。

返回：

如果文档与给定的过滤器查询匹配，则此方法返回已删除的文档。

如果没有文档与给定的过滤器查询匹配，则此方法返回null。

findOneAndUpdate()函数

findOneAndUpdate()用于查找MongoDB中一个文档并进行更新

findOneAndReplace()函数

findOneAndUpdate()用于查找MongoDB中一个文档并用新的文档进行替代

数据准备

db.students.drop()
db.students.insertMany([
         {"_id":"1001","name":"程明","sex":"男","age":19,"address":"宛城区",score:56},
         {"_id":"1002","name":"刘萍","sex":"女","age":18,"address":"卧龙区",score:75},
         {"_id":"1003","name":"张静","sex":"女","age":20,"address":"高新区",score:88},
         {"_id":"1004","name":"陈好","sex":"女","age":20,"address":"宛城区",score:82},
         {"_id":"1005","name":"施行","sex":"男","age":20,"address":"卧龙区",score:73},
         {"_id":"1006","name":"刘文","sex":"女","age":18,"address":"高新区",score:96},
         {"_id":"1007","name":"李德胜","sex":"男","age":20,"address":"宛城区",score:68},
         {"_id":"1008","name":"苏锦","sex":"男","age":18,"address":"卧龙区",score:47}
])
db.students.insert({"_id":"1011","name":"程芳","address":"宛城区",score:56})
db.students.insert({"_id":"1012","name":"冰冰","sex":0,score:56})
db.students.insert({"_id":"1013","name":"君君","sex":1,score:56})

查找students集合中的文档
db.students.find()
db.students.find().pretty()
第一个条件省略代表没有条件，第二个条件省略代表显示所有字段
第一个参数代表查询的条件
查询students中姓名为刘文的文档
db.students.find({"name":"刘文"})
条件和条件间逗号隔开，如果查询中给定了多个查询条件，条件之间默认的关系为and关系。
查询students中性别为男，年龄为20的文档
db.students.find({"sex":"男","age":20})
查询集合students所有人的姓名
db.students.find({},{"name":1})
_id字段默认显示，不显示需要设置"_id":0
db.students.find({},{"name":1,"_id":0})
查询students中性别为女的姓名，年龄，不显示_id
db.students.find({"sex":"女"},{"name":1,"age":1,"sex":1,"_id":0})
返回满足条件的第一条文档，且格式化显示
db.students.findOne({"sex":"男","age":20})
db.students.findOne({"sex":"女"})
db.students.findOne({"sex":"女"},{"name":1,"age":1,"sex":1,"_id":0})
返回满足条件的第一条文档且删除，且格式化显示
db.students.findOneAndDelete({"sex":"男","age":20})
按照姓名字段对文档进行降序排序，然后删除年龄为18岁的第一个文档，如果没有文档与过滤器查询匹配，返回null
db.students.findOneAndDelete({age:18},{sort:{name:-1}})
查找张静，并更新其年龄=年龄-5，并格式化返回更新前数据
db.students.findOneAndUpdate({name:"张静"},{$inc:{age:-5}})
查找张静，用新的文档进行替代
db.students.findOneAndReplace({name:"张静"},{name:"莉莉",location:"nyist"})

distinct

作用：获取集合中指定字段的不重复值，并以数组的形式返回
语法：db.collection_name.distinct(field,query,options)
field -----指定要返回的字段(string)
query-----条件查询(document)
options-----其他的选项(document)

数据准备

db.inventory.insertMany([
{ "_id": 1, "dept": "A", "item": { "sku": "111", "color": "red" }, "sizes": [ "S", "M" ] },
{ "_id": 2, "dept": "A", "item": { "sku": "111", "color": "blue" }, "sizes": [ "M", "L" ] },
{ "_id": 3, "dept": "B", "item": { "sku": "222", "color": "blue" }, "sizes": "S" },
{ "_id": 4, "dept": "A", "item": { "sku": "333", "color": "black" }, "sizes": [ "S" ] }])

查询不同的address

db.students.distinct("address")

查找所有学生的姓名

db.students.distinct("name")

查询inventory中有哪些部门

db.inventory.distinct("dept")

获取item子字段sku的不重复值

db.inventory.distinct("item.sku")

获取数组格式字段的不重复值

db.inventory.distinct("sizes")

满足dept为A数据的item字段的子字段color的不重复值

db.inventory.distinct("item.color",{dept:"A"})

查询inventory中部门的个数

db.inventory.distinct("dept").length

条件操作符/关系运算符

条件操作符用于比较两个表达式并从MongoDB集合中获取数据。

语法格式：find（{键：{操作符：条件}}）或者findOne（{键：{操作符：条件}}）

$gt 大于操作符使用$gt做大于的条件判断，可以用于数字或日期进行判断。

$gte 大于或等于操作符使用$gte做大于或等于的条件判断，可以用于数字或日期进行判断。

$lt 小于操作符使用$lt做小于的条件判断，可以用于数字或日期进行判断。

$lte 小于或等于操作符使用$lte做小于或等于的条件判断，可以用于数字或日期进行判断。

$ne 不等操作符使用$ne做不等的条件判断。

$eq 等于操作符使用$eq做相等的条件判断。

关系运算符
序号	运算符	含义	示例
1	$gt	>	年龄大于1：{"age":{$gt:1}}
2	$gte	>=	成绩及格：{"grade":{$gte:60}}
3	$It	<	未成年：{"age":{$lt:16}}
4	$Ite	<=	学分小于等于2：{"credit":{$lte:2}}
5	$ne	!=	姓名不是文静：{"name":{$ne:"文静"}}
6	$eq	=	年龄是19岁：{"age":{$eq:19}}}

查询年龄大于19岁的学生信息
db.students.find({"age":{$gt:19}})
查询年龄小于等于20岁的学生姓名，性别，年龄
db.students.find({"age":{$lte:20}},{"name":1,"sex":1,"age":1,"_id":0})
查询年龄不是19岁的学生，没有age字段的文档也会被查询出来
db.students.find({"age":{$ne:19}})

MongoDB日期类型

Date()

字符串

显示当前的时间

new Date()

ISODate型

构建一个格林尼治时间,和Date()相差8小时.

我们是+8时区，时差相差8，所以+8小时就是系统当前时间

ISODate()

时间戳

也是格林尼治时间

db.test.find({time:{$type:"date"}})
db.test.find({time:{$type:"string"}})

插入时间类型数据
db.test.insert({_id:1,time:Date()})
db.test.insert({_id:2,time:new Date()})
db.test.insert({_id:3,time:new Date(1679283433769)})
db.test.insert({_id:4,time:ISODate("2023-03-20 11:40:00")})
db.test.insert({_id:5,time:ISODate("20230110 11:40:00")})
db.test.insert({_id:6,time:ISODate("20220110")})
db.test.insert({_id:7,time:new Date("2021-01-10")})
db.test.insert({_id:9,time:new Date().toLocaleString()}) //toLocaleString() 返回包含当前时区信息的时间字符串

查看时间数据类型
Date()
new Date()
ISODate()
ISODate("2024-09-26T02:30:09.075Z").valueOf()

查找时间类型数据

db.test.find({time:ISODate("20220110")})

db.test.find({time:{$eq:ISODate("20220110")}})

db.test.find({time:new Date(1679283433769)})

db.test.find({time:{$gt:new Date(1679283433769)}})

查找2022年的文档

db.test.find({time:{$gte:new Date("2022-01-01"),$lte:new Date("2022-12-31")}})

逻辑运算符

可以使用$and操作符表示多个条件间的并且关系。
语法格式：find（{$and:[{条件一},{条件二},......]}）
可以使用$or操作符表示多条件间或者关系。
语法格式：find（{$or:[{条件一},{条件二},......]}）

逻辑运算符
1	$and	逻辑与，$and所针对的条件被放在一个数组中，每个数组元素都是and的一个条件，and操作符条件放在数组中，数组中是and的条件 {$and:[{K:V},{K:V}.....]}
2	$or	逻辑或，$or所针对的条件被放在一个数组中，每个数组元素都是or的一个条件 {$or:[{K:V},{K:V},...]}
3	$not	逻辑非，取反操作，不能单独使用，必须和其他操作条件一起使用{field:{$not:{表达式}}}

查询年龄20-21岁的学生
db.students.find({age:{$gte:20},age:{$lte:21}}) 相同key的条件，后面的条件会覆盖前面的条件
db.students.find({age:{$lte:21},age:{$gte:20}})
db.students.find({age:{$gte:20,$lte:21}})
db.students.find({$and:[{"age":{$gte:20}},{"age":{$lte:21}}]})
查找年龄20，地址宛城区的学生
db.students.find({$and:[{age:20},{address:"宛城区"}]})
db.students.find({age:20,address:"宛城区"})
查询年龄大于19岁，或者成绩大于90分的学生信息
db.students.find({$or:[{"age":{$gt:19}},{"score":{$gt:90}}]})
查询年龄不是19岁的学生
db.students.find({"age":{$ne:19}})
db.students.find({"age":{$eq:19}})
db.students.find({"age":{$not:{$eq:19}}})

$type操作符

$type操作符是基于BSON类型来检索集合中匹配的数据类型（根据key：value中value的类型作为查询条件），并返回结果。
语法：

db.集合名.find({$type:类型值}) //这里的类型值能使用Number也能使用alias

数据准备

db.bbs.insert([{
  "title":"hello Java",
  "date":new Date(),
  "by":"Mike",
  "likes":1001,
  "city":null,
    "sex":0},
  {_id:1,
   title:"Hello MongoDB",
   city:"Nanyang",
    sex:"男"},
  {_id:2,
   title:"Hello MongoDB",
   likes:NumberInt(10)
}])

查询sex值的类型为number类型的文档
db.students.find({sex:{$type:'number'}})
db.bbs.find({sex:{$type:"int"}})
db.bbs.find({sex:{$type:"number"}}).pretty()
db.bbs.find({sex:{$type:1}}).pretty()
查询sex值的类型为string类型
db.bbs.find({sex:{$type:2}}).pretty()
查询like值为int类型的文档
db.bbs.find({likes:{$type:"int"}})
db.bbs.find({likes:{$type:16}})
查询date为date类型的文档
db.bbs.find({date:{$type:"date"}})
db.bbs.find({date:{$type:9}})
查询_id为objectId类型的文档
db.bbs.find({_id:{$type:"objectId"}})
db.bbs.find({_id:{$type:7}})
查询city为null的文档
db.bbs.find({city:null})
db.bbs.find({city:{$eq:null}})
db.bbs.find({city:{$type:"null"}})
db.bbs.find({city:{$type:10}})
查询tags类型为数组的文档
db.bbs.find({tags:{$type:4}})
db.bbs.find({tags:{$type:"array"}})

范围查询

$mod	用来匹配字段值对（divisor）取模，值等于（remainder）的文档 {field:{$mod:[divisor,remainder]}}
$in	用来匹配键值等于指定数组中任意值的文档 {field:{$in:[value1,value2,...]}}
$nin	用来匹配键值不存在或者键值不等于指定数组中任意值的文档 {field:{$nin:[value1,value2,...]}}
null	用来匹配值为null或者键不存在的文档 {filed:null}
$exists	用来判断某个字段是否存在 {field:{$exists:<Boolean>}}
$exists和null联合使用	如果真正做到查询某个字段为null，需要和$exists连用。 {field:{$in:[null],$exists:true}}

数据准备

db.students.drop()
db.students.insertMany([
         {"_id":"1001","name":"程明","sex":"男","age":19,"major":"计算机应用技术","credits":52,score:92},
         {"_id":"1002","name":"刘萍","sex":"女","age":18,"major":"移动应用开发","credits":51,score:88},
         {"_id":"1003","name":"张静","sex":"女","age":20,"major":"计算机应用技术","credits":48,score:96},
         {"_id":"1004","name":"陈好","sex":"女","age":20,"major":"软件技术","credits":53,score:97},
         {"_id":"1005","name":"施行","sex":"男","age":20,"major":"计算机应用技术","credits":54,score:60},
         {"_id":"1006","name":"刘文平","sex":"女","age":18,"major":"软件技术","credits":50,score:86},
         {"_id":"1007","name":"李德胜","sex":"男","age":20,"major":"计算机应用技术","credits":55,score:95},
         {"_id":"1008","name":"苏锦州","sex":"男","age":18,"major":"移动应用开发","credits":50,score:70}, 
         {"_id":"1009","name":"张文杰","sex":"女","age":20,"major":"软件技术","credits":53,score:40},
         {"_id":"1010","name":"王林","sex":"男","age":18,"major":"移动应用开发","credits":47,score:87}])
db.students.insertMany([
{"_id":"1011","name":"张三","age":20,"address":"卧龙区",course:["Java","MySQL","mongo DB"]},
{"_id":"1012","name":"李四","age":19,"address":"卧龙区",course:["Java","mongoDB"]},
{"_id":"1013","name":"王五","age":18,"address":"宛城区",course:["Java","Hadoop"]},
{"_id":"1014","name":"赵六","age":19,"address":"宛城区",course:["Linux","MySQL"]},
{"_id":"1015","name":"田七","age":21,"address":"卧龙区",course:["Python","JS"]},
{"_id":"1016","name":"张三","age":18,"address":"高新区",course:["Java","MySQL","mongo DB"]},
{"_id":"1017","name":"张三","age":19,"address":"高新区"}
])
db.students.insertMany([
         {"_id":"1018","name":"程明","sex":"男","age":19,"credits":null,score:56},
         {"_id":"1019","name":"刘萍","sex":"女","age":18,"major":null,score:null},
         {"_id":"1020","name":"张静","sex":"女","age":20,"major":null,"credits":88}
])

查询年龄的值模除20余1的记录

db.students.find({"age":21})

db.students.find({"age":{$mod:[20,1]}})

查询年龄是18或19的记录

db.students.find({$or:[{"age":18},{"age":19}]})

db.students.find({"age":{$in:[18,19]}})

查询年龄不是18和20的记录

db.students.find({$and:[{"age":{$ne:18}},{"age":{$ne:20}}]})

db.students.find({"age":{$nin:[18,20]}})

查询地址不是宛城区和卧龙区的记录（没有地址字段的记录也被匹配出来）

db.students.find({$and:[{"address":{$ne:"宛城区"}},{"address":{$ne:"卧龙区"}}]})

db.students.find({"address":{$nin:["宛城区","卧龙区"]}})

查询专业为null的记录（没有专业字段的记录也被匹配）

db.students.find({"major":null})

查询专业为null的记录

db.students.find({$and:[{"major":null},{"major":{$exists:true}}]})

db.students.find({"major":{$in:[null],$exists:true}})

查询专业不为null的记录

db.students.find({"major":{$ne:null}})

查找score字段不存在的记录

db.students.find({"score":{$exists:false}})

查找score字段存在的记录

db.students.find({"score":{$exists:true}})

查找字段为空并且这个键存在

模糊查询

正则表达式对象 {<field>: /pattern/<options>}

在MongoDB中可以通过//与^$|实现模糊查询，

注意使用模糊查询时查询条件不能放在双引号或单引号中（放引号内是精确匹配）

使用^表示起始位置，使用$表示结尾位置, |表示或。

查询文档中，name值中含有好的内容。

db.students.find({name:/好/})

查询文档中，name值中以刘开头的内容。

db.students.find({name:/^刘/})

查询文档中，name值中以萍结尾的内容。

db.students.find({name:/萍$/})

查找姓刘或者姓张的学生信息

db.students.find({"name":/刘|张/}) --查找姓名包含刘或者张的信息

db.students.insert({"name":"王关张"})

db.students.find({"name":/^刘|^张/})

查找姓名中包含文的学生信息

db.students.find({"name":/文/})

正则查询

MongoDB中查询条件可以用正则表达式作为匹配约束。
语法格式：
db.COLLECTION_NAME.find({字段名：正则表达式, $option:正则选项})
正则表达式格式：/XXXXXX/
或者
db.COLLECTION_NAME.find({字段名：{$regex:正则表达式,$option:正则选项}})

$regex正则表达式
MongoDB使用$regex操作符来设置匹配字符串的正则表达式，使用 PCRE作为正则表达式语言。
regex操作符
{<field>:{$regex:/pattern/，$options:’<options>’}}
{<field>:{$regex:’pattern’，$options:’<options>’}}
{<field>:{$regex:/pattern/<options>}}
|表示或 ^表示以..开头 $以...结尾
.点号字符在正则表达式中是一个通配符，它代表所有字符和数字。
*号表示前面的匹配符出现>=0次
+号表示前面的匹配符出现>=1次
?号表示前面的匹配符出现<=1次
{666}表示前面的匹配符出现666次
{666,888}表示前面的匹配符出现666~888次

$regex与正则表达式对象的区别:
在$in操作符中只能使用正则表达式对象，例如:{name:{$in:[/^joe/i,/^jack/}}
在使用隐式的$and操作符中，只能使用$regex，例如:{name:{$regex:/^jo/i, $nin:['john']}}
当option选项中包含X或S选项时，只能使用$regex
例如:{name:{$regex:/m.*line/,$options:"si"}}

查找姓名中包含文的学生信息
db.students.find({"name":{$regex:/文/}})
查找姓名中name字段以刘开头的数据
db.students.find({name:{$regex:/^刘/}})
查询文档中，name值中以萍结尾的内容。
db.students.find({name:{$regex:/萍$/}})
查找course字段以j开头的数据，忽略大小写
db.students.insert({course:"java"})
db.students.insert({course:"Java"})
db.students.find({course:{$regex:/^j/}})
db.students.find({course:{$regex:/^j/i}})
db.students.find({course:/^j/})
db.students.find({course:/^j/i})
db.students.find({course:{$regex:/^j/,$options:"i"}})
查询文档中，name值中以刘开头，萍结尾的内容
db.students.insert({name:"刘某萍"})
. 匹配任意字符 * 0次或多次
db.students.find({name:/^刘.*萍$/})
db.students.find({name:{$regex:/^刘.*萍$/}})
查询文档中，name值中以刘开头或者萍结尾的内容
db.students.find({name:{$in:[/^刘/,/萍$/]}})
db.students.find({$or:[{name:/^刘/},{name:/萍$/}]})
查找姓名中name字段不是以刘开头的数据
db.students.find({name:{$not:/^刘/}})
查询姓名字段不以刘开头或者张开头的数据
db.students.find({name:{$nin:[/^刘/,/^张/]}})

数据准备

db.geci.insert([
{words:"Trouble will find you no mater where you go oh oh, No Matter if you're fast no matter if you are slow oh oh"},
{words:"He is there in the dark,He is there in my heart,He waits in the winds,He is gotta play a part"},
{words:"Trouble is a friend,Yeah trouble is a friend of mine oh oh,Trouble is a friend but trouble is a foe oh oh"},
{words:"And no matter what I feed him he always seems to grow oh oh"},
{words:"He sees what I see and he knows what I know oh oh"}
])

查找words里包含trouble的文档，不区分大小写
db.geci.find({words:/trouble/i})
db.geci.find({words:{$regex:/trouble/i}})
db.geci.find({words:{$regex:"trouble",$options:"i"}})
db.geci.find({words:{$regex:/trouble/,$options:"i"}})
db.geci.find({words:{$regex:"trouble",$options:"$i"}})
查找words里出现trouble3-4次的文档，不区分大小写
db.geci.find({
words: {
$regex: "(.*trouble.*){3,4}",$options:"$i"
}
})
db.geci.insert({words:"troubletroubletroubleaaaa"})
db.geci.find({
words: {
$regex: "(trouble){3,4}",$options:"$i"
}
});
查找和trouble friend相关的文档
db.geci.find({
words: {
$regex: ".*trouble.*friend.*",$options:"$i"
}
});

数组查询

数据准备

db.students.drop()
db.students.insertMany([
{"_id":"1011","name":"张三","age":20,"address":"卧龙区",course:["Java","MySQL","mongoDB"]},
{"_id":"1012","name":"李四","age":19,"address":"卧龙区",course:["Java","mongoDB"]},
{"_id":"1013","name":"王五","age":18,"address":"宛城区",course:["Java","Hadoop"]},
{"_id":"1014","name":"赵六","age":19,"address":"宛城区",course:["Linux","MySQL"]},
{"_id":"1015","name":"田七","age":21,"address":"卧龙区",course:["Python","JS"]},
{"_id":"1016","name":"张三","age":18,"address":"高新区",course:["Java","MySQL","mongoDB"]},
{"_id":"1017","name":"张三","age":19,"address":"高新区"}
])

查询选修MySQL这门课程的学生信息
db.students.find({"course":{$in:["MySQL"]}})
db.students.find({"course":"MySQL"})
查询选修课程中包含m的文档信息
db.students.find({course:/m/i})
db.students.find({course:{$regex:/m/i}})
查询选修了Java和mongoDB两门课程的学生信息
需要用到数组匹配
db.students.find({"course":["Java","mongoDB"]})
只匹配到一条数据，这种方式是精确匹配，内容和顺序必须和检索条件一致
db.students.find({"course":{$in:["Java","mongoDB"]}})—对吗？
in相当于或选修Java或mongoDB
注意：默认情况下，值为数组代表的是精确匹配。

查询选修了Java和mongoDB两门课程的学生信息
db.students.find({$and:[{"course":"mongo DB"},{"course":"Java"}]})
db.students.find({"course":{$all:["Java","mongo DB"]}})
all也可用于单个值
查找姓名为李四的学生信息
db.students.find({"name":{$all:["李四"]}})
db.students.find({"name":"李四"})
db.students.find({"name":{$in:["李四"]}})
查询course中第二门课程（下标从0开始）为MySQL的学生信息（course.1的引号不能省略）
db.students.find({"course.1":/mysql/i})
查询选修了3门课程的学生信息
db.students.find({"course":{$size:3}})
查询选修课大于3门课程的学生信息
db.students.find({"course":{$size:{$gt:3}}})
这种方式是错误的 size必须指定一个定值，不能接收一个范围值，不能与其他查询子句组合
slice为1 返回第一门课程为-1返回最后一门课程
返回年龄为19岁的所有学生信息，只显示1门课程
db.students.find({"age":19},{"course":{$slice:1}})
db.students.find({"age":19,"course":{$exists:true}},{"course":{$slice:1}})
返回年龄为18岁的所有学生信息，只显示最后1门课程
db.students.find({"age":18},{"course":{$slice:-1}})
db.students.find({"age":18,"course":{$exists:true}},{"course":{$slice:-1}})
返回年龄为20岁的所有学生信息，要求只显示第2门和第3门课程
db.students.find({"age":20,"course":{$exists:true}},{"course":{$slice:[1,2]}})

$all	用来匹配那些指定键的键值中包含数组的所有元素的文档，数组中元素顺序不影响查询结果。 {field:{$all:[value1,value2,....]}}
key.index	想要查询数组指定为位置的元素，需要使用key.index语法指定下标
$size	查询指定长度的数组，size必须指定一个定值，不能接收一个范围值，不能与其他查询子句组合
$slice	返回数组中的部分数据
$slice:[start,count]	返回从start开始（包含），共返回count个数据

排序和分页

limit()函数可以在MongoDB中读取指定数量的数据记录，函数接收一个数字参数，该参数指定从MongoDB中读取的记录条数。
语法格式：db.COLLECTION_NAME.find().limit(NUMBER)
skip()函数可以跳过指定数量的数据，函数接收一个数字参数作为跳过的记录条数。
语法格式： db.COLLECTION_NAME.find().limit(NUMBER).skip(NUMBER)
可以使用skip函数与limit函数实现MongoDB的分页查询，但是官方并不推荐，因为会扫描全部文档然后返回结果，效率过低。
sort()函数对查询的文档进行排序，可以通过参数指定排序的字段，使用1和-1指定排序的方式，1为升序，-1为降序。
语法格式：db.COLLECTION_NAME.find().sort({排序键：1})

sort()	在MongoDB里面数据的排序操作使用sort()函数，在排序的时候可以升序（1）和降序（-1）
$natural	按添加数据的顺序排序
skip(n)	表示略过前n条数据
limit(n)	表示总共取n条数据

数据准备

db.students.drop()
db.students.insert({"_id":"1011","age":22,"name":"张三","sex":"男",
"address":"卧龙区",
"parents":[
{"name":"张三爸爸","age":55,"job":"处长"},
{"name":"张三妈妈","age":42,"job":"主任"}]})
db.students.insert({"_id":"1012","age":19,"name":"李四","sex":"男",
"address":"卧龙区",
"parents":[
{"name":"李四爸爸","age":48,"job":"处长"},
{"name":"李四妈妈","age":42,"job":"主任"}]})
db.students.insert({"_id":"1013","age":21,"name":"王五","sex":"女",
"address":"高新区",
"parents":[
{"name":"王五爸爸","age":45,"job":"医生"},
{"name":"王五妈妈","age":42,"job":"教师"}]})
db.students.insert({"_id":"1014","age":18,"name":"赵六","sex":"男",
"address":"卧龙区",
"parents":[
{"name":"赵六爸爸","age":40,"job":"司机"},
{"name":"赵六妈妈","age":39,"job":"会计"}]})
db.students.insert({"_id":"1015","age":18,"name":"田七","sex":"女",
"address":"高新区",
"parents":[
{"name":"田七爸爸","age":45,"job":"处长"},
{"name":"田七妈妈","age":42,"job":"主任"}]})
db.students.insert({"_id":"1016","age":19,"name":"八宝","sex":"男",
"address":"宛城区",
"parents":[
{"name":"八宝爸爸","age":45,"job":"处长"},
{"name":"八宝妈妈","age":42,"job":"主任"}]})
db.students.insert({"_id":"1017","age":19,"name":"金九","sex":"男",
"address":"宛城区",
"parents":[
{"name":"金九爸爸","age":43,"job":"局长"},
{"name":"金九妈妈","age":45,"job":"教师"}
]})

排序

将学生信息按照年龄排列(降序-1，升序1)
db.students.find({},{"parents":0}).sort({"age":-1})
db.students.find({},{"parents":0}).sort({"age":1})
按照添加数据的顺序降序排序（自然顺序）
db.students.find({},{"parents":0}).sort({"$natural":-1})
db.students.find({},{"parents":0}).sort({"$natural":1})

数据分页

显示学生表中前3条数据
db.students.find({},{"parents":0}).limit(3)
显示学生表中第4、5条数据，先略过前3条，再取2条
db.students.find({},{"parents":0}).skip(3).limit(2)
显示学生表中年龄最小的前3条记录
db.students.find({},{"parents":0}).sort({"age":1}).limit(3)
显示学生表中第4、5条数据的记录数
db.students.find({},{"parents":0}).skip(3).limit(2).count()
结果为7 find查询条件为空
如何返回限制后的记录数量查询结果的记录条数，count()加非0数字或者true
db.students.find({},{"parents":0}).skip(3).limit(2).count(true)

count()和size()

DBCursor.count()：计数与查询匹配的对象数，不考虑限制/跳过。
DBCursor.size()：计算与查询匹配的对象数，考虑了限制/跳过。
db.students.find({}).count()
db.students.find({}).size()
db.students.find({sex:"男"}).count()
db.students.find({sex:"男"}).size()
db.students.find({}).skip(2)
db.students.find({}).skip(2).count()
db.students.find({}).skip(2).size()
db.students.find({}).skip(2).limit(5)
db.students.find({}).skip(2).limit(5).count()
db.students.find({}).skip(2).limit(5).size()
db.students.find({}).skip(2).limit(5).count({applySkipLimit:true})
db.students.find({}).skip(2).limit(5).count(true)

内嵌文档查询

精确匹配
以张三的parents作为查询条件查找
db.students.find({"parents":[
{"name":"张三爸爸","age":55,"job":"处长"},
{"name":"张三妈妈","age":42,"job":"主任"}]}).pretty()
db.students.find({"parents":[
{"name":"张三妈妈","age":42,"job":"主任"},
{"name":"张三爸爸","age":55,"job":"处长"}]}).pretty()
调换顺序之后查找不到数据，数量顺序文档必须一致，这里是精确匹配
键值对匹配key.index
键值对匹配方式与顺序无关
db.students.find({"parents.age":55}).pretty()
追加数据
db.students.insert({"_id":"1018","name":{"first":"Brack","last":"Obama"}})
db.students.insert({"_id":"1019","name":{"first":"Michelle","last":"Obama"}})
查询firstname为Brack的数据
db.students.find({"name.first":"Brack"}).pretty() 引号不能省略
查找lastname为Obama的记录
db.students.find({"name.last":"Obama"}).pretty()
查找firstname为Brack,lastname为Obama的记录
db.students.find({"name.first":"Brack","name.last":"Obama"}).pretty()
db.students.find({"name.last":"Obama","name.first":"Brack"}).pretty()

内嵌数组查询

$elemMatch 可以把查询条件限制到单个文档中

追加数据

db.blogs.insert({
	"content":"今年冬天冷么？",
	"comment":[
		{
			"author":"zhangsan",
			"score":3,
			"comment":"好冷啊"
		},{
			"author":"lisi",
			"score":5,
			"comment":"打雪仗啊"
		}
	]
})

查询评论中作者z开头n结尾的数据

db.blogs.find({"comment.author":{$regex:/^z.*n$/}})

查询评论中用户“zhangsan”，评分超过4分的博客

db.blogs.find({"comment.author":"zhangsan","comment.score":{$gte:4}}).pretty()

两个文档都进行显示，原因是键值对匹配查询条件和不同的文档进行匹配

键值对无法对单个文档进行匹配，需要用到$elemMatch

db.blogs.find({"comment":{$elemMatch:{"author":"zhangsan","score":{$gt:4}}}}).pretty()

db.blogs.find({"comment":{$elemMatch:{"author":"zhangsan","score":{$gt:2}}}}).pretty()

查询学生父母是年龄45的教师的学生

db.students.find({"parents.job":"教师",'parents.age':45})

db.students.find({"parents":{$elemMatch:{"job":"教师","age":45}}}).pretty()

$where查询

$where

where查询接收Javascript函数或者字符串作为查询条件，再迭代当前集合的所有文档，如果满足函数的条件，则返回该文档

对当前集合所有的文档进行迭代，每条记录都会执行，记录满足函数的条件，返回，每条文档用this来替代。针对集合中每个文档执行where后的函数内容，where查询需要将bson数据转换为JS数据，where效率较低，因此不建议使用where查询
添加数据
db.foods.insertMany([
{"_id":"1002","apple":5,"banana":2,"watermelon":3},
{"_id":"1003","apple":1,"banana":4,"watermelon":4},
{"_id":"1004","apple":7,"banana":6,"watermelon":3},
{"_id":"1005","apple":1,"banana":4,"watermelon":4},
{"_id":"1006","bar":"baz","banana":"baz"}
])
查询年龄大于20的学生信息
db.students.find({"age":{$gt:20}},{"parents":0})
db.students.find({$where:function(){if(this.age>20) return true;}},{"parents":0})
db.students.find({$where:function(){ return this.age>20;}},{"parents":0})
db.students.find({$where:"this.age>20"},{"parents":0}) （必须加引号）
查询年龄在19-21之间的男生信息
db.students.find({"age":{$gte:19,$lte:21},"sex":"男"},{"parents":0})
db.students.find({$and:[{"age":{$gte:19}},{"age":{$lte:21}},{"sex":"男"}]},{"parents":0})
db.students.find({$where:function(){if(this.age>=19 && this.age<=21 && this.sex=="男") return true;}},{"parents":0})
db.students.find({$where:function(){ return (this.age>=19 && this.age<=21 && this.sex=="男");}},{"parents":0})
db.students.find({$and:[{$where:"this.age>=19"},{$where:"this.age<=21"},{$where:"this.sex=='男'"}]},{"parents":0})
查询任意两个值相同的文档
db.foods.find({$where:function(){
   for(var i in this){
       for(var j in this){
           if(i!=j&&this[i]==this[j]) return true;
       }
   }
}})
查询apple的数量大于banana的数量的文档
db.foods.find({$where:"this.apple>this.banana"})