jjzjj

database - 如何检查索引交集是否支持 MongoDB 中的查询?

coder 2023-11-07 原文

tl;博士

  1. 我已经设置了可用作我的查询的索引交集的索引
  2. 由于数据不足,查询规划器不喜欢交叉点
  3. 现在我需要一种稳定的方法来验证这个潜在交叉路口计划的正确性,就像使用explain() hint( ) 用于单个索引设置

我完全理解为什么索引交集不是首选 atm,而且在大多数情况下实际上可能不是首选。但我只是在寻找一种方法来总体上验证索引交集。

========

我有一个 notifications 集合,其中包含诸如

{
    "_id": ObjectId("5cdd1819c1136c394a052aa2"),
    "notifiable": DBRef("users", ObjectId("5cdd172ac1136c1bdc06bdf2")),
    "read_at": ISODate("2019-05-16T07:59:17.985Z")
}

...它有以下索引:

[
    {
        "v" : 2,
        "key" : {
            "notifiable.$id" : 1,
            "notifiable.$ref" : 1,
            "created_at" : -1,
            "updated_at" : -1
        },
        "name" : "notifiable.$id_1_notifiable.$ref_1_created_at_-1_updated_at_-1",
        "ns" : "example.notifications"
},
{
        "v" : 2,
        "key" : {
            "read_at" : 1
        },
        "name" : "read_at_1",
        "ns" : "example.notifications"
    }
]

当我运行查询时,例如

db.notifications.find({ read_at: { $gt: ISODate("2019-05-16T07:55:57.799Z") }, "notifiable.$id": ObjectId("5cdd172ac1136c1bdc06bdf2") })

...我希望 MongoDB 在需要时使用这两个索引的交集。但是自MongoDB takes a lot of factors into consideration to determine whether an intersection of indices should be used ,我的查询只使用了 1 个索引(可能是因为集合中只有几个文档),甚至 explain(true) 的结果也没有任何 AND_SORTED AND_HASH阶段:

