草庐IT

mongodb - 为什么一个 mongoDB 复合索引会影响另一个复合索引？

coder 2023-10-28 原文

根据我从 mongodb 文档中读到的内容，查询中只使用了一个索引。但是，我发现一些其他复合索引的存在会影响此查询的质量。这是一个例子:

db.products.ensureIndex({'b':1，'l.d':1，'l.i':1})

db.products.find({'b' : {$in : b.ct}, 'l.d' : {$lt : d}}).limit(24).sort({'l.i' : 1} ).解释()

{ "cursor" : "BtreeCursor b_1_l.d_1_l.i_1 multi",
"isMultiKey" : true,
"n" : 24,
"nscannedObjects" : 1079,
"nscanned" : 1102,
"nscannedObjectsAllPlans" : 1182,
"nscannedAllPlans" : 1205,
"scanAndOrder" : true,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
....}

db.products.ensureIndex({'l.i' :1, 'b' : 1, 'l.d' : 1})

db.products.find({'b' : {$in : b.ct}, 'l.d' : {$lt : d}}).limit(24).sort({'l.i' : 1} ).解释()

{ "cursor" : "BtreeCursor b_1_l.d_1_l.i_1 multi",
"isMultiKey" : true,
"n" : 24,
"nscannedObjects" : 614,
"nscanned" : 624,
"nscannedObjectsAllPlans" : 1283,
"nscannedAllPlans" : 1875,
"scanAndOrder" : true,
"indexOnly" : false,
"nYields" : 1,
"nChunkSkips" : 0,
....}

nscanned 的值几乎减少了一半。为什么？

============================================= =================

根据评论，我更新了我的命令行序列以提供更详细的信息。请注意，索引名称已更改，因为我修改了数据库。结果是一样的。两个指数更好，但为什么呢？

db.products.stats()

{
"ns" : "mytest.products",
"count" : 209607,
"size" : 90155636,
"avgObjSize" : 430.11748653432375,
"storageSize" : 123936768,
"numExtents" : 11,
"nindexes" : 1,
"lastExtentSize" : 37625856,
"paddingFactor" : 1,
"systemFlags" : 0,
"userFlags" : 0,
"totalIndexSize" : 5927600,
"indexSizes" : {
    "_id_" : 5927600
},
"ok" : 1
}

b.ct

[
2020,
3564969011,
2021,
15762981,
271619011,
2023,
2024,
2027,
3825141,
505092,
2025,
2028,
10825721,
2080,
2026,
2085,
2029,
2030,
2032,
3564970011,
2081,
2082,
2083,
2084,
271621011,
2087

]

d

ISODate("2012-11-30T00:00:00Z")

db.products.ensureIndex({'b': 1, 'd': 1, 'i' : 1})

db.products.stats()

{
"ns" : "mytest.products",
"count" : 209607,
"size" : 90155636,
"avgObjSize" : 430.11748653432375,
"storageSize" : 123936768,
"numExtents" : 11,
"nindexes" : 2,
"lastExtentSize" : 37625856,
"paddingFactor" : 1,
"systemFlags" : 0,
"userFlags" : 0,
"totalIndexSize" : 22614816,
"indexSizes" : {
    "_id_" : 5927600,
    "b_1_d_1_i_1" : 16687216
},
"ok" : 1
}

db.products.find({'b': {$in: b.ct}, 'd': {$lt: d}}).limit(24).sort({'i': 1} ).解释()

{
"cursor" : "BtreeCursor b_1_d_1_i_1 multi",
"isMultiKey" : true,
"n" : 24,
"nscannedObjects" : 1294,
"nscanned" : 1300,
"nscannedObjectsAllPlans" : 1395,
"nscannedAllPlans" : 1401,
"scanAndOrder" : true,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 12,
"indexBounds" : {
    "b" : [
        [
            2020,
            2020
        ],
        [
            2021,
            2021
        ],
        [
            2023,
            2023
        ],
        [
            2024,
            2024
        ],
        [
            2025,
            2025
        ],
        [
            2026,
            2026
        ],
        [
            2027,
            2027
        ],
        [
            2028,
            2028
        ],
        [
            2029,
            2029
        ],
        [
            2030,
            2030
        ],
        [
            2032,
            2032
        ],
        [
            2080,
            2080
        ],
        [
            2081,
            2081
        ],
        [
            2082,
            2082
        ],
        [
            2083,
            2083
        ],
        [
            2084,
            2084
        ],
        [
            2085,
            2085
        ],
        [
            2087,
            2087
        ],
        [
            505092,
            505092
        ],
        [
            3825141,
            3825141
        ],
        [
            10825721,
            10825721
        ],
        [
            15762981,
            15762981
        ],
        [
            271619011,
            271619011
        ],
        [
            271621011,
            271621011
        ],
        [
            3564969011,
            3564969011
        ],
        [
            3564970011,
            3564970011
        ]
    ],
    "d" : [
        [
            true,
            ISODate("2012-11-30T00:00:00Z")
        ]
    ],
    "i" : [
        [
            {
                "$minElement" : 1
            },
            {
                "$maxElement" : 1
            }
        ]
    ]
},
"server" : "li91-182:27017"
}

