Lumikha ng Koleksyon
Bago gumamit ng mga index, kailangan naming gumawa ng bagong koleksyon sa aming MongoDB. Nakagawa na kami ng isa at nagpasok ng 10 dokumento, pinangalanang 'Dummy'. Ang function na find() MongoDB ay nagpapakita ng lahat ng mga tala mula sa 'Dummy' na koleksyon sa MongoDB shell screen sa ibaba.
pagsubok> db.Dummy.find() 
Piliin ang Uri ng Pag-index
Bago magtatag ng index, kailangan mo munang matukoy ang mga column na karaniwang gagamitin sa pamantayan ng query. Mahusay na gumaganap ang mga index sa mga column na madalas na sinasala, pinagbubukod-bukod, o hinahanap. Ang mga field na may malaking cardinality (maraming iba't ibang value) ay kadalasang mahuhusay na opsyon sa pag-index. Narito ang ilang mga halimbawa ng code para sa iba't ibang uri ng index.
Halimbawa 01: Single Field Index
Ito marahil ang pinakapangunahing uri ng index, na nag-i-index ng isang column upang mapahusay ang bilis ng query sa column na iyon. Ang ganitong uri ng index ay ginagamit para sa mga query kung saan gumagamit ka ng isang key field para i-query ang mga record ng koleksyon. Ipagpalagay na ginagamit mo ang field na 'uri' upang i-query ang mga talaan ng koleksyon na 'Dummy' sa loob ng function ng paghahanap tulad ng nasa ibaba. Ang utos na ito ay titingnan ang buong koleksyon, na maaaring tumagal ng mahabang panahon para maproseso ang malalaking koleksyon. Samakatuwid, kailangan nating i-optimize ang pagganap ng query na ito.
pagsubok> db.Dummy.find({type: 'emp' })
Ang mga talaan ng koleksyon ng Dummy sa itaas ay natagpuan gamit ang field na 'uri' ibig sabihin, naglalaman ng kundisyon. Samakatuwid, ang single-key index ay maaaring gamitin dito upang i-optimize ang query sa paghahanap. Kaya, gagamitin namin ang createIndex() function ng MongoDB upang lumikha ng index sa field na 'uri' ng koleksyong 'Dummy'. Ang paglalarawan ng paggamit ng query na ito ay nagpapakita ng matagumpay na paglikha ng isang solong-key na index na pinangalanang 'type_1' sa shell.
pagsubok> db.Dummy.createIndex({ uri: 1 })Gamitin natin ang find() na query sa sandaling makuha nito ang paggamit ng field na 'uri'. Ang operasyon ay magiging mas mabilis ngayon kaysa sa dating ginamit na function na find() dahil ang index ay nasa lugar dahil magagamit ng MongoDB ang index upang mabilis na makuha ang mga talaan na may hiniling na titulo ng trabaho.
pagsubok> db.Dummy.find({type: 'emp' })
Halimbawa 02: Compound Index
Maaaring gusto naming maghanap ng mga item batay sa iba't ibang pamantayan sa ilang partikular na sitwasyon. Ang pagpapatupad ng compound index para sa mga field na ito ay maaaring makatulong na mapabuti ang pagganap ng query. Sabihin nating, sa pagkakataong ito, gusto mong maghanap mula sa koleksyon na 'Dummy' gamit ang maraming field na naglalaman ng iba't ibang kundisyon sa paghahanap habang ipinapakita ang query. Ang query na ito ay naghahanap ng mga tala mula sa koleksyon kung saan ang field na 'uri' ay nakatakda sa 'emp,' at ang field na 'sal' ay higit sa 350.
Ang $gte logical operator ay ginamit upang ilapat ang kundisyon sa field na 'sal'. Isang kabuuan ng dalawang talaan ang naibalik pagkatapos hanapin ang buong koleksyon, na binubuo ng 10 talaan.
pagsubok> db.Dummy.find({type: 'emp' , sal: {$gte: 350 } }) 
Gumawa tayo ng compound index para sa nabanggit na query. Ang compound index na ito ay may mga field na 'uri' at 'sal'. Ang mga numerong '1' at '-1' ay kumakatawan sa pataas at pababang pagkakasunud-sunod, ayon sa pagkakabanggit, para sa mga field na 'uri' at 'sal'. Ang pagkakasunud-sunod ng mga column ng compound index ay mahalaga at dapat tumugma sa mga pattern ng query. Ang MongoDB ay nagbigay ng pangalang 'type_1_sal_-1' sa compound index na ito tulad ng ipinapakita.
pagsubok> db.Dummy.createIndex({ uri: 1 , ay:- 1 }) 
Pagkatapos gamitin ang parehong find() na query para maghanap ng mga record na may 'type' na value ng field bilang 'emp' at ang value ng 'sal' na field na mas malaki kaysa sa katumbas ng 350, nakuha namin ang parehong output na may kaunting pagbabago sa pagkakasunud-sunod kumpara sa nakaraang resulta ng query. Ang mas malaking tala ng halaga para sa field na 'sal' ay nasa unang lugar na ngayon, habang ang pinakamaliit ay nasa pinakamababa ayon sa '-1' na itinakda para sa field na 'sal' sa compound index sa itaas.
pagsubok> db.Dummy.find({type: 'emp' , sal: {$gte: 350 } }) 
Halimbawa 03: Text Index
Minsan, maaari kang makatagpo ng isang sitwasyon kung saan dapat mong harapin ang isang malaking set ng data, tulad ng malalaking paglalarawan ng mga produkto, sangkap, atbp. Maaaring maging kapaki-pakinabang ang isang text index para sa pagsasagawa ng mga paghahanap sa buong teksto sa isang malaking field ng teksto. Halimbawa, gumawa kami ng bagong koleksyon na pinangalanang 'Pagsubok' sa loob ng aming database ng pagsubok. Nagpasok ng kabuuang 6 na tala sa koleksyong ito gamit ang insertMany() function ayon sa find() query sa ibaba.
pagsubok> db.Test.insertMany([{name: 'Ana' , ng: 'Siya ay nakatira sa London at isang mahusay na guro' },
{name: 'Robert' , ng: 'Siya ay isang kahanga-hangang manlalaro ng Football' },
{name: 'mula sa' , ng: 'Baka naglalakbay sa Dubai' },
{name: 'Jacob' , ng: 'Siya ay mindblowing at mayaman.' },
{name: 'Cillian' , ng: 'Ang isang pelikulang sobrang simula ay sumikat sa loob ng ilang segundo' },
{name: 'Ken' , ng: 'Food lover. Kakainin ka rin niya.' }
])
Ngayon, gagawa kami ng text index sa field na 'Des' ng koleksyong ito, na ginagamit ang createIndex() function ng MongoDB. Ang keyword na 'text' sa field na value ay nagpapakita ng uri ng isang index, na isang 'text' na index. Ang pangalan ng index, des_text, ay na-autogenerate.
pagsubok> db.Test.createIndex({ des: 'text' })Ngayon, ang function na find() ay ginamit upang isagawa ang 'text-search' sa koleksyon sa pamamagitan ng 'des_text' index. Ang operator ng $search ay ginamit upang hanapin ang salitang 'pagkain' sa mga talaan ng koleksyon at ipakita ang partikular na tala na iyon.
pagsubok> db.Test.find({ $text: { $search: 'pagkain' }}); 
I-verify ang Mga Index:
Maaari mong suriin at ilista ang lahat ng inilapat na index ng iba't ibang mga koleksyon sa iyong MongoDB. Para dito, gamitin ang getIndexes() method kasama ang pangalan ng isang koleksyon sa iyong MongoDB shell screen. Hiwalay naming ginamit ang command na ito para sa mga koleksyon ng 'Test' at 'Dummy'. Ipinapakita nito ang lahat ng kinakailangang impormasyon tungkol sa mga built-in at tinukoy ng user na mga index sa iyong screen.
pagsubok> db.Test.getIndexes()pagsubok> db.Dummy.getIndexes()
Mga Drop Index:
Oras na para tanggalin ang mga index na dati nang ginawa para sa koleksyon gamit ang dropIndex() function kasama ang parehong field name kung saan inilapat ang index. Ang query sa ibaba ay nagpapakita na ang nag-iisang index ay inalis.
pagsubok> db.Dummy.dropIndex({type: 1 }) 
Sa parehong paraan, maaaring i-drop ang compound index.
test> db.Dummy.drop index({type: 1 , ay: 1 }) 
Konklusyon
Sa pamamagitan ng pagpapabilis sa pagkuha ng data mula sa MongoDB, ang pag-index ay mahalaga para sa pagpapahusay ng kahusayan ng mga query. Walang mga index, dapat hanapin ng MongoDB ang buong koleksyon para sa mga tugmang talaan, na nagiging hindi gaanong epektibo habang lumalaki ang laki ng set. Ang kakayahan ng MongoDB na mabilis na matuklasan ang mga tamang talaan gamit ang istraktura ng database ng index ay nagpapabilis sa pagproseso ng mga query kapag ginamit ang angkop na pag-index.