Transazioni MongoDB

MongoDB supporta le transazioni per combinare e isolare le varie asserzioni per elaborare in un'unica operazione. Le operazioni di transazione sono raggruppate ed elaborate in un ambiente distinto dalle altre query piuttosto che essere eseguite una per una man mano che vengono fornite al server. Le proprietà delle transazioni aiutano le raccolte MongoDB nel mantenimento della conformità acida. La coerenza del database viene mantenuta e la durata si ottiene quando la modifica della transazione non viene salvata fino a quando non vengono commessi.

Passaggio 1: creazione dei dati di esempio in MongoDB per la transazione

Per eseguire le transazioni in MongoDB, abbiamo bisogno di una raccolta con i documenti. Qui, stabiliamo la collezione MongoDB "Bank" e aggiungiamo tre documenti con l'aiuto del metodo InsertMany. La struttura di query di inserire il documento è la seguente:

db.Banca pubblica.InsertMany ([
Person_name: "Sam",
Person_city: "Los Angeles",
Account_Number: "132309423",
Importo: 150000.400,
Person_name: "Emily",
Person_city: "California",
Account_number: "752889411",
Importo: 370000.400,
Person_name: "Maddy",
Person_city: "Houston",
Account_Number: "34305909",
Importo: 560000.400
])

L'output viene visualizzato nella seguente immagine, indicando che i documenti vengono aggiunti correttamente alla collezione "PublicBank". Ora, dimostriamo come avviare e completare le transazioni utilizzando questo campione di esempio "PublicBank".

Inoltre, creiamo l'indice come "Account_number: 1" di ciascun documento nella raccolta "PublicBank" utilizzando il metodo createIndex () per verificare che il valore del campo del nome di ciascun documento sia diverso. Ciò è molto utile per convalidare i requisiti di coerenza durante l'elaborazione delle transazioni.

db.Banca pubblica.CreateIndex ("account_number": 1, "univoco": true)

Passaggio 2: creare la transazione della raccolta di campioni specificata di MongoDB

In questa sezione, iniziamo la transazione dichiarando la variabile "sessione". Questa variabile "sessione" memorizza tutti gli oggetti di sessione utilizzati per la nostra transazione. La query è fornita nel seguente in cui definiamo il "DB.getmongo ().Dichiarazione iniziale () "dopo aver dichiarato la variabile" sessione ". Il metodo getmongo () viene utilizzato per verificare che la connessione sia stabilita correttamente. Il metodo Stargession () viene chiamato per iniziare la sessione per le operazioni di transazione poiché la sessione deve ancora essere avviata per eseguire una serie di operazioni insieme come transazione.

sessione = db.getmongo ().avvio ()

Quando eseguiamo la query di sessione nella shell, genera la sessione "ID" come mostrato nella seguente immagine:

Ora, impostiamo il metodo parametro: startTransaction () con la variabile "sessione" per l'operazione di lettura e scrittura nella nostra transazione MongoDB. L'inizio viene fornita per la prima volta con il parametro "ReadConcern". Quindi, impostiamo l'opzione ReadConcern con il "livello" di "Snapshot" che recupera i dati da un'istantanea della maggior parte dei dati impegnati. La "maggioranza" è impostata contro l'opzione "W" del parametro "WriteConcern".

sessione.startTransaction (
"readconcern": "livello": "snapshot",
"WriteConcern": "w": "maggioranza"

)

Si noti che la query starttransaction non restituisce nulla come output perché viene eseguita correttamente. Restituisce l'output se qualcosa è andato storto con questa query o mentre si avvia la sessione. Dopo aver eseguito la recente query, siamo all'interno di una transazione che è attiva e può iniziare a eseguire le dichiarazioni che fanno parte della transazione.

Passaggio 3: lavorare all'interno della sessione di transazione in mongodb

Invece di ottenere le informazioni direttamente dall'oggetto del database "DB", dichiariamo un'altra variabile che prende un riferimento all'oggetto sessione. La variabile è definita prima di lavorare nella transazione attiva che rappresenta la raccolta con cui vogliamo lavorare nel contesto della sessione.

var bank = sessione.getDatabase ('test').getCollection ('PublicBank')