db.products.ensureIndex({'i': 1, 'b': 1, 'd' : 1})

db.products.stats()

{
"ns" : "mytest.products",
"count" : 209607,
"size" : 90155636,
"avgObjSize" : 430.11748653432375,
"storageSize" : 123936768,
"numExtents" : 11,
"nindexes" : 3,
"lastExtentSize" : 37625856,
"paddingFactor" : 1,
"systemFlags" : 0,
"userFlags" : 0,
"totalIndexSize" : 39302032,
"indexSizes" : {
    "_id_" : 5927600,
    "b_1_d_1_i_1" : 16687216,
    "i_1_b_1_d_1" : 16687216
},
"ok" : 1
}

db.products.find({'b': {$in: b.ct}, 'd': {$lt: d}}).limit(24).sort({'i': 1} ).解释()

{
"cursor" : "BtreeCursor b_1_d_1_i_1 multi",
"isMultiKey" : true,
"n" : 24,
"nscannedObjects" : 206,
"nscanned" : 206,
"nscannedObjectsAllPlans" : 445,
"nscannedAllPlans" : 619,
"scanAndOrder" : true,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 6,
"indexBounds" : {
    "b" : [
        [
            2020,
            2020
        ],
        [
            2021,
            2021
        ],
        [
            2023,
            2023
        ],
        [
            2024,
            2024
        ],
        [
            2025,
            2025
        ],
        [
            2026,
            2026
        ],
        [
            2027,
            2027
        ],
        [
            2028,
            2028
        ],
        [
            2029,
            2029
        ],
        [
            2030,
            2030
        ],
        [
            2032,
            2032
        ],
        [
            2080,
            2080
        ],
        [
            2081,
            2081
        ],
        [
            2082,
            2082
        ],
        [
            2083,
            2083
        ],
        [
            2084,
            2084
        ],
        [
            2085,
            2085
        ],
        [
            2087,
            2087
        ],
        [
            505092,
            505092
        ],
        [
            3825141,
            3825141
        ],
        [
            10825721,
            10825721
        ],
        [
            15762981,
            15762981
        ],
        [
            271619011,
            271619011
        ],
        [
            271621011,
            271621011
        ],
        [
            3564969011,
            3564969011
        ],
        [
            3564970011,
            3564970011
        ]
    ],
    "d" : [
        [
            true,
            ISODate("2012-11-30T00:00:00Z")
        ]
    ],
    "i" : [
        [
            {
                "$minElement" : 1
            },
            {
                "$maxElement" : 1
            }
        ]
    ]
},
"server" : "li91-182:27017"
}

db.products.getIndexes()

[
{
    "v" : 1,
    "key" : {
        "_id" : 1
    },
    "ns" : "mytest.products",
    "name" : "_id_"
},
{
    "v" : 1,
    "key" : {
        "b" : 1,
        "d" : 1,
        "i" : 1
    },
    "ns" : "mytest.products",
    "name" : "b_1_d_1_i_1"
},
{
    "v" : 1,
    "key" : {
        "i" : 1,
        "b" : 1,
        "d" : 1
    },
    "ns" : "mytest.products",
    "name" : "i_1_b_1_d_1"
}
]

db.products.dropIndex({'i': 1, 'b': 1, 'd' : 1}) { “nIndexesWas”:3，“确定”:1 }

db.products.getIndexes()

[
{
    "v" : 1,
    "key" : {
        "_id" : 1
    },
    "ns" : "mytest.products",
    "name" : "_id_"
},
{
    "v" : 1,
    "key" : {
        "b" : 1,
        "d" : 1,
        "i" : 1
    },
    "ns" : "mytest.products",
    "name" : "b_1_d_1_i_1"
}
]

db.products.find({'b': {$in: b.ct}, 'd': {$lt: d}}).limit(24).sort({'i': 1} ).解释()

