db.collection.find()

打开交互式教程

嵌入式字段规范

对于嵌套文档中的字段，您可以使用以下任一方式指定字段：

• 点表示法，例如 "field.nestedfield": <value>

• 嵌套形式，例如 { field: { nestedfield: <value> } }

_id 字段投影

默认情况下，_id 字段包含在返回的文档中，除非你在投影中明确指定 _id: 0 来抑制该字段。

包含或排除

投影中不能同时包含包含和排除指定，除非是 _id 字段。

• 在显式包含字段的投影中，_id 是唯一可以显式排除的字段。

• 在显式排除字段的投影中，_id 是唯一可以显式包含的字段；然而，_id 字段默认包含。

请参阅投影示例。

会话空闲超时

MongoDB 驱动程序和 mongosh 将所有操作与服务器会话关联，除了未确认的写操作。对于未明确与会话关联的操作（即使用 Mongo.startSession()），MongoDB 驱动程序和 mongosh 创建一个隐式会话并将其与操作关联。

如果会话空闲超过30分钟，MongoDB服务器将该会话标记为过期，并可能随时关闭它。当MongoDB服务器关闭会话时，它也会终止会话中所有正在进行的操作和打开的光标。这包括配置了noCursorTimeout()或maxTimeMS()大于30分钟的光标。

对于可能空闲超过30分钟的操作，可以使用Mongo.startSession()将操作与显式会话关联，并定期使用refreshSessions命令刷新会话。有关更多信息，请参阅会话空闲超时。

等性查询

• 以下操作返回 bios 集合 中 _id 等于 5 的文档。

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

• 以下操作返回 bios 集合 中，嵌套文档的 name 字段的 last 字段等于 "Hopper" 的文档。

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

  注意

  要访问嵌套文档中的字段，请使用 点表示法 (<嵌套文档>.<字段>)。

使用运算符进行查询

要查找符合一组选择标准的文档，请使用带有 <criteria> 参数的 find() 方法。

MongoDB 提供了各种 查询运算符 来指定这些标准。

• 以下操作使用 $in 运算符返回 bios 集合 中 _id 等于 5 或 ObjectId("507c35dd8fada716c89d0013") 的文档。

  db.bios.find(
     { _id: { $in: [ 5, ObjectId("507c35dd8fada716c89d0013") ] } }
  )

• 以下操作使用 $gt 运算符返回所有来自 bios 集合且 birth 大于 new Date('1950-01-01') 的文档。

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

• 以下操作使用 $regex 运算符返回 bios 集合 中 name.last 字段以字母 N 开头的文档（或 "LIKE N%"）。

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

有关查询运算符的列表，请参阅 查询选择器。

查询范围

使用比较运算符组合来指定字段的范围。以下操作从文档中返回birth字段在new Date('1940-01-01')和new Date('1960-01-01')（不包含）之间的所有文档。

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

有关查询运算符的列表，请参阅 查询选择器。

查询多个条件

以下操作返回所有来自的文档，其中birth字段大于new Date('1950-01-01')，且death字段不存在。

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

有关查询运算符的列表，请参阅 查询选择器。

在嵌入文档上查询精确匹配

以下操作返回 bios 集合 中嵌入文档的 name 字段与 精确 { first: "Yukihiro", last: "Matsumoto" } 匹配的文档，包括顺序

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

name 字段必须与嵌入文档完全匹配。查询不匹配以下 name 字段

{
   first: "Yukihiro",
   aka: "Matz",
   last: "Matsumoto"
}
{
   last: "Matsumoto",
   first: "Yukihiro"
}

查询嵌入文档的字段

以下操作返回包含嵌套文档的 bios 集合，其中嵌套文档的 name 字段包含字段 first，其值为 "Yukihiro"，以及字段 last，其值为 "Matsumoto"。查询使用 点表示法 来访问嵌套文档中的字段。

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

查询匹配 name 字段包含嵌套文档的文档，该嵌套文档具有字段 first，其值为 "Yukihiro"，以及字段 last，其值为 "Matsumoto"。例如，查询将匹配具有以下值的 name 字段的文档：

