MongoDB -transaksjoner

MongoDB støtter transaksjoner for å kombinere og isolere de forskjellige påstandene som skal behandles i en enkelt operasjon. Transaksjonsoperasjonene er gruppert og behandlet i et miljø som er forskjellig fra andre spørsmål i stedet for å bli utført en etter en, da de blir gitt til serveren. Transaksjonsegenskapene hjelper MongoDB -samlingene med å opprettholde syrenes overholdelse. Konsistensen av databasen beholdes, og holdbarhet oppnås når transaksjonsmodifiseringen ikke lagres før de er begått.

Trinn 1: Opprette eksempeldata i MongoDB for transaksjonen

For å utføre transaksjonene i MongoDB, trenger vi en samling som har dokumentene. Her etablerer vi "publicbank" MongoDB -samlingen og legger til tre dokumenter til den ved hjelp av InsertMany -metoden. Spørringsstrukturen for å sette inn dokumentet er som følger:

db.PublicBank.INSERTMANY ([
Person_name: "Sam",
Person_city: "Los Angeles",
Konto_nummer: "132309423",
Beløp: 150000.400,
Person_name: "Emily",
Person_city: "California",
Konto_nummer: "752889411",
Beløp: 370000.400,
Person_name: "Maddy",
Person_city: "Houston",
Konto_nummer: "34305909",
Beløp: 560000.400
])

Utgangen vises i følgende bilde, noe som indikerer at dokumentene blir lagt til i "PublicBank" -samlingen. Nå demonstrerer vi hvordan du starter og fullfører transaksjonene ved å bruke denne "publicbank" -prøvedataene.

Videre oppretter vi indeksen som "Account_number: 1" i hvert dokument i "publicbank" -samlingen ved hjelp av CreateIndex () -metoden for å bekrefte at navnefeltverdien til hvert dokument er forskjellig. Dette er veldig nyttig for å validere konsistenskravene mens du behandler transaksjonene.

db.PublicBank.createIndex ("account_number": 1, "unik": true)

Trinn 2: Opprett transaksjonen for den spesifiserte prøvesamlingen av MongoDB

I denne delen starter vi transaksjonen ved å erklære variabelen "økt". Denne "økt" -variabelen lagrer alle sesjonsobjektene som brukes til transaksjonen vår. Spørringen er gitt i det følgende der vi definerer “DB.getmongo ().StartSession () ”uttalelse etter å ha erklært variabelen“ økt ”. GetMongo () -metoden brukes til å bekrefte at forbindelsen er etablert riktig. StartSession () -metoden kalles for å begynne økten for transaksjonsoperasjonene, da økten fremdeles må settes i gang for å utføre en serie operasjoner sammen som en transaksjon.

økt = db.getmongo ().StartSession ()

Når vi kjører øktforespørselen i skallet, genererer det “ID” -økten som vist i følgende bilde:

Nå setter vi parameteren: StartTransaction () -metoden med "Session" -variabelen for lese- og skriveoperasjonen i vår MongoDB -transaksjon. Startundersøkelsen er først utstyrt med parameteren “ReadConcern”. Deretter setter vi ReadConcern -alternativet med "nivået" av "øyeblikksbilde" som henter dataene fra et øyeblikksbilde av flertallet av engasjerte data. "Flertallet" er satt mot "W" -alternativet til "Writeconcern" -parameteren.

økt.starttransaksjon (
"ReadConcern": "nivå": "Snapshot",
"Writeconcern": "w": "flertall"

)

Merk at starttransaksjonsspørsmålet ikke returnerer noe som en utdata fordi det utføres vellykket. Den returnerer utdataene hvis noe gikk galt med denne spørringen eller mens du startet økten. Etter å ha utført den nylige spørringen, er vi inne i en transaksjon som er aktiv og kan begynne å utføre uttalelsene som er en del av transaksjonen.

Trinn 3: Arbeide innenfor øvelsen med transaksjonen i MongoDB

I stedet for å innhente informasjonen direkte fra "DB" -databaseobjektet, erklærer vi en annen variabel som tar en referanse til sesjonsobjektet. Variabelen er definert før du jobber i den aktive transaksjonen som representerer samlingen som vi ønsker å jobbe med innenfor konteksten av økten.

var bank = økt.getDatabase ('test').getCollection ('publicbank')

