Как написать комбинаторику функции в postgres?

после того, как я спал над ним, у меня была совершенно новая, более простая и быстрая идея:

CREATE OR REPLACE FUNCTION f_combos(_arr anyarray)
  RETURNS TABLE (combo anyarray) LANGUAGE plpgsql AS
$BODY$
BEGIN
    IF array_upper(_arr, 1) IS NULL THEN
        combo := _arr; RETURN NEXT; RETURN;
    END IF;

    CASE array_upper(_arr, 1)
--  WHEN 0 THEN -- does not exist
    WHEN 1 THEN
        RETURN QUERY VALUES ('{}'), (_arr);
    WHEN 2 THEN
        RETURN QUERY VALUES ('{}'), (_arr[1:1]), (_arr), (_arr[2:2]);
    ELSE
        RETURN QUERY
        WITH x AS (
            SELECT f.combo FROM f_combos(_arr[1:array_upper(_arr, 1)-1]) f
            )
        SELECT x.combo FROM x
        UNION ALL
        SELECT x.combo || _arr[array_upper(_arr, 1)] FROM x;
    END CASE;
END
$BODY$;

звоните:

SELECT * FROM f_combos('{1,2,3,4,5,6,7,8,9}'::int[]) ORDER BY 1;

512 строк, общее время выполнения: 2.899 ms

объяснить

• лечить особые случаи с NULL и пустой массив.
• построить комбинации для примитивного массива из двух.
• любой более длинный массив разбивается на:
  • комбинации для одного и того же массива длины n-1
  • плюс все они объединены с элементом n .. рекурсивно.

очень просто, как только вы его получили.

• работает для 1-мерных целых массивов, начиная с Нижний индекс 1 (см. ниже).
• 2-3 раза быстрее, чем старое решение, Весы лучше.
• работает любой тип элемента снова (с использованием полиморфных типов).
• включает пустой массив в результат как показано в вопросе (и как @Craig указал мне в комментариях).
• короче, элегантнее.

предполагается индексы массива начиная с 1 (по умолчанию). Если вы не уверены в своих значениях, вызовите такую функцию для нормализации:

SELECT * FROM  f_combos(_arr[array_lower(_arr, 1):array_upper(_arr, 1)]);

не уверен,что есть более элегантный способ нормализации индексов массива. Я отправил вопрос о что:
нормализовать индексы массива для 1-мерного массива, чтобы они начинались с 1

старое решение (медленнее)

CREATE OR REPLACE FUNCTION f_combos2(_arr int[], _a int[] = '{}', _z int[] = '{}')
 RETURNS SETOF int[] LANGUAGE plpgsql AS
$BODY$
DECLARE
   i int;
   j int;
   _up int;
BEGIN
   IF array_length(_arr,1) > 0 THEN 
      _up := array_upper(_arr, 1);

      FOR i IN array_lower(_arr, 1) .. _up LOOP
         FOR j IN i .. _up  LOOP
            CASE j-i
            WHEN 0,1 THEN
               RETURN NEXT _a || _arr[i:j] || _z;
            WHEN 2 THEN
               RETURN NEXT _a || _arr[i:i] || _arr[j:j] || _z;
               RETURN NEXT _a || _arr[i:j] || _z;
            ELSE
               RETURN NEXT _a || _arr[i:i] || _arr[j:j] || _z;
               RETURN QUERY SELECT *
               FROM f_combos2(_arr[i+1:j-1], _a || _arr[i], _arr[j] || _z);
            END CASE;
         END LOOP;
      END LOOP;
   ELSE
      RETURN NEXT _arr;
   END IF;
END;
$BODY$;

звоните:

SELECT * FROM f_combos2('{7,15,48}'::int[]) ORDER BY 1;

работает для одномерных целочисленных массивов. Это может быть дополнительно оптимизировано, но это, безусловно, не требуется для охвата этого вопроса.
ORDER BY чтобы наложить порядок, отображаемый в вопросе.

укажите NULL или пустой массив, как NULL упоминается в комментарии.

протестировано с PostgreSQL 9.1, но должно работать с любой наполовину современной версией. array_lower() и array_upper() существуют, по крайней мере, с PostgreSQL 7.4. Только параметры по умолчанию являются новыми в версии 8.4. Можно легко заменить.

производительность приличная.

SELECT DISTINCT * FROM f_combos('{1,2,3,4,5,6,7,8,9}'::int[]) ORDER BY 1;

511 строк, общее время выполнения: 7,729 МС

объяснение

он основывается на этом простая форма это только создает все комбинации соседних элементов:

CREATE FUNCTION f_combos(_arr int[])
  RETURNS SETOF int[] LANGUAGE plpgsql AS
$BODY$
DECLARE
   i  int;
   j  int;
  _up int;
BEGIN
   _up := array_upper(_arr, 1);

   FOR i in array_lower(_arr, 1) .. _up LOOP
      FOR j in i .. _up LOOP
         RETURN NEXT _arr[i:j];
      END LOOP;
   END LOOP;
END;
$BODY$;

но это не для суб-массивы с более чем двумя элементами. Итак:

• для любого суб-массива с 3 элементами добавляется один массив только с внешними двумя элементами. это ярлык для этого специального случая, который повышает производительность и является не очень нужны.

• для любого суб-массива с более чем 3 элементами я беру внешний два элементы на все комбинации внутренних элементов построенный той же функцией рекурсивно.