MongoDB 索引（二）

4.索引交集

MongoDB可以使用多个索引的交集来实现查询。一般情况下，每个指标的交集包含两个指标;但是，MongoDB可以使用多个/嵌套的索引交叉点来解析查询。
要说明索引交集，请考虑具有以下索引的集合订单:

{ qty: 1 }
{ item: 1 }

MongoDB可以使用两个索引的交集来支持以下查询:

db.orders.find( { item: "abc123", qty: { $gt: 15 } } )

要确定MongoDB是否使用了索引交集，请运行explain();explain()的结果将包括一个and_ordered阶段或一个AND_HASH阶段。

4.1指数前缀的交集
使用索引交集，MongoDB可以使用整个索引或索引前缀的交集。索引前缀是复合索引的子集，由一个或多个从索引开始的键组成。

考虑一个具有以下索引的托收订单:

{ qty: 1 }
{ status: 1, ord_date: -1 }

要完成下面的查询，它指定了qty字段和status字段的条件，MongoDB可以使用两个索引的交集:

db.orders.find( { qty: { $gt: 10 } , status: "A" } )

4.2 索引交集和复合索引
索引交集并不能消除创建复合索引的需要。然而,因为两个订单列表(即列出了键的顺序索引)和排序顺序(升序或降序),物质复合索引,复合指数可能不支持查询条件不包括前缀索引键或指定一个不同的排序顺序。

例如，如果一个集合订单有以下复合索引，并且状态字段列在ord_date字段之前:

{ status: 1, ord_date: -1 }

复合索引可以支持以下查询:

db.orders.find( { status: { $in: ["A", "P" ] } } )
db.orders.find(
   {
     ord_date: { $gt: new Date("2014-02-01") },
     status: {$in:[ "P", "A" ] }
   }
)

但不包括以下两个查询:

db.orders.find( { ord_date: { $gt: new Date("2014-02-01") } } )
db.orders.find( { } ).sort( { ord_date: 1 } )

但是，如果集合有两个单独的索引:

{ status: 1 }
{ ord_date: -1 }

这两个索引可以单独地或通过索引交集来支持前面提到的所有四个查询。
创建支持查询的复合索引还是依赖于索引交集，这取决于系统的具体情况。

4.3 索引交集和排序
当sort()操作需要一个完全独立于查询谓词的索引时，不应用索引交集。
例如，orders集合有以下索引:

{ qty: 1 }
{ status: 1, ord_date: -1 }
{ status: 1 }
{ ord_date: -1 }

MongoDB不能使用索引交集进行以下查询与排序:

db.orders.find( { qty: { $gt: 10 } } ).sort( { status: 1 } )

That is, MongoDB does not use the { qty: 1 } index for the query, and the separate { status:1 } or the { status: 1, ord_date: -1 } index for the sort.

However, MongoDB can use index intersection for the following query with sort since the index {status: 1, ord_date: -1 } can fulfill part of the query predicate.

db.orders.find( { qty: { $gt: 10 } , status: "A" } ).sort( { ord_date: -1 } )

5. 管理索引

这个页面显示了如何管理现有的索引。有关创建索引的说明，请参阅特定的索引类型页。

5.1 查看现有索引
以下部分提供了查看集合或整个数据库上现有索引的方法。

5.1.1 列出集合上的所有索引
要返回集合上所有索引的列表，请使用db. collections . getindexes()方法或驱动程序的类似方法。
例如，要查看人员集合上的所有索引，请运行以下命令:

db.people.getIndexes()

5.1.2 列出数据库的所有索引
要列出数据库中的所有收集索引，可以在mongo shell中使用以下操作:

db.getCollectionNames().forEach(function(collection) {
   indexes = db[collection].getIndexes();
   print("Indexes for " + collection + ":");
   printjson(indexes);
});

从3.0版本开始，MongoDB不支持直接访问系统。索引集合，该集合以前用于列出数据库中的所有索引。

5.1.3 列出特定类型的索引
要列出所有数据库中所有集合的特定类型的所有索引(例如散列、文本)，可以在mongo shell中使用以下操作:

// The following finds all hashed indexes

