MongoDB -Transaktionen

MongoDB unterstützt Transaktionen, um die verschiedenen Behauptungen zu kombinieren und zu isolieren, um in einem einzigen Betrieb zu verarbeiten. Die Transaktionsvorgänge werden in einer Umgebung gruppiert und verarbeitet, die sich von anderen Abfragen unterscheidet, anstatt einzeln ausgeführt zu werden, wie sie dem Server zur Verfügung gestellt werden. Die Transaktionseigenschaften unterstützen die MongoDB -Sammlungen bei der Aufrechterhaltung der Säurekonformität. Die Konsistenz der Datenbank wird beibehalten und die Haltbarkeit wird erhalten, wenn die Transaktionsänderung erst gespeichert wird, wenn sie festgelegt sind.

Schritt 1: Erstellen der Beispieldaten in MongoDB für die Transaktion

Um die Transaktionen in MongoDB durchzuführen, benötigen wir eine Sammlung mit den Dokumenten. Hier legen wir die MongoDB -Sammlung „Publicbank“ ein und fügen ihm drei Dokumente mit Hilfe der InsertMany -Methode hinzu. Die Abfragestruktur des Einsetzens des Dokuments lautet wie folgt:

db.Publicbank.InsertMany ([
Person_Name: "Sam",
Person_City: "Los Angeles",
Account_Number: "132309423",
Betrag: 150000.400,
Person_Name: "Emily",
Person_City: "Kalifornien",
Account_Number: "752889411",
Betrag: 370000.400,
Person_Name: "Maddy",
Person_City: "Houston",
Account_Number: "34305909",
Betrag: 560000.400
]))

Die Ausgabe wird im folgenden Bild angezeigt, was darauf hinweist, dass die Dokumente erfolgreich zur Sammlung „Publicbank“ hinzugefügt werden. Jetzt zeigen wir, wie die Transaktionen mit diesen Beispieldaten „Publicbank“ gestartet und abgeschlossen werden können.

Darüber hinaus erstellen wir den Index als "Account_Number: 1" jedes Dokuments in der Sammlung „PublicBank“ mit der Methode createIdex (), um zu überprüfen. Dies ist sehr hilfreich, um die Konsistenzanforderungen bei der Verarbeitung der Transaktionen zu validieren.

db.Publicbank.createIdex ("account_number": 1, "eindeutig": true)

Schritt 2: Erstellen Sie die Transaktion der angegebenen Probenerfassung von MongoDB

In diesem Abschnitt beginnen wir die Transaktion, indem wir die Variable „Sitzung“ deklarieren. Diese Variable „Sitzung“ speichert alle Sitzungsobjekte, die für unsere Transaktion verwendet werden. Die Abfrage ist im folgenden Ort vorgesehen, an dem wir das „DB“ definieren.GetMongo ().StartSession () ”Erklärung nach der Erklärung der Variablen„ Sitzung “. Die Methode getMongo () wird verwendet, um zu überprüfen, ob die Verbindung ordnungsgemäß hergestellt wird. Die Methode startSession () wird aufgerufen, um die Sitzung für die Transaktionsvorgänge zu beginnen, da die Sitzung noch eingeleitet werden muss, um eine Reihe von Operationen als Transaktion zusammenzuführen.

Sitzung = db.GetMongo ().startSession ()

Wenn wir die Sitzungsabfrage in der Shell ausführen, generiert sie die im folgende Bild gezeigte "ID" -Stsion:

Jetzt setzen wir den Parameter: die Methode starttransaction () mit der Variablen „Sitzung“ für den Lese- und Schreibvorgang in unserer MongoDB -Transaktion. Der StartSession wird zuerst mit dem Parameter „ReadConcern“ versehen. Anschließend setzen wir die ReadConcern -Option mit der „Ebene“ von „Snapshot“, die die Daten von einem Snapshot der Mehrheit der engagierten Daten abruft. Die „Mehrheit“ wird gegen die Option "W" des Parameters "WriteConcern" festgelegt.

Sitzung.Starttransaktion (
"ReadConcern": "Level": "Snapshot",
"WriteConcern": "W": "Mehrheit"

)

Beachten Sie, dass die Starttransaction -Abfrage nichts als Ausgabe zurückgibt, da sie erfolgreich ausgeführt wird. Es gibt die Ausgabe zurück, wenn bei dieser Abfrage etwas schief gelaufen ist oder beim Starten der Sitzung. Nachdem wir die jüngste Abfrage ausgeführt haben, befinden wir uns in einer aktiven Transaktion und können mit der Ausführung der Aussagen, die Teil der Transaktion sind.

Schritt 3: Arbeiten innerhalb der Transaktionssitzung in MongoDB

Anstatt die Informationen direkt aus dem Datenbankobjekt „DB“ zu erhalten. Die Variable wird vor der Arbeit in der aktiven Transaktion definiert, die die Sammlung darstellt, mit der wir im Kontext der Sitzung arbeiten möchten.

var bank = Sitzung.getDatabase ('Test').GetCollection ('PublicBank')

