MongoDB Cursor游标方法(第 12 天)

作者 : 慕源网 本文共15222个字,预计阅读时间需要39分钟 发布时间: 2021-11-1 共356人阅读

在阅读本文之前,我强烈建议您阅读本系列的前几期:

游标方法

MongoDB 提供了一系列游标方法。顾名思义,这些方法为游标执行操作并返回结果。本文解释了一些重要且有用的游标方法。

方法名称 描述
Count 返回游标中的文档总数
Limit 限制游标中的记录
Skip 跳过光标中的多个文档
Sort 以有序形式返回结果
Next 从光标返回下一个文档
toArray 返回一个包含游标返回的所有文档的数组。
Size 返回游标中文档的计数。
hasNext hasNext() 方法用于查找光标是否包含下一个(更多)文档或也不是
forEach 为游标中的每个文档应用 JavaScript 函数。
Explain 返回有关游标的查询执行计划的信息

首先,我们创建一个集合。

db.createCollection(“Employee”,{ipped:false,autoIndexID:false,size:5040320,max:50})

现在将以下数据插入到“ Employee ”集合中。

{  
         "_id" : ObjectId("55cc8833211cb7f01f58ce20"),  
         "Name" : "Pankaj Choudhary",  
         "City" : "Alwar",  
         "Salary" : 35000  
 }  
 {  
         "_id" : ObjectId("55cc8850211cb7f01f58ce21"),  
         "Name" : "Sandeep Jangid",  
         "City" : "Jaipur",  
         "Salary" : 25000  
 }  
 {  
         "_id" : ObjectId("55cc8868211cb7f01f58ce22"),  
         "Name" : "Rahul Prajapat",  
         "City" : "Delhi",  
         "Salary" : 27000  
 }  
 {  
         "_id" : ObjectId("55cc887b211cb7f01f58ce23"),  
         "Name" : "Sanjeev Baldia",  
         "City" : "Delhi",  
         "Salary" : 47000  
 }  
 {  
         "_id" : ObjectId("55cc8895211cb7f01f58ce24"),  
         "Name" : "Narendra Sharma",  
         "City" : "Jaipur",  
         "Salary" : 35000  
 }  
 {  
         "_id" : ObjectId("55cc88b0211cb7f01f58ce25"),  
         "Name" : "Omi Choudhary",  
         "City" : "Alwar",  
         "Salary" : 27000  
 }  
 {  
         "_id" : ObjectId("55cc88f5211cb7f01f58ce27"),  
         "Name" : "Nitin Yadav",  
         "City" : "Jaipur",  
         "Salary" : 32000  
 }  

插入上述数据后,“ Employee ”集合如下所示。

 

现在我们通过使用每个示例中的“Employee”集合来理解每个方法。

Count() 方法

Count 方法返回存在于游标中或被游标引用的文档数。要确定匹配文档的数量,请将 count() 方法附加到 find() 查询。

语法

db.Collection_Name.find(<query>).count(<applySkipLimit>)

参数

Name 类型 描述
Query Document 定义选择标准
applySkipLimit Boolean 可选的。考虑skip() 和limit() 方法的效果。该值默认为 false。

要对集合的所有文档进行计数,请使用 count() 方法而不使用 find() 方法中的任何查询参数。

示例

db.Employee.find().count()

此查询返回“Employee”集合中存在的文档总数。

输出

7

带有 Query 参数的 Count 方法:要计算符合特定条件的所有文档,请使用 find 方法中的 query 参数。

示例

db.Employee.find({Salary:{$gt:30000}}).count()

此查询返回工资大于 30000 的所有员工的计数。

输出

4

Use Limit with Count 方法

使用 limit 方法和 count 方法返回特定文档的总数。如果我们使用 limit 方法,那么我们必须将 applySkipLimit 参数的值设置为 true。

示例

db.Employee.find({Salary:{$gt:30000}}).limit(2).count()

输出

4

