Why a fast function becomes slow when inside ANY? - performance

Question

I have a function that returns an array of integers. If I call:
select getmun_gaz(12554)
it returns an 'integer[]' in 33 ms:
{1547,1564}
Exactly the same result I get with:
select array[1547,1564]
The same type (integer[]), the same values ({1547,1564}), only a slight time difference. So, why this works instantly:
select *
from loc
where id = any(array[1547,1564])
but this takes more than 2 minutes?
select *
from loc
where id = any(getmun_gaz(12554))
I will post the contents of the function and the structure of the tables if needed. The table from where this data comes is indeed large, but this made no difference in the beginning, so why it does in the end?
The function:
CREATE OR REPLACE FUNCTION getmun_gaz(gaz_id integer)
RETURNS integer[] AS
$BODY$
with recursive locpais as (
select l.id, l.nome, l.tipo tid, lt.tipo, lp.pai, 1 as profund
from loc l
left join locpai lp on lp.loc = l.id
left join loctipo lt on lt.id = l.tipo
where l.id = gaz_id
union
select l.id, l.nome, l.tipo tid, lt.tipo, lp.pai, profund+1
from loc l
left join locpai lp on lp.loc = l.id
left join loctipo lt on lt.id = l.tipo
join locpais p on (l.id = p.pai)
)
select array_agg(id) from locpais
where tid = 8
$BODY$
LANGUAGE sql VOLATILE
COST 100;
I'll add the table structures later, if needed. Gotta go now.

Answer 1

It's because of your function's volatility.
Declaring a function as VOLATILE tells Postgres that it has side-effects, and/or its value changes every time you call it (e.g. random()). This means that in your query, Postgres has to call it once for every single row in the loc table, and can't use an index on id to speed things up.
If your function only contains SELECTs, with no calls to other VOLATILE functions, then you can declare it as STABLE. This tells Postgres that the result will stay the same when called multiple times within a single query; the query planner can now call it once at the start and re-use the value for each id comparison, and can also optimimise away most of these comparisons by using an index.

Answer 2

The problem with second one is if function isnt IMMUTABLE db need to calculate his value for each row
At difference with any(array[1547,1564]) is a constant.