ORDER BY a lista de valores IN

Eu tenho uma consulta SQL simples no PostgreSQL 8.3 que pega um monte de comentários. Eu forneço uma lista classificada de valores para a INconstrução na WHEREcláusula:

SELECT * FROM comments WHERE (comments.id IN (1,3,2,4));

Isso retorna comentários em uma ordem arbitrária que, no meu caso, é como ids 1,2,3,4.

Quero que as linhas resultantes classificadas como na lista da INconstrução: (1,3,2,4).
Como conseguir isso?

Você pode fazer isso facilmente com (introduzido no PostgreSQL 8.2) VALUES (), ().

A sintaxe será assim:

select c.*
from comments c
join (
  values
    (1,1),
    (3,2),
    (2,3),
    (4,4)
) as x (id, ordering) on c.id = x.id
order by x.ordering

Só porque é tão difícil de encontrar e precisa ser espalhado: no mySQL isso pode ser feito de maneira muito mais simples , mas não sei se funciona em outro SQL.

SELECT * FROM `comments`
WHERE `comments`.`id` IN ('12','5','3','17')
ORDER BY FIELD(`comments`.`id`,'12','5','3','17')

No Postgres 9.4 ou posterior, isso é provavelmente mais simples e rápido :

SELECT c.*
FROM   comments c
JOIN   unnest('{1,3,2,4}'::int[]) WITH ORDINALITY t(id, ord) USING (id)
ORDER  BY t.ord;

• Usando o novo WITH ORDINALITY, que @a_horse já mencionou .

• Não precisamos de uma subconsulta, podemos usar a função de retorno de conjunto como uma tabela.

• Uma string literal para entregar na matriz em vez de um construtor ARRAY pode ser mais fácil de implementar com alguns clientes.

Explicação detalhada:

• PostgreSQL unnest () com número do elemento

Eu acho que assim é melhor:

SELECT * FROM "comments" WHERE ("comments"."id" IN (1,3,2,4))
    ORDER BY  id=1 DESC, id=3 DESC, id=2 DESC, id=4 DESC

Com o Postgres 9.4, isso pode ser feito um pouco mais curto:

select c.*
from comments c
join (
  select *
  from unnest(array[43,47,42]) with ordinality
) as x (id, ordering) on c.id = x.id
order by x.ordering;

Ou um pouco mais compacto sem uma tabela derivada:

select c.*
from comments c
  join unnest(array[43,47,42]) with ordinality as x (id, ordering) 
    on c.id = x.id
order by x.ordering

Removendo a necessidade de atribuir / manter manualmente uma posição para cada valor.

Com o Postgres 9.6, isso pode ser feito usando array_position():

with x (id_list) as (
  values (array[42,48,43])
)
select c.*
from comments c, x
where id = any (x.id_list)
order by array_position(x.id_list, c.id);

O CTE é usado para que a lista de valores precise ser especificada apenas uma vez. Se isso não for importante, também pode ser escrito como:

select c.*
from comments c
where id in (42,48,43)
order by array_position(array[42,48,43], c.id);

Outra maneira de fazer isso no Postgres seria usar a idxfunção

SELECT *
FROM comments
ORDER BY idx(array[1,3,2,4], comments.id)

Não se esqueça de criar a idxfunção primeiro, conforme descrito aqui: http://wiki.postgresql.org/wiki/Array_Index

No Postgresql:

select *
from comments
where id in (1,3,2,4)
order by position(id::text in '1,3,2,4')

Ao pesquisar isso um pouco mais, encontrei esta solução:

SELECT * FROM "comments" WHERE ("comments"."id" IN (1,3,2,4)) 
ORDER BY CASE "comments"."id"
WHEN 1 THEN 1
WHEN 3 THEN 2
WHEN 2 THEN 3
WHEN 4 THEN 4
END

No entanto, isso parece bastante detalhado e pode ter problemas de desempenho com grandes conjuntos de dados. Alguém pode comentar sobre essas questões?

Para fazer isso, acho que você provavelmente deveria ter uma tabela "ORDER" adicional que define o mapeamento dos IDs por ordem (efetivamente fazendo o que sua resposta à sua própria pergunta dizia), que você pode usar como uma coluna adicional no seu você pode então escolher.

Dessa forma, você descreve explicitamente a ordem que deseja no banco de dados, onde deveria estar.

sans SEQUENCE, funciona apenas no 8.4:

