iis服务器助手广告广告

扫码关注官方微信

扫码下载APP
返回顶部
首页 > 资讯 > 数据库 >MongoDB中索引怎么用
  • 364

0
分享到

MongoDB中索引怎么用

2024-04-02 19:04:59 364人浏览 独家记忆
摘要

小编给大家分享一下mongoDB中索引怎么用，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！ 在任何数

小编给大家分享一下mongoDB中索引怎么用，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！

在任何数据库之中，索引都是一种提升数据库检索性能的手段。
MonGoDB数据库里面依然会存在两种索引创建：一种是自动创建，另外一种是手工创建。

范例：重新准备一个新的简单集合。
db.emp.drop();
db.emp.insert({"name":"赵一","sex":"男","age":30,"sal":1000,"loc":"北京"});
db.emp.insert({"name":"钱二","sex":"女","age":22,"sal":5000,"loc":"上海"});
db.emp.insert({"name":"孙三","sex":"男","age":40,"sal":2000,"loc":"深圳"});
db.emp.insert({"name":"李四","sex":"女","age":30,"sal":7000,"loc":"北京"});
db.emp.insert({"name":"周五","sex":"女","age":30,"sal":6400,"loc":"北京"});
db.emp.insert({"name":"吴六","sex":"男","age":30,"sal":2500,"loc":"重庆"});
db.emp.insert({"name":"郑七","sex":"女","age":50,"sal":4700,"loc":"成都"});
db.emp.insert({"name":"王八","sex":"男","age":35,"sal":8000,"loc":"北京"});

此时在emp的集合上并没有去设置任何的索引，可以通过getIndexes()函数来观察在emp集合中的索引。

范例：查询默认状态下emp集合的索引内容
> db.emp.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "hr.emp"
        }
]

现在发现会存在有一个“_id”列的索引内容。但是如果要想创建自己的索引，则可以使用如下的语法：
索引创建：db.集合名称.createIndex({列:1})
设置的1表示索引按照升序的方式进行排序，如果使用降序则使用“-1”

范例：创建一个索引，在age字段上设置一个降序索引
> db.emp.createIndex({"age":-1})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 1,
        "numIndexesAfter" : 2,
        "ok" : 1
此时并没有设置索引的名字，所以名字是自动命名的。命名的规范：“字段名称_索引的排序模式”
> db.emp.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "hr.emp"
        },
        {
                "v" : 2,
                "key" : {
                        "age" : -1
                },
                "name" : "age_-1",
                "ns" : "hr.emp"
        }
]

范例：针对于当前的age字段上的索引做一个分析
> db.emp.find({"age":30}).explain("executionStats");
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "hr.emp",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "age" : {
                                "$eq" : 30
                        }
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "age" : -1
                                },
                                "indexName" : "age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[30.0, 30.0]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 4,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 4,
                "totalDocsExamined" : 4,
                "executionStages" : {
                        "stage" : "FETCH",
                        "nReturned" : 4,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 5,
                        "advanced" : 4,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 4,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 4,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 5,
                                "advanced" : 4,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "keyPattern" : {
                                        "age" : -1
                                },
                                "indexName" : "age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[30.0, 30.0]"
                                        ]
                                },
                                "keysExamined" : 4,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                }
        },
        "serverInfo" : {
                "host" : "D2-LZY245",
                "port" : 27017,
                "version" : "3.4.7",
                "gitVersion" : "cf38c1b8a0a8dca4a11737581beafef4fe120bcd"
        },
        "ok" : 1
}

此时的查询使用了索引的技术，但是下面再来观察一个查询，不使用索引字段