{
  first: "Yukihiro",
  aka: "Matz",
  last: "Matsumoto"
}
{
  last: "Matsumoto",
  first: "Yukihiro"
}

有关更多信息示例，请参阅嵌套文档查询。

查询数组元素

以下示例查询 bios 集合 中的 contribs 数组。

• 以下操作返回包含元素 "UNIX" 的 contribs 数组的 bios 集合 中的文档。

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

• 以下操作返回包含元素 "ALGOL" 或 "Lisp" 的 contribs 数组的 bios 集合 中的文档。

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

• 以下操作使用 $all 查询操作符返回包含元素 "ALGOL" 和 "Lisp" 的 contribs 数组的 bios 集合 中的文档。

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

  更多示例，请参阅 $all。另请参阅 $elemMatch。

• 以下操作使用 $size 操作符来返回 bios 集合中 contribs 数组的长度为 4 的文档。

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

有关查询数组的更多信息及示例，请参阅

• 查询数组

• 查询嵌入式文档数组

有关特定于数组的查询操作符列表，请参阅 数组。

查询文档数组

以下示例查询 bios 集合中的 awards 数组。

• 以下操作返回 bios 集合中 awards 数组包含字段为 award 等于 "Turing Award" 的元素的文档。

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

• 以下操作返回 bios 集合中 awards 数组至少包含一个同时满足字段 award 等于 "Turing Award" 且字段 year 大于 1980 的元素的文档。

  db.bios.find(
     { awards: { $elemMatch: { award: "Turing Award", year: { $gt: 1980 } } } }
  )

  使用 $elemMatch 操作符来指定数组元素上的多个条件。

有关查询数组的更多信息及示例，请参阅

• 查询数组

• 查询嵌入式文档数组

有关特定于数组的查询操作符列表，请参阅 数组。

指定要返回的字段

以下操作在 bios 集合 中查找所有文档，并仅返回 name 字段、contribs 字段和 _id 字段。

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

明确排除的字段

以下操作查询 bios 集合，并返回所有字段，除了嵌入文档中的 name 字段的第一个字段和 birth 字段

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

明确排除 _id 字段

以下操作在 bios 集合 中查找文档，并仅返回 name 字段和 contribs 字段

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

关于数组和嵌入文档

以下操作查询 bios 集合，并返回嵌入文档中的 name 字段的最后一个字段和 contribs 数组中的前两个元素

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

您还可以使用嵌套表单来指定嵌入字段。例如

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

使用聚合表达式

db.collection.find() 投影可以接受 聚合表达式和语法。

使用聚合表达式和语法，您可以投影新字段或以新值投影现有字段。例如，以下操作使用聚合表达式覆盖 name 和 awards 字段的值，并包含新字段 reportDate、reportBy 和 reportNumber。

db.bios.find(
   { },
   {
     _id: 0,
     name: {
        $concat: [
           { $ifNull: [ "$name.aka", "$name.first" ] },
           " ",
           "$name.last"
        ]
     },
     birth: 1,
     contribs: 1,
     awards: { $cond: { if: { $isArray: "$awards" }, then: { $size: "$awards" }, else: 0 } },
     reportDate: { $dateToString: {  date: new Date(), format: "%Y-%m-%d" } },
     reportBy: "hellouser123",
     reportNumber: { $literal: 1 }
   }
)

将 reportRun 字段设置为值 1 操作返回以下文档