前面的查询返回 4 而不是 2,因为我们没有将 applySkipLimit 参数的值设置为真的。现在我们将值applySkipLimit参数设置为 true 并获得所需的输出。

示例

db.Employee.find({Salary:{$gt:30000}}).limit(2).count(true)

输出

2

注意: db.collection.find(<query>).count() 构造适用于与 db.collection.count(<query>) 相同。

示例 1

查询:db.Employee.find().count()

输出:7

查询:db.Employee.count()

输出:7

示例 2

查询:db.Employee.find({Salary:{$gt:30000}}). count()

输出:4

查询:db.Employee.count({Salary:{$gt:30000}})

输出:

Limit() 方法

Limit 方法指定游标将返回的最大文档数。MongoDB 中的 Limit() 方法类似于 SQL 数据库的 limit 语句。该limit()

方法接受一个整数类型参数,它是您要显示的文档数。我们必须使用 Limit() 方法来防止 MongoDB 返回超过处理所需的结果。Limit(0) (A limit() value of 0)相当于设置无限制。

语法:db.Collection_Name.find(<query>).limit(number)

参数

参数 类型 描述
Query Document 指定选择标准
Number Integer 指定要显示的文档数

限制 Cursor 的输出

要检索特定数量的数据,请在 limit 方法中传递 <number> 参数的值。

示例

db.Employee.find().limit(3).pretty()

此查询从游标中检索前 3 条记录。

输出

{  
         "_id" : ObjectId("55cc8833211cb7f01f58ce20"),  
         "Name" : "Pankaj Choudhary",  
         "City" : "Alwar",  
         "Salary" : 35000  
 }  
 {  
         "_id" : ObjectId("55cc8850211cb7f01f58ce21"),  
         "Name" : "Sandeep Jangid",  
         "City" : "Jaipur",  
         "Salary" : 25000  
 }  
 {  
         "_id" : ObjectId("55cc8868211cb7f01f58ce22"),  
         "Name" : "Rahul Prajapat",  
         "City" : "Delhi",  
         "Salary" : 27000  
 } 

带有查询参数的限制方法

要检索与选择条件匹配的特定数量的文档,请使用 find 中的 <query> 参数和 limit 方法中的 <number> 参数。

示例

db.Employee.find({City:”Delhi”}).limit(2).pretty()

此查询返回居住在“Delhi”城市的前 2 名员工的详细信息。

输出

 

{
   "_id" : ObjectId("55cc8868211cb7f01f58ce22"),
   "Name" : "Rahul Prajapat",
   "City" : "Delhi",
   "Salary" : 27000
}
{
   "_id" : ObjectId("55cc887b211cb7f01f58ce23"),
   "Name" : "Sanjeev Baldia",
   "City" : "Delhi",
   "Salary" : 47000
}

Skip() 方法从游标返回的结果中跳过文档。换句话说,skip() 方法控制 MongoDB 返回结果。

语法:db.Collection_Name.find(<query>).skip(number>)

参数:

参数 类型 描述
Query Document 指定选择标准
Number Integer 指定要跳过的文档数

从特定位置开始结果

我们可以使用 skip() 方法从特定位置开始结果。如果我们想从集合的第三个文档中检索结果,那么在skip方法中传递3作为参数值。skip() 方法的默认值是 0。 但是,skip() 方法的开销很大,因为它需要服务器从集合的开头开始获取跳过位置,然后才开始返回结果。

示例

db.Employee.find().skip(3).pretty()

此查询从结果中跳过前 3 个文档并打印其余文档。

输出

