Documenten beheren in MongoDB

Inleiding

Wanneer u MongoDB gebruikt, besteedt u het grootste deel van uw tijd aan het op de een of andere manier beheren van documenten. Of u nu nieuwe documenten maakt en aan collecties toevoegt, documenten ophaalt, gegevens bijwerkt of verouderde items opruimt, documenten staan ​​centraal in het MongoDB-model.

In deze handleiding bespreken we wat MongoDB-documenten zijn en vervolgens de algemene bewerkingen die u waarschijnlijk moet weten om een ​​documentgerichte omgeving te beheren.

Wat zijn MongoDB-documenten?

In MongoDB worden alle gegevens binnen databases en collecties opgeslagen in documenten. Aangezien collecties standaard geen vereist schema specificeren, kunnen documenten binnen een collectie een willekeurig complexe structuur bevatten en hoeven ze niet overeen te komen met het formaat dat wordt gebruikt door verwante documenten. Dit biedt ongelooflijke flexibiliteit en zorgt ervoor dat het schema zich organisch kan ontwikkelen naarmate de applicatievereisten veranderen.

MongoDB-documenten gebruiken zelf het BSON-gegevensserialisatieformaat, een binaire weergave van de JSON JavaScript Object Notation. Dit zorgt voor een georganiseerde structuur met gedefinieerde gegevenstypen die programmatisch kunnen worden opgevraagd en bewerkt.

BSON-documenten worden weergegeven door een paar accolades ({} ) die sleutel-waardeparen bevatten. In BSON staan ​​deze gegevenskoppelingen bekend als het veld en de waarde . Het veld komt eerst en wordt weergegeven door een string. De waarde kan elk geldig BSON-gegevenstype zijn. Een dubbele punt (: ) scheidt het veld van zijn waarde. Een komma wordt gebruikt om elk veld en waardepaar van elkaar te scheiden.

Als voorbeeld is hier een geldig BSON-document dat MongoDB kan begrijpen:

{    _id: 80380,    vehicle_type: "car",    mileage: 7377.80,    color: "blue",    markets: [        "US",        "UK"    ],    options: {        transmission: "automatic",        num_doors: 4,        power_windows: true    }}
 

Hier kunnen we nogal wat soorten zien:

• _id is een geheel getal
• vehicle_type en color zijn strings
• mileage is een vlotter
• markets is een array van strings
• options bevat een genest document met waarden bestaande uit een tekenreeks, een geheel getal en een boolean

Door deze flexibiliteit zijn documenten een vrij flexibel medium voor het opslaan van gegevens. Nieuwe velden kunnen eenvoudig worden toegevoegd, documenten kunnen in elkaar worden ingesloten en de structurele complexiteit komt exact overeen met de gegevens die worden opgeslagen.

Nieuwe documenten maken

Als u een nieuw document wilt maken, gaat u naar een database waarin u het gemaakte document wilt opslaan. We gebruiken een school database voor demonstratiedoeleinden in dit artikel:

use school
 

U wilt ook de verzameling kiezen waar u de documenten wilt invoegen. Net als bij databases hoeft u niet expliciet de collectie te maken waarin u het document wilt invoegen. MongoDB maakt het automatisch aan wanneer de eerste gegevens worden geschreven. Voor dit voorbeeld gebruiken we een verzameling genaamd students .

Nu u weet waar het document zal worden opgeslagen, kunt u een nieuw document invoegen met een van de volgende methoden.

De insert() gebruiken methode

De insert() methode stelt u in staat om een ​​of meer documenten in te voegen in de collectie die wordt aangeroepen.

Om een ​​enkel document in te voegen, geeft u het document door aan de methode door het op de verzameling aan te roepen. Hier voegen we een nieuw document in voor een student genaamd Ashley:

db.students.insert(    {        first_name: "Ashley",        last_name: "Jenkins",        dob: new Date("January 08, 2003"),        grade_level: 8    })
 

WriteResult({ "nInserted" : 1 })
 

Als u meer dan één document tegelijk wilt invoegen, in plaats van een document door te geven aan insert() , een reeks documenten doorgeven. We kunnen twee nieuwe documenten toevoegen voor studenten genaamd Brian en Leah:

db.students.insert(    [        {            first_name: "Brian",            last_name: "McMantis",            dob: new Date("September 18, 2010"),            grade_level: 2        },        {            first_name: "Leah",            last_name: "Drake",            dob: new Date("October 03, 2009")        }    ])
 

