pg.ddx.io pgsql-committers@postgresql.org mailing list archivehelp / color / mirror / Atom feed
pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. 6+ messages / 1 participants [nested] [flat]
* pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. @ 2022-02-11 20:24 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-02-11 20:24 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Don't use_physical_tlist for an IOS with non-returnable columns. createplan.c tries to save a runtime projection step by specifying a scan plan node's output as being exactly the table's columns, or index's columns in the case of an index-only scan, if there is not a reason to do otherwise. This logic did not previously pay attention to whether an index's columns are returnable. That worked, sort of accidentally, until commit 9a3ddeb51 taught setrefs.c to reject plans that try to read a non-returnable column. I have no desire to loosen setrefs.c's new check, so instead adjust use_physical_tlist() to not try to optimize this way when there are non-returnable column(s). Per report from Ryan Kelly. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/CAHUie24ddN+pDNw7fkhNrjrwAX=fXXfGZZEHhRuofV_N_ftaSg@mail.gmail.com Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/e5691cc9170bcd6c684715c2755d919c5a16fea2 Modified Files -------------- src/backend/optimizer/plan/createplan.c | 16 ++++++++++++++++ src/test/regress/expected/gist.out | 16 ++++++++++++++++ src/test/regress/sql/gist.sql | 5 +++++ 3 files changed, 37 insertions(+) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. @ 2022-02-11 20:24 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-02-11 20:24 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Don't use_physical_tlist for an IOS with non-returnable columns. createplan.c tries to save a runtime projection step by specifying a scan plan node's output as being exactly the table's columns, or index's columns in the case of an index-only scan, if there is not a reason to do otherwise. This logic did not previously pay attention to whether an index's columns are returnable. That worked, sort of accidentally, until commit 9a3ddeb51 taught setrefs.c to reject plans that try to read a non-returnable column. I have no desire to loosen setrefs.c's new check, so instead adjust use_physical_tlist() to not try to optimize this way when there are non-returnable column(s). Per report from Ryan Kelly. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/CAHUie24ddN+pDNw7fkhNrjrwAX=fXXfGZZEHhRuofV_N_ftaSg@mail.gmail.com Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/277e744ae176ef8e411a9e6c5b2e649322ee6bdd Modified Files -------------- src/backend/optimizer/plan/createplan.c | 16 ++++++++++++++++ src/test/regress/expected/gist.out | 16 ++++++++++++++++ src/test/regress/sql/gist.sql | 5 +++++ 3 files changed, 37 insertions(+) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. @ 2022-02-11 20:24 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-02-11 20:24 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Don't use_physical_tlist for an IOS with non-returnable columns. createplan.c tries to save a runtime projection step by specifying a scan plan node's output as being exactly the table's columns, or index's columns in the case of an index-only scan, if there is not a reason to do otherwise. This logic did not previously pay attention to whether an index's columns are returnable. That worked, sort of accidentally, until commit 9a3ddeb51 taught setrefs.c to reject plans that try to read a non-returnable column. I have no desire to loosen setrefs.c's new check, so instead adjust use_physical_tlist() to not try to optimize this way when there are non-returnable column(s). Per report from Ryan Kelly. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/CAHUie24ddN+pDNw7fkhNrjrwAX=fXXfGZZEHhRuofV_N_ftaSg@mail.gmail.com Branch ------ REL_13_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/0778b24ced8a873b432641001d046d1dde602466 Modified Files -------------- src/backend/optimizer/plan/createplan.c | 16 ++++++++++++++++ src/test/regress/expected/gist.out | 16 ++++++++++++++++ src/test/regress/sql/gist.sql | 5 +++++ 3 files changed, 37 insertions(+) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. @ 2022-02-11 20:24 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-02-11 20:24 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Don't use_physical_tlist for an IOS with non-returnable columns. createplan.c tries to save a runtime projection step by specifying a scan plan node's output as being exactly the table's columns, or index's columns in the case of an index-only scan, if there is not a reason to do otherwise. This logic did not previously pay attention to whether an index's columns are returnable. That worked, sort of accidentally, until commit 9a3ddeb51 taught setrefs.c to reject plans that try to read a non-returnable column. I have no desire to loosen setrefs.c's new check, so instead adjust use_physical_tlist() to not try to optimize this way when there are non-returnable column(s). Per report from Ryan Kelly. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/CAHUie24ddN+pDNw7fkhNrjrwAX=fXXfGZZEHhRuofV_N_ftaSg@mail.gmail.com Branch ------ REL_12_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/32e801676b1ef821c6ee308f7ea42386a3e15768 Modified Files -------------- src/backend/optimizer/plan/createplan.c | 16 ++++++++++++++++ src/test/regress/expected/gist.out | 16 ++++++++++++++++ src/test/regress/sql/gist.sql | 5 +++++ 3 files changed, 37 insertions(+) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. @ 2022-02-11 20:24 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-02-11 20:24 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Don't use_physical_tlist for an IOS with non-returnable columns. createplan.c tries to save a runtime projection step by specifying a scan plan node's output as being exactly the table's columns, or index's columns in the case of an index-only scan, if there is not a reason to do otherwise. This logic did not previously pay attention to whether an index's columns are returnable. That worked, sort of accidentally, until commit 9a3ddeb51 taught setrefs.c to reject plans that try to read a non-returnable column. I have no desire to loosen setrefs.c's new check, so instead adjust use_physical_tlist() to not try to optimize this way when there are non-returnable column(s). Per report from Ryan Kelly. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/CAHUie24ddN+pDNw7fkhNrjrwAX=fXXfGZZEHhRuofV_N_ftaSg@mail.gmail.com Branch ------ REL_11_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/14ee565f399b69b56eaed29c5e2f5a33ab45710f Modified Files -------------- src/backend/optimizer/plan/createplan.c | 16 ++++++++++++++++ src/test/regress/expected/gist.out | 16 ++++++++++++++++ src/test/regress/sql/gist.sql | 5 +++++ 3 files changed, 37 insertions(+) ^ permalink raw reply [nested|flat] 6+ messages in thread
* pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. @ 2022-02-11 20:24 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 6+ messages in thread From: Tom Lane @ 2022-02-11 20:24 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Don't use_physical_tlist for an IOS with non-returnable columns. createplan.c tries to save a runtime projection step by specifying a scan plan node's output as being exactly the table's columns, or index's columns in the case of an index-only scan, if there is not a reason to do otherwise. This logic did not previously pay attention to whether an index's columns are returnable. That worked, sort of accidentally, until commit 9a3ddeb51 taught setrefs.c to reject plans that try to read a non-returnable column. I have no desire to loosen setrefs.c's new check, so instead adjust use_physical_tlist() to not try to optimize this way when there are non-returnable column(s). Per report from Ryan Kelly. Like the previous patch, back-patch to all supported branches. Discussion: https://postgr.es/m/CAHUie24ddN+pDNw7fkhNrjrwAX=fXXfGZZEHhRuofV_N_ftaSg@mail.gmail.com Branch ------ REL_10_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/b6f869beeab06981c223ff35088fdb8a5422584d Modified Files -------------- src/backend/optimizer/plan/createplan.c | 16 ++++++++++++++++ src/test/regress/expected/gist.out | 16 ++++++++++++++++ src/test/regress/sql/gist.sql | 5 +++++ 3 files changed, 37 insertions(+) ^ permalink raw reply [nested|flat] 6+ messages in thread
end of thread, other threads:[~2022-02-11 20:24 UTC | newest] Thread overview: 6+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2022-02-11 20:24 pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. Tom Lane <tgl@sss.pgh.pa.us> 2022-02-11 20:24 pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. Tom Lane <tgl@sss.pgh.pa.us> 2022-02-11 20:24 pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. Tom Lane <tgl@sss.pgh.pa.us> 2022-02-11 20:24 pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. Tom Lane <tgl@sss.pgh.pa.us> 2022-02-11 20:24 pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. Tom Lane <tgl@sss.pgh.pa.us> 2022-02-11 20:24 pgsql: Don't use_physical_tlist for an IOS with non-returnable columns. 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