范例：针对于sal字段进行查询
> db.emp.find({"sal":{"$gt":5000}}).explain("executionStats");
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "hr.emp",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "sal" : {
                                "$gt" : 5000
                        }
                },
                "winningPlan" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "sal" : {
                                        "$gt" : 5000
                                }
                        },
                        "direction" : "forward"
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 3,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 8,
                "executionStages" : {
                        "stage" : "COLLSCAN",
                        "filter" : {
                                "sal" : {
                                        "$gt" : 5000
                                }
                        },
                        "nReturned" : 3,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 10,
                        "advanced" : 3,
                        "needTime" : 6,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "direction" : "forward",
                        "docsExamined" : 8
                }
        },
        "serverInfo" : {
                "host" : "D2-LZY245",
                "port" : 27017,
                "version" : "3.4.7",
                "gitVersion" : "cf38c1b8a0a8dca4a11737581beafef4fe120bcd"
        },
        "ok" : 1
}
此时在sal字段上并没有设置索引，所以当前的索引形式就变成了全集合扫描的模式。
但是如果说，现在换一种形式，年龄和薪水一起执行查询：
> db.emp.find({"age":30,"sal":7000}).explain("executionStats")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "hr.emp",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "age" : {
                                                "$eq" : 30
                                        }
                                },
                                {
                                        "sal" : {
                                                "$eq" : 7000
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "filter" : {
                                "sal" : {
                                        "$eq" : 7000
                                }
                        },
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "age" : -1
                                },
                                "indexName" : "age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[30.0, 30.0]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 4,
                "totalDocsExamined" : 4,
                "executionStages" : {
                        "stage" : "FETCH",
                        "filter" : {
                                "sal" : {
                                        "$eq" : 7000
                                }
                        },
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 5,
                        "advanced" : 1,
                        "needTime" : 3,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 4,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 4,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 5,
                                "advanced" : 4,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "keyPattern" : {
                                        "age" : -1
                                },
                                "indexName" : "age_-1",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[30.0, 30.0]"
                                        ]
                                },
                                "keysExamined" : 4,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                }
        },
        "serverInfo" : {
                "host" : "D2-LZY245",
                "port" : 27017,
                "version" : "3.4.7",
                "gitVersion" : "cf38c1b8a0a8dca4a11737581beafef4fe120bcd"
        },
        "ok" : 1
}
这个时候虽然age字段上面存在索引，由于sal字段上面没有索引，所以依然使用的是全表扫描操作。为了解决此时的问题，可以使用一个复合索引。
> db.emp.createIndex({"age":-1,"sal":-1},{name:"age_-1_sal_-1_index"})
{
        "createdCollectionAutomatically" : false,
        "numIndexesBefore" : 2,
        "numIndexesAfter" : 3,
        "ok" : 1
}

范例：默认使用索引
> db.emp.find({"age":30,"sal":7000}).explain("executionStats")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "hr.emp",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$and" : [
                                {
                                        "age" : {
                                                "$eq" : 30
                                        }
                                },
                                {
                                        "sal" : {
                                                "$eq" : 7000
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "age" : -1,
                                        "sal" : -1
                                },
                                "indexName" : "age_-1_sal_-1_index",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ],
                                        "sal" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[30.0, 30.0]"
                                        ],
                                        "sal" : [
                                                "[7000.0, 7000.0]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [
                        {
                                "stage" : "FETCH",
                                "filter" : {
                                        "sal" : {
                                                "$eq" : 7000
                                        }
                                },
                                "inputStage" : {
                                        "stage" : "IXSCAN",
                                        "keyPattern" : {
                                                "age" : -1
                                        },
                                        "indexName" : "age_-1",
                                        "isMultiKey" : false,
                                        "multiKeyPaths" : {
                                                "age" : [ ]
                                        },
                                        "isUnique" : false,
                                        "isSparse" : false,
                                        "isPartial" : false,
                                        "indexVersion" : 2,
                                        "direction" : "forward",
                                        "indexBounds" : {
                                                "age" : [
                                                        "[30.0, 30.0]"
                                                ]
                                        }
                                }
                        }
                ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 1,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 1,
                "totalDocsExamined" : 1,
                "executionStages" : {
                        "stage" : "FETCH",
                        "nReturned" : 1,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 3,
                        "advanced" : 1,
                        "needTime" : 0,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 1,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 1,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 2,
                                "advanced" : 1,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "keyPattern" : {
                                        "age" : -1,
                                        "sal" : -1
                                },
                                "indexName" : "age_-1_sal_-1_index",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ],
                                        "sal" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[30.0, 30.0]"
                                        ],
                                        "sal" : [
                                                "[7000.0, 7000.0]"
                                        ]
                                },
                                "keysExamined" : 1,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                }
        },
        "serverInfo" : {
                "host" : "D2-LZY245",
                "port" : 27017,
                "version" : "3.4.7",
                "gitVersion" : "cf38c1b8a0a8dca4a11737581beafef4fe120bcd"
        },
        "ok" : 1
}