BulkWriteResult({        "writeErrors" : [ ],        "writeConcernErrors" : [ ],        "nInserted" : 2,        "nUpserted" : 0,        "nMatched" : 0,        "nModified" : 0,        "nRemoved" : 0,        "upserted" : [ ]})
 

Omdat we een bulkschrijfbewerking hebben uitgevoerd, is onze retourwaarde een BulkWriteResult in plaats van de WriteResult object dat we eerder zagen.

Terwijl de insert() methode flexibel is, is het in veel MongoDB-stuurprogramma's verouderd ten gunste van de volgende twee methoden.

De insertOne() gebruiken methode

De insertOne() methode kan worden gebruikt om een ​​enkel document in te voegen. In tegenstelling tot de insert() methode, kan het slechts één document tegelijk invoegen, wat het gedrag een beetje voorspelbaarder maakt.

De syntaxis is hetzelfde als wanneer u insert() . gebruikt om één document toe te voegen. We kunnen nog een leerling toevoegen met de naam Naomi:

db.students.insertOne(    {        first_name: "Naomi",        last_name: "Pyani"    })
 

{        "acknowledged" : true,        "insertedId" : ObjectId("60e877914655cbf49ff7cb86")}
 

In tegenstelling tot insert() , de insertOne() methode retourneert een document met wat aanvullende nuttige informatie. Het bevestigt dat het schrijven is bevestigd door het cluster en bevat de object-ID die aan het document is toegewezen, aangezien we er geen hebben verstrekt.

De insertMany() gebruiken methode

Om scenario's te dekken waarin u meerdere documenten tegelijk wilt invoegen, gebruikt u de insertMany() methode wordt nu aanbevolen. Net als bij het invoegen van meerdere documenten met insert() , insertMany() neemt een reeks documenten in beslag.

We kunnen drie nieuwe studenten toevoegen met de namen Jasmine, Michael en Toni:

db.students.insertMany(    [        {            first_name: "Jasmine",            last_name: "Took",            dob: new Date("April 11, 2011")        },        {            first_name: "Michael",            last_name: "Rodgers",            dob: new Date("February 25, 2008"),            grade_level: 6        },        {            first_name: "Toni",            last_name: "Fowler"        }    ])
 

{        "acknowledged" : true,        "insertedIds" : [                ObjectId("60e8792d4655cbf49ff7cb87"),                ObjectId("60e8792d4655cbf49ff7cb88"),                ObjectId("60e8792d4655cbf49ff7cb89")        ]}
 

Net als bij insertOne() , insertMany() retourneert een document dat het schrijven bevestigt en een array biedt met de ID's die zijn toegewezen aan de ingevoegde documenten.

Zoeken naar bestaande documenten

Het opvragen van documenten is een vrij uitgebreid onderwerp dat een eigen artikel verdient. U kunt details vinden over het formuleren van query's om verschillende soorten documenten op te halen in onze gids over het opvragen van gegevens binnen MongoDB.

Hoewel de details het beste kunnen worden achtergelaten in het artikel waarnaar hierboven is gelinkt, kunnen we in ieder geval de methoden behandelen die MongoDB biedt om documenten op te vragen. De belangrijkste manier om documenten op te halen van MongoDB is door de find() . aan te roepen methode op de betreffende collectie.

Om bijvoorbeeld alle documenten van de students . te verzamelen , kunt u find() . aanroepen zonder argumenten:

db.students.find()
 

{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb85"), "first_name" : "Leah", "last_name" : "Drake", "dob" : ISODate("2009-10-03T00:00:00Z") }{ "_id" : ObjectId("60e877914655cbf49ff7cb86"), "first_name" : "Naomi", "last_name" : "Pyani" }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb87"), "first_name" : "Jasmine", "last_name" : "Took", "dob" : ISODate("2011-04-11T00:00:00Z") }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

Om de uitvoer leesbaarder te maken, kunt u ook de pretty() . koppelen methode na find() :

db.<collection>.find().pretty()
 