{
    "queryPlanner": {
        "plannerVersion": 1,
        "namespace": "example.notifications",
        "indexFilterSet": false,
        "parsedQuery": {
            "$and": [{
                    "notifiable.$id": {
                        "$eq": ObjectId("5cdd172ac1136c1bdc06bdf2")
                    }
                },
                {
                    "read_at": {
                        "$gt": ISODate("2019-05-16T07:55:57.799Z")
                    }
                }
            ]
        },
        "winningPlan": {
            "stage": "FETCH",
            "filter": {
                "notifiable.$id": {
                    "$eq": ObjectId("5cdd172ac1136c1bdc06bdf2")
                }
            },
            "inputStage": {
                "stage": "IXSCAN",
                "keyPattern": {
                    "read_at": 1
                },
                "indexName": "read_at_1",
                "isMultiKey": false,
                "multiKeyPaths": {
                    "read_at": []
                },
                "isUnique": false,
                "isSparse": false,
                "isPartial": false,
                "indexVersion": 2,
                "direction": "forward",
                "indexBounds": {
                    "read_at": [
                        "(new Date(1557993357799), new Date(9223372036854775807)]"
                    ]
                }
            }
        },
        "rejectedPlans": [{
            "stage": "FETCH",
            "filter": {
                "read_at": {
                    "$gt": ISODate("2019-05-16T07:55:57.799Z")
                }
            },
            "inputStage": {
                "stage": "IXSCAN",
                "keyPattern": {
                    "notifiable.$id": 1,
                    "notifiable.$ref": 1,
                    "created_at": -1,
                    "updated_at": -1
                },
                "indexName": "notifiable.$id_1_notifiable.$ref_1_created_at_-1_updated_at_-1",
                "isMultiKey": false,
                "multiKeyPaths": {
                    "notifiable.$id": [],
                    "notifiable.$ref": [],
                    "created_at": [],
                    "updated_at": []
                },
                "isUnique": false,
                "isSparse": false,
                "isPartial": false,
                "indexVersion": 2,
                "direction": "forward",
                "indexBounds": {
                    "notifiable.$id": [
                        "[ObjectId('5cdd172ac1136c1bdc06bdf2'), ObjectId('5cdd172ac1136c1bdc06bdf2')]"
                    ],
                    "notifiable.$ref": [
                        "[MinKey, MaxKey]"
                    ],
                    "created_at": [
                        "[MaxKey, MinKey]"
                    ],
                    "updated_at": [
                        "[MaxKey, MinKey]"
                    ]
                }
            }
        }]
    },
    "executionStats": {
        "executionSuccess": true,
        "nReturned": 1,
        "executionTimeMillis": 0,
        "totalKeysExamined": 2,
        "totalDocsExamined": 2,
        "executionStages": {
            "stage": "FETCH",
            "filter": {
                "notifiable.$id": {
                    "$eq": ObjectId("5cdd172ac1136c1bdc06bdf2")
                }
            },
            "nReturned": 1,
            "executionTimeMillisEstimate": 0,
            "works": 4,
            "advanced": 1,
            "needTime": 1,
            "needYield": 0,
            "saveState": 0,
            "restoreState": 0,
            "isEOF": 1,
            "invalidates": 0,
            "docsExamined": 2,
            "alreadyHasObj": 0,
            "inputStage": {
                "stage": "IXSCAN",
                "nReturned": 2,
                "executionTimeMillisEstimate": 0,
                "works": 3,
                "advanced": 2,
                "needTime": 0,
                "needYield": 0,
                "saveState": 0,
                "restoreState": 0,
                "isEOF": 1,
                "invalidates": 0,
                "keyPattern": {
                    "read_at": 1
                },
                "indexName": "read_at_1",
                "isMultiKey": false,
                "multiKeyPaths": {
                    "read_at": []
                },
                "isUnique": false,
                "isSparse": false,
                "isPartial": false,
                "indexVersion": 2,
                "direction": "forward",
                "indexBounds": {
                    "read_at": [
                        "(new Date(1557993357799), new Date(9223372036854775807)]"
                    ]
                },
                "keysExamined": 2,
                "seeks": 1,
                "dupsTested": 0,
                "dupsDropped": 0,
                "seenInvalidated": 0
            }
        },
        "allPlansExecution": [{
                "nReturned": 1,
                "executionTimeMillisEstimate": 0,
                "totalKeysExamined": 2,
                "totalDocsExamined": 2,
                "executionStages": {
                    "stage": "FETCH",
                    "filter": {
                        "notifiable.$id": {
                            "$eq": ObjectId("5cdd172ac1136c1bdc06bdf2")
                        }
                    },
                    "nReturned": 1,
                    "executionTimeMillisEstimate": 0,
                    "works": 3,
                    "advanced": 1,
                    "needTime": 1,
                    "needYield": 0,
                    "saveState": 0,
                    "restoreState": 0,
                    "isEOF": 1,
                    "invalidates": 0,
                    "docsExamined": 2,
                    "alreadyHasObj": 0,
                    "inputStage": {
                        "stage": "IXSCAN",
                        "nReturned": 2,
                        "executionTimeMillisEstimate": 0,
                        "works": 3,
                        "advanced": 2,
                        "needTime": 0,
                        "needYield": 0,
                        "saveState": 0,
                        "restoreState": 0,
                        "isEOF": 1,
                        "invalidates": 0,
                        "keyPattern": {
                            "read_at": 1
                        },
                        "indexName": "read_at_1",
                        "isMultiKey": false,
                        "multiKeyPaths": {
                            "read_at": []
                        },
                        "isUnique": false,
                        "isSparse": false,
                        "isPartial": false,
                        "indexVersion": 2,
                        "direction": "forward",
                        "indexBounds": {
                            "read_at": [
                                "(new Date(1557993357799), new Date(9223372036854775807)]"
                            ]
                        },
                        "keysExamined": 2,
                        "seeks": 1,
                        "dupsTested": 0,
                        "dupsDropped": 0,
                        "seenInvalidated": 0
                    }
                }
            },
            {
                "nReturned": 1,
                "executionTimeMillisEstimate": 0,
                "totalKeysExamined": 2,
                "totalDocsExamined": 2,
                "executionStages": {
                    "stage": "FETCH",
                    "filter": {
                        "read_at": {
                            "$gt": ISODate("2019-05-16T07:55:57.799Z")
                        }
                    },
                    "nReturned": 1,
                    "executionTimeMillisEstimate": 0,
                    "works": 3,
                    "advanced": 1,
                    "needTime": 1,
                    "needYield": 0,
                    "saveState": 0,
                    "restoreState": 0,
                    "isEOF": 1,
                    "invalidates": 0,
                    "docsExamined": 2,
                    "alreadyHasObj": 0,
                    "inputStage": {
                        "stage": "IXSCAN",
                        "nReturned": 2,
                        "executionTimeMillisEstimate": 0,
                        "works": 3,
                        "advanced": 2,
                        "needTime": 0,
                        "needYield": 0,
                        "saveState": 0,
                        "restoreState": 0,
                        "isEOF": 1,
                        "invalidates": 0,
                        "keyPattern": {
                            "notifiable.$id": 1,
                            "notifiable.$ref": 1,
                            "created_at": -1,
                            "updated_at": -1
                        },
                        "indexName": "notifiable.$id_1_notifiable.$ref_1_created_at_-1_updated_at_-1",
                        "isMultiKey": false,
                        "multiKeyPaths": {
                            "notifiable.$id": [],
                            "notifiable.$ref": [],
                            "created_at": [],
                            "updated_at": []
                        },
                        "isUnique": false,
                        "isSparse": false,
                        "isPartial": false,
                        "indexVersion": 2,
                        "direction": "forward",
                        "indexBounds": {
                            "notifiable.$id": [
                                "[ObjectId('5cdd172ac1136c1bdc06bdf2'), ObjectId('5cdd172ac1136c1bdc06bdf2')]"
                            ],
                            "notifiable.$ref": [
                                "[MinKey, MaxKey]"
                            ],
                            "created_at": [
                                "[MaxKey, MinKey]"
                            ],
                            "updated_at": [
                                "[MaxKey, MinKey]"
                            ]
                        },
                        "keysExamined": 2,
                        "seeks": 1,
                        "dupsTested": 0,
                        "dupsDropped": 0,
                        "seenInvalidated": 0
                    }
                }
            }
        ]
    },
    "ok": 1,
    "operationTime": Timestamp(1557996666, 2),
    "$clusterTime": {
        "clusterTime": Timestamp(1557996666, 2),
        "signature": {
            "hash": BinData(0, "hDKqoIo9DL71/n8vfgSDS3czZ9c="),
            "keyId": NumberLong("6685056801689305089")
        }
    }
}