Qui, creiamo la variabile "banca" specificando il modificatore "var". Quindi, facciamo riferimento all'oggetto "sessione" che invoca il metodo getDatabase () e il metodo getCollection (). Il metodo getDatabase () prende il nome del database MongoDB "Test" e forma il database "Test". Forniamo la collezione "PublicBank" al metodo getCollection ().

Inserire il singolo documento all'interno della sessione di transazione

Ora, all'interno della sessione attiva, eseguiamo l'operazione di transazione di inserire un altro documento nella raccolta "PublicBank" utilizzando il metodo insertOne (). Il metodo insertOne () viene chiamato con la "banca" e inserisce il documento con i seguenti campi:

Banca.insertone (
"Person_name": "James",
"Person_city": "New York",
"Account_number": "99931001",
"Importo": 450000.900
)

Il mongodb restituisce un messaggio di successo che indica che viene eseguita l'operazione di transazione. Poiché la sessione di transazione è ancora attiva, il documento che viene inserito in precedenza non verrà visualizzato nella collezione originale. Potrebbero esserci casi in cui la transazione include il nuovo record o si traduce in un rollback alla condizione iniziale della sessione di transazione.

Aggiorna il documento all'interno della sessione di transazione

Ancora una volta, eseguiamo un'altra transazione nella stessa collezione "PublicBank" che è specificata con due comandi. Innanzitutto, prendiamo un riferimento di sessione e quindi diamo un nome di raccolta al metodo getDatabase (). Successivamente, utilizziamo la parola chiave "transazione" sulla raccolta. Aggiorna il valore del campo dato con il metodo UpdateOne (). Qui, il metodo UpdateOne () è assegnato con due espressioni: "Account_number:" 132309423 "e" $ set: importo: 6700000.000 ". Innanzitutto, troviamo il valore "account_number" che è uguale al valore "132309423". Quando si ottiene questo valore, impostiamo il campo del documento "Importo" con il nuovo valore di "670000.000 "utilizzando l'operatore $ set.

sessione.getDatabase ("PublicBank").transazioni.Aggiornamento (account_number: "132309423", $ set: importo: 6700000.000)

Ora, quando viene eseguita la query, genera i risultati riconosciuti con il vero valore. Qui, il matchcount: 1 afferma che un documento è abbinato che soddisfa la condizione. Il "ModifiedCount: 1" indica che un documento viene aggiornato con la condizione che viene applicata ad esso. Non abbiamo ancora commesso la transazione, quindi la raccolta al di fuori della sessione di transazione non viene modificata.

Commettere la sessione di transazione con il metodo committransaction ()

Un commit in una transazione di database si riferisce alla memorizzazione permanente dei dati dopo una serie di aggiornamenti provvisorosi. Usiamo il seguente comando in MongoDB per commettere la sessione di transazione attiva:

sessione.committransaction ()

Ora, tutte le modifiche sono archiviate nella raccolta "PublicBank" eseguendo il comando commit di MongoDB. Abbiamo visto le modifiche che abbiamo apportato all'interno della transazione. Quello che segue è il documento che inseriamo nella collezione "PublicBank" quando la transazione è attiva:

db.banca pubblica.find (persona_name: James ”)

Successivamente, abbiamo una transazione di aggiornamento del documento con il nuovo valore del campo "importo". Il valore viene anche aggiornato quando il comando commit viene applicato alla transazione.

db.banca pubblica.find (account_number: “132309423”)

Abortire la sessione di transazione con il metodo AbortTransaction ()

A volte, non vogliamo l'operazione di commit durante la transazione. Per questo, abortiamo la transazione che non influisce sul valore della transazione. La transazione viene ripristinata al suo stato precedente. La seguente dichiarazione dovrebbe essere eseguita durante l'apertura della transazione:

sessione.AbortTransaction ()

La sessione di transazione termina qui. Eventuali modifiche pertinenti vengono scartate. Il database inverte le alterazioni e ritorna allo stato iniziale piuttosto che creare un nuovo stato coerente.

Conclusione

Abbiamo coperto concettualmente la transazione MongoDB in questa guida. Abbiamo imparato ad avviare le transazioni in MongoDB. Abbiamo anche inserito il nuovo documento e aggiornato il valore del documento indicato all'interno della transazione. Quindi, le dichiarazioni di impegno vengono utilizzate per completare le transazioni. Inoltre, il modo per ripristinare le modifiche apportate alle transazioni viene eseguito anche attraverso la dichiarazione di abort.