MongoDB学习笔记（一）- 文档查询和投影

文章目录

安装mongodb

我使用的是macOS bigsur，因此这里记录的是在mac下安装mongodb社区版。在mac下最便捷的安装方式就是使用brew来安装，使用以下命令：

1. 添加官方tap

   1brew tap mongodb/brew
   

2. 安装mongo全家桶，包括社区版服务端，Shell和数据库相关工具

   1brew install mongodb-community
   

安装完成后，对应的二进制文件和配置文件的位置如下：（Intel处理器）

MongoDB官方提供了以供学习用的示例数据集合，可以从https://atlas-education.s3.amazonaws.com/sampledata.archive下载，关于示例数据集的详细信息，可以参考：The MongoDB Atlas Sample Datasets。

以服务的方式启动/停止mongodb

启动mongodb服务：

1brew services start mongodb-community@5.0

服务启动后，可以通过mongo命令连接并进入shell。

停止mongodb服务：

1brew services stop mongodb-community@5.0

mongodb查询操作

这里介绍的关于mongodb的查询操作（MQL）是通过mongosh方法来实现的，这些方法底层是基于JavaScript，但是如果你使用JavaScript来连接那么你应该参考相应语言的包（idiomatic driver ）。关于新增、删除和更新的方法可以查看文档：mongosh Methods — MongoDB Manual。这里记录一下查找方法的使用。

方法定义

方法定义：db.collection.find(query, projection)

参数列表如下：

构建query的时候，会涉及到字段或者嵌套字段。所谓嵌套字段是指子文档里的字段。指定嵌套的字段的方式有两种：

• 点标记法："field.nestedfield": <value>
• 嵌套的方式：{ field: { nestedfield: <value> } } （**注意：**这种方式和点标记法不一样，这种方式将匹配名称为filed的子文档，子文档只包含一个名为nestedfield的字段）

查询选择器

这部分官网有很好的解释说明，详见：Query and Projection Operators — MongoDB Manual

比较

注意： 在进行比较的时候，比较操作符两边的数据需要是相同的BSON类型（Comparison/Sort Order — MongoDB Manual）

对于同一个字段的范围的判断，可以使用下面提到的$and逻辑运算，也可以简单的放在一起：

1db.bios.find({birth: {$gt: new Date("1940-01-01"), $lt: new Date("1960-01-01")}})

或者：

1db.bios.find({$and:[{birth:{$gt: new Date("1940-01-01")}},{birth:{$lt: new Date("1960-01-01")}}]})

逻辑运算

$not用于修饰数学符号来实现不大于、不小于诸如此类，而$and $not $nor是用于逻辑表达式之间的运算(逻辑表达式由字段和数学表达式构成)，这里要区分开。

元素（Element）

评估（Evaluation）

数组（Array)

Projection(投影)

投影的目的是将query的结果按要求返回，比如需要返回哪些字段、返回几个符合条件的数组元素。注意：

1. 包含或者排除，这二者在投影里是互斥的。即指定了包含的字段，那么结果仅返回指定的字段，如果指定了排除的字段，那么返回的结果不包含被排除的字段
2. _id是特例，默认是包含在返回结果里，如果不希望结果里返回，是需要在投影里排除掉。_id的排除是可以和其他字段的包含同时存在

关于对于数组的投影，参考以下操作符：

查询示例

这个部分的数据来源是官方bios数据集：The bios Example Collection — MongoDB Manual

查询所有文档

find()方法的query部分不传值，或者传递一个空的文档，那么返回的接口就是所有文档。

1db.bios.find()

按照特定的值查询

• 查找_id为5的文档：

  1db.bios.find({_id: 5})
  

• 查找name子文档里last的值为"Hopper"的文档：

  1db.bios.find({"name.last": "Hopper"})
  

使用查询选择器

• 查找_id的值等于5或者等于ObjectId("51e062189c6ae665454e301d")的文档：

  1db.bios.find({_id: {$in: [5, ObjectId("51e062189c6ae665454e301d")]}})
  

• 查找birth在1950之后的文档：

  1db.bios.find({birth: {$gt: new Date("1950-01-01")}})
  

• 使用正则表达式查找name子文档下last以N开头的文档：

  1db.bios.find(
  2   { "name.last": { $regex: /^N/ } }
  3)
  

  $regex的语法格式如下：

  1{ <field>: { $regex: /pattern/, $options: '<options>' } }
  2{ <field>: { $regex: 'pattern', $options: '<options>' } }
  3{ <field>: { $regex: /pattern/<options> } }
  

按照值范围查询

查找birth在1940和1960之间的文档：

1db.bios.find({birth: {$gt: new Date("1940-01-01"), $lt: new Date("1960-01-01")}})

根据多个条件查询

