SQL-запрос для сопоставления списка значений со списком полей в любом порядке без повторения

Нет намного способа лучше, но вы можете использовать in:

SELECT *
FROM table
WHERE :val1 in (fieldA, fieldB, fieldC) and
      :val2 in (fieldA, fieldB, fieldC) and
      :val3 in (fieldA, fieldB, fieldC)

По крайней мере он короче. И это стандартный SQL, поэтому он должен работать в любой базе данных.

... Я могу принять ответы, которые могут работать на PostgreSQL. (Я хочу узнать, есть ли умный способ написания запросов такого типа без «грубой силы»)

В Postgres есть «умный способ» с отсортированными массивами.

Целое число

Для значений integer используйте sort_asc() дополнительного модуль intarray.

SELECT * FROM tbl
WHERE  sort_asc(ARRAY[id1, id2, id3]) = '{1,2,3}' -- compare sorted arrays

Работает для любого количества элементов.

Другие типы

Как поясняется в комментарии, мы имеем дело со строками.
Создайте вариант sort_asc(), который работает для любого типа, который можно сортировать. :

CREATE OR REPLACE FUNCTION sort_asc(anyarray)
  RETURNS anyarray LANGUAGE sql IMMUTABLE AS
'SELECT array_agg(x ORDER BY x COLLATE "C") FROM unnest($1) AS x';

Не так быстро, как брат из intarray, но достаточно быстро.

• Сделайте его IMMUTABLE, чтобы разрешить его использование в индексах.
• Используйте COLLATE "C", чтобы игнорировать правила сортировки текущей локали: быстрее, неизменно .
• Чтобы функция работала для любого типа, который можно сортировать, используйте полиморфный параметр.

Запрос тот же:

SELECT * FROM tbl
WHERE  sort_asc(ARRAY[val1, val2, val3]) = '{bar,baz,foo}';

Или, если вы не уверены в порядке сортировки в локали "C"...

SELECT * FROM tbl
WHERE  sort_asc(ARRAY[val1, val2, val3]) = sort_asc('{bar,baz,foo}'::text[]);

Показатель

Для лучшей производительности чтения создайте функциональный указатель (за некоторую плату написать производительность):

CREATE INDEX tbl_arr_idx ON tbl (sort_asc(ARRAY[val1, val2, val3]));

SQL Fiddle демонстрирует все.

Мой ответ предполагает, что есть столбец Key, который мы можем выделить. На выходе должны быть все ключи, которые соответствуют всем трем значениям и каждому используемому полю и значению:

Это «должно» дать вам список ключей, соответствующих критериям

SELECT F.KEY
FROM (
SELECT DISTINCT L.Key, L.POS
FROM (
  SELECT Key, 'A' AS POS, FieldA AS FIELD FROM table AS A
  UNION ALL
  SELECT Key, 'B' AS POS, FieldB AS FIELD FROM table AS A
  UNION ALL
  SELECT Key, 'C' AS POS, FieldC AS FIELD FROM table AS A ) AS L
WHERE L.FIELD IN(:VAL1, :VAL2, :VAL3)
) AS F
GROUP BY F.KEY
HAVING COUNT(*) = 3

Хотя ответ Гордона определенно короче и почти наверняка быстрее, я играл с идеей о том, как минимизировать изменение кода при увеличении количества комбинаций.

И я могу придумать что-то для Postgres, которое ни в коем случае не короче, но более «дружественно к изменениям»:

with recursive params (val) as (
   values (1),(2),(3) -- these are the input values
), all_combinations as (
   select array[val] as elements
   from params
   union all
   select ac.elements||p.val
   from params p
     join all_combinations ac 
       on array_length(ac.elements,1) < (select count(*) from params)
)
select *
from the_table
where array[id1,id2,id3] = any (select elements from all_combinations);

Что оно делает?

Сначала мы создаем CTE, содержащий искомые значения, затем рекурсивный CTE строит список всех возможных перестановок из этих значений. Этот список будет включать слишком много элементов, потому что он также будет содержать массивы с 1 или двумя элементами.

Окончательный выбор, который помещает столбцы, которые необходимо сравнить, в массив и сравнивает их с перестановками, сгенерированными CTE.

Вот пример SQLFiddle: http://sqlfiddle.com/#!15/43066/1

Используя наивный подход, я бы использовал предложение in для этой работы, и, поскольку повторений быть не должно, исключил, когда поля повторяются.

Есть также некоторые оптимизации, которые вы могли бы сделать.

Сначала вы можете исключить последнее поле, так как:

A <> B, A <> C
A <> B, B <> C, 

Также означает, что:

C <> B,  C <> A

Кроме того, для следующих запросов не требуется ранее запрошенное поле, поскольку:

A <> B == B <> A

Запрос будет записан так:

SELECT * FROM table
WHERE :val1 in (fieldA, fieldB, fieldC) and
  :val2 in (fieldA, fieldB, fieldC) and
  :val3 in (fieldA, fieldB, fieldC) and
  fieldA not in (fieldB, fieldC) and
  fieldB <> fieldC

Это наивный подход, возможно, есть и другие, использующие MySQL API, но этот работает.