db.adminCommand("listDatabases").databases.forEach(function(d){
   let mdb = db.getSiblingDB(d.name);
   mdb.getCollectionInfos({ type: "collection" }).forEach(function(c){
      let currentCollection = mdb.getCollection(c.name);
      currentCollection.getIndexes().forEach(function(idx){
        let idxValues = Object.values(Object.assign({}, idx.key));

        if (idxValues.includes("hashed")) {
          print("Hashed index: " + idx.name + " on " + idx.ns);
          printjson(idx);
        };
      });
   });
});

5.2 删除索引
MongoDB提供了两种从集合中删除索引的方法:

db.collection.dropIndex()和
db.collection.dropIndexes ()

5.2.1 删除特定的指数

要删除索引，请使用db.collection.dropIndex()方法。

例如，下面的操作删除了accounts集合中tax-id字段上的升序索引:

db.accounts.dropIndex( { "tax-id": 1 } )

操作返回带有操作状态的文档:

{ "nIndexesWas" : 3, "ok" : 1 }

其中nIndexesWas的值反映了删除该索引之前索引的数量。
对于文本索引，将索引名传递给db.collection.dropIndex()方法。有关详细信息，请参见使用索引名称来删除文本索引。

请注意：
从MongoDB 4.2开始，db.collection.dropIndexes()可以接受一个索引名数组。

5.2.2 删除所有索引
还可以使用db.collection.dropIndexes()从集合中删除除_id索引之外的所有索引。
例如，下面的命令从accounts集合中删除所有索引:

db.accounts.dropIndexes()

这些shell帮助程序为dropIndexes数据库命令提供包装器。对于这些操作，您的客户机库可能具有不同的或附加的接口。

5.3 修改索引
要修改现有索引，需要删除并重新创建该索引。这个规则的例外是TTL索引，可以通过collMod命令结合索引收集标志修改TTL索引。

6.衡量索引的使用

6.1 使用$indexStats获取索引访问信息
使用$indexStats聚合阶段获得关于集合中每个索引的使用情况的统计信息。例如，下面的聚合操作返回对orders集合使用的索引的统计信息:

db.orders.aggregate( [ { $indexStats: { } } ] )

6.2 使用explain()返回查询计划

使用executionStats模式下的db.collection.explain()或sor.explain()方法返回关于查询过程的统计信息，包括使用的索引、扫描的文档数量和查询处理所需的时间(以毫秒为单位)。

在allPlansExecution模式下运行db.collection.explain()或sor.explain()方法，以查看在计划选择期间收集的部分执行统计信息。

6.3 与hint()一起使用的控件索引
要强制MongoDB为db.collection.find()操作使用特定的索引，请使用hint()方法指定索引。将hint()方法附加到find()方法中。考虑下面的例子:

db.people.find(
   { name: "John Doe", zipcode: { $gt: "63000" } }
).hint( { zipcode: 1 } )

要查看特定索引的执行统计信息，可以在db.collection.find()后面附加一个hint()方法和一个指针.explain()，例如:

db.people.find(
   { name: "John Doe", zipcode: { $gt: "63000" } }
).hint( { zipcode: 1 } ).explain("executionStats")

或者，将hint()方法附加到db.collection.explain().find():

db.people.explain("executionStats").find(
   { name: "John Doe", zipcode: { $gt: "63000" } }
).hint( { zipcode: 1 } )

为hint()方法指定$natural操作符，以防止MongoDB使用任何索引:

db.people.find(
   { name: "John Doe", zipcode: { $gt: "63000" } }
).hint( { $natural: 1 } )

6.4指数指标
除了$indexStats聚合阶段之外，MongoDB还提供了各种索引统计信息，您可以在分析数据库的索引使用情况时考虑这些统计信息:

In the output of serverStatus:

metrics.queryExecutor.scanned

metrics.operation.scanAndOrder

In the output of collStats:

totalIndexSize

indexSizes

In the output of dbStats:

dbStats.indexes

dbStats.indexSize

7. 索引策略

应用程序的最佳索引必须考虑许多因素，包括预期的查询类型、读写比率和系统上的空闲内存数量。

在开发索引策略时，您应该深入了解应用程序的查询。在构建索引之前，应映射将要运行的查询类型，以便能够构建引用这些字段的索引。索引会带来性能代价，但是对于大数据集的频繁查询来说，这种代价是值得的。考虑应用程序中每个查询的相对频率，以及该查询是否适合索引。