但是如果换到了以下条件：
> db.emp.find({"$or":[{"age":{"$gt":30}},{"sal":{"$gt":5000}}]}).explain("executionStats")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "hr.emp",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$or" : [
                                {
                                        "age" : {
                                                "$gt" : 30
                                        }
                                },
                                {
                                        "sal" : {
                                                "$gt" : 5000
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "SUBPLAN",
                        "inputStage" : {
                                "stage" : "COLLSCAN",
                                "filter" : {
                                        "$or" : [
                                                {
                                                        "age" : {
                                                                "$gt" : 30
                                                        }
                                                },
                                                {
                                                        "sal" : {
                                                                "$gt" : 5000
                                                        }
                                                }
                                        ]
                                },
                                "direction" : "forward"
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 5,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 0,
                "totalDocsExamined" : 8,
                "executionStages" : {
                        "stage" : "SUBPLAN",
                        "nReturned" : 5,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 10,
                        "advanced" : 5,
                        "needTime" : 4,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "inputStage" : {
                                "stage" : "COLLSCAN",
                                "filter" : {
                                        "$or" : [
                                                {
                                                        "age" : {
                                                                "$gt" : 30
                                                        }
                                                },
                                                {
                                                        "sal" : {
                                                                "$gt" : 5000
                                                        }
                                                }
                                        ]
                                },
                                "nReturned" : 5,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 10,
                                "advanced" : 5,
                                "needTime" : 4,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "direction" : "forward",
                                "docsExamined" : 8
                        }
                }
        },
        "serverInfo" : {
                "host" : "D2-LZY245",
                "port" : 27017,
                "version" : "3.4.7",
                "gitVersion" : "cf38c1b8a0a8dca4a11737581beafef4fe120bcd"
        },
        "ok" : 1
}

现在发现并没有使用索引，所以这个时候看能否强制使用一次索引：hint()函数为强制使用索引操作。
范例：强制使用索引
> db.emp.find({"$or":[{"age":{"$gt":50}},{"sal":{"$gt":3000}}]}).hint("age_-1_sal_-1_index").explain("executionStats")
{
        "queryPlanner" : {
                "plannerVersion" : 1,
                "namespace" : "hr.emp",
                "indexFilterSet" : false,
                "parsedQuery" : {
                        "$or" : [
                                {
                                        "age" : {
                                                "$gt" : 50
                                        }
                                },
                                {
                                        "sal" : {
                                                "$gt" : 3000
                                        }
                                }
                        ]
                },
                "winningPlan" : {
                        "stage" : "FETCH",
                        "filter" : {
                                "$or" : [
                                        {
                                                "age" : {
                                                        "$gt" : 50
                                                }
                                        },
                                        {
                                                "sal" : {
                                                        "$gt" : 3000
                                                }
                                        }
                                ]
                        },
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "keyPattern" : {
                                        "age" : -1,
                                        "sal" : -1
                                },
                                "indexName" : "age_-1_sal_-1_index",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ],
                                        "sal" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[MaxKey, MinKey]"
                                        ],
                                        "sal" : [
                                                "[MaxKey, MinKey]"
                                        ]
                                }
                        }
                },
                "rejectedPlans" : [ ]
        },
        "executionStats" : {
                "executionSuccess" : true,
                "nReturned" : 5,
                "executionTimeMillis" : 0,
                "totalKeysExamined" : 8,
                "totalDocsExamined" : 8,
                "executionStages" : {
                        "stage" : "FETCH",
                        "filter" : {
                                "$or" : [
                                        {
                                                "age" : {
                                                        "$gt" : 50
                                                }
                                        },
                                        {
                                                "sal" : {
                                                        "$gt" : 3000
                                                }
                                        }
                                ]
                        },
                        "nReturned" : 5,
                        "executionTimeMillisEstimate" : 0,
                        "works" : 9,
                        "advanced" : 5,
                        "needTime" : 3,
                        "needYield" : 0,
                        "saveState" : 0,
                        "restoreState" : 0,
                        "isEOF" : 1,
                        "invalidates" : 0,
                        "docsExamined" : 8,
                        "alreadyHasObj" : 0,
                        "inputStage" : {
                                "stage" : "IXSCAN",
                                "nReturned" : 8,
                                "executionTimeMillisEstimate" : 0,
                                "works" : 9,
                                "advanced" : 8,
                                "needTime" : 0,
                                "needYield" : 0,
                                "saveState" : 0,
                                "restoreState" : 0,
                                "isEOF" : 1,
                                "invalidates" : 0,
                                "keyPattern" : {
                                        "age" : -1,
                                        "sal" : -1
                                },
                                "indexName" : "age_-1_sal_-1_index",
                                "isMultiKey" : false,
                                "multiKeyPaths" : {
                                        "age" : [ ],
                                        "sal" : [ ]
                                },
                                "isUnique" : false,
                                "isSparse" : false,
                                "isPartial" : false,
                                "indexVersion" : 2,
                                "direction" : "forward",
                                "indexBounds" : {
                                        "age" : [
                                                "[MaxKey, MinKey]"
                                        ],
                                        "sal" : [
                                                "[MaxKey, MinKey]"
                                        ]
                                },
                                "keysExamined" : 8,
                                "seeks" : 1,
                                "dupsTested" : 0,
                                "dupsDropped" : 0,
                                "seenInvalidated" : 0
                        }
                }
        },
        "serverInfo" : {
                "host" : "D2-LZY245",
                "port" : 27017,
                "version" : "3.4.7",
                "gitVersion" : "cf38c1b8a0a8dca4a11737581beafef4fe120bcd"
        },
        "ok" : 1
}

如果正常来讲，这个代码根本就不可能调用默认的索引执行，如果需要可以使用hint()函数强制MongoDB必须使用索引。
如果在一个集合里面设置了过多的索引，实际上会导致性能下降。那么可以删除索引。

范例：删除一个索引
> db.emp.dropIndex("age_-1_sal_-1_index")
{ "nIndexesWas" : 3, "ok" : 1 }
> db.emp.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "hr.emp"
        },
        {
                "v" : 2,
                "key" : {
                        "age" : -1
                },
                "name" : "age_-1",
                "ns" : "hr.emp"
        }
]

范例：删除非"_id"的索引，也就是自定义的索引
> db.emp.dropIndexes();
{
        "nIndexesWas" : 2,
        "msg" : "non-_id indexes dropped for collection",
        "ok" : 1
}
> db.emp.getIndexes();
[
        {
                "v" : 2,
                "key" : {
                        "_id" : 1
                },
                "name" : "_id_",
                "ns" : "hr.emp"
        }
]
以上是“MongoDB中索引怎么用”这篇文章的所有内容，感谢各位的阅读！相信大家都有了一定的了解，希望分享的内容对大家有所帮助，如果还想学习更多知识，欢迎关注编程网数据库频道！

您可能感兴趣的文档:
点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: MongoDB中索引怎么用

