pg.ddx.io pgsql-committers@postgresql.org mailing list archivehelp / color / mirror / Atom feed
pgsql: Fix incorrect step generation in HASH partition pruning 7+ messages / 1 participants [nested] [flat]
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:51 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:51 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/f0c409d9c7a6a92bb4a6b5812ffc5ef94b4c8ed0 Modified Files -------------- src/backend/partitioning/partprune.c | 103 ++++++------ src/test/regress/expected/partition_prune.out | 219 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 ++++++- 3 files changed, 315 insertions(+), 62 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:51 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:51 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ REL_16_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/6352f1627641025f90423b44716b6ad5f2adb7b6 Modified Files -------------- src/backend/partitioning/partprune.c | 103 ++++++------ src/test/regress/expected/partition_prune.out | 219 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 ++++++- 3 files changed, 315 insertions(+), 62 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:52 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:52 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ REL_15_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/916adc7c50bbfe6e53d80dd66b61c580f0f3c89e Modified Files -------------- src/backend/partitioning/partprune.c | 103 ++++++------ src/test/regress/expected/partition_prune.out | 219 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 ++++++- 3 files changed, 315 insertions(+), 62 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:52 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:52 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/cd15bff4814bbc785116f2cffe840b527f7d6cb9 Modified Files -------------- src/backend/partitioning/partprune.c | 103 ++++++------ src/test/regress/expected/partition_prune.out | 219 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 ++++++- 3 files changed, 315 insertions(+), 62 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:53 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:53 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ REL_13_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/45c4b2a3aa72c1b4f24c51e7e219fda8f83df868 Modified Files -------------- src/backend/partitioning/partprune.c | 103 ++++++------ src/test/regress/expected/partition_prune.out | 219 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 ++++++- 3 files changed, 315 insertions(+), 62 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:53 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:53 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ REL_12_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/cd259de50ac5dc67bca5662921c4234682fe3c4a Modified Files -------------- src/backend/partitioning/partprune.c | 106 ++++++++----- src/test/regress/expected/partition_prune.out | 219 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 ++++++- 3 files changed, 319 insertions(+), 61 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix incorrect step generation in HASH partition pruning @ 2023-10-12 06:54 David Rowley <drowley@postgresql.org> 0 siblings, 0 replies; 7+ messages in thread From: David Rowley @ 2023-10-12 06:54 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix incorrect step generation in HASH partition pruning get_steps_using_prefix_recurse() incorrectly assumed that it could stop recursive processing of the 'prefix' list when cur_keyno was one before the step_lastkeyno. Since hash partition pruning can prune using IS NULL quals, and these IS NULL quals are not present in the 'prefix' list, then that logic could cause more levels of recursion than what is needed and lead to there being no more items in the 'prefix' list to process. This would manifest itself as a crash in some code that expected the 'start' ListCell not to be NULL. Here we adjust the logic so that instead of stopping recursion at 1 key before the step_lastkeyno, we just look at the llast(prefix) item and ensure we only recursively process up until just before whichever the last key is. This effectively allows keys to be missing in the 'prefix' list. This change does mean that step_lastkeyno is no longer needed, so we remove that from the static functions. I also spent quite some time reading this code and testing it to try to convince myself that there are no other issues. That resulted in the irresistible temptation of rewriting some comments, many of which were just not true or inconcise. Reported-by: Sergei Glukhov Reviewed-by: Sergei Glukhov, tender wang Discussion: https://postgr.es/m/2f09ce72-315e-2a33-589a-8519ada8df61@postgrespro.ru Backpatch-through: 11, where partition pruning was introduced. Branch ------ REL_11_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/07f261b3172d6371019af38f61d17f5c3c1fe9aa Modified Files -------------- src/backend/partitioning/partprune.c | 106 +++++++----- src/test/regress/expected/partition_prune.out | 236 ++++++++++++++++++++++++-- src/test/regress/sql/partition_prune.sql | 55 +++++- 3 files changed, 335 insertions(+), 62 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
end of thread, other threads:[~2023-10-12 06:54 UTC | newest] Thread overview: 7+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2023-10-12 06:51 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org> 2023-10-12 06:51 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org> 2023-10-12 06:52 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org> 2023-10-12 06:52 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org> 2023-10-12 06:53 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org> 2023-10-12 06:53 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org> 2023-10-12 06:54 pgsql: Fix incorrect step generation in HASH partition pruning David Rowley <drowley@postgresql.org>
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