Hier erstellen wir die Variable "Bank", indem wir den "VAR" -Modifikator angeben. Anschließend verweisen wir auf das "Sitzungs" -Objekt, das die Methode getDatabase () und die Methode getCollection () aufruft. Die Methode getDatabase () nimmt den Namen der MongoDB -Datenbank „Test“ an und bildet die "Test" -Datenbank. Wir geben die Kollektion „Publicbank“ in die GetCollection () -Methode zur Verfügung.

Fügen Sie das einzelne Dokument in die Transaktionssitzung ein

In der aktiven Sitzung führen wir nun den Transaktionsbetrieb des Einfügens eines anderen Dokuments in die Sammlung „Publicbank“ mit der InsertOne () -Methode durch. Die Methode InsertOne () wird mit der „Bank“ aufgerufen und fügt das Dokument mit den folgenden Feldern ein:

Bank.Inserton (
"Person_Name": "James",
"Person_City": "New York",
"Account_Number": "99931001",
"Betrag": 450000.900
)

Der MongoDB gibt eine Erfolgsnachricht zurück, die angibt, dass der Transaktionsvorgang durchgeführt wird. Da die Transaktionssitzung noch aktiv ist, wird das zuvor eingefügte Dokument in der Originalsammlung nicht angezeigt. Es kann Fälle geben, in denen entweder die Transaktion den neuen Datensatz enthält oder zu einem Rollback der Ausgangsbedingung der Transaktionssitzung führt.

Aktualisieren Sie das Dokument in der Transaktionssitzung

Auch hier führen wir eine weitere Transaktion in derselben „Publicbank“ -Kollektion durch, die mit zwei Befehlen angegeben ist. Zuerst nehmen wir eine Sitzungsreferenz und geben dann der Methode getDatabase () einen Sammelamen an. Danach verwenden wir das Schlüsselwort "Transaktion" über die Sammlung. Aktualisieren Sie den Wert des angegebenen Feldes mit der updateOne () -Methode. Hier wird die updateOne () -Methode mit zwei Ausdrücken zugewiesen: "Account_Number:" 132309423 "und" $ set: Betrag: 6700000).000 ”. Erstens finden wir den "Account_Number", der dem Wert "132309423" entspricht. Wenn dieser Wert erhalten wird, setzen wir das Feld "Betrag" -Dokument mit dem neuen Wert von „670000.000 ”mit dem $ Set -Operator.

Sitzung.getDatabase ('PublicBank').Transaktionen.updateone (account_number: "132309423", $ set: Betrag: 6700000.000)

Wenn die Abfrage ausgeführt wird, generiert sie die anerkannten Ergebnisse mit dem wahren Wert. Hier stellt der MatchCount: 1 fest, dass ein Dokument übereinstimmt, was die Bedingung erfüllt. Das „ModifiedCount: 1“ gibt an, dass ein Dokument mit der darauf angewendeten Bedingung aktualisiert wird. Wir haben die Transaktion immer noch nicht begangen, sodass die Sammlung außerhalb der Transaktionssitzung nicht geändert wird.

Beiten Sie die Transaktionssitzung mit der Methode commentTransaction ()

Ein Commit in einer Datenbank -Transaktion bezieht sich auf die dauerhafte Speicherung der Daten nach einer Reihe vorläufiger Aktualisierungen. Wir verwenden den folgenden Befehl in mongoDB, um die aktive Transaktionssitzung zu begehen:

Sitzung.commentTransaction ()

Jetzt werden alle Änderungen in der Sammlung „Publicbank“ gespeichert, indem das Commit -Befehl von MongoDB ausgeführt wird. Wir haben die Änderungen gesehen, die wir in der Transaktion vorgenommen haben. Das Folgende ist das Dokument, das wir in die Sammlung „Publicbank“ einfügen, wenn die Transaktion aktiv ist:

db.Publicbank.find (Person_Name: James ”)

Als nächstes haben wir eine Transaktion zur Aktualisierung des Dokuments mit dem neuen Wert des Felds „Betrag“. Der Wert wird auch aktualisiert, wenn der Befehl des Komits auf die Transaktion angewendet wird.

db.Publicbank.find (account_number: "132309423")

Brechen Sie die Transaktionssitzung mit der Methode aborttransaction () ab

Manchmal wollen wir nicht, dass der Commit -Betrieb über die Transaktion betrieben wird. Zu diesem Zweck haben wir die Transaktion ab, die den Wert der Transaktion nicht beeinflusst. Die Transaktion wird in ihren vorherigen Zustand wiederhergestellt. Die folgende Erklärung sollte ausgeführt werden, während die Transaktion abgebrochen wird:

Sitzung.AbortTransaction ()

Die Transaktionssitzung endet hier. Alle relevanten Änderungen werden verworfen. Die Datenbank kehrt die Änderungen um und kehrt in ihren Anfangszustand zurück, anstatt einen neuen konsistenten Zustand zu erstellen.

Abschluss

Wir haben die MongoDB -Transaktion konzeptionell in diesem Leitfaden behandelt. Wir haben gelernt, die Transaktionen in MongoDB zu beginnen. Wir haben auch das neue Dokument eingefügt und den Wert des angegebenen Dokuments innerhalb der Transaktion aktualisiert. Anschließend werden die Commit -Aussagen verwendet, um die Transaktionen abzuschließen. Darüber hinaus wird der Weg, um die Änderungen, die an den Transaktionen vorgenommen werden.