查找birth在1920之后，且death为false的文档：

1db.bios.find( {
2   birth: { $gt: new Date('1920-01-01') },
3   death: { $exists: false }
4} )

或者使用$and操作符

1db.bios.find({$and: [
2    {birth: {$gt: new Date("1920-01-01")}},
3    {death: {$exists: false}}
4]})

精确匹配子文档

所谓精确匹配是指要求子文档的字段的个数以及字段顺序与给定的查询条件中的子文档一致。下面的例子中，要求匹配name子文档的first为Yukihiro，last为Matsumoto，文档中这两个字段的顺序也是要匹配上

1db.bios.find(
2    { name: { first: "Yukihiro", last: "Matsumoto" } }
3)

下面的两种情况无法匹配成功：

 1{
 2   "first": "Yukihiro",
 3   "aka": "Matz",
 4   "last": "Matsumoto"
 5}
 6
 7{
 8   "last": "Matsumoto",
 9   "first": "Yukihiro"
10}

匹配子文档的字段

使用点标记法匹配子文档字段。例如查找name子文档下first为Yukihiro且last为Matsumoto的文档

1db.bios.find(
2   {
3     "name.first": "Yukihiro",
4     "name.last": "Matsumoto"
5   }
6)

根据数组元素(数组元素类型为简单类型)来查找

• 查找contribs数组里含有UNIX元素的文档（至少有一个元素符合即可）：

  1db.bios.find({contribs: "UNIX"})
  

• 查找contribs数组里含有ALGOL或者Lisp元素的文档（至少有一个元素在$in列表里）：

  1db.bios.find({contribs: {$in: ["ALGOL", "Lisp"]}})
  

• 查找contribs数组里含有ALGOL和Lisp元素的文档（至少包含$all里定义的所有元素）：

  1db.bios.find({contribs: {$all: ["ALGOL", "Lisp"]}})
  

• 查找contribs数组大小为4的文档：

  1db.bios.find({contribs: {$size: 4}})
  

根据数组元素(数组元素类型为文档类型)来查找

• 查找awards数组下的子文档中的award的值为Turing Award的文档：

  1db.bios.find(
  2   { "awards.award": "Turing Award" }
  3)
  

• 查找awards数组元素中award的值为Turing Award且year(这里必须要在一个数组元素同时满足)大于1999的文档：

  1db.bios.find(
  2   { awards: { $elemMatch: { award: "Turing Award", year: { $gt: 2000 } } } }
  3)
  

  上面的查询可以匹配：

   1"awards": [
   2      {
   3        "award": "Rosing Prize",
   4        "year": 1999,
   5        "by": "Norwegian Data Association"
   6      },
   7      {
   8        "award": "Turing Award",
   9        "year": 2001,
  10        "by": "ACM"
  11      },
  12      {
  13        "award": "IEEE John von Neumann Medal",
  14        "year": 2001,
  15        "by": "IEEE"
  16      }
  17    ]
  

  但是无法匹配：

   1"awards": [
   2      {
   3        "award": "Turing Award",
   4        "year": 1983,
   5        "by": "ACM"
   6      },
   7      {
   8        "award": "National Medal of Technology",
   9        "year": 1998,
  10        "by": "United States"
  11      },
  12      {
  13        "award": "Japan Prize",
  14        "year": 2011,
  15        "by": "The Japan Prize Foundation"
  16      }
  17    ]
  

  如果这里不使用elemMatch而是使用下面的方式，结果返回的是awards元素里包含award为”Turing Award“和year大于1975的元素。这两个条件是要求awards下的所有元素里，满足这两个条件即可。这两个条件是限制在awards上，不是限制在单一的数组元素上，因此上面无法匹配的例子也可以被下面的查询匹配。

  1db.bios.find(
  2   {
  3        "awards.award": "Turing Award" ,
  4        "awards.year": {$gt: 1975}
  5   }
  6)
  

投影示例

指定要包含的字段

查找bios集合里所有文档并返回文档的name和contribs字段：

1db.bios.find( { }, { name: 1, contribs: 1 } )

指定要排除的字段

查找bios集合里contribs为OOP的集合，返回的时候排除掉name.first和birth字段：

1db.bios.find(
2   { contribs: 'OOP' },
3   { 'name.first': 0, birth: 0 }
4)

显式排除_id字段

查找bios集合里所有文档并返回文档的name和contribs字段但不包括_id：

1db.bios.find(
2   { },
3   { name: 1, contribs: 1, _id: 0 }
4)

对子文档和数组投影

查找bios集合里的所有文档并返回name.last，以及contribs数组里的前两个元素

1db.bios.find(
2    {},
3    {_id: 0, 'name.last': 1, contribs: {$slice: 2}}
4)