{        "_id" : ObjectId("60e8743b4655cbf49ff7cb83"),        "first_name" : "Ashley",        "last_name" : "Jenkins",        "dob" : ISODate("2003-01-08T00:00:00Z"),        "grade_level" : 8}{        "_id" : ObjectId("60e875d54655cbf49ff7cb84"),        "first_name" : "Brian",        "last_name" : "McMantis",        "dob" : ISODate("2010-09-18T00:00:00Z"),        "grade_level" : 2}{        "_id" : ObjectId("60e875d54655cbf49ff7cb85"),        "first_name" : "Leah",        "last_name" : "Drake",        "dob" : ISODate("2009-10-03T00:00:00Z")}{        "_id" : ObjectId("60e877914655cbf49ff7cb86"),        "first_name" : "Naomi",        "last_name" : "Pyani"}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb87"),        "first_name" : "Jasmine",        "last_name" : "Took",        "dob" : ISODate("2011-04-11T00:00:00Z")}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb88"),        "first_name" : "Michael",        "last_name" : "Rodgers",        "dob" : ISODate("2008-02-25T00:00:00Z"),       "grade_level" : 6}{        "_id" : ObjectId("60e8792d4655cbf49ff7cb89"),        "first_name" : "Toni",        "last_name" : "Fowler"}
 

Je kunt zien dat een _id veld is toegevoegd aan elk van de documenten. MongoDB vereist een unieke _id voor elk document in een verzameling. Als u er geen opgeeft bij het maken van een object, wordt er een voor u toegevoegd. U kunt deze ID gebruiken om een ​​enkel object betrouwbaar op te halen:

db.students.find(    {        _id : ObjectId("60e8792d4655cbf49ff7cb89")    })
 

