Hur man utför CRUD-operationer i MongoDB

MongoDB ger sina användare möjligheten att skapa moderna databaser som är lättillgängliga och manipulerade.

MongoDB är en NoSQL-källkodsdatabas som är tillgänglig för användning i alla operativsystem.

Om du lärde dig databasdesign i skolan är chansen att du inte lärde dig att använda MongoDB eller fick mycket erfarenhet av NoSQL-databaser. Det är ingen överraskning - fram till 1998 hade många inte ens hört talas om NoSQL, och det var först 2009 som NoSQL-databaser började få dragkraft.

Vad är NoSQL?

Förkortningen SQL står för "strukturerat frågespråk." SQL används för att utföra matematiska operationer på data som finns i databaser som är styvt strukturerade av rader och kolumner (tabeller).

Akronymen NoSQL, beroende på vem du frågar, står för "inte bara SQL" eller "icke SQL." Men det faktum att alla kan komma överens om är att NoSQL används för att utföra operationer på data som finns i databaser som inte är strukturerade av rader och kolumner.

Det finns några NoSQL-databaser som existerar, men namnet som står ovanför resten är MongoDB. Faktum är att vissa tror att MongoDB är den enda databasen i sitt slag.

Vad är MongoDB?

NoSQL stöder fyra olika typer av databaser: dokument, nyckel-värdebutiker, kolumnorienterad och graf. MongoDB är en dokumentdatabas eftersom den lagrar data i ett JSON-liknande dokument, och som alla databaser stöder den alla viktiga CRUD-operationer.

Relaterad: Hur en MongoDB-databas bättre kan organisera dina data

Vad är CRUD-operationer?

Förkortningen CRUD står för "skapa, läsa, uppdatera och radera." CRUD representerar de fyra grundläggande funktionskraven i alla databaser. Om du använder en databas som inte tillåter dig att skapa, läsa, uppdatera eller ta bort poster, är det inte en databas.

Ladda ner MongoDB

Innan du kan utföra några CRUD-operationer i MongoDB måste du ladda ner och installera MongoDB på din enhet (eller använd en tillgänglig molnversion), kör MongoDB-servern, anslut till den och skapa slutligen en ny databas.

MongoDB-servern kan laddas ner från tjänstemannen MongoDB-webbplats.

Köra MongoDB-servern

Kör MongoDB-servern från din IDE-konsol.

/Users/Administrator/mongodb/bin/mongod.exe --dbpath = / Users / Administrator / mongodb-data

Koden ovan kör MongoDB-servern. Den första halvan ger den direkta sökvägen till den körbara filen MongoDB (mongod.exe) som är lagrad på din enhet. Sökvägen på din enhet ska vara annorlunda, men målet är att nå mongod.exe-filen i bin-mappen.

Den andra halvan av koden (som är åtskild av mellanslagstangenten) är en annan sökväg. Den här sökvägen leder till "mongodb-data", som är en fil som du måste skapa på egen hand. Den här filen innehåller alla data som skapas i vår databas.

Vår fil heter “mongodb-data”, men namnet kan vara vad du tycker är lämpligt.

Att köra ovanstående kod bör producera flera kodrader, men de två raderna som du måste ägna stor uppmärksamhet åt kan ses nedan:

{"t": {"$ date": "2021-04-14T18: 10: 11.779-05: 00"}, "s": "I", "c": "NÄTVERK", "id": 23015, "ctx": "lyssnare", "msg": "Lyssnar på", "attr": {"adress": "127.0.0.1"}}
{"t": {"$ date": "2021-04-14T18: 10: 11.797-05: 00"}, "s": "I", "c": "NÄTVERK", "id": 23016, "ctx": "lyssnare", "msg": "Väntar på anslutningar", "attr": {"port": 27017, "ssl": "off"}}

Dessa två rader innehåller localhost respektive standardporten på MongoDB-servern. Dessa två siffror behövs för att senare skapa en anslutning till MongoDB-servern så att vi kan utföra våra CRUD-operationer.

