MIME-Version: 1.0
From: Ed Behn <ed@behn.us>
Date: Sat, 21 Mar 2026 08:22:38 -0400
Message-ID: 
 <CAJBL5DNPYDw84qDohS5CMXOLESsozV7QNJ6NwS1M66+tvHmzdw@mail.gmail.com>
Subject: Persistent data across SETOF calls
To: pgsql-hackers@postgresql.org
Content-Type: multipart/alternative; boundary="000000000000a811f9064d87dd64"
Archived-At: 
 <https://www.postgresql.org/message-id/CAJBL5DNPYDw84qDohS5CMXOLESsozV7QNJ6NwS1M66%2BtvHmzdw%40mail.gmail.com>
Precedence: bulk

--000000000000a811f9064d87dd64
Content-Type: text/plain; charset="UTF-8"

Good day-
    I maintain the PL/Haskell language handler. Typically, the handler
compiles function code and stores the compiled data in the fn_extra field
of FmgrInfo. The fn_extra field persists from one call to the next within a
query meaning the expensive compilation only needs to happen once per
query.

    However, when calling a set-returning function multiple times in a
query, there appears to be no way to carry data from one set to another.
This is because the fn_extra field stores the FuncCallContext structure.
While the user_fctx field of the FuncCallContext structure persists from
one call to the next, it is NULLed out at the end of a set.

    For example, if there is a table, t, with a column, i, and a
set-returning function, func, the following query is very inefficient:

    SELECT *
    FROM t, func(i)

This is because the function is recompiled for each row of t.

Is there a way around this? Ideally, there would be a field that
persists from one set to another within a query.

Thank you for any help you can provide.
              -Ed

--000000000000a811f9064d87dd64
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div dir=3D"ltr"><div dir=3D"ltr"><div dir=3D"ltr">Good da=
y-<div>=C2=A0 =C2=A0 I maintain the PL/Haskell language handler. Typically,=
 the handler compiles function code and stores the compiled data in the fn_=
extra field of FmgrInfo. The fn_extra field persists from one call to the n=
ext within a query meaning the expensive compilation only needs to happen o=
nce per query.=C2=A0</div><div><br></div><div>=C2=A0 =C2=A0 However, when c=
alling a set-returning function multiple times in a query, there appears to=
 be no way to carry data from one set to another. This is because the fn_ex=
tra field stores the FuncCallContext structure. While the user_fctx field o=
f the FuncCallContext structure persists from one call to the next, it is N=
ULLed out at the end of a set.=C2=A0</div><div><br></div><div>=C2=A0 =C2=A0=
 For=C2=A0example, if there is a table, t, with a column, i, and a set-retu=
rning function, func, the following query is very inefficient:</div><div><b=
r></div><div>=C2=A0 =C2=A0 SELECT *</div><div>=C2=A0 =C2=A0 FROM t, func(i)=
</div><div><br></div><div>This is because the function is recompiled for ea=
ch row of t.=C2=A0</div><div><br></div><div>Is there a way around this? Ide=
ally, there would=C2=A0be a field that persists=C2=A0from one set to anothe=
r within a query.=C2=A0</div><div><br></div><div>Thank=C2=A0you for any=C2=
=A0help you can provide.=C2=A0</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0=
 =C2=A0 =C2=A0 -Ed</div></div>
</div>
</div>
</div>

--000000000000a811f9064d87dd64--