Temporäres Schema pro Verbindung?

Ich versuche, meine Unit-Tests von H2 nach Postgresql zu migrieren.

Derzeit gibt mir H2 ein speicherinternes Schema, sodass jede Verbindung einem eindeutigen Schema zugeordnet ist, die Tabellen erstellt, den Test ausführt und das Schema löscht. Die Erstellung und Zerstörung des Schemas wird automatisch von H2 übernommen.

Die Komponententests werden gleichzeitig ausgeführt.

Was ist der beste Weg, dies in Postgresql zu tun? Speziell,

1. Wie erhalte ich ein eindeutiges Schema pro Verbindung?
   • Sollte das Testframework eindeutige Namen generieren oder gibt es dafür einen integrierten Mechanismus?
2. Wie stelle ich sicher, dass das Schema getrennt wird, wenn die Verbindung getrennt wird?
   • Ich möchte nicht mit baumelnden Schemata enden, wenn Unit-Tests getötet werden.
3. Welcher Ansatz liefert die höchste Leistung?
   • Ich muss Dutzende von Schemas pro Sekunde erstellen / löschen.

UPDATE : Ich habe hier eine verwandte Antwort gefunden, aber es werden keine Schemas gelöscht, falls der Prozess, der die Komponententests ausführt, abgebrochen wird.

pg_temp ist ein Alias ​​für das temporäre Schema der aktuellen Sitzung.

Wenn Sie SET search_path TO pg_tempvor dem Ausführen Ihrer Tests eine ausführen, sollte alles nur funktionieren (solange nichts explizit auf ein Schema verweist).

Wenn Sie Ihr Skript überhaupt nicht ändern möchten, legen Sie search_pathfür den Benutzer, bei dem sich die Tests anmelden, Folgendes fest:

> ALTER ROLE testuser SET search_path = pg_temp;

Dann befindet sich alles, was der Benutzer erstellt, in pg_temp, sofern nicht ausdrücklich angegeben.

Hier ist ein Beispiel aus psql, das das tatsächliche Schema (für diese Verbindung) zeigt, in das der Alias ​​aufgelöst wird:

> SET search_path TO pg_temp;
SET
> create table test();
CREATE TABLE
> \dt test
          List of relations
  Schema   | Name | Type  |  Owner
-----------+------+-------+----------
 pg_temp_4 | test | table | postgres
(1 row)

Und wie zu erwarten ist, unterscheidet sich dieses Schema für jede gleichzeitige Verbindung und ist nach dem Schließen der Verbindung nicht mehr vorhanden.

Beachten Sie, dass dies auch für Funktionen funktioniert, obwohl Sie beim Aufrufen explizit auf das Schema pg_temp verweisen müssen.

Sie können den Namen des aktuellen temporären Schemas (nach dem Erstellen der ersten temporären Tabelle) wie in dem von Ihnen hinzugefügten Link angegebenen abrufen:

SELECT nspname
FROM   pg_namespace
WHERE  oid = pg_my_temp_schema();

Aber Ihr aktueller Plan würde immer noch nicht viel Sinn machen. Um Tabellen im aktuellen temporären Schema zu erstellen, erstellen Sie einfach temporäre Tabellen. Das ist alles. Standardmäßig search_pathist das so definiert, dass temporäre Tabellen zuerst sichtbar sind. Ein nie muss Schema qualifizieren temporäre Tabellen. Sie sollten das aktuelle temporäre Schema niemals direkt ansprechen müssen - das ist ein Implementierungsdetail.

Umfassen Ihre Tests Transaktionen? DDL ist in PostgreSQL transaktional. Wenn Sie also Ihr Schema und Ihre Tabellen erstellen und dann Ihre Tests ausführen, alles innerhalb einer einzigen Transaktion, die dann zurückgesetzt wird, wird das Schema niemals festgeschrieben und ist für andere Sitzungen sichtbar.

Sie müssten weiterhin einen wahrscheinlich eindeutigen Namen für Ihr Schema verwenden (möglicherweise Hostname und PID), da CREATE SCHEMAdieser sofort fehlschlägt, wenn bereits ein Schema mit identischem Namen vorhanden ist, und blockiert, wenn eine andere Sitzung ein Schema mit identischem Namen in erstellt hat eine nicht festgeschriebene Transaktion.

Eine Alternative wäre möglicherweise nur die Verwendung temporärer Tabellen, wenn Sie Ihre Datenbankerstellungsskripts dazu ändern können.

Ich habe gerade eine Idee.

Postgresql garantiert, dass eine Sitzung die temporären Tabellen einer anderen Sitzung nicht sehen kann. Ich vermute, dies bedeutet, dass beim Erstellen einer temporären Tabelle ein temporäres Schema erstellt wird. Vielleicht könnte ich folgendes tun:

1. Erstellen Sie eine (Dummy-) temporäre Tabelle und suchen Sie das Schema.
2. Verwenden Sie dieses Schema für den Test (erstellen Sie die Tabellen, führen Sie den Test aus).
3. Wenn die Verbindung geschlossen wird, löscht Postgresql das Schema.

Ich mag es nicht, mich auf Implementierungsdetails zu verlassen, aber in diesem Fall scheint dies ziemlich sicher zu sein.