我尝试了 https://docs.mongodb.com/v4.0/core/index-intersection/ 中的 orders 示例并得到相同的结果。因为MongoDB currently doesn't allow using multiple indices as a hint ,我不能强制 MongoDB 在我的查询中使用这两个索引。更糟糕的是,以前 explain(true) 似乎总是包含类似 "cursor": "Complex Plan" 的东西,当有可用的索引交叉计划时(Why doesn't MongoDB use index intersection? ) 但现在此信息已被删除。

那么,当可能有足够的数据时,我怎么知道是否会使用索引的交集?

PS:我正在使用运行 MongoDB 4.0.9 Enterprise atm 的 MongoDB Atlas。

最佳答案

如果您查看解释执行统计输出,您会发现它使用的索引非常有效——在这里使用复合索引而不是索引交集似乎是查询计划器的一个不错的决定:

    "executionStats": {
        "executionSuccess": true,
        "nReturned": 1,
        "executionTimeMillis": 0,
        "totalKeysExamined": 2,
        "totalDocsExamined": 2,
...
    }

当绝对没有更好的选择时,会使用索引交集,大部分数据都在磁盘上,并且您没有任何远程选择性的索引。

如果您想在本地查看,您可以创建集合,其中 {a: 1}{b: 1} 不是很有选择性,并且您可以看到 mongo 考虑并拒绝使用这些作为索引交集。