设计索引的最佳总体策略是使用与您将在生产环境中运行的数据集类似的数据集来分析各种索引配置，以查看哪些配置执行得最好。检查为集合创建的当前索引，以确保它们支持当前和计划的查询。如果不再使用索引，则删除该索引。

通常，MongoDB只使用一个索引来满足大多数查询。但是，$或查询的每个子句可以使用不同的索引，此外，MongoDB还可以使用多个索引的交集。
以下文件介绍了索引策略:

创建索引来支持您的查询
当索引包含由查询扫描的所有字段时，索引支持查询。创建支持查询的索引将极大地提高查询性能。
使用索引对查询结果进行排序
为了支持有效的查询，在指定索引字段的顺序和排序顺序时，请使用这里的策略。

确保索引适合RAM
当索引适合RAM时，系统可以避免从磁盘读取索引，从而获得最快的处理速度。
创建确保选择性的查询
选择性是查询使用索引缩小结果的能力。选择性允许MongoDB将索引用于与完成查询相关的大部分工作。

8. 创建索引来支持您的查询

当索引包含由查询扫描的所有字段时，索引支持查询。查询扫描索引，而不是集合。创建支持查询的索引将极大地提高查询性能。
本文档描述了创建支持查询的索引的策略。

8.1 如果所有查询都使用相同的单键，则创建单键索引
如果只查询给定集合中的一个键，那么只需要为该集合创建一个单键索引。例如，您可以在产品集合中创建一个category索引:

db.products.createIndex( { "category": 1 } )

8.2 创建复合索引来支持几个不同的查询
如果您有时只查询一个键，而其他时候查询该键和第二个键的组合，那么创建复合索引要比创建单键索引更有效。MongoDB将为这两个查询使用复合索引。例如，您可以在category和item上创建一个索引。

db.products.createIndex( { "category": 1, "item": 1 } )

这两个选项都可以使用。您可以只查询类别，也可以查询类别与项目的组合。多个字段上的单个复合索引可以支持搜索这些字段的“前缀”子集的所有查询。

EXAMPLE

The following index on a collection:

{ x: 1, y: 1, z: 1 }

Can support queries that the following indexes support:

{ x: 1 }
{ x: 1, y: 1 }

在某些情况下，前缀索引可以提供更好的查询性能:例如，如果z是一个大数组。
{x: 1, y: 1, z: 1}索引还可以支持许多与以下索引相同的查询:

{ x: 1, z: 1 }

此外，{x: 1, z: 1}还有一个额外的用途。给出以下查询:

db.collection.find( { x: 5 } ).sort( { z: 1} )

{x: 1, z: 1}索引支持查询和排序操作，而{x: 1, y: 1, z: 1}索引只支持查询。有关排序的更多信息，请参见使用索引对查询结果排序。

从2.6版开始，MongoDB可以使用index intersection来实现查询。创建支持查询的复合索引还是依赖于索引交集，这取决于系统的具体情况。有关详细信息，请参阅索引交集和复合索引。

索引的使用和排序
若要为字符串比较使用索引，操作还必须指定相同的排序规则。也就是说，如果具有排序规则的索引指定了不同的排序规则，则不支持对索引字段执行字符串比较的操作。
例如，集合myColl在排序区域设置为“fr”的字符串字段类别上有一个索引。

db.myColl.createIndex( { category: 1 }, { collation: { locale: "fr" } } )

下面的查询操作指定了与索引相同的排序规则，可以使用索引:

db.myColl.find( { category: "cafe" } ).collation( { locale: "fr" } )

但是，下面的查询操作，在默认情况下使用“简单”的二进制排序器，不能使用索引:

db.myColl.find( { category: "cafe" } )

对于索引前缀键不是字符串、数组和嵌入文档的复合索引，指定不同排序规则的操作仍然可以使用索引来支持对索引前缀键的比较。
例如，集合myColl在数值字段score和price以及字符串字段类别上有一个复合索引;索引是用排序区域设置“fr”创建的，用于字符串比较:

db.myColl.createIndex(
   { score: 1, price: 1, category: 1 },
   { collation: { locale: "fr" } } )

以下操作使用“简单”的二进制排序规则进行字符串比较，可以使用索引:

db.myColl.find( { score: 5 } ).sort( { price: 1 } )
db.myColl.find( { score: 5, price: { $gt: NumberDecimal( "10" ) } } ).sort( { price: 1 } )

