Indexering beheren voor de API voor MongoDB van Azure Cosmos DB

  • Artikel
  • 11 minuten om te lezen

VAN TOEPASSING OP: Azure Cosmos DB-API voor MongoDB

Azure Cosmos DB API voor MongoDB maakt gebruik van de belangrijkste mogelijkheden voor indexbeheer van Azure Cosmos DB. Dit artikel is gericht op het toevoegen van indexen met Azure Cosmos DB API voor MongoDB. Indexen zijn gespecialiseerde gegevensstructuren die het opvragen van uw gegevens ongeveer een orde van grootte sneller maken.

Indexeren voor MongoDB-serverversie 3.6 en hoger

Azure Cosmos DB API voor MongoDB-serverversie 3.6+ indexeert automatisch het veld en de _id shardsleutel (alleen in shard-verzamelingen). De API dwingt automatisch de uniekheid van het _id veld per shardsleutel af.

De API voor MongoDB gedraagt zich anders dan Azure Cosmos DB SQL API, waarmee standaard alle velden worden geïndexeerd.

Indexeringsbeleid bewerken

We raden u aan uw indexeringsbeleid te bewerken in Data Explorer binnen de Azure Portal. . U kunt indexen met één veld en jokertekens toevoegen vanuit de editor voor indexeringsbeleid in de Data Explorer:

Indexeringsbeleidseditor

Notitie

U kunt geen samengestelde indexen maken met behulp van de editor voor indexeringsbeleid in de Data Explorer.

Indextypen

Eén veld

U kunt indexen maken voor elk veld. De sorteer volgorde van de index met één veld is niet van belang. Met de volgende opdracht maakt u een index op het veld name :

db.coll.createIndex({name:1})

U kunt dezelfde index met één veld maken name in de Azure Portal:

Naamindex toevoegen in indexeringsbeleidseditor

Eén query maakt gebruik van meerdere indexen met één veld, indien beschikbaar. U kunt maximaal 500 indexen met één veld per verzameling maken.

Samengestelde indexen (MongoDB-serverversie 3.6+)

In de API voor MongoDB zijn samengestelde indexen vereist als uw query de mogelijkheid nodig heeft om op meerdere velden tegelijk te sorteren. Voor query's met meerdere filters die niet hoeven te worden gesorteerd, maakt u meerdere indexen met één veld in plaats van een samengestelde index om te besparen op indexeringskosten.

Een samengestelde index of indexen met één veld voor elk veld in de samengestelde index resulteren in dezelfde prestaties voor het filteren in query's.

Notitie

U kunt geen samengestelde indexen maken voor geneste eigenschappen of matrices.

Met de volgende opdracht maakt u een samengestelde index op de velden name en age :

db.coll.createIndex({name:1,age:1})

U kunt samengestelde indexen gebruiken om efficiënt te sorteren op meerdere velden tegelijk, zoals wordt weergegeven in het volgende voorbeeld:

db.coll.find().sort({name:1,age:1})

U kunt ook de voorgaande samengestelde index gebruiken om efficiënt te sorteren op een query met de tegenovergestelde sorteerorde op alle velden. Hier volgt een voorbeeld:

db.coll.find().sort({name:-1,age:-1})

De volgorde van de paden in de samengestelde index moet echter exact overeenkomen met de query. Hier is een voorbeeld van een query waarvoor een extra samengestelde index nodig is:

db.coll.find().sort({age:1,name:1})

Notitie

Samengestelde indexen worden alleen gebruikt in query's waarmee resultaten worden gesorteerd. Voor query's met meerdere filters die niet hoeven te worden gesorteerd, maakt u indexen met één veld met meerdere velden.

Indexen met meerdere sleutels

Azure Cosmos DB maakt indexen met meerdere sleutels om inhoud te indexeren die is opgeslagen in matrices. Als u een veld indexeert met een matrixwaarde, Azure Cosmos DB elk element in de matrix automatisch geïndexeerd.

Georuimtelijke indexen

Veel georuimtelijke operators profiteren van georuimtelijke indexen. Momenteel ondersteunt Azure Cosmos DB API voor MongoDB 2dsphere indexen. De API biedt nog geen ondersteuning voor 2d indexen.

Hier is een voorbeeld van het maken van een georuimtelijke index in het location veld:

db.coll.createIndex({ location : "2dsphere" })

Tekstindexen

Azure Cosmos DB API voor MongoDB biedt momenteel geen ondersteuning voor tekstindexen. Voor tekstzoekquery's op tekenreeksen moet u een Azure Cognitive Search met Azure Cosmos DB.

Jokertekenindexen

