Eu tenho uma tabela do PostgreSQL desta forma:

base_id int | mods smallint[]
     3      |   {7,15,48}

Eu preciso preencher uma tabela deste formulário:

combo_id int | base_id int | mods smallint[]
     1       |     3       |      
     2       |     3       |      {7}
     3       |     3       |      {7,15}   
     4       |     3       |      {7,48}   
     5       |     3       |      {7,15,48}
     6       |     3       |      {15}
     7       |     3       |      {15,48}
     8       |     3       |      {48}

Eu acho que eu poderia conseguir isso usando uma função que faz quase exatamente isso, iterando sobre a primeira tabela e escrevendo combinações para a segunda tabela:Gere todas as combinações em SQL

Mas, eu sou um novato do Postgres e não posso para a vida de mim descobrir como fazer isso usando plpgsql. Não precisa ser particularmente rápido; só será executado periodicamente no backend. A primeira tabela tem aproximadamente 80 registros e um cálculo aproximado sugere que podemos esperar cerca de 2600 registros para a segunda tabela.

Alguém pode pelo menos me apontar na direção certa?

Editar: Craig: Eu tenho o PostgreSQL 9.0. Eu fui capaz de usar UNNEST ():

FOR messvar IN SELECT * FROM UNNEST(mods) AS mod WHERE mod BETWEEN 0 AND POWER(2, @n) - 1
LOOP
    RAISE NOTICE '%', messvar;
END LOOP;

mas depois não sabia para onde ir em seguida.

Editar: Para referência, acabei usando a solução da Erwin, com uma única linha adicionada para adicionar um resultado nulo ('{}') a cada conjunto e o caso especial ao qual o Erwin se refere foi removido:

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

    IF _a = '{}' AND _z = '{}' THEN RETURN QUERY SELECT '{}'::int[]; END IF;
    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;
          ELSE
             RETURN NEXT _a || _arr[i:i] || _arr[j:j] || _z;
             RETURN QUERY SELECT *
             FROM f_combos(_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$

Então, usei essa função para preencher minha tabela:

INSERT INTO e_ecosystem_modified (ide_ecosystem, modifiers) 
(SELECT ide_ecosystem, f_combos(modifiers) AS modifiers FROM e_ecosystem WHERE ecosystemgroup <> 'modifier' ORDER BY ide_ecosystem, modifiers);

De 79 linhas na minha tabela de origem com um máximo de 7 itens na matriz de modificadores, a consulta levou 250ms para preencher 2630 linhas na minha tabela de saída. Fantástico.