Opret samling
Før vi bruger indekser, skal vi oprette en ny samling i vores MongoDB. Vi har allerede oprettet et og indsat 10 dokumenter med navnet 'Dummy'. Find() MongoDB-funktionen viser alle poster fra 'Dummy'-samlingen på MongoDB-skalskærmen nedenfor.
test> db.Dummy.find() 
Vælg Indekseringstype
Før du etablerer et indeks, skal du først bestemme de kolonner, der almindeligvis vil blive brugt i forespørgselskriterier. Indekser klarer sig godt på kolonner, der ofte filtreres, sorteres eller søges efter. Felter med en stor kardinalitet (mange forskellige værdier) er ofte fremragende indekseringsmuligheder. Her er nogle kodeeksempler for forskellige indekstyper.
Eksempel 01: Enkeltfeltindeks
Det er sandsynligvis den mest fundamentale type indeks, som indekserer en enkelt kolonne for at øge forespørgselshastigheden på den kolonne. Denne type indeks bruges til forespørgsler, hvor du bruger et enkelt nøglefelt til at forespørge samlingsposterne. Antag, at du bruger 'type'-feltet til at forespørge posterne i samlingen 'Dummy' i find-funktionen som nedenfor. Denne kommando ville se gennem hele samlingen, hvilket kan tage lang tid for store samlinger at behandle. Derfor er vi nødt til at optimere ydelsen af denne forespørgsel.
test> db.Dummy.find({type: 'emp' })
Optegnelserne fra Dummy-samlingen ovenfor er fundet ved at bruge 'type'-feltet, dvs. indeholdende en betingelse. Derfor kan enkeltnøgleindekset her bruges til at optimere søgeforespørgslen. Så vi vil bruge funktionen createIndex() i MongoDB til at oprette et indeks på 'type'-feltet i 'Dummy'-samlingen. Illustrationen af brugen af denne forespørgsel viser den vellykkede oprettelse af et enkeltnøgleindeks med navnet 'type_1' på skallen.
test> db.Dummy.createIndex({ type: 1 })Lad os bruge find()-forespørgslen, når den har opnået ved at bruge 'type'-feltet. Handlingen vil være væsentligt hurtigere nu end den tidligere brugte find()-funktion, da indekset er på plads, fordi MongoDB kan bruge indekset til hurtigt at hente posterne med den ønskede jobtitel.
test> db.Dummy.find({type: 'emp' })
Eksempel 02: Sammensat indeks
Vi ønsker måske at lede efter varer baseret på forskellige kriterier under visse omstændigheder. Implementering af et sammensat indeks for disse felter kan hjælpe med at forbedre forespørgselsydeevnen. Lad os sige, at du denne gang vil søge fra samlingen 'Dummy' ved hjælp af flere felter, der indeholder forskellige søgebetingelser, som forespørgslen vises. Denne forespørgsel har søgt efter poster fra samlingen, hvor 'type'-feltet er sat til 'emp', og 'sal'-feltet er større end 350.
Den logiske operator $gte er blevet brugt til at anvende betingelsen på 'sal'-feltet. Der blev i alt returneret to plader efter gennemsøgning af hele samlingen, som består af 10 poster.
test> db.Dummy.find({type: 'emp' , sal: {$gte: 350 } }) 
Lad os oprette et sammensat indeks for den førnævnte forespørgsel. Dette sammensatte indeks har 'type' og 'sal' felter. Tallene '1' og '-1' repræsenterer henholdsvis stigende og faldende rækkefølge for felterne 'type' og 'sal'. Rækkefølgen af det sammensatte indekss kolonner er vigtig og bør svare til forespørgselsmønstrene. MongoDB har givet navnet 'type_1_sal_-1' til dette sammensatte indeks som vist.
test> db.Dummy.createIndex({ type: 1 , vil:- 1 }) 
Efter at have brugt den samme find()-forespørgsel til at søge efter poster med 'type'-feltværdien som 'emp' og værdien af 'sal'-felt større end lig med 350, har vi opnået det samme output med en lille ændring i rækkefølgen sammenlignet med det tidligere forespørgselsresultat. Den større værdipost for 'sal'-feltet er nu på førstepladsen, mens den mindste er på den laveste i henhold til '-1' sat for 'sal'-feltet i det sammensatte indeks ovenfor.
test> db.Dummy.find({type: 'emp' , sal: {$gte: 350 } }) 
Eksempel 03: Tekstindeks
Nogle gange kan du støde på en situation, hvor du bør håndtere et stort datasæt, som store beskrivelser af produkter, ingredienser osv. Et tekstindeks kan være nyttigt til at udføre fuldtekstsøgninger i et stort tekstfelt. For eksempel har vi lavet en ny samling med navnet 'Test' i vores testdatabase. Indsatte i alt 6 poster i denne samling ved hjælp af funktionen insertMany() i henhold til find()-forespørgslen nedenfor.
test> db.Test.insertMany([{navn: 'Ana' , af: 'Hun bor i London og er en god lærer' },
{navn: 'Robert' , af: 'Han er sådan en fantastisk fodboldspiller' },
{navn: 'fra' , af: 'Rejser måske Dubai' },
{navn: 'Jacob' , af: 'Han er tankevækkende og rig.' },
{navn: 'Cillian' , af: 'En films superstart er lige blevet berømmelse på få sekunder' },
{navn: 'Ken' , af: 'Madelsker. Hun kan også spise dig.' }
])
Nu vil vi oprette et tekstindeks på 'Des'-feltet i denne samling, ved at anvende MongoDBs createIndex() funktion. Nøgleordet 'tekst' i feltværdien viser typen af et indeks, som er et 'tekst'-indeks. Indeksnavnet, des_text, er blevet autogenereret.
test> db.Test.createIndex({ des: 'tekst' })Nu er find()-funktionen blevet brugt til at udføre 'tekstsøgning' på samlingen via 'des_text'-indekset. $search-operatøren blev brugt til at søge efter ordet 'mad' i samlingsposterne og vise den pågældende post.
test> db.Test.find({ $text: { $search: 'mad' }}); 
Bekræft indekser:
Du kan kontrollere og liste ned alle de anvendte indekser for forskellige samlinger i din MongoDB. Til dette skal du bruge metoden getIndex() sammen med navnet på en samling på din MongoDB-skalskærm. Vi har brugt denne kommando separat til samlingerne 'Test' og 'Dummy'. Dette viser alle de nødvendige oplysninger vedrørende de indbyggede og brugerdefinerede indekser på din skærm.
test> db.Test.getIndex()test> db.Dummy.getIndex()
Drop-indekser:
Det er tid til at slette de indekser, der tidligere blev oprettet til samlingen ved hjælp af dropIndex()-funktionen sammen med det samme feltnavn, som indekset var blevet anvendt på. Nedenstående forespørgsel viser, at det enkelte indeks er blevet fjernet.
test> db.Dummy.dropIndex({type: 1 }) 
På samme måde kan det sammensatte indeks droppes.
test> db.Dummy.drop index({type: 1 , vil: 1 }) 
Konklusion
Ved at fremskynde hentning af data fra MongoDB er indeksering afgørende for at forbedre effektiviteten af forespørgsler. Manglende indekser skal MongoDB søge i hele samlingen efter matchende poster, hvilket bliver mindre effektivt, efterhånden som sættets størrelse øges. MongoDBs evne til hurtigt at opdage de rigtige poster ved at bruge indeksdatabasestrukturen fremskynder behandlingen af forespørgsler, når passende indeksering bruges.