MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

MongoDB索引的创建与优化策略

2023-03-081.3k 阅读

MongoDB索引基础概念

在深入探讨MongoDB索引的创建与优化策略之前，我们先来理解一些基础概念。索引在数据库中就像是一本书的目录，它可以帮助数据库快速定位和检索数据，从而显著提高查询效率。

MongoDB中的索引是一种特殊的数据结构，它基于B - 树数据结构（默认情况）来构建。B - 树结构能够在对数时间内完成插入、删除和查找操作，这使得索引对于大型数据集的查询性能提升极为关键。

索引类型

  1. 单字段索引 单字段索引是最基本的索引类型，它基于单个字段创建。例如，假设我们有一个存储用户信息的集合users，其中有一个email字段。如果我们经常根据email字段来查询用户，那么创建一个基于email字段的单字段索引就非常有意义。
// 在MongoDB shell中创建单字段索引
db.users.createIndex({email: 1});

这里的1表示升序索引，如果使用-1则表示降序索引。

  1. 复合索引 复合索引是基于多个字段创建的索引。它适用于需要根据多个条件进行查询的场景。比如，在一个orders集合中，我们经常根据customer_id和order_date两个字段进行查询，就可以创建一个复合索引。
// 创建复合索引
db.orders.createIndex({customer_id: 1, order_date: -1});

复合索引的字段顺序非常重要，它会影响查询的效率。通常，将选择性更高（即重复值较少）的字段放在前面。

  1. 多键索引 多键索引用于对数组类型的字段创建索引。例如，在一个products集合中，tags字段是一个包含多个标签的数组。
// 创建多键索引
db.products.createIndex({tags: 1});

MongoDB会为数组中的每个元素创建一个索引条目，这样就可以快速查询包含特定标签的产品。

  1. 文本索引 文本索引用于对文本类型的字段进行全文搜索。例如，在一个articles集合中，content字段包含文章的正文内容。
// 创建文本索引
db.articles.createIndex({content: "text"});

文本索引支持更复杂的文本查询，如模糊匹配、词干分析等。

  1. 地理位置索引 地理位置索引用于对地理位置相关的数据进行索引，支持2D和2Dsphere两种类型。2D索引适用于平面坐标（如地图上的XY坐标），而2Dsphere索引适用于地球表面的球面坐标（如经纬度）。
// 创建2Dsphere索引
db.places.createIndex({location: "2dsphere"});

假设location字段存储的是经纬度数组[longitude, latitude]，这样就可以高效地进行地理位置查询，如查找某个范围内的地点。

MongoDB索引的创建

在集合创建时创建索引

在创建集合的同时，可以指定要创建的索引。例如，我们创建一个books集合，并同时为title字段创建一个单字段索引。

db.createCollection("books", {
    validator: {
        $jsonSchema: {
            bsonType: "object",
            required: ["title", "author"],
            properties: {
                title: {
                    bsonType: "string",
                    description: "必须是字符串且是必填字段"
                },
                author: {
                    bsonType: "string",
                    description: "必须是字符串且是必填字段"
                }
            }
        }
    },
    indexes: [
        {
            key: {title: 1},
            name: "title_index"
        }
    ]
});

这里通过indexes数组指定了要创建的索引，key指定了索引基于的字段及顺序，name为索引指定了一个名称。

在已有集合上创建索引

对于已经存在的集合，可以随时使用createIndex方法来创建索引。例如，我们在已经存在的employees集合上为department字段创建一个单字段索引。

db.employees.createIndex({department: 1});

如果需要创建更复杂的索引，如复合索引，同样可以使用createIndex方法。

// 在employees集合上创建复合索引
db.employees.createIndex({department: 1, salary: -1});

这将创建一个基于department字段升序和salary字段降序的复合索引。

后台创建索引

在大型集合上创建索引可能会消耗大量资源，影响数据库的正常操作。为了避免这种情况，可以在后台创建索引。

// 后台创建索引
db.largeCollection.createIndex({field: 1}, {background: true});

这样创建索引的操作将在后台进行，不会阻塞其他数据库操作。不过，后台创建索引可能会使创建过程稍微变慢，因为它会与其他操作共享资源。

索引的查看与管理

查看集合的索引

