mirror of
https://github.com/postgres/postgres.git
synced 2025-12-12 02:37:31 +03:00
1d2fe56e42
PL/Python failed if a PL/Python function was invoked recursively via SPI, since arguments are passed to the function in its global dictionary (a horrible decision that's far too ancient to undo) and it would delete those dictionary entries on function exit, leaving the outer recursion level(s) without any arguments. Not deleting them would be little better, since the outer levels would then see the innermost level's arguments. Since PL/Python uses ValuePerCall mode for evaluating set-returning functions, it's possible for multiple executions of the same SRF to be interleaved within a query. PL/Python failed in such a case, because it stored only one iterator per function, directly in the function's PLyProcedure struct. Moreover, one interleaved instance of the SRF would see argument values that should belong to another. Hence, invent code for saving and restoring the argument entries. To fix the recursion case, we only need to save at recursive entry and restore at recursive exit, so the overhead in non-recursive cases is negligible. To fix the SRF case, we have to save when suspending a SRF and restore when resuming it, which is potentially not negligible; but fortunately this is mostly a matter of manipulating Python object refcounts and should not involve much physical data copying. Also, store the Python iterator and saved argument values in a structure associated with the SRF call site rather than the function itself. This requires adding a memory context deletion callback to ensure that the SRF state is cleaned up if the calling query exits before running the SRF to completion. Without that we'd leak a refcount to the iterator object in such a case, resulting in session-lifespan memory leakage. (In the pre-existing code, there was no memory leak because there was only one iterator pointer, but what would happen is that the previous iterator would be resumed by the next query attempting to use the SRF. Hardly the semantics we want.) We can buy back some of whatever overhead we've added by getting rid of PLy_function_delete_args(), which seems a useless activity: there is no need to delete argument entries from the global dictionary on exit, since the next time anyone would see the global dict is on the next fresh call of the PL/Python function, at which time we'd overwrite those entries with new arg values anyway. Also clean up some really ugly coding in the SRF implementation, including such gems as returning directly out of a PG_TRY block. (The only reason that failed to crash hard was that all existing call sites immediately exited their own PG_TRY blocks, popping the dangling longjmp pointer before there was any chance of it being used.) In principle this is a bug fix; but it seems a bit too invasive relative to its value for a back-patch, and besides the fix depends on memory context callbacks so it could not go back further than 9.5 anyway. Alexey Grishchenko and Tom Lane
98 lines
2.4 KiB
PL/PgSQL
98 lines
2.4 KiB
PL/PgSQL
--
|
|
-- Test returning SETOF
|
|
--
|
|
|
|
CREATE FUNCTION test_setof_error() RETURNS SETOF text AS $$
|
|
return 37
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
SELECT test_setof_error();
|
|
|
|
|
|
CREATE FUNCTION test_setof_as_list(count integer, content text) RETURNS SETOF text AS $$
|
|
return [ content ]*count
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
CREATE FUNCTION test_setof_as_tuple(count integer, content text) RETURNS SETOF text AS $$
|
|
t = ()
|
|
for i in range(count):
|
|
t += ( content, )
|
|
return t
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
CREATE FUNCTION test_setof_as_iterator(count integer, content text) RETURNS SETOF text AS $$
|
|
class producer:
|
|
def __init__ (self, icount, icontent):
|
|
self.icontent = icontent
|
|
self.icount = icount
|
|
def __iter__ (self):
|
|
return self
|
|
def next (self):
|
|
if self.icount == 0:
|
|
raise StopIteration
|
|
self.icount -= 1
|
|
return self.icontent
|
|
return producer(count, content)
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
CREATE FUNCTION test_setof_spi_in_iterator() RETURNS SETOF text AS
|
|
$$
|
|
for s in ('Hello', 'Brave', 'New', 'World'):
|
|
plpy.execute('select 1')
|
|
yield s
|
|
plpy.execute('select 2')
|
|
$$
|
|
LANGUAGE plpythonu;
|
|
|
|
|
|
-- Test set returning functions
|
|
SELECT test_setof_as_list(0, 'list');
|
|
SELECT test_setof_as_list(1, 'list');
|
|
SELECT test_setof_as_list(2, 'list');
|
|
SELECT test_setof_as_list(2, null);
|
|
|
|
SELECT test_setof_as_tuple(0, 'tuple');
|
|
SELECT test_setof_as_tuple(1, 'tuple');
|
|
SELECT test_setof_as_tuple(2, 'tuple');
|
|
SELECT test_setof_as_tuple(2, null);
|
|
|
|
SELECT test_setof_as_iterator(0, 'list');
|
|
SELECT test_setof_as_iterator(1, 'list');
|
|
SELECT test_setof_as_iterator(2, 'list');
|
|
SELECT test_setof_as_iterator(2, null);
|
|
|
|
SELECT test_setof_spi_in_iterator();
|
|
|
|
-- set-returning function that modifies its parameters
|
|
CREATE OR REPLACE FUNCTION ugly(x int, lim int) RETURNS SETOF int AS $$
|
|
global x
|
|
while x <= lim:
|
|
yield x
|
|
x = x + 1
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
SELECT ugly(1, 5);
|
|
|
|
-- interleaved execution of such a function
|
|
SELECT ugly(1,3), ugly(7,8);
|
|
|
|
-- returns set of named-composite-type tuples
|
|
CREATE OR REPLACE FUNCTION get_user_records()
|
|
RETURNS SETOF users
|
|
AS $$
|
|
return plpy.execute("SELECT * FROM users ORDER BY username")
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
SELECT get_user_records();
|
|
SELECT * FROM get_user_records();
|
|
|
|
-- same, but returning set of RECORD
|
|
CREATE OR REPLACE FUNCTION get_user_records2()
|
|
RETURNS TABLE(fname text, lname text, username text, userid int)
|
|
AS $$
|
|
return plpy.execute("SELECT * FROM users ORDER BY username")
|
|
$$ LANGUAGE plpythonu;
|
|
|
|
SELECT get_user_records2();
|
|
SELECT * FROM get_user_records2();
|