{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler" }
 

U kunt meer te weten komen over verschillende manieren om gegevens op te vragen in het artikel dat hierboven is gelinkt.

Bestaande documenten bijwerken

Veel of de meeste gebruiksscenario's voor databases vereisen dat u bestaande gegevens in de database kunt wijzigen. Een veld moet mogelijk worden bijgewerkt om een ​​nieuwe waarde weer te geven of u moet mogelijk aanvullende informatie aan een bestaand document toevoegen zodra dit beschikbaar komt.

MongoDB gebruikt een aantal gerelateerde methoden om bestaande documenten bij te werken:

• updateOne() :werkt een enkel document binnen een verzameling bij op basis van het verstrekte filter.
• updateMany() :werkt meerdere documenten binnen een verzameling bij die overeenkomen met het opgegeven filter.
• replaceOne() :Vervangt een heel document in een verzameling op basis van het verstrekte filter.

We zullen bespreken hoe je elk van deze varianten kunt gebruiken om verschillende soorten updates uit te voeren.

operators bijwerken

Voordat we elk van de methoden bekijken om documenten bij te werken, moeten we enkele van de beschikbare update-operators doornemen.

• $currentDate :Stelt de waarde van een veld in op de huidige datum, hetzij als datum- of tijdstempeltype.
  • Syntaxis:{ $currentDate: { <field>: <type>, ... } }
• $inc :Verhoogt de waarde van een veld met een vast bedrag.
  • Syntaxis:{ $inc: { <field>: <amount>, ... } }
• $min :werkt de waarde van een veld bij als de opgegeven waarde kleiner is dan de huidige waarde.
  • Syntaxis:{ $min: { <field>: <value>, ... } }
• $max :werkt de waarde van een veld bij als de opgegeven waarde groter is dan de huidige waarde.
  • Syntaxis:{ $max: { <field>: <value>, ... } }
• $mul :werkt de waarde van een veld bij door deze te vermenigvuldigen met het opgegeven getal.
  • Syntaxis:{ $mul: { <field>: <value>, ... } }
• $rename :hernoemt een veldnaam naar een nieuwe identifier.
  • Syntaxis:{ $rename: { <field>: <new_name>, ... } }
• $set :Vervangt de waarde van een veld door de gegeven waarde.
  • Syntaxis:{ $set: { <field>: value, ... } }
• $setOnInsert :Stelt tijdens upsert-bewerkingen de waarde van een veld in als een nieuw document wordt gemaakt en doet niets anders.
  • Syntaxis:{ $setOnInsert: { <field>: <value>, ... } }
• $unset :Verwijdert een veld uit het document.
  • Syntaxis:{ $unset: { <field>: "", ... } }
• $ :Een tijdelijke aanduiding voor het eerste array-element dat voldoet aan de query.
  • Syntaxis:{ <update_operator>: {<array>.$: <value> } }
• $[] :Een tijdelijke aanduiding voor alle array-elementen die voldoen aan de query.
  • Syntaxis:{ <update_operator>: { <array>.$[]: <value> } }
• $addToSet :Voegt waarden toe aan de array, tenzij ze al aanwezig zijn.
  • Syntaxis:{ $addToSet: { <field>: <value>, ... } }
• $pop :Verwijdert het eerste of laatste element van een array.
  • Syntaxis:{ $pop: { <field>: (-1 or 1), ... } }
• $pull :Verwijdert alle elementen van een array die overeenkomen met een voorwaarde.
  • Syntaxis:{ $pull: { <field>: <condition>, ... } }
• $push :Voegt een waarde toe aan een array.
  • Syntaxis:{ $push: { <field>: <value>, ... } }
• $pullAll :Verwijdert alle gespecificeerde elementen uit een array.
  • Syntaxis:{ $pullAll: { <field>: [ <value>, ... ], ...} }
• $each :Wijzigt $addToSet en $push operators zodat ze elk element van een array toevoegen in plaats van een array als een enkel element.
  • Syntaxis:{ <update_operator>: { <field>: { $each: [ <value>, ... ] }, ... } }
• $position :Gebruikt met $each en specificeert de positie van de $push operator moet at.
  . invoegen
  • Syntaxis:{ $push: { <field>: { $each: [ <value>, ... ], $position: <num> } } }
• $slice :Gebruikt met $each en $push om het aantal totale elementen in de array te beperken.
  • Syntaxis:{ $push: { <field>: { $each: [ <value>, ... ], $slice: <num> } } }
• $sort :Gebruikt met $each en $push om array-elementen te sorteren.
  • Syntaxis:{ $push: { <field>: { $each: [ <value>, ... ], $sort: <sort_order> } } }

Met deze verschillende update-operators kunt u verschillende velden van uw documenten op verschillende manieren bijwerken.

Een enkel document in een verzameling bijwerken

MongoDB's updateOne() methode wordt gebruikt om een ​​enkel document binnen een collectie bij te werken. De methode heeft twee vereiste argumenten nodig, evenals een document waarin optionele argumenten worden gespecificeerd.

Het eerste argument is een document dat de filtervoorwaarden specificeert die zullen worden gebruikt om documenten te selecteren. Sinds de updateOne() methode maximaal één document in een verzameling wijzigt, wordt het eerste document gebruikt dat aan de filtervoorwaarden voldoet.

Het tweede argument specificeert de update-bewerking die moet worden uitgevoerd. De hierboven gegeven update-bewerkingen kunnen hier worden gespecificeerd om de inhoud van het overeenkomende document te wijzigen.

Het derde argument is een document met verschillende opties om het gedrag van de methode te wijzigen. De belangrijkste potentiële waarden zijn:

• upsert :verandert de bewerking in een upsert-procedure door een nieuw document in te voegen als het filter niet overeenkomt met bestaande documenten.
• collation :Een document dat taalspecifieke regels definieert die van toepassing zijn op de operatie.

We kunnen bijvoorbeeld een enkele leerlingrecord bijwerken die we filteren op de _id veld om ervoor te zorgen dat we het juiste document targeten. We kunnen het grade_level . instellen naar een nieuwe waarde:

db.students.updateOne(    { _id: ObjectId("60e8792d4655cbf49ff7cb89") },    { $set: { grade_level: 3 } })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

Meerdere documenten in een verzameling bijwerken

MongoDB's updateMany() methode werkt vergelijkbaar met de updateOne() methode, maar werkt in plaats daarvan elk document bij dat overeenkomt met het gegeven filter in plaats van te stoppen na de eerste overeenkomst.

De updateMany() syntaxis volgt exact de updateOne() syntaxis, dus het enige verschil is de reikwijdte van de bewerking.

Als we bijvoorbeeld alle instanties van "compositie" willen veranderen in "schrijven" in de subjects array in onze teachers incassodocumenten, zouden we zoiets als dit kunnen gebruiken:

db.teachers.updateMany(    { subject: "composition" },    { $set: { "subjects.$": "writing" } })
 

{ "acknowledged" : true, "matchedCount" : 3, "modifiedCount" : 3 }
 

Als u de documenten controleert, had elke instantie van "compositie" vervangen moeten worden door "schrijven":

db.teachers.find()
 

{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Nancy", "last_name" : "Smith", "subjects" : [ "vocabulary", "pronunciation" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }
 

Een document vervangen

De replaceOne() methode werkt vergelijkbaar met de updateOne() methode, maar vervangt het hele document in plaats van afzonderlijke velden bij te werken. De syntaxis is hetzelfde als de vorige twee opdrachten.

Als Nancy Smith bijvoorbeeld uw school verlaat en u vervangt haar door een lerares genaamd Clara Newman die literatuur doceert, kunt u het volgende typen:

db.teachers.replaceOne(    {        $and: [             { first_name: "Nancy" },            { last_name: "Smith" }        ]    },    {        first_name: "Clara",        last_name: "Newman",        subjects: [ "literature" ]    })
 

{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
 

U kunt zien dat het overeenkomende document is verwijderd en dat het door het opgegeven document is vervangen:

db.teachers.find()
 

{ "_id" : ObjectId("60eddca65eb74f5c676f3baa"), "first_name" : "Clara", "last_name" : "Newman", "subjects" : [ "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bab"), "first_name" : "Ronald", "last_name" : "Taft", "subjects" : [ "literature", "grammar", "writing" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bac"), "first_name" : "Casey", "last_name" : "Meyers", "subjects" : [ "literature", "writing", "grammar" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bad"), "first_name" : "Rebecca", "last_name" : "Carrie", "subjects" : [ "grammar", "literature" ] }{ "_id" : ObjectId("60eddca65eb74f5c676f3bae"), "first_name" : "Sophie", "last_name" : "Daggs", "subjects" : [ "literature", "writing", "grammar", "vocabulary", "pronunciation" ] }
 

Hoe documenten te verwijderen

Het verwijderen van documenten uit collecties maakt ook deel uit van de documentlevenscyclus. Om een ​​document te verwijderen, kunt u de deleteOne() . gebruiken of deleteMany() methoden. Ze hebben dezelfde syntaxis en verschillen alleen in het aantal documenten waarop ze werken.

Voor het grootste deel is alles wat u hoeft te doen om documenten met een van deze methoden te verwijderen, het te voorzien van een filterdocument dat specificeert hoe u het te verwijderen document wilt selecteren. De deleteOne() methode zal maximaal één document verwijderen (ongeacht hoeveel overeenkomsten het filter produceert) terwijl de deleteMany() methode verwijdert elk document dat overeenkomt met de filtervoorwaarden.

Als u bijvoorbeeld één leerling wilt verwijderen, kunt u een _id . opgeven om ze expliciet te matchen:

db.students.deleteOne({    _id: ObjectId("60e8792d4655cbf49ff7cb87")})
 

{ "acknowledged" : true, "deletedCount" : 1 }
 

Als we een leerling willen verwijderen waaraan geen cijfer is toegewezen, kunnen we de deleteMany() gebruiken methode in plaats daarvan:

db.students.deleteMany({    grade_level: { $eq: null }})
 

{ "acknowledged" : true, "deletedCount" : 2 }
 

Als we dit controleren, zouden we moeten zien dat aan alle overige studenten een bepaald leerjaar is toegewezen:

db.students.find()
 

{ "_id" : ObjectId("60e8743b4655cbf49ff7cb83"), "first_name" : "Ashley", "last_name" : "Jenkins", "dob" : ISODate("2003-01-08T00:00:00Z"), "grade_level" : 8 }{ "_id" : ObjectId("60e875d54655cbf49ff7cb84"), "first_name" : "Brian", "last_name" : "McMantis", "dob" : ISODate("2010-09-18T00:00:00Z"), "grade_level" : 2 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb88"), "first_name" : "Michael", "last_name" : "Rodgers", "dob" : ISODate("2008-02-25T00:00:00Z"), "grade_level" : 6 }{ "_id" : ObjectId("60e8792d4655cbf49ff7cb89"), "first_name" : "Toni", "last_name" : "Fowler", "grade_level" : 3 }
 

Conclusie

Door te leren hoe u documenten kunt maken, opvragen, bijwerken en verwijderen, beschikt u over de vaardigheden die u nodig hebt om dagelijks effectief documenten binnen MongoDB te beheren. Door vertrouwd te raken met de verschillende document- en verzamelmethoden en de operators waarmee u informatie kunt matchen en wijzigen, kunt u complexe gedachten uitdrukken die het databasesysteem kan begrijpen.