const toInsert = [];
for (let i = 0; i < 10000; i++) { toInsert.push({a: i % 10, b: i % 9 }); }
db.test_coll.createIndex({a: 1});
db.test_coll.createIndex({b: 1});
db.test_coll.find({a: 100, b: 100}).explain()

查看被拒绝的计划:

...
            {
                "stage" : "FETCH",
                "filter" : {
                    "$and" : [
                        {
                            "b" : {
                                "$eq" : 100
                            }
                        },
                        {
                            "a" : {
                                "$eq" : 100
                            }
                        }
                    ]
                },
                "inputStage" : {
                    "stage" : "AND_SORTED",
                    "inputStages" : [
                        {
                            "stage" : "IXSCAN",
                            "keyPattern" : {
                                "b" : 1
                            },
                            "indexName" : "b_1",
                            "isMultiKey" : false,
                            "multiKeyPaths" : {
                                "b" : [ ]
                            },
                            "isUnique" : false,
                            "isSparse" : false,
                            "isPartial" : false,
                            "indexVersion" : 2,
                            "direction" : "forward",
                            "indexBounds" : {
                                "b" : [
                                    "[100.0, 100.0]"
                                ]
                            }
                        },
                        {
                            "stage" : "IXSCAN",
                            "keyPattern" : {
                                "a" : 1
                            },
                            "indexName" : "a_1",
                            "isMultiKey" : false,
                            "multiKeyPaths" : {
                                "a" : [ ]
                            },
                            "isUnique" : false,
                            "isSparse" : false,
                            "isPartial" : false,
                            "indexVersion" : 2,
                            "direction" : "forward",
                            "indexBounds" : {
                                "a" : [
                                    "[100.0, 100.0]"
                                ]
                            }
                        }
                    ]
                }
            }
        ]

关于database - 如何检查索引交集是否支持 MongoDB 中的查询?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/56164822/

