Lesere som deg er med på å støtte MUO. Når du foretar et kjøp ved å bruke lenker på nettstedet vårt, kan vi tjene en tilknyttet provisjon.
Å bygge en produksjonsklar nettapplikasjon krever at du sørger for at den er trygg og skalerbar.
En av de mest avgjørende tingene å vite om databaser er ACID-prinsippet som står for atomitet, konsistens, isolasjon og holdbarhet. Relasjonsdatabaser som MySQL støtter ACID-transaksjoner naturlig. Men MongoDB er en NoSQL-database og støtter ikke ACID-transaksjoner som standard.
Som programmerer bør du vite hvordan du introduserer ACID-egenskaper i MongoDB-databasene dine.
Hva er databasetransaksjoner?
En databasetransaksjon er en sekvens av databasespørringer eller operasjoner som alle utføres sammen som én enhet for å fullføre én oppgave.
Databasetransaksjoner følger begrepene ACID-egenskaper. Dette bidrar til å sikre at ingen endringer skjer med mindre alle operasjoner er vellykkede. Det sikrer også at databasen er konsistent.
ACID-egenskapene forklart
De fire egenskapene som utgjør ACID-prinsippene er:
- Atomitet er egenskapen som konseptualiserer transaksjoner som små enheter av et program. Dette innebærer at alle spørringene enten kjører vellykket eller mislykkes sammen.
- Konsistens sier at databaseposter må forbli konsistente før og etter hver transaksjon.
- Isolering sikrer at når flere transaksjoner kjøres samtidig, påvirker den ene ikke den andre.
- Varighet fokuserer på systemfeil eller feil. Den sikrer at en forpliktet transaksjon ikke går tapt i tilfelle systemfeil. Dette kan innebære teknikker som er nødvendige for å gjenopprette data fra en sikkerhetskopi automatisk når systemet kommer opp igjen.
Hvordan implementere MongoDB-databasetransaksjoner i Node.js ved hjelp av Mongoose
MongoDB har blitt en mye brukt databaseteknologi gjennom årene på grunn av dens NoSQL-natur og fleksibel dokumentbasert modell. Det gir deg også muligheten til å organisere dataene dine bedre og mer fleksibelt enn i SQL eller relasjonsdatabaser.
For å implementere databasetransaksjoner i MongoDB, kan du vurdere et eksempelscenario på en jobboppføringsapplikasjon der en bruker kan legge ut, oppdatere eller slette en jobb. Her er et enkelt databaseskjemadesign for denne applikasjonen:
For å følge med krever denne delen grunnleggende kunnskap om Node.js-programmering og MongoDB.
Transaksjoner støttes ikke på frittstående MongoDB-installasjoner. Du må bruke en MongoDB replikasett eller MongoDB splittet klynge for at transaksjoner skal fungere. Derfor er den enkleste måten å bruke transaksjoner på opprette en skyvertsbasert MongoDB-forekomst (MongoDB Atlas). Som standard er hver Atlas-databaseforekomst et replikasett eller sharded cluster.
Etter å ha satt opp et fungerende Node.js og MongoDB-prosjekt, kan du sette opp en tilkobling til en Mongo-database i Node.js. Hvis du ikke har gjort det før nå, installer mongoose ved å kjøre npm installer mongoose i terminalen din.
import mangust fra "mangus"la MONGO_URL = process.env. MONGO_URL || 'din-mongo-database-url';
la forbindelse;
konst connectDb = asynkron () => {
prøve {
avvente mongoose.connect (MONGO_URL, {
useNewUrlParser: ekte,
bruk UnifiedTopology: ekte,
});
console.log("KOBLET TIL DATABASE");
forbindelse = mongoose.forbindelse;
} å fange (feil) {
console.error("TILKOBLING AV DATABASE FEILTE!");
konsoll.feil(feil.beskjed);
prosess.exit(1); // lukk appen hvis databasetilkoblingen mislykkes
}
};
Du bør lagre tilkoblingen i en variabel slik at du kan bruke den til å starte en transaksjon senere i programmet.
Du kan implementere bruker- og jobbsamlingene slik:
konst userSchema = ny mangust. Skjema({
Navn: String,
e-post: String,
arbeidsplasser: [mangus. Skjema. Typer. ObjectId]
});konst jobbskjema = ny mangust. Skjema({
tittel: String,
plassering: String,
lønn: String,
plakat: mangust.Skjema.Typer.ObjectId
});
const userCollection = mongoose.model('bruker', brukerskjema);
const jobCollection = mongoose.model('jobb', jobbskjema);
Du kan skrive en funksjon for å legge til en bruker i databasen slik:
konst createUser = asynkron (bruker) => {
konst nybruker = avvente userCollection.create (bruker);
konsoll.log("Bruker lagt til databasen");
konsoll.log (ny bruker);
}
Koden nedenfor viser funksjonen for å opprette en jobb og legge den til på plakatens liste over jobber ved hjelp av en databasetransaksjon.
konst createJob = asynkron (jobb) => {
konst { userEmail, title, location, salary } = jobb;// få brukeren fra DB
konst bruker = avvente userCollection.findOne({ e-post: userEmail });// start transaksjonsøkten
konst økt = avvente forbindelse.startSession();// kjør alle databasespørringer i en try-catch-blokk
prøve {
avvente session.startTransaction();// skape jobb
konst nyjobb = avvente jobCollection.create(
[
{
tittel,
plassering,
lønn,
plakat: user._id,
},
],
{ økt }
);
konsoll.log("Opprettet ny jobb vellykket!");
konsoll.log (newJob[0]);// legg til jobb til brukerlisten over postede jobber
konst newJobId = newJob[0]._id;
konst addedToUser = avvente userCollection.findByIdAndUpdate(
bruker-ID,
{ $addToSet: { arbeidsplasser: newJobId } },
{ økt }
);konsoll.log("Jobb ble lagt til på brukerens jobbliste");
konsoll.log (addedToUser);avvente session.commitTransaction();
konsoll.log("Vellykket utført DB-transaksjon");
} å fange (e) {
konsoll.feil (e);
konsoll.log("Kunne ikke fullføre databaseoperasjoner");
avvente session.abortTransaction();
} endelig {
avvente session.endSession();
konsoll.log("Avsluttet transaksjonsøkt");
}
};
EN skape spørring som kjører i en transaksjon tar vanligvis inn og returnerer en matrise. Du kan se dette i koden ovenfor hvor det opprettes ny jobb og lagrer den _id eiendom inewJobId variabel.
Her er en demonstrasjon av hvordan funksjonene ovenfor fungerer:
konst mockUser = {
navn: "Timmy Omolana",
e-post: "[email protected]",
};konst mockJob = {
title: "Salgssjef",
sted: "Lagos, Nigeria",
lønn: "$40,000",
brukerE-post: "[email protected]", // e-post til den opprettede brukeren
};konst startServer = asynkron () => {
avvente kobleDb();
avvente createUser (mockUser);
avvente createJob (mockJob);
};
startServer()
.deretter()
.catch((feil) => konsoll.log (feil));
Hvis du lagrer denne koden og kjører den med npm start eller node kommando, bør den produsere en utgang som dette:
En annen måte å implementere ACID-transaksjoner i MongoDB ved å bruke Mongoose er å bruke withTransaction() funksjon. Denne tilnærmingen gir liten fleksibilitet ettersom den kjører alle spørringer i en tilbakeringingsfunksjon som du sender som et argument til funksjonen.
Du kan refaktorisere databasetransaksjonen ovenfor for å bruke withTransaction() som dette:
konst createJob = asynkron (jobb) => {
konst { userEmail, title, location, salary } = jobb;// få brukeren fra DB
konst bruker = avvente userCollection.findOne({ e-post: userEmail });// start transaksjonsøkten
konst økt = avvente forbindelse.startSession();// kjør alle databasespørringer i en try-catch-blokk
prøve {
konst transaksjonssuksess = avvente session.withTransaction(asynkron () => {
konst nyjobb = avvente jobCollection.create(
[
{
tittel,
plassering,
lønn,
plakat: user._id,
},
],
{ økt }
);konsoll.log("Opprettet ny jobb vellykket!");
konsoll.log (newJob[0]);// legg til jobb til brukerlisten over postede jobber
konst newJobId = newJob[0]._id;
konst addedToUser = avvente userCollection.findByIdAndUpdate(
bruker-ID,
{ $addToSet: { arbeidsplasser: newJobId } },
{ økt }
);konsoll.log("Jobb ble lagt til på brukerens jobbliste");
konsoll.log (addedToUser);
});
hvis (transaksjonssuksess) {
konsoll.log("Vellykket utført DB-transaksjon");
} ellers {
konsoll.log("Transaksjonen mislyktes");
}
} å fange (e) {
konsoll.feil (e);
konsoll.log("Kunne ikke fullføre databaseoperasjoner");
} endelig {
avvente session.endSession();
konsoll.log("Avsluttet transaksjonsøkt");
}
};
Dette vil gi samme utgang som forrige implementering. Du står fritt til å velge hvilken stil du skal bruke når du implementerer databasetransaksjoner i MongoDB.
Denne implementeringen bruker ikke commitTransaction() og abortTransaction() funksjoner. Dette er fordi withTransaction() funksjonen forplikter automatisk vellykkede transaksjoner og avbryter mislykkede. Den eneste funksjonen du bør ringe i alle tilfeller er session.endSession() funksjon.
Implementering av ACID-databasetransaksjoner i MongoDB
Databasetransaksjoner er enkle å bruke når de gjøres riktig. Du bør nå forstå hvordan databasetransaksjoner fungerer i MongoDB og hvordan du kan implementere dem i Node.js-applikasjoner.
For å utforske ideen om ACID-transaksjoner og hvordan de fungerer i MongoDB, bør du vurdere å bygge en fintech-lommebok eller bloggeapplikasjon.