{  
         "_id" : ObjectId("55cc887b211cb7f01f58ce23"),  
         "Name" : "Sanjeev Baldia",  
         "City" : "Delhi",  
         "Salary" : 47000  
 }  
 {  
         "_id" : ObjectId("55cc8895211cb7f01f58ce24"),  
         "Name" : "Narendra Sharma",  
         "City" : "Jaipur",  
         "Salary" : 35000  
 }  
 {  
         "_id" : ObjectId("55cc88b0211cb7f01f58ce25"),  
         "Name" : "Omi Choudhary",  
         "City" : "Alwar",  
         "Salary" : 27000  
 }  
 {  
         "_id" : ObjectId("55cc88f5211cb7f01f58ce27"),  
         "Name" : "Nitin Yadav",  
         "City" : "Jaipur",  
         "Salary" : 32000  
 }  

使用带有限制的skip() 方法

我们也可以使用带有limit() 的skip() 方法。这一次,skip() 方法从游标中删除起始文档,并根据 limit() 方法的 <number> 参数的值返回文档。

示例

db.Employee.find().limit(2).skip(1).pretty()

此查询跳过第一个文档并从游标返回接下来的两个文档。

输出

 

{
   "_id" : ObjectId("55cc8850211cb7f01f58ce21"),
   "Name" : "Sandeep Jangid",
   "City" : "Jaipur",
   "Salary" : 25000
}
{
   "_id" : ObjectId("55cc8868211cb7f01f58ce22"),
   "Name" : "Rahul Prajapat",
   "City" : "Delhi",
   "Salary" : 27000
}

Sort() 方法

sort() 方法按特定顺序检索结果。排序可以通过单个字段或多个字段完成。在从数据库中检索任何文档之前,我们必须对游标使用 sort() 方法。MongoDB 不保证查询结果的顺序。MongoDB 使用 top-k 排序算法。该算法根据排序顺序缓冲前 k 个结果或最后 k 个结果。

语法: db.Collection_Name.find(<query>).sort(<sort>)

参数

参数 类型 描述
Query Document 指定选择标准
Sort Document 定义结果集的排序顺序。

sort 参数包含如下字段和值对。

语法:{ field:sorting_order)

Sorting_Order

Value 描述
1 按升序排序
-1 按降序排序

当 sort() 方法比较各种类型的数据时,使用以下比较顺序。

类型 Order
MinKey 1
Null 2
Numbers(int,double) 3
Symbol , String 4
Object 5
Array 6
BinData 7
ObjectId 8
Boolean 9
Date 10
Timestamp 11
Regular Expression 12
MaxKey 13

关于排序顺序的重要信息:

  • MongoDB treats { } (not existing) 和“null” 视为相同
  • sort() 方法按升序比较数组的最小元素
  • 按降序排列,sort() 方法是数组的最大元素。
  • 空数组的排序优先级小于 null 或不存在的字段。

现在我们考虑一些例子。

根据字段

对结果进行排序要根据任何字段对检索结果进行排序,请通过该字段的名称任意排序。

1. 根据单个字段对结果进行排序

示例

db.Employee.find().sort({“Salary”:1}).pretty()

此查询按“Salary”字段升序对结果进行排序。

输出

{  
         "_id" : ObjectId("55cc8850211cb7f01f58ce21"),  
         "Name" : "Sandeep Jangid",  
         "City" : "Jaipur",  
         "Salary" : 25000  
 }  
 {  
         "_id" : ObjectId("55cc8868211cb7f01f58ce22"),  
         "Name" : "Rahul Prajapat",  
         "City" : "Delhi",  
         "Salary" : 27000  
 }  
 {  
         "_id" : ObjectId("55cc88b0211cb7f01f58ce25"),  
         "Name" : "Omi Choudhary",  
         "City" : "Alwar",  
         "Salary" : 27000  
 }  
 {  
         "_id" : ObjectId("55cc88f5211cb7f01f58ce27"),  
         "Name" : "Nitin Yadav",  
         "City" : "Jaipur",  
         "Salary" : 32000  
 }  
 {  
         "_id" : ObjectId("55cc8833211cb7f01f58ce20"),  
         "Name" : "Pankaj Choudhary",  
         "City" : "Alwar",  
         "Salary" : 35000  
 }  
 {  
         "_id" : ObjectId("55cc8895211cb7f01f58ce24"),  
         "Name" : "Narendra Sharma",  
         "City" : "Jaipur",  
         "Salary" : 35000  
 }  
 {  
         "_id" : ObjectId("55cc887b211cb7f01f58ce23"),  
         "Name" : "Sanjeev Baldia",  
         "City" : "Delhi",  
         "Salary" : 47000  
 }  

