Grundsätzliches

Um mehrere Aktionen in der Objektdatenbank geschlossen vornehmen zu können, werden Transaktionen zur Verfügung gestellt. Wenn eine Reihe von Operationen in der Objektdatenbank in einer Transaktion zusammengefasst sind, können diese z.B. in einem Fehlerfall alle durch den Abbruch der Transaktion rückgängig gemacht werden. Dafür werden die Operationen in einer Transaktion bis zur Bestätigung bzw. bis zum Abbruch in einem Transaktionspuffer gehalten und nicht gleich gespeichert.

Für die Instanz, welche die Transaktion gestartet hat, stellt sich der Zustand der Objektdatenbank dar, als ob das bzw. die Objekte schon gespeichert bzw. gelöscht sind. Währenddessen ist im Mehrbenutzerbetrieb für die anderen Instanzen (Clients des GloServer's) das bzw. die Objekte weiterhin aus der Objektdatenbank gültig.

Es werden geschachtelte Transaktionen unterstützt. Geschachtelt bedeutet hier, dass während einer Transaktion eine weitere Transaktion initiiert werden kann. Wenn diese weitere Transaktion abgebrochen wird, wird nur bis zum letzten "Start" einer Transaktion zurückgerollt. Alle vorherigen und weiteren Aktionen werden bei einer "Bestätigung" der Transaktion ausgeführt. Damit können Transaktionen in Einheiten gekapselt und in weiteren Transaktionen transparent genutzt werden.

Beispiele:
Base.beginTransaction() >> Obj_ A->store() >> Base.beginTransaction() >> Obj_B->store() >> Base.abortTransaction() >> Base.commitTransaction()
Ergebnis: Nur Obj_A ist gespeichert.

Base.beginTransaction() >> Obj_ A->store() >> Base.beginTransaction() >> Obj_B->store() >> Base.commitTransaction() >> Base.abortTransaction()
Ergebnis: Kein Objekt ist gespeichert.

Base.beginTransaction() >> Obj_ A->store() >> Base.beginTransaction() >> Obj_B->store() >> Base.commitTransaction() >> Base.commitTransaction()
Ergebnis: Obj_A und Obj_B sind gespeichert.

Zu beachten: Objekte die in einer Transaktion gespeichert bzw. gelöscht werden sollen, sind so lange von der Transaktion gesperrt, bis diese beendet ist. Siehe auch glo::LK_TRANSACTION_WRITE und glo::LK_TRANSACTION_DELETE. Wenn ein Objekt in der Transaktion ein Objekt dependent referenziert und/oder die Aktion (glo::BasePersistent::store (...) bzw. glo::BasePersistent::deleteInBase (...)) mit entsprechenden Parameter glo::EnDeepMode aufgerufen wurde, ist das referenzierte Objekt ggf. von der Transaktion mitgesperrt worden.
Eine Transaktion schützt nicht vor fehlerhaften Zuständen. Wenn ein Client "1" z.B. ein Objekt "A" geladen hat und ein anderer Client "2" dieses Objekt in einer Transaktion ändert, speichert und die Transaktion bestätigt, kann immer noch der ahnungslose Client "1" ggf. aus Attributen berechnete Änderungen an Objekt "A" vornehmen und dieses speichern. Dieses kann verhindert werden, indem vor einer berechneten Änderung und Speicherung von Objekten, diese gesperrt (siehe glo::BasePersistent::lock (…) ), dann aufgefrischt (siehe glo::BasePersistent::refresh() ) und dann erst geändert und gespeichert werden.

Transaktion starten

Der Start einer Transaktion kann über glo::Base::beginTransaction() initiiert werden. Objektdatenbank-Operationen wie glo::BasePersistent::store (...) und glo::BasePersistent::deleteInBase (...) werden nicht in der Objektdatenbank ausgeführt, sondern im Transaktionspuffer vorgehalten.

Zu beachten: Abfragen wie z.B. glo::BasePersistent::refresh() bzw. das Neuladen eines Objektes, welches während einer Transaktion gespeichert wurde, liefern die Daten für die Instanz welche die Transaktion gestartet hat, aus dem Transaktionspuffer.
Sollte das Objekt in einer Transaktion gelöscht worden sein, ist dieses Objekt für die Instanz, welche die Transaktion gestartet hat, nicht mehr in der Objektdatenbank vorhanden.
Währenddessen ist im Mehrbenutzerbetrieb für die anderen Instanzen (Clients des GloServers's) das Objekt weiterhin aus der Objektdatenbank gültig.

Achtung: Der Start einer Transaktion muss immer über glo::Base::commitTransaction() bzw. glo::Base::abortTransaction() beendet werden, da sonst die Objekte in der Transaktion nicht freigegeben werden können. Siehe auch Transaktion bestätigen und Transaktion abbrechen.

Transaktion bestätigen

Eine Transaktion kann über glo::Base::commitTransaction() bestätigt werden. Das bedeutet, dass alle Aktionen in der Objektdatenbank wie glo::BasePersistent::store (...) und glo::BasePersistent::deleteInBase (...) welche seit dem letzten Start der Transaktion initiiert wurden, ausgeführt und dann aus dem Transaktionspuffer entfernt werden.

Transaktion abbrechen

Eine Transaktion kann über glo::Base::abortTransaction() abgebrochen werden. Das bedeutet, dass alle Aktionen in der Objektdatenbank wie glo::BasePersistent::store (...) und glo::BasePersistent::deleteInBase (...) welche seit dem letzten Start der Transaktion initiiert wurden, aus dem Transaktionspuffer entfernt, also nicht ausgeführt werden.

Zu beachten: Die Objekte, die nicht gespeichert wurden, haben noch ihre ggf. veränderten Werte. Ein glo::BasePersistent::refresh() wird nicht automatisch ausgeführt!