ORDINA DALL'elenco dei valori IN

Ho una semplice query SQL in PostgreSQL 8.3 che raccoglie molti commenti. Fornisco un elenco ordinato di valori per il INcostrutto nella WHEREclausola:

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

Questo restituisce commenti in un ordine arbitrario che nel mio caso sembra essere un ID 1,2,3,4.

Voglio che le righe risultanti ordinati come la lista nel INcostrutto: (1,3,2,4).
Come raggiungerlo?

Puoi farlo abbastanza facilmente con (introdotto in PostgreSQL 8.2) VALUES (), ().

La sintassi sarà così:

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

Solo perché è così difficile da trovare e deve essere diffuso: in mySQL questo può essere fatto molto più semplice , ma non so se funziona in altri SQL.

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

In Postgres 9.4 o successivo, questo è probabilmente il più semplice e veloce :

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

• Usando il nuovo WITH ORDINALITY, che @a_horse ha già menzionato .

• Non abbiamo bisogno di una sottoquery, possiamo usare la funzione di restituzione del set come una tabella.

• Una stringa letterale da consegnare nell'array anziché in un costruttore ARRAY può essere più facile da implementare con alcuni client.

Spiegazione dettagliata:

• PostgreSQL unnest () con numero di elemento

Penso che in questo modo sia meglio:

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

Con Postgres 9.4 questo può essere fatto un po 'più breve:

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;

O un po 'più compatto senza una tabella derivata:

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

Rimozione della necessità di assegnare / mantenere manualmente una posizione per ciascun valore.

Con Postgres 9.6 questo può essere fatto 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);

Il CTE viene utilizzato in modo tale che l'elenco di valori debba essere specificato una sola volta. Se ciò non è importante, questo può anche essere scritto come:

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

Un altro modo per farlo in Postgres sarebbe usare la idxfunzione.

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

Non dimenticare di creare idxprima la funzione, come descritto qui: http://wiki.postgresql.org/wiki/Array_Index

In Postgresql:

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

Sulla ricerca di questo ancora ho trovato questa soluzione:

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

Tuttavia, questo sembra piuttosto dettagliato e potrebbe avere problemi di prestazioni con set di dati di grandi dimensioni. Qualcuno può commentare questi problemi?

Per fare questo, penso che dovresti probabilmente avere una tabella "ORDER" aggiuntiva che definisce la mappatura degli ID da ordinare (facendo effettivamente ciò che ha detto la tua risposta alla tua domanda), che puoi quindi usare come colonna aggiuntiva sulla tua selezione che è quindi possibile ordinare.

In questo modo, descrivi esplicitamente l'ordine che desideri nel database, dove dovrebbe essere.

sans SEQUENCE, funziona solo su 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

o se preferisci il male al bene:

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

Ed ecco un'altra soluzione che funziona e utilizza una tabella costante ( 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

Ma di nuovo non sono sicuro che questo sia performante.

Ho un sacco di risposte ora. Posso ottenere alcuni voti e commenti in modo da sapere qual è il vincitore!

Ringrazia tutti :-)

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;

[MODIFICARE]

unnest non è ancora integrato in 8.3, ma puoi crearne uno tu stesso (la bellezza di qualsiasi *):

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;
$$;

quella funzione può funzionare in qualsiasi tipo:

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

Leggero miglioramento rispetto alla versione che utilizza una sequenza penso:

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)

qui, [bbs] è la tabella principale che ha un campo chiamato ids e ids è l'array che memorizza il comment.id.

passato in postgresql 9.6

Diamo un'impressione visiva di ciò che è già stato detto. Ad esempio, hai una tabella con alcune attività:

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 vuoi ordinare l'elenco delle attività in base al suo stato. Lo stato è un elenco di valori stringa:

(processing, pending,  completed, deleted)

Il trucco è dare a ogni valore di stato un numero intero e ordinare un elenco numerico:

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;

Il quale conduce a:

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

Credito @ user80168

Sono d'accordo con tutti gli altri poster che dicono "non farlo" o "SQL non è bravo in questo". Se si desidera ordinare in base a un certo aspetto dei commenti, aggiungere un'altra colonna intera a una delle tabelle per contenere i criteri di ordinamento e ordinare in base a quel valore. ad es. "ORDINA PER commenti.sort DESC" Se si desidera ordinare questi in un ordine diverso ogni volta, in questo caso SQL non fa per voi.