Como criar uma tabela temporária usando VALUES no PostgreSQL

EDIT: estou deixando a resposta original aceita como está, mas observe que a edição abaixo, conforme sugerido por a_horse_with_no_name , é o método preferido para criar uma tabela temporária usando VALUES.

Se você quiser apenas selecionar alguns valores, em vez de apenas criar uma tabela e inserir nela, você pode fazer algo como:

WITH  vals (k,v) AS (VALUES (0,-9999), (1, 100)) 
SELECT * FROM vals;

Para realmente criar uma tabela temporária de maneira semelhante, use:

WITH  vals (k,v) AS (VALUES (0,-9999), (1, 100)) 
SELECT * INTO temporary table temp_table FROM vals;

EDIT: Conforme apontado por a_horse_with_no_name, nos documentos afirma que CREATE TABLE AS...é funcionalmente semelhante a SELECT INTO ..., mas que o primeiro é um superconjunto do último e que SELECT INTOé usado em plpgslq para atribuir um valor a uma variável temporária - então falharia em Aquele caso. Portanto, enquanto os exemplos acima são válidos para SQL simples, a CREATE TABLEforma deve ser preferida.

CREATE TEMP TABLE temp_table AS                                     
WITH t (k, v) AS (
 VALUES
 (0::int,-99999::numeric), 
 (1::int,100::numeric)
)
SELECT * FROM t;

Observe também nos comentários de a_horse_with_no_name e na pergunta original do OP, isso inclui uma conversão para os tipos de dados corretos dentro da lista de valores e usa uma instrução CTE (WITH).

Além disso, como apontado na resposta de Evan Carrol, no Postgres anterior à versão 12, uma consulta CTE é sempre uma cerca de otimização , ou seja, o CTE é sempre materializado. Há muitas boas razões para usar CTEs, mas pode haver um impacto significativo no desempenho, se não for usado com cuidado. Há, no entanto, muitas instâncias em que a cerca de otimização pode realmente melhorar o desempenho, portanto, isso é algo para se estar ciente, não para evitar cegamente.

create table asprecisa de uma instrução select:

DROP TABLE IF EXISTS lookup;
CREATE TEMP TABLE lookup 
as 
select *
from (
   VALUES 
    (0::int,-99999::numeric), 
    (1::int, 100::numeric)
) as t (key, value);

Você também pode reescrever isso para usar um CTE:

create temp table lookup 
as 
with t (key, value) as (
  values 
    (0::int,-99999::numeric), 
    (1::int,100::numeric)
)
select * from t;

O problema são os tipos de dados. Se você removê-los, a instrução funcionará:

CREATE TEMP TABLE lookup
  (key, val) AS
VALUES 
  (0, -99999), 
  (1, 100) ;

Você pode definir os tipos lançando os valores da primeira linha:

CREATE TEMP TABLE lookup 
  (key, val) AS
VALUES 
  (0::bigint, -99999::int), 
  (1, 100) ;

Você realmente não precisa criar uma tabela nem usar um CTE, se tudo que você precisa é usar alguns valores em suas consultas. Você pode inline-los:

SELECT  *
FROM    (VALUES(0::INT, -99999::NUMERIC), (1, 100)) AS lookup(key, val)

Então você pode obter um produto cartesiano com um CROSS JOIN(onde a outra relação pode ser, é claro, uma tabela regular, visualização, etc.). por exemplo:

SELECT  *
FROM    (VALUES(0::int, -99999::numeric), (1, 100)) AS lookup(key, val)
       ,(VALUES('Red'), ('White'), ('Blue')) AS colors(color);

que rende:

key |val    |color |
----|-------|------|
0   |-99999 |Red   |
1   |100    |Red   |
0   |-99999 |White |
1   |100    |White |
0   |-99999 |Blue  |
1   |100    |Blue  |

Ou JOINos valores com outro relacionamento (que novamente pode ser uma tabela regular, visão, etc.), por exemplo:

SELECT  *
FROM    (VALUES(0::int, -99999::numeric), (1, 100)) AS lookup(key, val)
  JOIN  (VALUES('Red', 1), ('White', 0), ('Blue', 1)) AS colors(color, lookup_key)
          ON colors.lookup_key = lookup.key;

que rende:

key |val    |color |lookup_key |
----|-------|------|-----------|
1   |100    |Red   |1          |
0   |-99999 |White |0          |
1   |100    |Blue  |1          |

Primeiro, sempre use o padronizado CREATE TABLE AS, SELECT INTOcomo sugerido em outras respostas, é uma sintaxe obsoleta há mais de uma década. Você pode usarCREATE TABLE AS com um CTE

Embora muitas respostas aqui estejam sugerindo o uso de um CTE, isso não é preferível. Na verdade, é provável que seja um pouco mais lento. Basta envolvê-lo como uma mesa.

DROP TABLE IF EXISTS lookup;

CREATE TEMP TABLE lookup(key, value) AS
  VALUES
  (0::int,-99999::numeric),
  (1,100);

Se você precisar escrever uma instrução select, também poderá fazer isso (e não precisa de um CTE).

CREATE TEMP TABLE lookup(key, value) AS
  SELECT key::int, value::numeric
  FROM ( VALUES
    (0::int,-99999::numeric),
    (1,100)
  ) AS t(key, value);

Um CTE no PostgreSQL força a materialização. É uma cerca de otimização. Por esse motivo, geralmente não é uma boa ideia usá-los em qualquer lugar, exceto quando você entende os custos e sabe que isso pode fornecer uma melhoria de desempenho. Você pode ver a lentidão aqui, por exemplo,

\timing
CREATE TABLE foo AS
  SELECT * FROM generate_series(1,1e7);
Time: 5699.070 ms

CREATE TABLE foo AS
  WITH t AS ( SELECT * FROM generate_series(1,1e7) ) 
  SELECT * FROM t;
Time: 6484.516 ms

WITH u AS (
    SELECT * FROM (VALUES (1, 'one'), (2, 'two'), (3, 'three')) AS account (id,name)
)
SELECT id, name, length(name) from u;