select * from comments c
join 
(
    select id, row_number() over() as id_sorter  
    from (select unnest(ARRAY[1,3,2,4]) as id) as y
) x on x.id = c.id
order by x.id_sorter

SELECT * FROM "comments" JOIN (
  SELECT 1 as "id",1 as "order" UNION ALL 
  SELECT 3,2 UNION ALL SELECT 2,3 UNION ALL SELECT 4,4
) j ON "comments"."id" = j."id" ORDER BY j.ORDER

ou se você prefere o mal ao bem:

SELECT * FROM "comments" WHERE ("comments"."id" IN (1,3,2,4))
ORDER BY POSITION(','+"comments"."id"+',' IN ',1,3,2,4,')

E aqui está outra solução que funciona e usa uma tabela constante ( http://www.postgresql.org/docs/8.3/interactive/sql-values.html ):

SELECT * FROM comments AS c,
(VALUES (1,1),(3,2),(2,3),(4,4) ) AS t (ord_id,ord)
WHERE (c.id IN (1,3,2,4)) AND (c.id = t.ord_id)
ORDER BY ord

Mas, novamente, não tenho certeza de que isso tenha desempenho.

Eu tenho um monte de respostas agora. Posso obter algumas votações e comentários para saber qual é o vencedor!

Obrigado a todos :-)

create sequence serial start 1;

select * from comments c
join (select unnest(ARRAY[1,3,2,4]) as id, nextval('serial') as id_sorter) x
on x.id = c.id
order by x.id_sorter;

drop sequence serial;

[EDITAR]

O unnest ainda não está embutido no 8.3, mas você pode criar um você mesmo (a beleza de qualquer *):

create function unnest(anyarray) returns setof anyelement
language sql as
$$
    select $1[i] from generate_series(array_lower($1,1),array_upper($1,1)) i;
$$;

essa função pode funcionar em qualquer tipo:

select unnest(array['John','Paul','George','Ringo']) as beatle
select unnest(array[1,3,2,4]) as id

Leve melhoria em relação à versão que usa uma sequência, eu acho:

CREATE OR REPLACE FUNCTION in_sort(anyarray, out id anyelement, out ordinal int)
LANGUAGE SQL AS
$$
    SELECT $1[i], i FROM generate_series(array_lower($1,1),array_upper($1,1)) i;
$$;

SELECT 
    * 
FROM 
    comments c
    INNER JOIN (SELECT * FROM in_sort(ARRAY[1,3,2,4])) AS in_sort
        USING (id)
ORDER BY in_sort.ordinal;

select * from comments where comments.id in 
(select unnest(ids) from bbs where id=19795) 
order by array_position((select ids from bbs where id=19795),comments.id)

aqui, [bbs] é a tabela principal que possui um campo chamado ids e ids é a matriz que armazena o comments.id.

passado no postgresql 9.6

Vamos ter uma impressão visual sobre o que já foi dito. Por exemplo, você tem uma tabela com algumas tarefas:

SELECT a.id,a.status,a.description FROM minicloud_tasks as a ORDER BY random();

 id |   status   |   description    
----+------------+------------------
  4 | processing | work on postgres
  6 | deleted    | need some rest
  3 | pending    | garden party
  5 | completed  | work on html

E você deseja ordenar a lista de tarefas por seu status. O status é uma lista de valores de sequência:

(processing, pending,  completed, deleted)

O truque é atribuir um valor a cada valor de status e ordenar a lista numérica:

SELECT a.id,a.status,a.description FROM minicloud_tasks AS a
  JOIN (
    VALUES ('processing', 1), ('pending', 2), ('completed', 3), ('deleted', 4)
  ) AS b (status, id) ON (a.status = b.status)
  ORDER BY b.id ASC;

O que leva a:

 id |   status   |   description    
----+------------+------------------
  4 | processing | work on postgres
  3 | pending    | garden party
  5 | completed  | work on html
  6 | deleted    | need some rest

Crédito @ user80168

Concordo com todos os outros pôsteres que dizem "não faça isso" ou "SQL não é bom nisso". Se você deseja classificar por algum aspecto dos comentários, adicione outra coluna inteira a uma de suas tabelas para manter seus critérios de classificação e classificar por esse valor. por exemplo, "ORDER BY comments.sort DESC" Se você quiser classificá-las em uma ordem diferente todas as vezes, então ... SQL não será para você neste caso.