Utföra CRUD-operationer

Nu när vår MongoDB-server är igång kan vi ansluta till den (med lämplig drivrutin) och börja utföra CRUD-operationer. För den här artikeln skapar vi en enkel användardatabas som lagrar namn och ålder för våra användare.

Skapa en användare

Det finns två huvudsakliga sätt att infoga användare i en MongoDB-databas. Båda metoderna är ganska lika, men metoden du ska välja beror på antalet användare du vill skapa i en specifik instans. Om ditt mål är att skapa en användare bör du använda insertOne metod.

Men om målet är att skapa mer än en användare åt gången, då insertMany metoden är ett bättre alternativ.

MongoDB insertOne Method Exempel

// importera mongodb och använd förstörning för att få MongoClient-funktionen
const {MongoClient} = kräver ("mongodb");
// anslutnings-URL: n och databasen som vi tänker ansluta till
const connectionURL = 'mongodb: //127.0.0.1: 27017';
const databaseName = 'user-manager';
// använder anslutningsfunktionen på MongoClient för att ansluta till MongoDB-servern
MongoClient.connect (connectionURL, {useUnifiedTopology: true}, (error, client) => {
// kontrollera om anslutningen upprättades
om (fel) {
return console.log ('Det gick inte att ansluta till databasen');
}
// komma åt databasen för användarhanteraren
const db = client.db (databaseName);
// infoga en användare i databasen
db.collection ('användare'). insertOne ({
namn: 'John Doe',
ålder: '28'
}, (fel, resultat) => {
om (fel) {
return console.log ('kunde inte skapa användare');
}
console.log (result.ops);
})
})

Innan vi kan skapa några användare måste en anslutning upprättas med MongoDB-servern med hjälp av MongoDB-drivrutinen för det språk du använder. Den mest populära drivrutinen, och den som vi använder i denna handledning, är NodeJS-drivrutinen.

Med den första raden i vår kod ovan kan vi använda destruktureringsmetoden för att hämta MongoClient-funktionen från vår server.

MongoClient accepterar tre argument:

• En URL (används för att ansluta till MongoDB-servern)
• Alternativ / inställningar (som i detta fall ställer in variabeln "useUnifiedTopology" till true för att underlätta användningen av den nya Server Discover and Monitoring-motorn)
• En återuppringningsfunktion som tar två argument (fel och klient)

Inom återuppringningsfunktionen i MongoClient-metoden kan vi äntligen infoga en användare i vår databas. Men innan vi kommer till den punkten måste vi få tillgång till databasen för användarhanteraren.

En av skönheterna med att använda MongoDB är att det inte finns något behov av att uttryckligen skapa en databas. När en referens till en viss databas har genererats med argumentet “klient” (som visas i koden ovan), kan du börja manipulera den.

Hänvisningen till användarhanterardatabasen som vi genererar lagras i variabeln “db”, som vi använder för att infoga vår första användare i databasen.

Med hjälp av "db" -referensen kan vi skapa en ny samling, som vi tilldelar namnet "användare".

De insertOne metoden tar två nödvändiga argument; dokumentet (användaren) och en återuppringningsfunktion. Med insertOne metod kan vi infoga en användare med namnet Peter Davis med åldern av 32, i vår databas.

Återuppringningsfunktionen tar två argument (fel och resultat). Resultatfunktionen innehåller en ops-metod som vi använder för att se användaren som vi just skapade i vår databas. Detta ger följande utdata i konsolen efter att koden ovan har körts:

[{name: 'Peter Davis', age: '32', _id: 60772f869475e84740003c45}]

Även om vi bara tillhandahöll två fält när vi skapade en användare kan du se från utdata ovan att ett tredje fält genererades. Det här är en annan cool sak med MongoDB; det genererar automatiskt ett unikt id för varje dokument som det skapar.

Relaterad: Hur är datamodellering annorlunda i MongoDB?