本文链接: https://www.lsjlt.com/news/65209.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档
去做题
猜你喜欢
  • MongoDB中索引怎么用
    小编给大家分享一下MongoDB中索引怎么用，相信大部分人都还不怎么了解，因此分享这篇文章给大家参考一下，希望大家阅读完这篇文章后大有收获，下面让我们一起去了解一下吧！ 在任何数...
    99+
    2024-04-02
  • MongoDB中怎么使用唯一索引
    这篇文章将为大家详细讲解有关MongoDB中怎么使用唯一索引，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。 唯一索引的主要目的是...
    99+
    2024-04-02
  • mongodb数据库中怎么使用索引
    这篇文章将为大家详细讲解有关mongodb数据库中怎么使用索引，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。      &nb...
    99+
    2024-04-02
  • 怎么在MongoDB中创建索引
    这期内容当中小编将会给大家带来有关怎么在MongoDB中创建索引，文章内容丰富且以专业的角度为大家分析和叙述，阅读完这篇文章希望大家可以有所收获。MongoDB 创建索引的语法1.为普通字段添加索引，并且为...
    99+
    2024-04-02
  • MongoDB中怎么使用地理信息索引
    MongoDB中怎么使用地理信息索引，很多新手对此不是很清楚，为了帮助大家解决这个难题，下面小编将为大家详细讲解，有这方面需求的人可以来学习下，希望你能有所收获。 地理信息索引分...
    99+
    2024-04-02
  • MongoDB中怎么实现过期索引
    这篇文章给大家介绍MongoDB中怎么实现过期索引，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。范例：设置过期索引，10秒后过期> db.phones.createIndex({...
    99+
    2024-04-02
  • mongodb怎么查看命中的索引
    在MongoDB中，可以使用explain()方法来查看命中的索引。explain()方法会返回查询的执行计划，包括是否命中索引以及...
    99+
    2023-08-30
    mongodb
  • MongoDB数据库索引怎么使用
    这篇“MongoDB数据库索引怎么使用”文章的知识点大部分人都不太理解，所以小编给大家总结了以下内容，内容详细，步骤清晰，具有一定的借鉴价值，希望大家阅读完这篇文章能有所收获，下面我们一起来看看这篇“MongoDB数据库索引怎么使用”文章吧...
    99+
    2023-07-02
  • mongodb怎么建立hash索引
    在MongoDB中，可以通过使用`createIndex()`方法来建立一个哈希索引。首先，连接到MongoDB数据库。然后，选择要...
    99+
    2023-09-06
    mongodb
  • MongoDB中的索引是怎样的
    本篇文章给大家分享的是有关MongoDB中的索引是怎样的，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。索引就像图书的目录一样，可以让我们快速定位到需要的内容，关系型数据库中有索...
    99+
    2023-06-19
  • 怎么在mongodb中查看当前索引
    在mongodb中查看当前索引的方法：1.启动mongodb；2.登录mongodb数据库；3.使用数据库；4.执行命令查看索引；具体步骤如下：首先，在命令行中启动mongodb服务；net start MongoDBmongodb服务启动...
    99+
    2024-04-02
  • MongoDB之索引（全文索引）
    在一些信息管理平台上经常需要进行信息模糊查询，最早的时候是在某个字段上实现的模糊查询，但是这个时候返回的信息并不会很准确，因为只能够查A字段或者是B字段，而在MongoDB里面实现了非常简单的全文检索。 ...
    99+
    2024-04-02
  • MongoDB索引类型怎么实现
    本文小编为大家详细介绍“MongoDB索引类型怎么实现”，内容详细，步骤清晰，细节处理妥当，希望这篇“MongoDB索引类型怎么实现”文章能帮助大家解决疑惑，下面跟着小编的思路慢慢深入，一起来学习新知识吧。MongoDB 4.2官方支持索引...
    99+
    2023-06-29
  • mongodb怎么查询指定索引
    在 MongoDB 中，可以使用 `db.collection.find()` 方法来查询指定索引。可以通过使用 `.hint()`...
    99+
    2023-09-04
    mongodb
  • mongodb怎么创建索引失败
    当创建索引失败时，有以下几个可能的原因：1. 重复的索引名称：如果尝试创建重复名称的索引，MongoDB会报错。确保使用唯一的索引名...
    99+
    2023-08-31
    mongodb
  • mongodb怎么建立唯一索引
    在MongoDB中，可以使用`createIndex()`方法来建立唯一索引。以下是建立唯一索引的步骤：1. 连接到MongoDB数...
    99+
    2023-08-23
    mongodb
  • MongoDB怎么让索引保持在内存中
    MongoDB是一个高性能的数据库，它会自动将经常访问的数据和索引放入内存中以提高查询性能。然而，有时候我们需要强制将索引保持在内存...
    99+
    2024-04-19
    MongoDB
  • MongoDB中使用hash索引有什么限制
    在MongoDB中，使用hash索引有以下限制： Hash索引仅适用于精确匹配查询，不支持范围查询或排序操作。 在对大型数据集进行...
    99+
    2024-04-19
    MongoDB
  • MongoDB中如何使用复合索引
    本篇文章给大家分享的是有关MongoDB中如何使用复合索引，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。什么是复合索引？复合索引，即Compo...
    99+
    2024-04-02
  • MongoDB中如何使用唯一索引
    这篇文章将为大家详细讲解有关MongoDB中如何使用唯一索引，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。我们用的是MongoDB数据存储用户信息，用户表中...
    99+
    2024-04-02
软考高级职称资格查询
iis服务器助手广告
软考职称历年真题下载
软考职称资料下载
热门wiki
近期文章
推荐阅读
热门问答
热门标签
编程网，编程工程师的家园，是目前国内优秀的开源技术社区之一，形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容，为IT开发者提供了一个发现、使用、并交流开源技术的平台。

  • 官方手机版

  • 微信公众号

  • 商务合作