pg.ddx.io pgsql-committers@postgresql.org mailing list archivehelp / color / mirror / Atom feed
pgsql: Fix edge case in plpgsql's make_callstmt_target(). 5+ messages / 1 participants [nested] [flat]
* pgsql: Fix edge case in plpgsql's make_callstmt_target(). @ 2024-08-07 16:55 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 5+ messages in thread From: Tom Lane @ 2024-08-07 16:55 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix edge case in plpgsql's make_callstmt_target(). If the plancache entry for the CALL statement is already stale, it's possible for us to fetch an old procedure OID out of it, and then fail with "cache lookup failed for function NNN". In ordinary usage this never happens because make_callstmt_target is called just once immediately after building the plancache entry. It can be forced however by setting up an erroneous CALL (that causes make_callstmt_target itself to report an error), then dropping/recreating the target procedure, then repeating the erroneous CALL. To fix, use SPI_plan_get_cached_plan() to fetch the plancache's plan, rather than assuming we can use SPI_plan_get_plan_sources(). This shouldn't add any noticeable overhead in the normal case, and in the stale-plan case we'd have had to replan anyway a little further down. The other callers of SPI_plan_get_plan_sources() seem OK, because either they don't need up-to-date plans or they know that the query was just (re) planned. But add some commentary in hopes of not falling into this trap again. Per bug #18574 from Song Hongyu. Back-patch to v14 where this coding was introduced. (Older branches have comparable code, but it's run after any required replanning, so there's no issue.) Discussion: https://postgr.es/m/18574-2ce7ba3249221389@postgresql.org Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/8d148bb8b8529ed8edeee4332e8eb41bac0fc193 Modified Files -------------- src/backend/executor/spi.c | 2 ++ src/pl/plpgsql/src/pl_exec.c | 26 ++++++++++++++------------ 2 files changed, 16 insertions(+), 12 deletions(-) ^ permalink raw reply [nested|flat] 5+ messages in thread
* pgsql: Fix edge case in plpgsql's make_callstmt_target(). @ 2024-08-07 16:55 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 5+ messages in thread From: Tom Lane @ 2024-08-07 16:55 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix edge case in plpgsql's make_callstmt_target(). If the plancache entry for the CALL statement is already stale, it's possible for us to fetch an old procedure OID out of it, and then fail with "cache lookup failed for function NNN". In ordinary usage this never happens because make_callstmt_target is called just once immediately after building the plancache entry. It can be forced however by setting up an erroneous CALL (that causes make_callstmt_target itself to report an error), then dropping/recreating the target procedure, then repeating the erroneous CALL. To fix, use SPI_plan_get_cached_plan() to fetch the plancache's plan, rather than assuming we can use SPI_plan_get_plan_sources(). This shouldn't add any noticeable overhead in the normal case, and in the stale-plan case we'd have had to replan anyway a little further down. The other callers of SPI_plan_get_plan_sources() seem OK, because either they don't need up-to-date plans or they know that the query was just (re) planned. But add some commentary in hopes of not falling into this trap again. Per bug #18574 from Song Hongyu. Back-patch to v14 where this coding was introduced. (Older branches have comparable code, but it's run after any required replanning, so there's no issue.) Discussion: https://postgr.es/m/18574-2ce7ba3249221389@postgresql.org Branch ------ REL_17_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/0dd33a6fcab746d518cec56d2bc0d8ec0edffd32 Modified Files -------------- src/backend/executor/spi.c | 2 ++ src/pl/plpgsql/src/pl_exec.c | 26 ++++++++++++++------------ 2 files changed, 16 insertions(+), 12 deletions(-) ^ permalink raw reply [nested|flat] 5+ messages in thread
* pgsql: Fix edge case in plpgsql's make_callstmt_target(). @ 2024-08-07 16:55 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 5+ messages in thread From: Tom Lane @ 2024-08-07 16:55 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix edge case in plpgsql's make_callstmt_target(). If the plancache entry for the CALL statement is already stale, it's possible for us to fetch an old procedure OID out of it, and then fail with "cache lookup failed for function NNN". In ordinary usage this never happens because make_callstmt_target is called just once immediately after building the plancache entry. It can be forced however by setting up an erroneous CALL (that causes make_callstmt_target itself to report an error), then dropping/recreating the target procedure, then repeating the erroneous CALL. To fix, use SPI_plan_get_cached_plan() to fetch the plancache's plan, rather than assuming we can use SPI_plan_get_plan_sources(). This shouldn't add any noticeable overhead in the normal case, and in the stale-plan case we'd have had to replan anyway a little further down. The other callers of SPI_plan_get_plan_sources() seem OK, because either they don't need up-to-date plans or they know that the query was just (re) planned. But add some commentary in hopes of not falling into this trap again. Per bug #18574 from Song Hongyu. Back-patch to v14 where this coding was introduced. (Older branches have comparable code, but it's run after any required replanning, so there's no issue.) Discussion: https://postgr.es/m/18574-2ce7ba3249221389@postgresql.org Branch ------ REL_16_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/a073835c19cfcd5ce1c9826f2f9356944d807b0e Modified Files -------------- src/backend/executor/spi.c | 2 ++ src/pl/plpgsql/src/pl_exec.c | 26 ++++++++++++++------------ 2 files changed, 16 insertions(+), 12 deletions(-) ^ permalink raw reply [nested|flat] 5+ messages in thread
* pgsql: Fix edge case in plpgsql's make_callstmt_target(). @ 2024-08-07 16:55 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 5+ messages in thread From: Tom Lane @ 2024-08-07 16:55 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix edge case in plpgsql's make_callstmt_target(). If the plancache entry for the CALL statement is already stale, it's possible for us to fetch an old procedure OID out of it, and then fail with "cache lookup failed for function NNN". In ordinary usage this never happens because make_callstmt_target is called just once immediately after building the plancache entry. It can be forced however by setting up an erroneous CALL (that causes make_callstmt_target itself to report an error), then dropping/recreating the target procedure, then repeating the erroneous CALL. To fix, use SPI_plan_get_cached_plan() to fetch the plancache's plan, rather than assuming we can use SPI_plan_get_plan_sources(). This shouldn't add any noticeable overhead in the normal case, and in the stale-plan case we'd have had to replan anyway a little further down. The other callers of SPI_plan_get_plan_sources() seem OK, because either they don't need up-to-date plans or they know that the query was just (re) planned. But add some commentary in hopes of not falling into this trap again. Per bug #18574 from Song Hongyu. Back-patch to v14 where this coding was introduced. (Older branches have comparable code, but it's run after any required replanning, so there's no issue.) Discussion: https://postgr.es/m/18574-2ce7ba3249221389@postgresql.org Branch ------ REL_15_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/de35207015567da892d825a704933e6681347f19 Modified Files -------------- src/backend/executor/spi.c | 2 ++ src/pl/plpgsql/src/pl_exec.c | 26 ++++++++++++++------------ 2 files changed, 16 insertions(+), 12 deletions(-) ^ permalink raw reply [nested|flat] 5+ messages in thread
* pgsql: Fix edge case in plpgsql's make_callstmt_target(). @ 2024-08-07 16:55 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 5+ messages in thread From: Tom Lane @ 2024-08-07 16:55 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix edge case in plpgsql's make_callstmt_target(). If the plancache entry for the CALL statement is already stale, it's possible for us to fetch an old procedure OID out of it, and then fail with "cache lookup failed for function NNN". In ordinary usage this never happens because make_callstmt_target is called just once immediately after building the plancache entry. It can be forced however by setting up an erroneous CALL (that causes make_callstmt_target itself to report an error), then dropping/recreating the target procedure, then repeating the erroneous CALL. To fix, use SPI_plan_get_cached_plan() to fetch the plancache's plan, rather than assuming we can use SPI_plan_get_plan_sources(). This shouldn't add any noticeable overhead in the normal case, and in the stale-plan case we'd have had to replan anyway a little further down. The other callers of SPI_plan_get_plan_sources() seem OK, because either they don't need up-to-date plans or they know that the query was just (re) planned. But add some commentary in hopes of not falling into this trap again. Per bug #18574 from Song Hongyu. Back-patch to v14 where this coding was introduced. (Older branches have comparable code, but it's run after any required replanning, so there's no issue.) Discussion: https://postgr.es/m/18574-2ce7ba3249221389@postgresql.org Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/7f875fb5bd603d8640cc7aca2c79c604aacd3890 Modified Files -------------- src/backend/executor/spi.c | 2 ++ src/pl/plpgsql/src/pl_exec.c | 26 ++++++++++++++------------ 2 files changed, 16 insertions(+), 12 deletions(-) ^ permalink raw reply [nested|flat] 5+ messages in thread
end of thread, other threads:[~2024-08-07 16:55 UTC | newest] Thread overview: 5+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2024-08-07 16:55 pgsql: Fix edge case in plpgsql's make_callstmt_target(). Tom Lane <tgl@sss.pgh.pa.us> 2024-08-07 16:55 pgsql: Fix edge case in plpgsql's make_callstmt_target(). Tom Lane <tgl@sss.pgh.pa.us> 2024-08-07 16:55 pgsql: Fix edge case in plpgsql's make_callstmt_target(). Tom Lane <tgl@sss.pgh.pa.us> 2024-08-07 16:55 pgsql: Fix edge case in plpgsql's make_callstmt_target(). Tom Lane <tgl@sss.pgh.pa.us> 2024-08-07 16:55 pgsql: Fix edge case in plpgsql's make_callstmt_target(). Tom Lane <tgl@sss.pgh.pa.us>
This inbox is served by DDX for PostgreSQL; see mirroring instructions for how to clone and mirror all data and code used for this inbox