可以使用getIndexes方法来查看集合上已经创建的索引。例如，对于customers集合：

db.customers.getIndexes();

这将返回一个包含集合所有索引信息的数组，每个元素包含索引的名称、基于的字段、是否唯一等信息。

[
    {
        "v": 2,
        "key": {
            "_id": 1
        },
        "name": "_id_",
        "ns": "test.customers"
    },
    {
        "v": 2,
        "key": {
            "email": 1
        },
        "name": "email_1",
        "ns": "test.customers"
    }
]

这里可以看到默认的_id索引以及我们创建的email索引。

删除索引

如果某个索引不再需要，可以使用dropIndex方法来删除它。例如，要删除customers集合上的email索引：

db.customers.dropIndex("email_1");

这里的email_1是索引的名称，可以通过getIndexes方法获取。

如果要删除集合上的所有用户创建的索引（不包括_id索引），可以使用dropIndexes方法：

db.customers.dropIndexes();

这将删除除_id索引之外的所有索引。

索引优化策略

分析查询语句

在优化索引之前，首先要分析查询语句。通过explain方法可以获取查询的执行计划，从而了解查询是如何使用索引的。例如，对于以下查询：

db.users.find({email: "example@test.com"}).explain("executionStats");

explain方法返回的结果包含很多信息，其中executionStats部分详细描述了查询的执行情况，包括是否使用了索引、扫描的文档数量等。

{
    "queryPlanner": {
        "plannerVersion": 1,
        "namespace": "test.users",
        "indexFilterSet": false,
        "parsedQuery": {
            "email": {
                "$eq": "example@test.com"
            }
        },
        "winningPlan": {
            "stage": "FETCH",
            "inputStage": {
                "stage": "IXSCAN",
                "keyPattern": {
                    "email": 1
                },
                "indexName": "email_1",
                "isMultiKey": false,
                "multiKeyPaths": {
                    "email": []
                },
                "isUnique": false,
                "isSparse": false,
                "isPartial": false,
                "indexVersion": 2,
                "direction": "forward",
                "indexBounds": {
                    "email": [
                        "[\"example@test.com\", \"example@test.com\"]"
                    ]
                }
            }
        },
        "rejectedPlans": []
    },
    "executionStats": {
        "executionSuccess": true,
        "nReturned": 1,
        "executionTimeMillis": 0,
        "totalKeysExamined": 1,
        "totalDocsExamined": 1,
        "executionStages": {
            "stage": "FETCH",
            "nReturned": 1,
            "executionTimeMillisEstimate": 0,
            "works": 2,
            "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": {
                    "email": 1
                },
                "indexName": "email_1",
                "isMultiKey": false,
                "multiKeyPaths": {
                    "email": []
                },
                "isUnique": false,
                "isSparse": false,
                "isPartial": false,
                "indexVersion": 2,
                "direction": "forward",
                "indexBounds": {
                    "email": [
                        "[\"example@test.com\", \"example@test.com\"]"
                    ]
                },
                "keysExamined": 1,
                "seeks": 1,
                "dupsTested": 0,
                "dupsDropped": 0,
                "seenInvalidated": 0
            }
        }
    },
    "serverInfo": {
        "host": "server0.example.com",
        "port": 27017,
        "version": "4.4.10",
        "gitVersion": "5235137c9c656c6668c2666f643564386363393234"
    },
    "ok": 1
}

从这个结果中，我们可以看到inputStage为IXSCAN，表示使用了索引，keysExamined和totalDocsExamined都为1，说明索引有效地减少了扫描的键和文档数量。

避免全表扫描

全表扫描是性能的大敌，当查询无法使用索引时，就会进行全表扫描。例如，以下查询就可能导致全表扫描：

db.users.find({age: {$gt: 30}}).sort({name: 1});

如果users集合没有合适的索引，MongoDB就需要扫描整个集合来满足查询条件。为了避免这种情况，可以创建一个复合索引：

db.users.createIndex({age: 1, name: 1});

这样，查询就可以利用索引，大大提高查询效率。

索引选择性优化

索引的选择性是指索引字段中不同值的比例。选择性越高，索引的效率就越高。例如，在一个gender字段中，只有male和female两个值，这个字段的选择性就比较低，创建索引可能对查询性能提升不大。而像email字段，每个值都几乎是唯一的，选择性就很高，创建索引会非常有效。

