agora inbox for pgsql-committers@postgresql.orghelp / color / mirror / Atom feed
pgsql: Fix btree_gist's NotEqual strategy on internal index pages. 7+ messages / 1 participants [nested] [flat]
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ master Details ------- https://git.postgresql.org/pg/commitdiff/eef644e57c38a79eb29bf9f3f05efbcee8fbdfce Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ REL_19_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/fc6649abefd44bd0edc4318e3e82caf34b0e885f Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ REL_18_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/12c519207db01a9d4a6b47b205883928a083758f Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ REL_17_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/86992769e8fb75910858f64172797f4f011e4f02 Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ REL_16_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/0663382c9bf9aac58ccd1586c92f10eac794b191 Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ REL_15_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/8f2a1b3d3511aa07c19c0066d75c06e81496f7c2 Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
* pgsql: Fix btree_gist's NotEqual strategy on internal index pages. @ 2026-07-03 17:50 Tom Lane <tgl@sss.pgh.pa.us> 0 siblings, 0 replies; 7+ messages in thread From: Tom Lane @ 2026-07-03 17:50 UTC (permalink / raw) To: pgsql-committers@lists.postgresql.org Fix btree_gist's NotEqual strategy on internal index pages. gbt_var_consistent() handled the <> (BtreeGistNotEqual) strategy without distinguishing leaf from internal pages, unlike every other strategy. In particular, it tried to apply the datatype-specific f_eq method, which is completely wrong since internal keys might not have the same representation as leaf keys. This led to OOB reads and potentially crashes, and most likely to wrong query results as well. On leaf pages we can apply the inverse of what the Equal strategy does. On internal pages, use a correct implementation of what the previous code intended: we can descend if the query value equals both bounds, *so long as the bounds aren't truncated*. With truncated bounds we don't quite know the range of what's below, so we must always descend. Adjust the code in gbt_num_consistent() to look similar, too. This fixes a performance buglet in that there's no need to do two comparisons on a leaf entry, but the main point is just to keep code consistency. Reported-by: 王跃林 <violin0613@tju.edu.cn> Author: Ayush Tiwari <ayushtiwari.slg01@gmail.com> Reviewed-by: Tom Lane <tgl@sss.pgh.pa.us> Discussion: https://postgr.es/m/AH*AvQCYKhQGVvPWi1GiU4oY.8.1781609375063.Hmail.3020001251@tju.edu.cn Backpatch-through: 14 Branch ------ REL_14_STABLE Details ------- https://git.postgresql.org/pg/commitdiff/286f9a3cec4b9c4b1d1c49d0b35b6ef074ed2629 Modified Files -------------- contrib/btree_gist/btree_utils_num.c | 15 +++++++++++++-- contrib/btree_gist/btree_utils_var.c | 23 +++++++++++++++++++++-- 2 files changed, 34 insertions(+), 4 deletions(-) ^ permalink raw reply [nested|flat] 7+ messages in thread
end of thread, other threads:[~2026-07-03 17:50 UTC | newest] Thread overview: 7+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us> 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us> 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us> 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us> 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us> 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us> 2026-07-03 17:50 pgsql: Fix btree_gist's NotEqual strategy on internal index pages. Tom Lane <tgl@sss.pgh.pa.us>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox