Ich würde gerne mit LISTEN/NOTIFY einen vollständigen Event-Mechanismus inkl. Parameter machen. Bekannterweise unterstützt NOTIFY aber keine Parameter.
Mein Lösungsansatz geht so:
Erstens werden die Parameter in einer Hilfstabelle abgelegt. Zweitens, da mehrere NOTIFY-Befehle, die innert kurzer Zeit gesendet werden von PostgreSQL zusammengefasst werden, muss jede Session eine temporäre Zählvariable mit sich tragen, um sich zu merken, welche Befehle in der Hilfstabelle schon abgearbeitet wurden. Dazu erstellt jede Session eine Sessionvariable (eine temporäre Tabelle mit einer Spalte/einer Zeile). Dort wird jeweils die als letzte abgearbeitete id der Hilfstabelle gespeichert. Als letztes muss es noch einen Mechanismus geben, der alte Einträge in der Hilfstabelle löscht, damit die Tabelle nicht unendlich gross wird.
Ich benötige also pro Eventart:
1 Hilfstabelle mit den Parametern
jede Session eine temporäre Tabelle um den Fortschritt in der Hilfstabelle zu speichern
einen Cleanup-Job um alte Einträge in der Hilfstabelle zu bereinigen
Das ganze halte ich aber für eine ziemlich unsaubere Lösung.
Deswegen verwende ich die ja, weil es in PostgreSQL sonst keine andere Möglichkeit gibt Sessionvariablen zu erzeugen (es sei denn ich ändere die PostgreSQL Konfigurationsdatei).
Das habe ich geschrieben: Ich will einen Eventmechanismus bauen, um z.B. von Applikation 1 Nachrichten zu Applikation 2 senden zu können. inkl. Parameter. Das soll schlussendlich so sein, dass jede Applikation sich bei gewissen Events anmelden kann und bei Änderungen notifiziert wird. Konkret habe ich in der GUI z.B. eine Tabelle mit gewissen Einträgen, die von mehreren Leuten abgearbeitet werden. Sobald eine Person auf eine Zeile in der Tabelle doppelklickt geht ein Popup auf und die Person kann die Daten vervollständigen, weitere Infos eintragen, etc… Währenddessen erscheint auf allen anderen Rechnern auf der gleichen Tabelle auf der entsprechenden Zeile ein Schlüsselsymbol, das anzeigt, dass jemand diesen Eintrag gerade bearbeitet.
Leider unterstützen NOTIFY/LISTEN keine Parameter und es kann laut Doku sein, dass mehrere NOTIFY’s der gleichen Art zusammengefasst werden. Deswegen das ganze Zeug drumherum. Der vorgeschlagene Weg funktioniert. Die Frage ist aber, wie man das geschickter machen kann. Ich will das schlussendlich in eine High-Level-Klasse kapseln, womit man relativ einfach Daten zwischen den Rechnern austauschen können soll.
Es braucht bloss eine globale Tabelle, in der die Events gespeichert werden. Beim Schreiben in diese Tabelle löst eine Stored Procedure ein NOTIFY aus - das geht automatisch.
In die Tabelle kannst du entweder direkt schreiben oder Mitteilungen von Triggern schreiben lassen, die andere Tabellen überwachen. Das wäre die Senden-Seite.
Auf der Empfangen Seite speicherst du am besten die letzte ID im Programm selbst - der Umweg, dafür temporäre Tabellen anzulegen, ist doch beträchtlich.
Das mit dem Löschen der Events wird kompliziert, wenn du dir keine Race Condition einfangen willst grübel Für deinen Anwendungszweck ist das jedoch auch nicht gut brauchbar: angenommen, ein Programm baut eine Verbindung auf, nachdem ein NOTIFY gesandt wurde - wie stellst du sicher, dass dieses Programm auch alle Infos erhält, welche Datensätze gesperrt sind?
Oder arbeitest du beim Start erst mal alle vorhandenen Datensätze ab - was ggf. sehr lange dauern kann.
Ich würde einfach eine Tabelle anlegen, in der jede Verbindung vor dem Bearbeiten eines Datensatzes einträgt, dass sie einen Datensatz bearbeiten möchte. Wenn du willst, kannst du Änderungen an dieser Tabelle mittels eines einfachen NOTIFY allen anderen Verbindungen mitteilen und diese schauen dann nach, welche Datensätze aktuell gesperrt sind. Wenn das eine Programm mit Bearbeiten fertig ist, löscht es (hinterher) seinen Eintrag wieder und die anderen Clients bekommen auch das mit, da ein weiteres NOTIFY erzeugt wird.
Das hört sich für mich weniger umständlich an als ein komplettes und fehleranfälliges Messagingsystem auf Basis von LISTEN/NOTIFY aufzubauen.
Danke für die Antwort! Das mit der clientseitigen id werde ich in Betracht ziehen.
Die Daten in der Event-Tabelle können gelöscht werden, sobald alle interessierten Clients davon gelesen haben. Das heisst die Daten müssten praktisch nur wenige Sekunden in der Tabelle bleiben.
Ich habe momenten 4 Stored Procedures: event_listen(evname), event_unlisten(evname), event_fetch(evname) und event_notify(evname, parameter).
Der Client erhält Daten nur über diejenigen Events, die zeitlich zwischen event_listen und event_unlisten erzeugt werden. Diese können mit even_fetch abgerufen werden (die Prozedur gibt einen Cursor zurück mit einer Tabelle mit einer Liste von Event-Parametern).
Dich interessiert eigentlich nicht, ob alle interessierten Clients gelesen haben (Hint: neue Clients können später hinzukommen), du kannst auch nicht genau feststellen, ob wirklich alle Clients die Daten schon gelesen haben.
LISTEN/NOTIFY sind Async, damit kommst du hier nicht so wirklich weiter. Noch dazu werden die Daten erst geschrieben bzw. die NOTIFYs versandt, wenn die Transaktion abgeschlossen ist. In der Zeit kann aber schon ein anderer Client deinen Datensatz bearbeiten.
Für das, was du vorhast, müsstest du die “Gesperrt”-Informationen vorher schreiben, nicht hinterher.