{
"cursor" : "BtreeCursor b_1_d_1_i_1 multi",
"isMultiKey" : true,
"n" : 24,
"nscannedObjects" : 1294,
"nscanned" : 1300,
"nscannedObjectsAllPlans" : 1395,
"nscannedAllPlans" : 1401,
"scanAndOrder" : true,
"indexOnly" : false,
"nYields" : 0,
"nChunkSkips" : 0,
"millis" : 131,
"indexBounds" : {
    "b" : [
        [
            2020,
            2020
        ],
        [
            2021,
            2021
        ],
        [
            2023,
            2023
        ],
        [
            2024,
            2024
        ],
        [
            2025,
            2025
        ],
        [
            2026,
            2026
        ],
        [
            2027,
            2027
        ],
        [
            2028,
            2028
        ],
        [
            2029,
            2029
        ],
        [
            2030,
            2030
        ],
        [
            2032,
            2032
        ],
        [
            2080,
            2080
        ],
        [
            2081,
            2081
        ],
        [
            2082,
            2082
        ],
        [
            2083,
            2083
        ],
        [
            2084,
            2084
        ],
        [
            2085,
            2085
        ],
        [
            2087,
            2087
        ],
        [
            505092,
            505092
        ],
        [
            3825141,
            3825141
        ],
        [
            10825721,
            10825721
        ],
        [
            15762981,
            15762981
        ],
        [
            271619011,
            271619011
        ],
        [
            271621011,
            271621011
        ],
        [
            3564969011,
            3564969011
        ],
        [
            3564970011,
            3564970011
        ]
    ],
    "d" : [
        [
            true,
            ISODate("2012-11-30T00:00:00Z")
        ]
    ],
    "i" : [
        [
            {
                "$minElement" : 1
            },
            {
                "$maxElement" : 1
            }
        ]
    ]
},
"server" : "li91-182:27017"
}

最佳答案

根据 10gen BSON is a bin­ary-en­coded seri­al­iz­a­tion of JSON-like doc­u­ments .然而，BSON 文档中的字段顺序确实很重要:

> db.things.insert({b:1,d:1,i:1});
> db.things.insert({i:2,b:2,d:2});
> db.things.insert({d:3,i:3,b:3});
> db.things.find();
{ "_id" : ObjectId("50904ee4875db529686c5775"), "b" : 1, "d" : 1, "i" : 1 }
{ "_id" : ObjectId("50904ef0875db529686c5776"), "i" : 2, "b" : 2, "d" : 2 }
{ "_id" : ObjectId("50904efc875db529686c5777"), "d" : 3, "i" : 3, "b" : 3 }

因此，每当您使用 db.products.ensureIndex({'b' : 1, 'l.d' : 1, 'l.i' : 1}) 创建索引，然后使用 db.products.ensureIndex({'l.i' :1, 'b' : 1, 'l.d' : 1}) 你得到了 2 个字段顺序不同的索引。这可以通过您提供的 db.products.getIndexes() 结果进行检查:

[{
    "v" : 1,
    "key" : {
        "b" : 1,
        "d" : 1,
        "i" : 1
    },
    "ns" : "mytest.products",
    "name" : "b_1_d_1_i_1"
},
{
    "v" : 1,
    "key" : {
        "i" : 1,
        "b" : 1,
        "d" : 1
    },
    "ns" : "mytest.products",
    "name" : "i_1_b_1_d_1"
}]

不同的字段顺序显然可能导致不同的 nscanned 值 - the number of items (including index tree nodes) to be scanned :

Number of items (documents or index entries) examined. Items might be objects or index keys.

关于mongodb - 为什么一个 mongoDB 复合索引会影响另一个复合索引？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/12880449/

mongodb34productscodemongodb-query