在创建复合索引时，要将选择性高的字段放在前面。例如，在orders集合中，customer_id的选择性比order_status高，所以复合索引应该这样创建：

db.orders.createIndex({customer_id: 1, order_status: 1});

这样可以确保在根据customer_id进行查询时，索引能够更有效地工作。

索引覆盖查询

索引覆盖查询是指查询所需的所有字段都包含在索引中，这样MongoDB就可以直接从索引中获取数据，而不需要再去文档中查找。例如，我们有一个products集合，包含name、price和description字段，我们经常查询name和price：

// 创建索引覆盖查询的索引
db.products.createIndex({name: 1, price: 1});

然后执行查询：

db.products.find({name: "Product Name"}, {name: 1, price: 1, _id: 0});

这里的查询只返回name和price字段，并且索引包含了这两个字段，所以查询可以直接从索引中获取数据，提高查询效率。

避免过度索引

虽然索引可以提高查询性能，但过多的索引也会带来问题。每个索引都会占用额外的存储空间，并且在插入、更新和删除操作时，都需要更新所有相关的索引，这会增加写操作的开销。因此，要根据实际的查询需求来创建索引，避免创建不必要的索引。

例如，如果一个集合很少进行查询，只是偶尔根据某个字段查询一次，那么为这个字段创建索引可能就不值得，因为索引带来的写操作开销可能会超过查询性能的提升。

索引与分片的关系

在MongoDB的分片集群环境中，索引的创建和使用也有一些特殊之处。

分片键与索引

分片键是用于将数据分布到不同分片上的字段或字段组合。通常，选择合适的分片键非常重要，它不仅影响数据的分布均匀性，还会影响查询性能。

如果查询经常基于分片键进行，那么在分片键上创建索引是非常必要的。例如，在一个按customer_id进行分片的orders集合中，查询经常根据customer_id来获取订单，那么在customer_id字段上创建索引可以提高查询效率。

// 在分片键customer_id上创建索引
db.orders.createIndex({customer_id: 1});

这样，当查询基于customer_id时，MongoDB可以快速定位到包含相关数据的分片。

跨分片查询与索引

当进行跨分片查询时，索引的作用更加关键。例如，我们有一个跨分片的products集合，并且经常根据category字段进行查询。为了提高跨分片查询的效率，需要在category字段上创建索引。

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

这样，MongoDB可以利用索引快速定位到包含相关数据的分片，然后在这些分片上进行进一步的查询，从而提高整体的查询性能。

然而，如果查询涉及多个字段，并且这些字段没有组成合适的复合索引，跨分片查询可能会变得低效。因此，在设计索引时，要充分考虑跨分片查询的场景，创建能够支持这些查询的索引。

性能测试与索引优化

使用工具进行性能测试

为了准确评估索引对性能的影响，可以使用一些性能测试工具，如mongostat、mongotop和benchmark工具。

mongostat可以实时监控MongoDB服务器的状态，包括插入、查询、更新、删除操作的速率，以及内存使用、锁的情况等。例如，在终端中运行mongostat：

mongostat

它会不断输出服务器的实时状态信息，帮助我们了解在执行查询或其他操作时服务器的负载情况。

mongotop则专注于数据库和集合级别的I/O统计，它可以告诉我们哪些数据库和集合花费了最多的时间在磁盘I/O上。运行mongotop：

mongotop

通过分析mongotop的输出，我们可以找出I/O性能瓶颈，从而针对性地优化索引。

另外，我们还可以使用自定义的benchmark工具来进行性能测试。例如，使用JavaScript编写一个简单的基准测试脚本，来测试不同索引情况下的查询性能：

const Benchmark = require('benchmark');
const {MongoClient} = require('mongodb');