{ "birth" : ISODate("1924-12-03T05:00:00Z"), "contribs" : [ "Fortran", "ALGOL", "Backus-Naur Form", "FP" ], "name" : "John Backus", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1927-09-04T04:00:00Z"), "contribs" : [ "Lisp", "Artificial Intelligence", "ALGOL" ], "name" : "John McCarthy", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1906-12-09T05:00:00Z"), "contribs" : [ "UNIVAC", "compiler", "FLOW-MATIC", "COBOL" ], "name" : "Grace Hopper", "awards" : 4, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1926-08-27T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Kristen Nygaard", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1931-10-12T04:00:00Z"), "contribs" : [ "OOP", "Simula" ], "name" : "Ole-Johan Dahl", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1956-01-31T05:00:00Z"), "contribs" : [ "Python" ], "name" : "Guido van Rossum", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1941-09-09T04:00:00Z"), "contribs" : [ "UNIX", "C" ], "name" : "Dennis Ritchie", "awards" : 3, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1965-04-14T04:00:00Z"), "contribs" : [ "Ruby" ], "name" : "Matz Matsumoto", "awards" : 1, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "birth" : ISODate("1955-05-19T04:00:00Z"), "contribs" : [ "Java" ], "name" : "James Gosling", "awards" : 2, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }
{ "contribs" : [ "Scala" ], "name" : "Martin Odersky", "awards" : 0, "reportDate" : "2020-06-05", "reportBy" : "hellouser123", "reportNumber" : 1 }

使用变量名

以下示例使用变量 myCursor 来迭代游标并打印匹配的文档

var myCursor = db.bios.find( );
myCursor

使用 next() 方法

以下示例使用游标方法 next() 来访问文档

var myCursor = db.bios.find( );
var myDocument = myCursor.hasNext() ? myCursor.next() : null;
if (myDocument) {
    var myName = myDocument.name;
    print (tojson(myName));
}

要打印，您也可以使用 printjson() 方法代替 print(tojson())

if (myDocument) {
   var myName = myDocument.name;
   printjson(myName);
}

使用 forEach() 方法

以下示例使用光标方法 forEach() 迭代光标并访问文档

var myCursor = db.bios.find( );
myCursor.forEach(printjson);

对结果集中的文档进行排序

sort() 方法对结果集中的文档进行排序。以下操作返回按 name 字段升序排序的 bios 集合 中的文档

db.bios.find().sort( { name: 1 } )

sort() 方法对应于 SQL 中的 ORDER BY 语句。

限制返回的文档数量

方法 limit() 用于限制结果集中文档的数量。以下操作在 bios 集合 中最多返回 5 个文档：

db.bios.find().limit( 5 )

limit() 对应于 SQL 中的 LIMIT 语句。

设置结果集的起始点

方法 skip() 控制结果集的起始点。以下操作跳过 bios 集合 中的前 5 个文档并返回所有剩余文档。

db.bios.find().skip( 5 )

指定排序规则

排序规则 允许用户指定字符串比较的语言特定规则，例如字母大小写和重音符号的规则。

collation() 方法用于指定 排序规则，适用于 db.collection.find() 操作。

db.bios.find( { "name.last": "hopper" } ).collation( { locale: "en_US", strength: 1 } )

组合游标方法

以下语句连接了游标方法 limit() 和 sort()：

db.bios.find().sort( { name: 1 } ).limit( 5 )
db.bios.find().limit( 5 ).sort( { name: 1 } )

这两个语句是等效的；即 limit() 和 sort() 方法的顺序不重要。两个语句都返回按 'name' 字段升序排序的前五个文档。

可用的 mongosh 游标方法

带有选项的limit

以下查询使用limit选项参数限制结果集中的文档数量

db.users.find(
   { username : "rajiv"}, // query
   { age : 1 }, // projection
   { limit : 1 } // options
)

带有选项的allowDiskUse

以下查询使用options参数启用allowDiskUse

db.users.find(
   { username : "david" },
   { age : 1 },
   { allowDiskUse : true }
)

使用选项进行说明

以下查询使用 options 参数获取 executionStats 解释输出

var cursor = db.users.find(
   { username: "amanda" },
   { age : 1 },
   { explain : "executionStats" }
)
cursor.next()

在查询中指定多个选项

以下查询在一个查询中使用多个 options。此查询将 limit 设置为 2 以返回仅两个文档，并将 showRecordId 设置为 true 以返回文档在结果集中的位置

db.users.find(
   {},
   { username: 1, age: 1 },
   {
     limit: 2,
     showRecordId: true
   }
)