2. 根据多个字段对结果进行排序

示例

db.Employee.find().sort({“Salary”:1,”City”:-1}).pretty()

该查询排序结果首先按“Salary”字段排序升序,在每个“Salary”字段中,按“City”字段降序排序。

输出

{  
     "_id" : ObjectId("55cc8850211cb7f01f58ce21"),  
     "Name" : "Sandeep Jangid",  
     "City" : "Jaipur",  
     "Salary" : 25000  
 }  
 {  
     "_id" : ObjectId("55cc8868211cb7f01f58ce22"),  
     "Name" : "Rahul Prajapat",  
     "City" : "Delhi",  
     "Salary" : 27000  
 }  
 {  
     "_id" : ObjectId("55cc88b0211cb7f01f58ce25"),  
     "Name" : "Omi Choudhary",  
     "City" : "Alwar",  
     "Salary" : 27000  
 }  
 {  
     "_id" : ObjectId("55cc88f5211cb7f01f58ce27"),  
     "Name" : "Nitin Yadav",  
     "City" : "Jaipur",  
     "Salary" : 32000  
 }  
 {  
     "_id" : ObjectId("55cc8895211cb7f01f58ce24"),  
     "Name" : "Narendra Sharma",  
     "City" : "Jaipur",  
     "Salary" : 35000  
 }  
 {  
     "_id" : ObjectId("55cc8833211cb7f01f58ce20"),  
     "Name" : "Pankaj Choudhary",  
     "City" : "Alwar",  
     "Salary" : 35000  
 }  
 {  
     "_id" : ObjectId("55cc887b211cb7f01f58ce23"),  
     "Name" : "Sanjeev Baldia",  
     "City" : "Delhi",  
     "Salary" : 47000  

Sort() 方法使用limit 和Projection

我们可以使用projection(返回特定字段)和sort() 方法限制。

示例

db.Employee.find({},{_id:0,Name:1,Salary:1}).sort({City:1}).limit(4).pretty()

该查询执行如下程序:

  1. 按“City”字段升序对文档进行排序。
  2. 现在选择前 4 个结果。
  3. 返回所选文档的“Name”和“Salary”字段。

输出

{ “Name” : “Pankaj Choudhary”, “Salary” : 35000 }
{ “Name”: “Omi Choudhary”, “Salary” : 27000 }
{ “Name”: “Rahul Prajapat”, “Salary” : 27000 }
{ “Name” : “Sanjeev Baldia”, “Salary” : 47000 }

Natural Sort

MongoDB在 sort() 方法中提供了一个“ $natural ”参数,以根据它们在数据库中的自然顺序返回项目。

这里,自然顺序是文档的插入顺序。

示例 1

db.Employee.find({},{_id:0,Name:1,Salary:1,City:1}).sort({$natural:1})。

Pretty()此查询根据文档的插入顺序从“Oldest”到“Newest”输入文档返回文档。

输出

{ "Name" : "Pankaj Choudhary", "City" : "Alwar", "Salary" : 35000 }
{ "Name" : "Sandeep Jangid", "City" : "Jaipur", "Salary" : 25000 }
{ "Name" : "Rahul Prajapat", "City" : "Delhi", "Salary" : 27000 }
{ "Name" : "Sanjeev Baldia", "City" : "Delhi", "Salary" : 47000 }
{ "Name" : "Narendra Sharma", "City" : "Jaipur", "Salary" : 35000 }
{ "Name" : "Omi Choudhary", "City" : "Alwar", "Salary" : 27000 }
{ "Name" : "Nitin Yadav", "City" : "Jaipur", "Salary" : 32000 }

示例 2

db.Employee.find({},{_id:0,Name:1,Salary:1,City:1}).sort({$natural:-1}).pretty()

此查询按插入顺序从“Newest”到“Oldest”输入文档返回文档。

输出

{ "Name" : "Nitin Yadav", "City" : "Jaipur", "Salary" : 32000 }
{ "Name" : "Omi Choudhary", "City" : "Alwar", "Salary" : 27000 }
{ "Name" : "Narendra Sharma", "City" : "Jaipur", "Salary" : 35000 }
{ "Name" : "Sanjeev Baldia", "City" : "Delhi", "Salary" : 47000 }
{ "Name" : "Rahul Prajapat", "City" : "Delhi", "Salary" : 27000 }
{ "Name" : "Sandeep Jangid", "City" : "Jaipur", "Salary" : 25000 }
{ "Name" : "Pankaj Choudhary", "City" : "Alwar", "Salary" : 35000 }

Next() 方法

Next() 方法从光标处检索下一个文档。如果游标不包含更多文档,则 Next() 方法返回 null。

语法: Cursor_objectName.next()

注意:cursor_objectName 是包含“db.collection.find()”方法返回的引用的对象。

示例

查询 1:var Cursor1=db.Employee.find()

在此查询中,我们将引用分配给 find() 方法返回的 Cursor1 对象。

查询 2: Cursor1.next()

此查询返回游标对象的第一个文档。

输出

{
“_id” : ObjectId(“55cc8833211cb7f01f58ce20”),
“Name” : “Pankaj Choudhary”,
“City” : “Alwar”,
“Salary” : 35000
}

Query 3

Cursor1.next()

此查询返回下一个(秒) 来自游标对象的文档。

输出

{
“_id” : ObjectId(“55cc8850211cb7f01f58ce21”),
“Name” : “Sandeep Jangid”,
“City” : “Jaipur”,
“Salary” : 25000
}

我们可以看到前面的查询,如下图:

toArray()方法

toArray() 方法返回一个包含游标中所有文档的数组,并完全迭代游标。toArray() 方法将所有文档从游标加载到内存中并耗尽游标。

语法:db.Collection_Name.find().toArray()

从游标中检索所有文档 要从游标中

检索所有文档,请对游标使用 toArray() 方法。

示例

db.Employee.find({},{_id:0,Name:1,Salary:1})。

[  
     {  
             "Name" : "Pankaj Choudhary",  
             "Salary" : 35000  
     },  
     {  
             "Name" : "Sandeep Jangid",  
             "Salary" : 25000  
     },  
     {  
             "Name" : "Rahul Prajapat",  
             "Salary" : 27000  
     },  
     {  
             "Name" : "Sanjeev Baldia",  
             "Salary" : 47000  
     },  
     {  
             "Name" : "Narendra Sharma",  
             "Salary" : 35000  
     },  
     {  
             "Name" : "Omi Choudhary",  
             "Salary" : 27000  
     },  
     {  
             "Name" : "Nitin Yadav",  
             "Salary" : 32000  
     }  
 ]  

使用数组变量

我们可以将结果存储到从 toArray() 方法检索的数组变量中。这种方法提供了从数组变量中检索特定文档的选项。

例子

var Array_=db.Employee.find({},{_id:0,Name:1,Salary:1}).toArray()  
if(Array_.length>0)  
{  
   Array_   
}  

输出

[  
     {  
             "Name" : "Pankaj Choudhary",  
             "Salary" : 35000  
     },  
     {  
             "Name" : "Sandeep Jangid",  
             "Salary" : 25000  
     },  
     {  
             "Name" : "Rahul Prajapat",  
             "Salary" : 27000  
     },  
     {  
             "Name" : "Sanjeev Baldia",  
             "Salary" : 47000  
     },  
     {  
             "Name" : "Narendra Sharma",  
             "Salary" : 35000  
     },  
     {  
             "Name" : "Omi Choudhary",  
             "Salary" : 27000  
     },  
     {  
             "Name" : "Nitin Yadav",  
             "Salary" : 32000  
     }  
 ] 

我们还可以从 Array 变量返回特定文档。

例子

var Array_=db.Employee.find({},{_id:0,Name:1,Salary:1}).limit(3).toArray()  
  
if(Array_.length>0)  
{  
   printjson(Array_[1])  
}  

前面的查询从 Array_ 变量返回第二个文档。

输出

{ “Name” : “Sandeep Jangid”, “Salary” : 25000 }

差异 b/w db.collection.find() 和 db.collection.find().toArray() 方法

“DBQuery.shellBatchSize”命令指定一次可见的文档数。我们可以使用“it”命令继续迭代游标。默认情况下,“DBQuery.shellBatchSize”的值为 20。这意味着 MongoDb 一次显示 20 条记录。find() 方法显示的记录数取决于“DBQuery.shellBatchSize”的值。换句话说,如果“DBQuery.shellBatchSize”的值等于 10,那么 find() 一次只显示 10 个文档,我们必须使用“it”命令来显示接下来的 10 个文档。

但是对 toArray() 方法中“DBQuery.shellBatchSize”的值没有影响,该方法在一个批次中显示所有文档。

示例

DBQuery.shellBatchSize =4

在此命令中,我们将“DBQuery.shellBatchSize”的值设置为 4。这意味着光标一次仅显示 4 个文档。

db.Employee.find({},{_id:0,Name:1})

输出

{ “Name” : “Pankaj Choudhary” }
{ “Name” : “Sandeep Jangid” }
{ “Name” : “Rahul Prajapat” }
{ “Name” : “Sanjeev Baldia” }

输入“it” 获取更多信息:

{ “Name” : “Narendra Sharma” }
{ “Name” : “Omi Choudhary” }
{ “Name” : “

在前面的例子中,我们可以看到光标一次只打印 4 个文档。要迭代光标,我们使用“it”命令。但是 toArray() 方法将在一个批次中显示所有文档。

让我们看一个例子。

db.Employee.find({},{_id:0,Name:1}).toArray()

输出

[  
    {  
            "Name" : "Pankaj Choudhary"  
    },  
    {  
            "Name" : "Sandeep Jangid"  
    },  
    {  
            "Name" : "Rahul Prajapat"  
    },  
    {  
            "Name" : "Sanjeev Baldia"  
    },  
    {  
            "Name" : "Narendra Sharma"  
    },  
    {  
            "Name" : "Omi Choudhary"  
    },  
    {  
            "Name" : "Nitin Yadav"  
    }  
]  

Size() 方法

Size() 方法返回在应用任何skip() 和limit() 方法后与find() 方法的选择标准匹配的文档数。

语法: db.collection_name.find().count()

计算所有文档

要计算集合的所有文档,请使用带有游标的 size() 方法。

示例

db.Employee.find({},{_id:0,Name:1}).size()

输出:7

limit 方法

要计算有限数量的文档,请使用 size() 方法和 limit() 方法。

示例

db.Employee.find({},{_id:0,Name:1}).limit(4).size()

输出: 4

skip() 方法

db.Employee.find({Salary:{$gt:25000 }}).skip(3).size()

输出: 3

size() 方法与 skip() 和 limit() 方法

db.Employee.find({Salary:{$gt:25000}}).limit(2).skip(1).size()

输出:2

hasNext()方法

hasNext() 方法查找包含下一个(更多)文档的光标。如果游标的进一步迭代是可能的,hasNext() 方法返回“true”,否则返回“false”。

语法: db.Collection_Came.find().hasNext()

示例 1

var nxt=db.Employee.find().limit(2)

var value=nxt.hasNext()?”Cursor conatin more document”:”Cursor does’ t

contains more document ” if(value){ printjson(value) }

输出

“Cursor conatin more document”

Example 2

var nxt=db.Employee.find().limit(2)
var value=nxt.hasNext()?nxt.next():null
if(value){ printjson(value) }


输出

{
“_id” : ObjectId(“55cc8833211cb7f01f58ce20”),
“Name” : “Pankaj Choudhary”,
“City ” : “Alwar”,
“Salary” : 35000
}

如果游标不包含另一个文档(并且通常我们对游标使用 next() 方法)那么 MongoDB 将抛出错误,如下所示。

2015-08-14T18:50:24.896+0530 E 查询错误:错误 hasNext:false:

at Error (<anonymous>)
at DBQuery.next (src/mongo/shell/query.js:255:15)
at (shell):1:5 at src/mongo/shell/query.js:255

forEach() 方法

我们可以使用带有游标变量的 forEach 循环来迭代游标并访问文档。forEach 方法迭代游标以将 JavaScript 函数应用到游标中的每个文档。

语法:db.Collection_Name.find(<query>).forEach(<function>)

参数

参数 类型 描述
Query Document 指定选择标准
Function JavaScript 从游标应用于每个文档的 JavaScript 函数

示例

db.Employee.find().forEach(function(Employee){ var detail= “Employee Name=”+Employee.Name +”
Employee Salary=” +Employee.Salary; print(detail );})

输出:

Employee Name=Pankaj Choudhary Employee Salary=35000
Employee Name=Sandeep Jangid Employee Salary=25000
Employee Name=Rahul Prajapat Employee Salary=27000
Employee Name=Sanjeev Baldia Employee Salary=47000
Employee Name=Narendra Sharma Employee Salary=35000
Employee Name=Omi Choudhary Employee Salary=27000
Employee Name=Nitin Yadav Employee Salary=32000


Explain() 方法

Explain() 方法返回 db.collection.find() 方法的查询计划。explain()方法返回的信息量取决于详细模式。cursor.explain() 方法返回 queryPlanner 和 executionStats。

语法: db.collectin_name.find().explain(verbosity)

参数

参数 类型 描述
Verbosity String 可选的。指定解释方法的详细模式。此方法指定解释的详细模式。

详细模式有以下 3 种可能性:

  1. queryPlanner
  2. executionStats
  3. allPlansExecution

详细的默认模式是 queryPlanner。

使用 queryPlanner 模式的 Explain() 方法

MongoDB 运行查询优化器来选择一个计划并返回被评估方法的 queryPlanner 信息。

示例

db.Employee.find().explain(“queryPlanner”)

输出

{  
     "queryPlanner" : {  
             "plannerVersion" : 1,  
             "namespace" : "Temp.Employee",  
             "indexFilterSet" : false,  
             "parsedQuery" : {  
                     "$and" : [ ]  
             },  
             "winningPlan" : {  
                     "stage" : "COLLSCAN",  
                     "filter" : {  
                             "$and" : [ ]  
                     },  
                     "direction" : "forward"  
             },  
             "rejectedPlans" : [ ]  
     },  
     "serverInfo" : {  
             "host" : "Your host name",  
             "port" : 27017,  
             "version" : "3.0.3",  
             "gitVersion" : "b40106b36eecd1b4407eb1ad1af6bc60593c6105"  
     },  
     "ok" : 1  
 }  

带有 executionStatsMode 的 Explain() 方法

MongoDB 运行查询优化器来选择一个计划并返回描述获胜计划执行情况的统计信息。

示例

db.Employee.find().explain(“executionStats”)

输出

{  
         "queryPlanner" : {  
                 "plannerVersion" : 1,  
                 "namespace" : "Temp.Employee",  
                 "indexFilterSet" : false,  
                 "parsedQuery" : {  
                         "$and" : [ ]  
                 },  
                 "winningPlan" : {  
                         "stage" : "COLLSCAN",  
                         "filter" : {  
                                 "$and" : [ ]  
                         },  
                         "direction" : "forward"  
                 },  
                 "rejectedPlans" : [ ]  
         },  
         "executionStats" : {  
                 "executionSuccess" : true,  
                 "nReturned" : 7,  
                 "executionTimeMillis" : 0,  
                 "totalKeysExamined" : 0,  
                 "totalDocsExamined" : 7,  
                 "executionStages" : {  
                         "stage" : "COLLSCAN",  
                         "filter" : {  
                                 "$and" : [ ]  
                         },  
                         "nReturned" : 7,  
                         "executionTimeMillisEstimate" : 0,  
                         "works" : 9,  
                         "advanced" : 7,  
                         "needTime" : 1,  
                         "needFetch" : 0,  
                         "saveState" : 0,  
                         "restoreState" : 0,  
                         "isEOF" : 1,  
                         "invalidates" : 0,  
                         "direction" : "forward",  
                         "docsExamined" : 7  
                 }  
  
},  
         "serverInfo" : {  
                 "host" : "Your Host Name",  
                 "port" : 27017,  
                 "version" : "3.0.3",  
                 "gitVersion" : "b40106b36eecd1b4407eb1ad1af6bc60593c6105"  
         },  
         "ok" : 1  
 }  

带有 allPlansExecution 的 Explain() 方法

MongoDB 运行查询优化器来选择获胜计划并返回描述获胜计划执行的统计信息,还返回计划选择期间捕获的其他候选计划的统计信息。

示例

db.Employee.find().explain(“allPlansExecution”)

输出

{  
     "queryPlanner" : {  
             "plannerVersion" : 1,  
             "namespace" : "Temp.Employee",  
             "indexFilterSet" : false,  
             "parsedQuery" : {  
                     "$and" : [ ]  
             },  
             "winningPlan" : {  
                     "stage" : "COLLSCAN",  
                     "filter" : {  
                             "$and" : [ ]  
                     },  
                     "direction" : "forward"  
             },  
             "rejectedPlans" : [ ]  
     },  
     "executionStats" : {  
             "executionSuccess" : true,  
             "nReturned" : 7,  
             "executionTimeMillis" : 0,  
             "totalKeysExamined" : 0,  
             "totalDocsExamined" : 7,  
             "executionStages" : {  
                     "stage" : "COLLSCAN",  
                     "filter" : {  
                             "$and" : [ ]  
                     },  
                     "nReturned" : 7,  
                     "executionTimeMillisEstimate" : 0,  
                     "works" : 9,  
                     "advanced" : 7,  
                     "needTime" : 1,  
                     "needFetch" : 0,  
                     "saveState" : 0,  
                     "restoreState" : 0,  
                     "isEOF" : 1,  
                     "invalidates" : 0,  
                     "direction" : "forward",  
                     "docsExamined" : 7  
             },  
"allPlansExecution" : [ ]  
     },  
     "serverInfo" : {  
             "host" : "Your Host Name",  
             "port" : 27017,  
             "version" : "3.0.3",  
             "gitVersion" : "b40106b36eecd1b4407eb1ad1af6bc60593c6105"  
     },  
     "ok" : 1  
 }  

今天我们学习一些游标方法。今天我没有解释所有的游标方法,换句话说,还有一些游标方法有待解释。但是我们现在不能理解这些方法,因为在理解它们之前我们必须有一些关于索引的基本知识。因此,在下一篇文章中,我将解释 MongoDB 中的“索引”。然后我们将完成剩余的游标方法。

感谢您阅读这篇文章。!


慕源网 » MongoDB Cursor游标方法(第 12 天)

常见问题FAQ

程序仅供学习研究,请勿用于非法用途,不得违反国家法律,否则后果自负,一切法律责任与本站无关。
请仔细阅读以上条款再购买,拍下即代表同意条款并遵守约定,谢谢大家支持理解!

发表评论

开通VIP 享更多特权,建议使用QQ登录