Läser en användare i MongoDB

De två huvudmetoderna som används för att läsa dokument från en MongoDB är: hitta och hitta en. De hitta metoden används för att läsa flera dokument åt gången och hitta en metoden används för att läsa ett enda dokument åt gången.

MongoDB findOne Method Exempel

// importera mongodb och använd förstörning för att få MongoClient-metoden
const {MongoClient} = kräver ("mongodb");
// anslutnings-URL: n och databasen som vi tänker ansluta till
const connectionURL = 'mongodb: //127.0.0.1: 27017';
const databaseName = 'user-manager';
// använder anslutningsfunktionen på MongoClient för att ansluta till MongoDB-servern
MongoClient.connect (connectionURL, {useUnifiedTopology: true}, (error, client) => {
// kontrollera om anslutningen upprättades
om (fel) {
return console.log ('Det gick inte att ansluta till databasen');
}
// skapa databasen för användarhanteraren
const db = client.db (databaseName);
// hitta en användare i databasen
db.collection ('användare'). findOne ({namn: 'Peter Davis'}, (fel, användare) => {
om (fel) {
return console.log ('kunde inte hitta användare');
}
console.log (användare);
})
});

Det är bra att komma ihåg att du alltid måste ansluta till MongoDB-servern och lämplig databas innan du kan utföra några CRUD-operationer (som vi ser i vårt exempel ovan).

De hitta en metoden tar två nödvändiga argument. Det första argumentet innehåller sökkriterierna; du kan söka efter ett dokument med valfritt variabelnamn som är unikt för det. I vårt exempel ovan använder vi namnet "Peter Davis".

Det andra argumentet för hitta en metoden är återuppringningsfunktionen som tar två argument; det första är ett fel om dokumentet inte kan lokaliseras och det andra är dokumentet (som vi kallade "användare").

Utförande av koden ovan ger följande resultat i konsolen:

{_id: 60772f869475e84740003c45, namn: 'Peter Davis', ålder: '32'}

Uppdatera en användare i MongoDB

Det finns två tillgängliga metoder för att uppdatera dokument i MongoDB. Även om strukturen för båda är mycket lika, updateOne används för att uppdatera ett dokument i taget och updateMany används för att uppdatera många dokument åt gången.

MongoDB updateOne Method Exempel

// Uppdatera en användares ålder
db.collection ('användare'). updateOne ({namn: "Peter Davis"},
{
$ set: {
ålder: '24'
}
})

Med koden ovan kan vi uppdatera Peter Davis ålder till 24 år.

Ta bort en användare i MongoDB

Det finns två metoder tillgängliga för att radera ett dokument från MongoDB. De deleteOne metoden används för att ta bort ett enda dokument och deleteMany metoden används för att ta bort flera dokument.

MongoDB deleteOne Method Exempel

// ta bort ett dokument
db.collection ('användare'). deleteOne ({namn: 'Peter Davis'})

Radering är den enklaste CRUD-operationen som kan utföras i MongoDB. Som du kan se i exemplet ovan (exklusive nödvändig anslutningskod och återuppringningsfunktion) tar det bara en rad kod.

Du kan nu utföra CRUD-operationer i MongoDB

Nu har du grundläggande kunskaper om MongoDB och du vet vad NoSQL betyder. Du vet också vad förkortningen CRUD står för och varför dessa operationer är viktiga egenskaper i varje databas.

Den här artikeln ger dig alla verktyg som behövs för att utföra de fyra grundläggande CRUD-operationerna i MongoDB. Nu när du är utrustad med CRUD-verksamhetens kunskap kan du börja lära dig hur du bäst modellerar dina data med MongoDB.

Bildkredit: Alexander Sosluev /WiKiMedia Commons

Hur är datamodellering annorlunda i MongoDB?

Tänker du en annan metod för databaser? Så här fungerar datamodellering i MongoDB.

Läs Nästa

Om författaren