U kunt jokertekenindexen gebruiken om query's op onbekende velden te ondersteunen. Stel dat u een verzameling hebt die gegevens over families bevat.

Hier is een deel van een voorbeelddocument in die verzameling:

"children": [
   {
     "firstName": "Henriette Thaulow",
     "grade": "5"
   }
]

Hier is nog een voorbeeld, dit keer met een iets andere set eigenschappen in children :

"children": [
    {
     "familyName": "Merriam",
     "givenName": "Jesse",
     "pets": [
         { "givenName": "Goofy" },
         { "givenName": "Shadow" }
         ]
   },
   {
     "familyName": "Merriam",
     "givenName": "John",
   }
]

In deze verzameling kunnen documenten veel verschillende eigenschappen hebben. Als u alle gegevens in de matrix wilt indexeren, hebt u twee opties: afzonderlijke indexen maken voor elke afzonderlijke eigenschap of één index met children jokertekens maken voor de hele children matrix.

Een index met jokertekens maken

Met de volgende opdracht maakt u een index met jokertekens voor alle eigenschappen in children :

db.coll.createIndex({"children.$**" : 1})

In tegenstelling tot in MongoDB kunnen jokertekenindexen meerdere velden in querypredicaten ondersteunen. Er is geen verschil in queryprestaties als u één index met jokertekens gebruikt in plaats van een afzonderlijke index voor elke eigenschap te maken.

U kunt de volgende indextypen maken met behulp van een jokertekensyntaxis:

  • Eén veld
  • Georuimtelijk

Alle eigenschappen indexeren

U kunt als volgende een index met jokertekens maken voor alle velden:

db.coll.createIndex( { "$**" : 1 } )

U kunt ook jokertekenindexen maken met behulp van de Data Explorer in de Azure Portal:

Index met jokertekens toevoegen in de editor voor indexeringsbeleid

Notitie

Als u nog maar net begint met ontwikkelen, raden we u ten zeerste aan om te beginnen met een index met jokertekens voor alle velden. Dit kan de ontwikkeling vereenvoudigen en het eenvoudiger maken om query's te optimaliseren.

Voor documenten met veel velden kunnen hoge RU-kosten (Request Unit) in rekening worden brengen voor schrijf- en updates. Als u dus een schrijfbelasting hebt, moet u ervoor kiezen om afzonderlijke indexpaden te gebruiken in plaats van indexen met jokertekens.

Beperkingen

Jokertekenindexen bieden geen ondersteuning voor een van de volgende indextypen of eigenschappen:

  • Samenstelling
  • TTL
  • Uniek

In tegenstelling tot in MongoDB kunt u in Azure Cosmos DB API voor MongoDB geen jokertekenindexen gebruiken voor:

  • Een jokertekenindex maken die meerdere specifieke velden bevat

    db.coll.createIndex(
    { "$**" : 1 },
    { "wildcardProjection " :
        {
           "children.givenName" : 1,
           "children.grade" : 1
        }
    }
)

  • Een jokertekenindex maken die geen meerdere specifieke velden bevat

    db.coll.createIndex(
    { "$**" : 1 },
    { "wildcardProjection" :
        {
           "children.givenName" : 0,
           "children.grade" : 0
        }
    }
)

Als alternatief kunt u meerdere jokertekenindexen maken.

Indexeigenschappen

De volgende bewerkingen zijn gebruikelijk voor accounts die wire-protocolversie 4.0 en accounts met eerdere versies bedienen. Meer informatie over ondersteunde indexen en geïndexeerde eigenschappen.

Unieke indexen

Unieke indexen zijn handig om af te afdwingen dat twee of meer documenten niet dezelfde waarde voor geïndexeerde velden bevatten.

Belangrijk

Unieke indexen kunnen alleen worden gemaakt wanneer de verzameling leeg is (bevat geen documenten).

Met de volgende opdracht maakt u een unieke index in het veld student_id :

globaldb:PRIMARY> db.coll.createIndex( { "student_id" : 1 }, {unique:true} )
{
    "_t" : "CreateIndexesResponse",
    "ok" : 1,
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 1,
    "numIndexesAfter" : 4
}

Voor shard-verzamelingen moet u de shardsleutel (partitiesleutel) verstrekken om een unieke index te maken. In andere woorden, alle unieke indexen voor een shard-verzameling zijn samengestelde indexen waarbij een van de velden de partitiesleutel is.

Met de volgende opdrachten maakt u een shardverzameling (de shardsleutel is ) met een coll unieke index voor de velden en university student_id university :

