Esquema temporário por conexão?

Estou tentando migrar meus testes de unidade do H2 para o Postgresql.

Atualmente, o H2 fornece um esquema na memória, de modo que cada conexão é mapeada para um esquema exclusivo, cria as tabelas, executa o teste e descarta o esquema. A criação e destruição do esquema são tratadas automaticamente pelo H2.

Os testes de unidade são executados simultaneamente.

Qual é a melhor maneira de fazer isso no Postgresql? Especificamente,

1. Como obtenho um esquema exclusivo por conexão?
   • A estrutura de teste deve gerar nomes exclusivos ou existe um mecanismo interno para fazer isso?
2. Como garantir que o esquema seja descartado quando a conexão for interrompida?
   • Eu não quero acabar com esquemas pendentes quando os testes de unidade são mortos.
3. Qual abordagem produzirá o melhor desempenho?
   • Eu preciso criar / descartar dezenas de esquemas por segundo.

ATUALIZAÇÃO : Encontrei uma resposta relacionada aqui, mas ela não descarta os esquemas caso o processo que executa os testes de unidade seja interrompido.

pg_temp é um alias para o esquema temporário da sessão atual.

Se você fizer um SET search_path TO pg_tempantes de executar seus testes, tudo funcionará (desde que nada faça referência a um esquema explicitamente).

Se você não deseja alterar seu script, defina search_patho usuário no qual os testes efetuam login como:

> ALTER ROLE testuser SET search_path = pg_temp;

Então, tudo o que o usuário criar estará em pg_temp, a menos que seja explicitamente especificado.

Aqui está um exemplo de psql, mostrando o esquema real (para esta conexão) para o qual o alias resolve:

> 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)

E, como seria de esperar, esse esquema é diferente para todas as conexões simultâneas e desaparece após o fechamento da conexão.

Observe que isso também funciona para funções, embora você precise referenciar explicitamente o esquema pg_temp ao chamá-las.

Você pode obter o nome do esquema temporário atual (depois de criar a primeira tabela temporária), conforme descrito no link que você adicionou:

SELECT nspname
FROM   pg_namespace
WHERE  oid = pg_my_temp_schema();

Mas seu plano atual ainda não faria muito sentido. Para criar tabelas no esquema temporário atual, basta criar tabelas temporárias. Isso é tudo. Por padrão, o search_pathé definido para que as tabelas temporárias sejam visíveis primeiro. Um não precisa de tabelas temporárias de esquema-qualificar. Você nunca precisa abordar o esquema temporário atual diretamente de forma alguma - esse é um detalhe da implementação.

Seus testes envolvem transações? O DDL é transacional no PostgreSQL; portanto, se você criar seu esquema e tabelas, executar seus testes, tudo dentro de uma única transação que será revertida, o esquema nunca será realmente confirmado e visível para outras sessões.

Você ainda precisará usar um nome provavelmente exclusivo para seu esquema (talvez inclua nome do host e PID), pois CREATE SCHEMAfalhará imediatamente se já existir um esquema com nome idêntico e bloqueará se outra sessão tiver criado um esquema com nome idêntico em uma transação não confirmada.

Uma alternativa seria apenas usar tabelas temporárias, se você puder modificar os scripts de criação de banco de dados para fazer isso.

Acabei de ter uma ideia.

O Postgresql garante que uma sessão não pode ver as tabelas temporárias de outra. Suponho que isso significa que, quando você cria uma tabela temporária, ele cria um esquema temporário. Então, talvez eu pudesse fazer o seguinte:

1. Crie uma tabela temporária (fictícia) e procure seu esquema.
2. Use este esquema para o teste (crie as tabelas, execute o teste).
3. Quando a conexão é fechada, o Postgresql descarta o esquema.

Não gosto de confiar nos detalhes da implementação, mas neste caso isso parece bastante seguro.