Como criar uma tabela temporária usando VALUES no PostgreSQL

Estou aprendendo o PostgreSQL e tentando descobrir como criar uma tabela temporária ou uma WITHdeclaração que possa ser usada no lugar da tabela regular, para fins de depuração.

Eu olhei a documentação para CREATE TABLE e ela diz que VALUESpode ser usada como uma consulta, mas não dá exemplo; a documentação da VALUEScláusula nela vinculada também não tem um exemplo?

Então, eu escrevi um teste simples da seguinte maneira:

DROP TABLE IF EXISTS lookup;
CREATE TEMP TABLE lookup (
  key integer,
  val numeric
) AS
VALUES (0,-99999), (1,100);

Mas o PostgreSQL (9.3) está reclamando

erro de sintaxe no "AS" ou próximo a ele

Minhas perguntas são:

1. Como posso corrigir a declaração acima?

2. Como posso adaptá-lo para ser usado em um WITH block?

Desde já, obrigado.

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ê deseja selecionar apenas alguns valores, em vez de apenas criar uma tabela e inseri-la, é possível 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: Como 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 no plpgslq para atribuir um valor a uma variável temporária - por isso falharia em Aquele caso. Portanto, enquanto os exemplos acima são válidos para SQL simples, o CREATE TABLEformulário deve ser preferido.

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 dos 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 na lista de valores e usa uma instrução CTE (WITH).

Além disso, como apontado na resposta de Evan Carrol, uma consulta CTE é uma cerca de otimização , ou seja, a CTE é sempre materializada. Há muitas boas razões para usar CTEs, mas pode haver um impacto significativo no desempenho, se não for usado com cuidado. Existem, no entanto, muitos casos em que a cerca de otimização pode realmente melhorar o desempenho; portanto, isso é algo que você deve estar ciente, para não evitar cegamente.

create table as precisa 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 o que você precisa é usar alguns valores em suas consultas. Você pode incorporá-los:

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

Em seguida, você pode obter um produto cartesiano com um CROSS JOIN(onde o outro relacionamento pode ser, é claro, uma tabela regular, exibiçã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 produz:

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, exibição etc.) regulares, 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 produz:

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

Primeiro, use sempre o padronizado CREATE TABLE AS, SELECT INTOcomo sugerido em outras respostas, há 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. De fato, é provavelmente um pouco mais lento. Apenas embrulhe 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 precisará 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 proporciona uma melhoria de desempenho. Você pode ver a desaceleraçã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;