globaldb:PRIMARY> db.runCommand({shardCollection: db.coll._fullName, key: { university: "hashed"}});
{
    "_t" : "ShardCollectionResponse",
    "ok" : 1,
    "collectionsharded" : "test.coll"
}
globaldb:PRIMARY> db.coll.createIndex( { "university" : 1, "student_id" : 1 }, {unique:true});
{
    "_t" : "CreateIndexesResponse",
    "ok" : 1,
    "createdCollectionAutomatically" : false,
    "numIndexesBefore" : 3,
    "numIndexesAfter" : 4
}

In het voorgaande voorbeeld retourneert het weglaten van "university":1 de -component een fout met het volgende bericht:

kan geen unieke index maken over {student_id : 1,0} met shardsleutelpatroon { universiteit : 1,0 }

TTL indexen

Als u de vervaldatum van documenten in een bepaalde verzameling wilt inschakelen, moet u een TTL-index (time-to-live) maken. Een TTL-index is een index in _ts het veld met een expireAfterSeconds waarde.

Voorbeeld:

globaldb:PRIMARY> db.coll.createIndex({"_ts":1}, {expireAfterSeconds: 10})

De voorgaande opdracht verwijdert alle documenten in de verzameling die niet db.coll zijn gewijzigd in de afgelopen 10 seconden.

Notitie

Het _ts veld is specifiek voor Azure Cosmos DB en is niet toegankelijk vanaf MongoDB-clients. Het is een gereserveerde eigenschap (systeem) die het tijdstempel bevat van de laatste wijziging van het document.

Voortgang van index bijhouden

Versie 3.6+ van Azure Cosmos DB API voor MongoDB ondersteunt de opdracht om de voortgang van de index op een currentOp() database-exemplaar bij te houden. Deze opdracht retourneert een document dat informatie bevat over bewerkingen die worden uitgevoerd op een database-exemplaar. U gebruikt de currentOp opdracht om alle bewerkingen die worden uitgevoerd in native MongoDB bij te houden. In Azure Cosmos DB API voor MongoDB ondersteunt deze opdracht alleen het bijhouden van de indexbewerking.

Hier volgen enkele voorbeelden die laten zien hoe u de opdracht currentOp gebruikt om de voortgang van de index bij te houden:

  • De voortgang van de index voor een verzameling ophalen:

    db.currentOp({"command.createIndexes": <collectionName>, "command.$db": <databaseName>})

  • De voortgang van de index voor alle verzamelingen in een database ophalen:

    db.currentOp({"command.$db": <databaseName>})

  • De voortgang van de index ophalen voor alle databases en verzamelingen in een Azure Cosmos-account:

    db.currentOp({"command.createIndexes": { $exists : true } })

Voorbeelden van uitvoer van de voortgang van de index

De voortgangsdetails van de index geven het voortgangspercentage voor de huidige indexbewerking weer. Hier ziet u een voorbeeld van de indeling van het uitvoerdocument voor verschillende fasen van de voortgang van de index:

  • Een indexbewerking voor een foo-verzameling en staafdatabase die voor 60 procent is voltooid, heeft het volgende uitvoerdocument. Het Inprog[0].progress.total veld geeft 100 weer als het doel voltooiingspercentage.

    {
      "inprog" : [
      {
              ………………...
              "command" : {
                      "createIndexes" : foo
                      "indexes" :[ ],
                      "$db" : bar
              },
              "msg" : "Index Build (background) Index Build (background): 60 %",
              "progress" : {
                      "done" : 60,
                      "total" : 100
              },
              …………..…..
      }
      ],
      "ok" : 1
}

  • Als een indexbewerking net is gestart op een foo-verzameling en staafdatabase, kan het uitvoerdocument een voortgang van 0 procent tonen totdat het een meetbaar niveau bereikt.

    {
      "inprog" : [
      {
              ………………...
              "command" : {
                      "createIndexes" : foo
                      "indexes" :[ ],
                      "$db" : bar
              },
              "msg" : "Index Build (background) Index Build (background): 0 %",
              "progress" : {
                      "done" : 0,
                      "total" : 100
              },
              …………..…..
      }
      ],
     "ok" : 1
}

  • Wanneer de indexbewerking wordt uitgevoerd, worden in het uitvoerdocument lege bewerkingen inprog weer geven.

    {
    "inprog" : [],
    "ok" : 1
}

Updates van achtergrondindexen

Indexupdates worden altijd op de achtergrond uitgevoerd, ongeacht de waarde die is opgegeven voor de index-eigenschap Achtergrond. Omdat indexupdates aanvraageenheden (AANVRAAGeenheden) met een lagere prioriteit gebruiken dan andere databasebewerkingen, leiden indexwijzigingen niet tot downtime voor schrijfbewerkingen, updates of verwijderen.