async function runBenchmark() {
    const uri = "mongodb://localhost:27017";
    const client = new MongoClient(uri);
    try {
        await client.connect();
        const db = client.db('test');
        const collection = db.collection('users');

        const suite = new Benchmark.Suite;

        // 测试没有索引的查询
        suite.add('No Index Query', async function () {
            await collection.find({email: "example@test.com"}).toArray();
        });

        // 测试有索引的查询
        await collection.createIndex({email: 1});
        suite.add('Index Query', async function () {
            await collection.find({email: "example@test.com"}).toArray();
        });

        suite
          .on('cycle', function (event) {
                console.log(String(event.target));
            })
          .on('complete', function () {
                console.log('Fastest is'+ this.filter('fastest').map('name'));
                client.close();
            })
          .run({ 'async': true });
    } catch (e) {
        console.error(e);
    }
}

runBenchmark();

这个脚本使用benchmark库来比较没有索引和有索引情况下的查询性能。通过这样的性能测试，可以直观地看到索引对查询性能的提升。

根据性能测试结果优化索引

根据性能测试工具的结果，我们可以针对性地优化索引。如果发现某个查询在没有索引时性能很差，而在创建索引后性能有显著提升，那么说明这个索引是必要的。

另一方面，如果发现某个索引并没有显著提升查询性能，或者导致写操作性能大幅下降，那么可能需要重新评估这个索引是否必要。例如，如果通过mongostat发现写操作的速率在创建某个索引后明显下降，而查询性能提升不明显，就可以考虑删除这个索引，或者调整索引结构。

同时，性能测试也可以帮助我们确定复合索引中字段的顺序。通过对不同字段顺序的复合索引进行性能测试，选择能够提供最佳查询性能的索引结构。

索引的维护与更新

索引重建

随着数据的不断插入、更新和删除，索引可能会出现碎片化，导致性能下降。在这种情况下，可以考虑重建索引。

在MongoDB中，可以通过先删除索引，然后重新创建索引的方式来重建索引。例如，对于customers集合上的email索引：

db.customers.dropIndex("email_1");
db.customers.createIndex({email: 1}, {name: "email_1"});

重建索引可以优化索引的存储结构，提高查询性能。不过，在重建索引期间，相关的查询性能可能会受到一定影响，所以建议在数据库负载较低的时候进行。

索引更新

当集合的结构或查询模式发生变化时，可能需要更新索引。例如，原来的查询只根据name字段进行，后来需要同时根据name和age字段进行查询。这时就需要将原来的单字段索引更新为复合索引。

// 先删除原来的单字段索引
db.users.dropIndex("name_1");
// 创建复合索引
db.users.createIndex({name: 1, age: 1});

在更新索引时，要注意对现有查询的影响。如果可能，尽量在数据库负载较低的时候进行更新，以减少对业务的影响。

索引在高并发场景下的应用

高并发读场景下的索引优化

在高并发读场景中，索引的性能至关重要。为了提高高并发读的性能，可以考虑以下几点：

  1. 使用覆盖索引：如前所述，覆盖索引可以直接从索引中获取查询所需的数据，减少磁盘I/O，从而提高并发读的性能。在高并发读场景下，确保常用查询的字段都包含在索引中。
  2. 合理设置索引缓存：MongoDB会将索引数据缓存到内存中，合理设置缓存大小可以提高索引的访问速度。可以通过调整--wiredTigerCacheSizeGB参数来设置WiredTiger存储引擎的缓存大小，以适应高并发读的需求。
  3. 避免索引争用：在高并发环境下，如果多个查询同时竞争同一个索引，可能会导致性能下降。通过创建合适的复合索引或分区索引，可以减少索引争用的情况。

高并发写场景下的索引优化

高并发写场景对索引的挑战更大，因为每次写操作都可能需要更新多个索引。为了优化高并发写场景下的索引性能：

  1. 批量操作：尽量使用批量插入、更新和删除操作，而不是单个操作。这样可以减少索引更新的次数，提高写操作的效率。例如，使用bulkWrite方法进行批量插入：
const bulkOps = [
    { insertOne: { document: { name: "User1", age: 25 } } },
    { insertOne: { document: { name: "User2", age: 30 } } }
];
db.users.bulkWrite(bulkOps);
  1. 优化索引结构：避免创建过多不必要的索引，减少写操作时索引更新的开销。同时，在设计索引时，要考虑写操作的频率和模式，尽量减少写操作对索引的影响。
  2. 使用部分索引：部分索引是基于集合的部分文档创建的索引。例如，只对age大于30的用户创建索引：