有关database - 如何检查索引交集是否支持 MongoDB 中的查询?的更多相关文章

  1. ruby - 如何使用 Nokogiri 的 xpath 和 at_xpath 方法 - 2

    我正在学习如何使用Nokogiri,根据这段代码我遇到了一些问题:require'rubygems'require'mechanize'post_agent=WWW::Mechanize.newpost_page=post_agent.get('http://www.vbulletin.org/forum/showthread.php?t=230708')puts"\nabsolutepathwithtbodygivesnil"putspost_page.parser.xpath('/html/body/div/div/div/div/div/table/tbody/tr/td/div

  2. ruby - 如何从 ruby​​ 中的字符串运行任意对象方法? - 2

    总的来说,我对ruby​​还比较陌生,我正在为我正在创建的对象编写一些rspec测试用例。许多测试用例都非常基础,我只是想确保正确填充和返回值。我想知道是否有办法使用循环结构来执行此操作。不必为我要测试的每个方法都设置一个assertEquals。例如:describeitem,"TestingtheItem"doit"willhaveanullvaluetostart"doitem=Item.new#HereIcoulddotheitem.name.shouldbe_nil#thenIcoulddoitem.category.shouldbe_nilendend但我想要一些方法来使用

  3. ruby - 其他文件中的 Rake 任务 - 2

    我试图在一个项目中使用rake,如果我把所有东西都放到Rakefile中,它会很大并且很难读取/找到东西,所以我试着将每个命名空间放在lib/rake中它自己的文件中,我添加了这个到我的rake文件的顶部:Dir['#{File.dirname(__FILE__)}/lib/rake/*.rake'].map{|f|requiref}它加载文件没问题,但没有任务。我现在只有一个.rake文件作为测试,名为“servers.rake”,它看起来像这样:namespace:serverdotask:testdoputs"test"endend所以当我运行rakeserver:testid时

  4. ruby-on-rails - Ruby net/ldap 模块中的内存泄漏 - 2

    作为我的Rails应用程序的一部分,我编写了一个小导入程序,它从我们的LDAP系统中吸取数据并将其塞入一个用户表中。不幸的是,与LDAP相关的代码在遍历我们的32K用户时泄漏了大量内存,我一直无法弄清楚如何解决这个问题。这个问题似乎在某种程度上与LDAP库有关,因为当我删除对LDAP内容的调用时,内存使用情况会很好地稳定下来。此外,不断增加的对象是Net::BER::BerIdentifiedString和Net::BER::BerIdentifiedArray,它们都是LDAP库的一部分。当我运行导入时,内存使用量最终达到超过1GB的峰值。如果问题存在,我需要找到一些方法来更正我的代

  5. python - 如何使用 Ruby 或 Python 创建一系列高音调和低音调的蜂鸣声? - 2

    关闭。这个问题是opinion-based.它目前不接受答案。想要改进这个问题?更新问题,以便editingthispost可以用事实和引用来回答它.关闭4年前。Improvethisquestion我想在固定时间创建一系列低音和高音调的哔哔声。例如:在150毫秒时发出高音调的蜂鸣声在151毫秒时发出低音调的蜂鸣声200毫秒时发出低音调的蜂鸣声250毫秒的高音调蜂鸣声有没有办法在Ruby或Python中做到这一点?我真的不在乎输出编码是什么(.wav、.mp3、.ogg等等),但我确实想创建一个输出文件。

  6. ruby-on-rails - Rails 3 中的多个路由文件 - 2

    Rails2.3可以选择随时使用RouteSet#add_configuration_file添加更多路由。是否可以在Rails3项目中做同样的事情? 最佳答案 在config/application.rb中:config.paths.config.routes在Rails3.2(也可能是Rails3.1)中,使用:config.paths["config/routes"] 关于ruby-on-rails-Rails3中的多个路由文件,我们在StackOverflow上找到一个类似的问题

  7. ruby-on-rails - 如何验证 update_all 是否实际在 Rails 中更新 - 2

    给定这段代码defcreate@upgrades=User.update_all(["role=?","upgraded"],:id=>params[:upgrade])redirect_toadmin_upgrades_path,:notice=>"Successfullyupgradeduser."end我如何在该操作中实际验证它们是否已保存或未重定向到适当的页面和消息? 最佳答案 在Rails3中,update_all不返回任何有意义的信息,除了已更新的记录数(这可能取决于您的DBMS是否返回该信息)。http://ar.ru

  8. ruby-on-rails - 'compass watch' 是如何工作的/它是如何与 rails 一起使用的 - 2

    我在我的项目目录中完成了compasscreate.和compassinitrails。几个问题:我已将我的.sass文件放在public/stylesheets中。这是放置它们的正确位置吗?当我运行compasswatch时,它不会自动编译这些.sass文件。我必须手动指定文件:compasswatchpublic/stylesheets/myfile.sass等。如何让它自动运行?文件ie.css、print.css和screen.css已放在stylesheets/compiled。如何在编译后不让它们重新出现的情况下删除它们?我自己编译的.sass文件编译成compiled/t

  9. ruby - ECONNRESET (Whois::ConnectionError) - 尝试在 Ruby 中查询 Whois 时出错 - 2

    我正在用Ruby编写一个简单的程序来检查域列表是否被占用。基本上它循环遍历列表,并使用以下函数进行检查。require'rubygems'require'whois'defcheck_domain(domain)c=Whois::Client.newc.query("google.com").available?end程序不断出错(即使我在google.com中进行硬编码),并打印以下消息。鉴于该程序非常简单,我已经没有什么想法了-有什么建议吗?/Library/Ruby/Gems/1.8/gems/whois-2.0.2/lib/whois/server/adapters/base.

  10. ruby - 如何将脚本文件的末尾读取为数据文件(Perl 或任何其他语言) - 2

    我正在寻找执行以下操作的正确语法(在Perl、Shell或Ruby中):#variabletoaccessthedatalinesappendedasafileEND_OF_SCRIPT_MARKERrawdatastartshereanditcontinues. 最佳答案 Perl用__DATA__做这个:#!/usr/bin/perlusestrict;usewarnings;while(){print;}__DATA__Texttoprintgoeshere 关于ruby-如何将脚

随机推荐