有关mongodb - 为什么一个 mongoDB 复合索引会影响另一个复合索引？的更多相关文章

  1. ruby - 为什么我可以在 Ruby 中使用 Object#send 访问私有(private)/ protected 方法？ - 2

    类classAprivatedeffooputs:fooendpublicdefbarputs:barendprivatedefzimputs:zimendprotecteddefdibputs:dibendendA的实例a=A.new测试a.foorescueputs:faila.barrescueputs:faila.zimrescueputs:faila.dibrescueputs:faila.gazrescueputs:fail测试输出failbarfailfailfail.发送测试[:foo,:bar,:zim,:dib,:gaz].each{|m|a.send(m)resc

  2. ruby-on-rails - Rails - 子类化模型的设计模式是什么？ - 2

    我有一个模型:classItem项目有一个属性“商店”基于存储的值，我希望Item对象对特定方法具有不同的行为。Rails中是否有针对此的通用设计模式？如果方法中没有大的if-else语句，这是如何干净利落地完成的？ 最佳答案 通常通过Single-TableInheritance. 关于ruby-on-rails-Rails-子类化模型的设计模式是什么？，我们在StackOverflow上找到一个类似的问题： https://stackoverflow.co

  3. ruby - 什么是填充的 Base64 编码字符串以及如何在 ruby​​ 中生成它们？ - 2

    我正在使用的第三方API的文档状态:"[O]urAPIonlyacceptspaddedBase64encodedstrings."什么是“填充的Base64编码字符串”以及如何在Ruby中生成它们。下面的代码是我第一次尝试创建转换为Base64的JSON格式数据。xa=Base64.encode64(a.to_json) 最佳答案 他们说的padding其实就是Base64本身的一部分。它是末尾的“=”和“==”。Base64将3个字节的数据包编码为4个编码字符。所以如果你的输入数据有长度n和n%3=1=>"=="末尾用于填充n%

  4. ruby - 解析 RDFa、微数据等的最佳方式是什么，使用统一的模式/词汇(例如 schema.org)存储和显示信息 - 2

    我主要使用Ruby来执行此操作，但到目前为止我的攻击计划如下:使用gemsrdf、rdf-rdfa和rdf-microdata或mida来解析给定任何URI的数据。我认为最好映射到像schema.org这样的统一模式，例如使用这个yaml文件，它试图描述数据词汇表和opengraph到schema.org之间的转换:#SchemaXtoschema.orgconversion#data-vocabularyDV:name:namestreet-address:streetAddressregion:addressRegionlocality:addressLocalityphoto:i

  5. ruby - 使用 Vim Rails，您可以创建一个新的迁移文件并一次性打开它吗？ - 2

    使用带有Rails插件的vim，您可以创建一个迁移文件，然后一次性打开该文件吗？textmate也可以这样吗？ 最佳答案 你可以使用rails.vim然后做类似的事情::Rgeneratemigratonadd_foo_to_bar插件将打开迁移生成的文件，这正是您想要的。我不能代表textmate。 关于ruby-使用VimRails，您可以创建一个新的迁移文件并一次性打开它吗？，我们在StackOverflow上找到一个类似的问题： https://sta

  6. ruby-on-rails - Rails - 一个 View 中的多个模型 - 2

    我需要从一个View访问多个模型。以前，我的links_controller仅用于提供以不同方式排序的链接资源。现在我想包括一个部分(我假设)显示按分数排序的顶级用户(@users=User.all.sort_by(&:score))我知道我可以将此代码插入每个链接操作并从View访问它，但这似乎不是“ruby方式”，我将需要在不久的将来访问更多模型。这可能会变得很脏，是否有针对这种情况的任何技术？注意事项:我认为我的应用程序正朝着单一格式和动态页面内容的方向发展，本质上是一个典型的网络应用程序。我知道before_filter但考虑到我希望应用程序进入的方向，这似乎很麻烦。最终从任何

  7. ruby-on-rails - 渲染另一个 Controller 的 View - 2

    我想要做的是有2个不同的Controller，client和test_client。客户端Controller已经构建，我想创建一个test_clientController，我可以使用它来玩弄客户端的UI并根据需要进行调整。我主要是想绕过我在客户端中内置的验证及其对加载数据的管理Controller的依赖。所以我希望test_clientController加载示例数据集，然后呈现客户端Controller的索引View，以便我可以调整客户端UI。就是这样。我在test_clients索引方法中试过这个:classTestClientdefindexrender:template=>

  8. ruby - 为什么 4.1%2 使用 Ruby 返回 0.0999999999999996？但是 4.2%2==0.2 - 2

    为什么4.1%2返回0.0999999999999996？但是4.2%2==0.2。 最佳答案 参见此处:WhatEveryProgrammerShouldKnowAboutFloating-PointArithmetic实数是无限的。计算机使用的位数有限(今天是32位、64位)。因此计算机进行的浮点运算不能代表所有的实数。0.1是这些数字之一。请注意，这不是与Ruby相关的问题，而是与所有编程语言相关的问题，因为它来自计算机表示实数的方式。 关于ruby-为什么4.1%2使用Ruby返

  9. ruby - ruby 中的 TOPLEVEL_BINDING 是什么？ - 2

    它不等于主线程的binding，这个toplevel作用域是什么？此作用域与主线程中的binding有何不同？>ruby-e'putsTOPLEVEL_BINDING===binding'false 最佳答案 事实是，TOPLEVEL_BINDING始终引用Binding的预定义全局实例，而Kernel#binding创建的新实例>Binding每次封装当前执行上下文。在顶层，它们都包含相同的绑定(bind)，但它们不是同一个对象，您无法使用==或===测试它们的绑定(bind)相等性。putsTOPLEVEL_BINDINGput

  10. ruby - Infinity 和 NaN 的类型是什么？ - 2

    我可以得到Infinity和NaNn=9.0/0#=>Infinityn.class#=>Floatm=0/0.0#=>NaNm.class#=>Float但是当我想直接访问Infinity或NaN时:Infinity#=>uninitializedconstantInfinity(NameError)NaN#=>uninitializedconstantNaN(NameError)什么是Infinity和NaN？它们是对象、关键字还是其他东西？ 最佳答案 您看到打印为Infinity和NaN的只是Float类的两个特殊实例的字符串

随机推荐