Her oppretter vi "Bank" -variabelen ved å spesifisere "var" -modifisereren. Deretter refererer vi til "økt" -objektet som påkaller getDatabase () -metoden og getCollection () -metoden. GetDatabase () -metoden tar navnet på "Test" MongoDB -databasen og danner "Test" -databasen. Vi tilbyr "publicbank" -samlingen i getCollection () -metoden.

Sett inn enkeltdokumentet i transaksjonsøkten

Nå, inne i den aktive økten, utfører vi transaksjonsdriften for å sette inn et annet dokument i "publicbank" -samlingen ved hjelp av Insertone () -metoden. Insertone () -metoden kalles med "banken" og setter inn dokumentet med følgende felt:

Bank.innsats (
"Person_name": "James",
"Person_city": "New York",
"Account_number": "99931001",
"Beløp": 450000.900
)

MongoDB returnerer en suksessmelding som indikerer at transaksjonsoperasjonen utføres. Ettersom transaksjonsøkten fremdeles er aktiv, vil ikke dokumentet som er satt inn i den opprinnelige samlingen vises i den originale samlingen. Det kan være tilfeller der enten transaksjonen inkluderer den nye posten eller resulterer i en tilbakevending til den opprinnelige tilstanden til transaksjonsøkten.

Oppdater dokumentet i transaksjonsøkten

Igjen utfører vi en annen transaksjon i den samme "publicbank" -samlingen som er spesifisert med to kommandoer. Først tar vi en øktreferanse og gir deretter et samlingsnavn til getDatabase () -metoden. Etter det bruker vi "transaksjonen" nøkkelordet over samlingen. Oppdater verdien av det gitte feltet med UpdateOne () -metoden. Her tilordnes UpdateOne () -metoden med to uttrykk - “Account_number:” 132309423 ”og“ $ Set: Beløp: 6700000.000 ”. Først finner vi “Account_number” som er lik verdien “132309423”. Når denne verdien er oppnådd, setter vi "beløp" -dokumentfeltet med den nye verdien av “670000.000 ”ved hjelp av $ SET -operatøren.

økt.getDatabase ('publicbank').transaksjoner.UpdateOne (Account_number: "132309423", $ set: beløp: 6700000.000)

Når spørringen blir utført, genererer det de anerkjente resultatene med den sanne verdien. Her sier MatchCount: 1 at ett dokument blir matchet som tilfredsstiller tilstanden. "ModifiedCount: 1" indikerer at ett dokument blir oppdatert med tilstanden som brukes på det. Vi begikk fortsatt ikke transaksjonen, så samlingen utenfor transaksjonsøkten er ikke endret.

Forplikt transaksjonsøkten med CommitTransaction () -metoden

En forpliktelse i en databasetransaksjon refererer til permanent lagring av dataene etter en serie tentative oppdateringer. Vi bruker følgende kommando i MongoDB for å begå den aktive transaksjonsøkten:

økt.CommitTransaction ()

Nå lagres alle endringene i "publicbank" -samlingen ved å utføre Commit -kommandoen til MongoDB. Vi så endringene som vi gjorde i transaksjonen. Følgende er dokumentet som vi setter inn i "publicbank" -samlingen når transaksjonen er aktiv:

db.publicBank.finn (person_name: james ”)

Deretter har vi en transaksjon med å oppdatere dokumentet med den nye verdien av "beløpet" -feltet. Verdien oppdateres også når Commit -kommandoen blir brukt på transaksjonen.

db.publicBank.finn (Account_number: “132309423”)

Avbryt transaksjonsøkten med AbortTransaction () -metoden

Noen ganger ønsker vi ikke forpliktelsesoperasjonen over transaksjonen. For dette aborterer vi transaksjonen som ikke påvirker verdien av transaksjonen. Transaksjonen blir gjenopprettet til sin forrige stat. Følgende uttalelse skal utføres mens du aborterer transaksjonen:

økt.aborttransaksjon ()

Transaksjonsøkten slutter her. Eventuelle relevante endringer blir kastet. Databasen reverserer endringene og går tilbake til sin opprinnelige tilstand i stedet for å opprette en ny konsistent tilstand.

Konklusjon

Vi dekket konseptuelt MongoDB -transaksjonen i denne guiden. Vi lærte å starte transaksjonene i MongoDB. Vi satte også inn det nye dokumentet og oppdaterte verdien av det gitte dokumentet i transaksjonen. Deretter brukes Commit -uttalelsene til å fullføre transaksjonene. Videre oppnås også måten å rulle tilbake endringene som gjøres i transaksjonene gjennom abortuttalelsen.