下面的操作使用“简单”的二进制排序规则对索引的类别字段进行字符串比较，可以使用该索引仅满足分数:查询的5部分:

db.myColl.find( { score: 5, category: "cafe" } )

9. 使用索引对查询结果进行排序

在MongoDB中，排序操作可以通过根据索引中的顺序检索文档来获得排序顺序。如果查询计划器无法从索引中获得排序顺序，它将在内存中对结果进行排序。使用索引的排序操作通常比不使用索引的排序操作具有更好的性能。此外，不使用索引的排序操作在使用32 mb内存时将终止。

请注意：
由于在MongoDB 3.6中对数组字段的排序行为的改变，当对一个用多键索引索引的数组进行排序时，查询计划包括一个阻塞排序阶段。新的排序行为可能会对性能产生负面影响。
在阻塞排序中，排序步骤必须消耗所有输入，然后才能产生输出。在非阻塞或索引排序中，排序步骤扫描索引以按请求的顺序产生结果。

9.1 使用单个字段索引进行排序
如果升序或降序索引位于单个字段上，则该字段上的排序操作可以是双向的。
例如，为一个集合记录在字段a上创建一个升序索引:

db.records.createIndex( { a: 1 } )

这个索引可以支持a上的升序排序:

db.records.find().sort( { a: 1 } )

该索引还可以支持以下降序排序对a通过遍历索引的逆序:

db.records.find().sort( { a: -1 } )

9.2 对多个字段进行排序
创建一个复合索引来支持对多个字段进行排序。
您可以在索引的所有键上或在一个子集上指定排序;但是，排序键必须按照它们在索引中出现的顺序列出。例如，索引键模式{a: 1, b: 1}可以支持{a: 1, b: 1}上的排序，但不支持{b: 1, a: 1}上的排序。

对于要为排序使用复合索引的查询，在cursor.sort()文档中为所有键指定的排序方向必须与索引键模式匹配或与索引键模式相反。例如，索引键模式{a: 1, b: -1}可以支持对{a: 1, b: -1}和{a: -1, b: 1}进行排序，但不支持对{a: -1, b: -1}或{a: 1, b: 1}进行排序。

9.2.1 排序和索引前缀
如果排序键对应于索引键或索引前缀，MongoDB可以使用索引对查询结果进行排序。复合索引的前缀是在索引键模式开始处由一个或多个键组成的子集。
例如，在数据收集上创建一个复合索引:

db.data.createIndex( { a:1, b: 1, c: 1, d: 1 } )

然后，以下是该索引的前缀:

{ a: 1 }
{ a: 1, b: 1 }
{ a: 1, b: 1, c: 1 }

下面的查询和排序操作使用索引前缀对结果进行排序。这些操作不需要对内存中的结果集进行排序。

Example	Index Prefix
db.data.find().sort( { a: 1 } )	{ a: 1 }
db.data.find().sort( { a: -1 } )	{ a: 1 }
db.data.find().sort( { a: 1, b: 1 } )	{ a: 1, b: 1 }
db.data.find().sort( { a: -1, b: -1 } )	{ a: 1, b: 1 }
db.data.find().sort( { a: 1, b: 1, c: 1 } )	{ a: 1, b: 1, c: 1 }
db.data.find( { a: { $gt: 4 } } ).sort( { a: 1, b: 1 } )	{ a: 1, b: 1 }

考虑下面的例子，其中索引的前缀键同时出现在查询谓词和排序中:

db.data.find( { a: { $gt: 4 } } ).sort( { a: 1, b: 1 } )

在这种情况下，MongoDB可以使用索引按照sort指定的顺序检索文档。如示例所示，查询谓词中的索引前缀可以与排序中的前缀不同。

9.2.2 索引的排序和非前缀子集
索引可以支持对索引键模式的非前缀子集进行排序操作。为此，查询必须包括排序键之前的所有前缀键上的相等条件。
例如，收集的数据有以下索引:

{ a: 1, b: 1, c: 1, d: 1 }

以下操作可以使用索引来获得排序顺序:

Example	Index Prefix
db.data.find( { a: 5 } ).sort( { b: 1, c: 1 } )	{ a: 1 , b: 1, c: 1 }
db.data.find( { b: 3, a: 4 } ).sort( { c: 1 } )	{ a: 1, b: 1, c: 1 }
db.data.find( { a: 5, b: { $lt: 3} } ).sort( { b: 1 } )	{ a: 1, b: 1 }