db.users.createIndex({age: 1}, {partialFilterExpression: {age: {$gt: 30}}});

这样可以减少索引的大小和维护成本，尤其适用于高并发写场景中只对部分数据进行频繁操作的情况。

索引与数据一致性

索引对数据一致性的影响

索引在保证数据一致性方面也起着重要作用。当进行写操作（插入、更新、删除）时，MongoDB不仅要更新文档数据，还要更新相关的索引。这确保了索引与文档数据的一致性。

例如，当更新一个文档的某个字段值时，如果这个字段上有索引，MongoDB会同时更新索引中对应的条目。如果索引更新失败，整个写操作会回滚，以保证数据的一致性。

然而，在高并发环境下，索引的更新可能会导致一些一致性问题。例如，当多个写操作同时尝试更新同一个索引时，可能会出现竞争条件，导致索引数据不一致。为了避免这种情况，MongoDB使用了锁机制来确保索引更新的原子性。

确保索引一致性的策略

为了确保索引的一致性，除了依赖MongoDB的内部机制外，还可以采取以下策略：

  1. 合理使用事务：从MongoDB 4.0开始支持多文档事务。在涉及多个文档和索引的复杂操作中，使用事务可以确保所有操作要么全部成功，要么全部失败，从而保证索引和数据的一致性。
const session = client.startSession();
session.startTransaction();
try {
    await db.collection1.insertOne({data: "value1"}, {session});
    await db.collection2.updateOne({condition: "value2"}, {$set: {newData: "newValue"}}, {session});
    await session.commitTransaction();
} catch (e) {
    await session.abortTransaction();
    console.error(e);
} finally {
    session.endSession();
}
  1. 定期进行数据校验：可以定期使用db.collection.validate()方法来校验集合的数据和索引的一致性。这个方法会检查集合的元数据、索引结构等，发现并修复一些潜在的一致性问题。
db.users.validate();
  1. 监控索引状态：通过db.currentOp()方法可以监控当前数据库操作，包括索引更新操作。及时发现并处理异常的索引更新操作，有助于保证索引的一致性。

通过以上策略，可以在不同层面上确保MongoDB索引与数据的一致性，提高数据库的可靠性和稳定性。

不同版本MongoDB索引特性差异

早期版本与现代版本索引特性对比

MongoDB在发展过程中，索引相关的特性不断演进。早期版本（如2.x系列）的索引功能相对较为基础，而现代版本（如4.x及以上）在索引方面有了显著的改进。

在早期版本中，索引类型相对较少，主要以单字段索引和复合索引为主。文本索引和地理位置索引的功能也相对简单。例如，早期版本的文本索引对语言支持有限，不具备复杂的词干分析和同义词处理能力。

而现代版本的MongoDB增加了更多的索引类型，如多键索引对数组处理更加灵活，文本索引支持更多语言的全文搜索，并且在词干分析、同义词处理等方面有了很大提升。地理位置索引在2Dsphere类型上对球面坐标的处理更加精确，支持更多复杂的地理位置查询。

版本升级对索引的影响及处理

当进行MongoDB版本升级时，索引可能会受到一些影响。例如，某些索引在新版本中可能需要进行重建以利用新的索引特性或优化。

在从较低版本升级到4.0及以上版本时，如果使用了旧版本的文本索引，可能需要重新创建文本索引以充分利用新版本增强的全文搜索功能。同样，对于地理位置索引，如果从早期版本升级，可能需要检查索引是否需要根据新版本的精确性要求进行调整。

在升级前，建议对索引进行备份，并在升级后对索引进行全面的测试。可以使用db.collection.getIndexes()方法获取当前集合的索引信息，并将其保存下来。升级后，根据新版本的特性和需求，重新创建或调整索引。同时，通过性能测试工具，如benchmark和mongostat，来验证索引在新版本中的性能是否达到预期。

通过了解不同版本MongoDB索引特性的差异，并在版本升级时妥善处理索引相关的问题，可以确保数据库在升级后能够充分发挥新特性的优势，同时保持良好的性能和稳定性。

通过以上全面深入的讲解，涵盖了MongoDB索引从基础概念、创建方法、管理手段到优化策略等各个方面，希望能帮助开发者更好地理解和应用MongoDB索引，提升数据库性能。