Het toevoegen van een nieuwe index heeft geen invloed op de leesbeschikbaarheid. Query's maken alleen gebruik van nieuwe indexen zodra de indextransformatie is voltooid. Tijdens de indextransformatie blijft de query-engine bestaande indexen gebruiken, zodat u vergelijkbare leesprestaties zult zien tijdens de indexeringstransformatie, zoals u hebt gezien voordat u de indexeringswijziging initieert. Wanneer u nieuwe indexen toevoegt, is er ook geen risico op onvolledige of inconsistente queryresultaten.

Bij het verwijderen van indexen en het onmiddellijk uitvoeren van query's hebben de filters op de verwijderde indexen, kunnen de resultaten inconsistent en onvolledig zijn totdat de indextransformatie is voltooid. Als u indexen verwijdert, biedt de query-engine geen consistente of volledige resultaten wanneer query's filteren op deze zojuist verwijderde indexen. De meeste ontwikkelaars verwijderen geen indexen en proberen er onmiddellijk query's op uit te voeren, zodat deze situatie in de praktijk onwaarschijnlijk is.

Notitie

U kunt de voortgang van de index volgen.

Opdracht ReIndex

Met reIndex de opdracht worden alle indexen voor een verzameling opnieuw gemaakt. In sommige zeldzame gevallen kunnen queryprestaties of andere indexproblemen in uw verzameling worden opgelost door de opdracht uit te reIndex voeren. Als u problemen ondervindt met indexeren, is het opnieuw maken van de indexen met de opdracht reIndex een aanbevolen aanpak.

U kunt de opdracht reIndex uitvoeren met de volgende syntaxis:

db.runCommand({ reIndex: <collection> })

U kunt de onderstaande syntaxis gebruiken om te controleren of het uitvoeren van de reIndex opdracht de queryprestaties in uw verzameling verbetert:

db.runCommand({"customAction":"GetCollection",collection:<collection>, showIndexes:true})

Voorbeelduitvoer:

{
        "database" : "myDB",
        "collection" : "myCollection",
        "provisionedThroughput" : 400,
        "indexes" : [
                {
                        "v" : 1,
                        "key" : {
                                "_id" : 1
                        },
                        "name" : "_id_",
                        "ns" : "myDB.myCollection",
                        "requiresReIndex" : true
                },
                {
                        "v" : 1,
                        "key" : {
                                "b.$**" : 1
                        },
                        "name" : "b.$**_1",
                        "ns" : "myDB.myCollection",
                        "requiresReIndex" : true
                }
        ],
        "ok" : 1
}

Als reIndex de queryprestaties verbetert, is requiresReIndex waar. Als reIndex de queryprestaties niet worden verbeterd, wordt deze eigenschap weggelaten.

Verzamelingen migreren met indexen

Op dit moment kunt u alleen unieke indexen maken wanneer de verzameling geen documenten bevat. Populaire Hulpprogramma's voor MongoDB-migratie proberen de unieke indexen te maken na het importeren van de gegevens. Als u dit probleem wilt omzeilen, kunt u handmatig de bijbehorende verzamelingen en unieke indexen maken in plaats van dat het hulpprogramma voor migratie het kan proberen. (U kunt dit gedrag voor bereiken mongorestore door de vlag in de --noIndexRestore opdrachtregel te gebruiken.)

Indexeren voor MongoDB versie 3.2

De beschikbare indexeringsfuncties en standaardinstellingen verschillen voor Azure Cosmos-accounts die compatibel zijn met versie 3.2 van het MongoDB-wire-protocol. U kunt de versie van uw account controleren en upgraden naar versie 3.6.

Als u versie 3.2 gebruikt, worden in deze sectie de belangrijkste verschillen met versie 3.6+ beschreven.

Standaardindexen laten vallen (versie 3.2)

In tegenstelling tot de 3.6+-versies van de API van Azure Cosmos DB voor MongoDB, indexeert versie 3.2 standaard elke eigenschap. U kunt de volgende opdracht gebruiken om deze standaardindexen voor een verzameling () te coll laten vallen:

> db.coll.dropIndexes()
{ "_t" : "DropIndexesResponse", "ok" : 1, "nIndexesWas" : 3 }

Nadat u de standaardindexen hebt laten vallen, kunt u meer indexen toevoegen zoals in versie 3.6+.

Samengestelde indexen (versie 3.2)

Samengestelde indexen bevatten verwijzingen naar meerdere velden van een document. Als u een samengestelde index wilt maken, moet u een upgrade uitvoeren naar versie 3.6 of 4.0.

Jokertekenindexen (versie 3.2)

Als u een jokertekenindex wilt maken, moet u een upgrade uitvoeren naar versie 4.0 of 3.6.

Volgende stappen