MongoDB biedt uitstekende ondersteuning voor arrays en biedt veel flexibiliteit in uw documentmodus. U kunt bijvoorbeeld arrays insluiten in documenten en ook documenten insluiten in arrays, enz. Het werken met arrays heeft echter een aantal problemen in MongoDB. In dit bericht zullen we kijken naar enkele van de problemen die MongoDB heeft met indexen en arrays.
Multikey-indexen
In MongoDB kunt u een arrayveld indexeren om een indexitem te maken voor elk element in de array. De resulterende index wordt een 'multikey'-index genoemd. Multikey-indexen kunnen worden gemaakt over scalaire waarden of ingesloten documenten. Raadpleeg deze documentatie voor meer informatie over indexen met meerdere toetsen.
Indexen met meerdere toetsen, hoewel nuttig, hebben verschillende beperkingen:
- Als u een samengestelde multikey-index maakt, heeft u maximaal één veld dat een array is.
- Een samengestelde index kan geen Shard-sleutel zijn.
- Een samengestelde index kan geen gehashte index zijn.
Een van de meest interessante aspecten van indexen met meerdere toetsen is hoe de grens van de intersectie van de index wordt berekend.
Index snijpunten
Hier is hoe de MongoDB-documentatie de grens van indexkruisingen definieert:
“De grenzen van een indexscan bepalen de delen van een index die moeten worden doorzocht tijdens een zoekopdracht. Als er meerdere predikaten over een index bestaan, zal MongoDB proberen de grenzen voor deze predikaten te combineren door ofwel kruispunt of compounding om een scan met kleinere grenzen te maken.”
Bereikquery's op arrays
Laten we beginnen met een eenvoudig voorbeeld om te zien hoe MongoDB indexgrenzen berekent voor query's op arrays. Stel dat we de volgende drie documenten in een verzameling hebben:
{x: 65}
{x: 35}
{x: [12,95]}
We stellen de volgende vraag:
db.coll.find({x :{ $gt :22, $lt:55})
De vraag is eenvoudig genoeg. Je zou verwachten dat het antwoord {x:35} is, maar de vraag geeft als resultaat:
{x:35}
{x:[25,95]}
De reden komt van hoe MongoDB omgaat met arrays. Hetzelfde element van de array hoeft niet aan beide voorwaarden te voldoen; zolang er één element is dat overeenkomt met elke voorwaarde, is het een overeenkomst. Dus in dit geval zijn de grenzen [22, Infinity] en [-Oneindig, 55]. Omdat er geen 'elemMatch'-operator wordt gebruikt, maakt MongoDB geen gebruik van het indexkruispunt. MongoDB specificeert niet welk van deze bereiken [22, Infinity] of [-Infinity, 55] zal worden gebruikt voor het uitvoeren van de query.
Als we het indexkruispunt willen gebruiken, moeten we de volgende query gebruiken:
db.coll.find(x :{ $elemMatch:{$gt :22,$lt:55}})
Wanneer u dit gebruikt, snijdt MongoDB de indexgrenzen en gebruikt [22, 55] als de grenzen. Zoals verwacht, retourneert deze query geen resultaten (elemMatch komt niet overeen met niet-arrays). Dus in wezen zijn bereikquery's op arrays redelijk nutteloos zonder de $elemMatch-operator.
Samengestelde multikey-indexen - Array- en niet-arrayvelden mengen
Overweeg een verzameling met de volgende documenten:
{item: 35, prices:[250,35]}
......
{item: 106, prices:[1500,65]}
We voegen een samengestelde index toe aan deze verzameling:
db.ensureIndex({item:1, prices:1});
Laten we nu een eenvoudige zoekopdracht uitvoeren:
db. coll. find({item: {$gt:12, $lt:65}});
De query ziet er eenvoudig genoeg uit, omdat we een niet-array-item met een vast bereik gebruiken. Ik verwacht dat de grens van het snijpunt van de index iets is als item:[[12,65] ] voor de query, maar als u een uitleg uitvoert, ziet u dit:
"indexBounds" : {
"item" : [ [ -Infinity, 65 ] ],
"prices" : [ [ { "$minElement" : 1 }, { "$maxElement" : 1 } ] ]
},
De reden is dat MongoDB detecteert dat dit een index met meerdere sleutels is en de intersectie van de indexgrenzen niet verwerkt, ongeacht het feit dat uw query geen matrixvelden gebruikt. De moraal van het verhaal is dat wanneer u array- en niet-array-velden in een index mengt, u altijd uw indexkruisingsgrenzen in de gaten moet houden. De kans is groot dat het niet efficiënt is.