如最后一个操作所示，只有排序子集之前的索引字段在查询文档中必须具有相等条件;其他索引字段可以指定其他条件。
如果查询没有在排序规范之前或与排序规范重叠的索引前缀上指定相等条件，则操作将不能有效地使用索引。例如，以下操作指定了一个{c: 1}的排序文档，但是查询文档不包含对前面索引字段a和b的相等匹配:

db.data.find( { a: { $gt: 2 } } ).sort( { c: 1 } )
db.data.find( { c: 5 } ).sort( { c: 1 } )

这些操作不会有效地使用索引{a: 1, b: 1, c: 1, d: 1}，甚至可能不会使用索引来检索文档。

9.3 索引的使用和排序
若要为字符串比较使用索引，操作还必须指定相同的排序规则。也就是说，如果具有排序规则的索引指定了不同的排序规则，则不支持对索引字段执行字符串比较的操作。
例如，集合myColl在排序区域设置为“fr”的字符串字段类别上有一个索引。

db.myColl.createIndex( { category: 1 }, { collation: { locale: "fr" } } )

下面的查询操作指定了与索引相同的排序规则，可以使用索引:

db.myColl.find( { category: "cafe" } ).collation( { locale: "fr" } )

但是，下面的查询操作，在默认情况下使用“简单”的二进制排序器，不能使用索引:

db.myColl.find( { category: "cafe" } )

db.myColl.createIndex(
   { score: 1, price: 1, category: 1 },
   { collation: { locale: "fr" } } )

以下操作使用“简单”的二进制排序规则进行字符串比较，可以使用索引:

db.myColl.find( { score: 5 } ).sort( { price: 1 } )
db.myColl.find( { score: 5, price: { $gt: NumberDecimal( "10" ) } } ).sort( { price: 1 } )

下面的操作使用“简单”的二进制排序规则对索引的类别字段进行字符串比较，可以使用该索引仅满足分数:查询的5部分:

db.myColl.find( { score: 5, category: "cafe" } )

10. 确保索引适合RAM

为了获得最快的处理速度，请确保索引完全适合RAM，以便系统可以避免从磁盘读取索引。
要检查索引的大小，可以使用db.collection.totalIndexSize()帮助器，它以字节为单位返回数据:

> db.collection.totalIndexSize()
4294976499

上面的示例显示索引大小接近4.3 gb。为了确保这个索引适合RAM，您不仅必须有超过那个可用RAM，而且还必须有RAM可用于其余的工作集。还请记住:

如果您拥有并使用多个集合，则必须考虑所有集合上的所有索引的大小。索引和工作集必须能够同时装入内存。
在某些有限的情况下，索引不需要装入内存。查看仅在RAM中保存最近值的索引。

10.1 仅在RAM中保存最近值的索引
在所有情况下，索引不必完全适合RAM。如果索引字段的值随着每次插入而增加，并且大多数查询选择最近添加的文档;然后MongoDB只需要在RAM中保留保存最近或“最右边”值的部分索引。这允许高效地使用索引进行读写操作，并最小化支持索引所需的RAM数量。

11. 创建确保选择性的查询

选择性是查询使用索引缩小结果的能力。有效的索引更具选择性，并且允许MongoDB将索引用于与完成查询相关的大部分工作。
为了确保选择性，可以编写查询来限制带索引字段的可能文档的数量。编写相对于索引数据具有适当选择性的查询。

例子：
假设您有一个名为status的字段，其中可能的值是新的并经过处理的。如果您在状态上添加了一个索引，那么您就创建了一个低选择性索引。索引对查找记录几乎没有帮助。
根据您的查询，更好的策略是创建一个包含低选择性字段和另一个字段的复合索引。例如，您可以在status和created_at上创建复合索引。
另一种选择(同样取决于您的用例)可能是使用单独的集合，每个集合对应一个状态。

例子
考虑一个集合上的索引{a: 1}(即按升序排序的键a上的索引)，其中a有三个值均匀地分布在集合上:

{ _id: ObjectId(), a: 1, b: "ab" }
{ _id: ObjectId(), a: 1, b: "cd" }
{ _id: ObjectId(), a: 1, b: "ef" }
{ _id: ObjectId(), a: 2, b: "jk" }
{ _id: ObjectId(), a: 2, b: "lm" }
{ _id: ObjectId(), a: 2, b: "no" }
{ _id: ObjectId(), a: 3, b: "pq" }
{ _id: ObjectId(), a: 3, b: "rs" }
{ _id: ObjectId(), a: 3, b: "tv" }

如果查询{a: 2, b: "no"} MongoDB必须扫描集合中的3个文档才能返回一个匹配的结果。类似地，对于{a: {$gt: 1}， b:“tv”}的查询必须扫描6个文档，也才能返回一个结果。
考虑一个集合上的相同索引，其中a有9个值均匀地分布在集合上:

{ _id: ObjectId(), a: 1, b: "ab" }
{ _id: ObjectId(), a: 2, b: "cd" }
{ _id: ObjectId(), a: 3, b: "ef" }
{ _id: ObjectId(), a: 4, b: "jk" }
{ _id: ObjectId(), a: 5, b: "lm" }
{ _id: ObjectId(), a: 6, b: "no" }
{ _id: ObjectId(), a: 7, b: "pq" }
{ _id: ObjectId(), a: 8, b: "rs" }
{ _id: ObjectId(), a: 9, b: "tv" }

如果查询{a: 2, b: "cd"}， MongoDB必须只扫描一个文档来完成查询。索引和查询的选择性更强，因为a的值是均匀分布的，查询可以使用索引选择特定的文档。
但是，虽然a上的索引更有选择性，但是像{a: {$gt: 5}、b:“tv”}这样的查询仍然需要扫描4个文档。

如果总体选择性较低，而且MongoDB必须读取大量文档才能返回结果，那么有些查询在没有索引的情况下执行起来可能更快。要确定性能，请参见使用度量指标。

11.索引参考

mongo Shell中的索引方法

Name	Description
`db.collection.createIndex()`	在集合上建立索引。
`db.collection.dropIndex()`	删除集合上的指定索引。
`db.collection.dropIndexes()`	删除集合上的所有索引。
`db.collection.getIndexes()`	返回描述集合上现有索引的文档数组。
`db.collection.reIndex()`	重新构建集合上的所有现有索引。
`db.collection.totalIndexSize()`	报告集合上索引使用的总大小。为collStats输出的totalIndexSize字段提供一个包装器。
`cursor.explain()`	报告游标的查询执行计划。
`cursor.hint()`	强制MongoDB为查询使用特定的索引。
`cursor.max()`	为游标指定独占的上界索引。使用`cursor.hint()`。
`cursor.min()`	为游标指定包含的下标界限. For use with `cursor.hint()`

索引数据库命令

Name	Description
`createIndexes`	为集合构建一个或多个索引。
`dropIndexes`	从集合中移除索引。
`compact`	对集合进行碎片整理并重新构建索引。
`reIndex`	重新构建集合上的所有索引。
`validate`	内部命令，用于扫描集合的数据和索引以确保正确性。
`geoSearch`	执行使用MongoDB的haystack索引功能的地理空间查询。
`checkShardingIndex`	在分片键上验证索引的内部命令。

地理空间查询选择器

Name	Description
`$geoWithin`	选择包围GeoJSON几何图形中的几何图形。2dsphere和2dindexes支持$geoWithin。
`$geoIntersects`	选择与GeoJSON几何图形相交的几何图形。2dsphere索引支持$geoIntersects。
`$near`	返回一个点附近的地理空间对象。需要地理空间索引。2dsphere和2d索引支持$near。
`$nearSphere`	返回接近球体上某一点的地理空间对象。需要地理空间索引。2dsphere和2d索引支持$nearSphere。

索引查询修饰符

Name	Description
`$explain`	强制MongoDB报告查询执行计划。见 `explain()`.
`$hint`	强制MongoDB使用特定的索引。See `hint()`
`$max`	指定要在查询中使用的索引的独占上限。 See `max()`.
`$min`	指定要在查询中使用的索引的包含下限。See `min()`.
`$returnKey`	强制光标只返回索引中包含的字段。

来源：CSDN

作者：木西爷

链接：https://blog.csdn.net/qq_33642970/article/details/104635256

标签

mongodb

mongodb命令

date