agora inbox for pgsql-hackers@postgresql.orghelp / color / mirror / Atom feed
[PATCH] Fix timeline-tracking failure while sending a historic timeline 14+ messages / 2 participants [nested] [flat]
* [PATCH] Fix timeline-tracking failure while sending a historic timeline @ 2021-01-05 04:34 Kyotaro Horiguchi <horikyoga.ntt@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Kyotaro Horiguchi @ 2021-01-05 04:34 UTC (permalink / raw) Walsender should track timeline switches while sending a historic timeline. Regain that behavior, which was broken in PG13, by a thinko of 709d003fbd. Backpatch to PG13. --- src/backend/replication/walsender.c | 2 +- src/test/perl/PostgresNode.pm | 36 ++++++++++++++++++++ src/test/recovery/t/001_stream_rep.pl | 41 ++++++++++++++++++++++- src/test/recovery/t/019_replslot_limit.pl | 37 ++++---------------- 4 files changed, 83 insertions(+), 33 deletions(-) diff --git a/src/backend/replication/walsender.c b/src/backend/replication/walsender.c index 7f87eb7f19..04f6c3ebb4 100644 --- a/src/backend/replication/walsender.c +++ b/src/backend/replication/walsender.c @@ -2478,7 +2478,7 @@ WalSndSegmentOpen(XLogReaderState *state, XLogSegNo nextSegNo, XLogSegNo endSegNo; XLByteToSeg(sendTimeLineValidUpto, endSegNo, state->segcxt.ws_segsize); - if (state->seg.ws_segno == endSegNo) + if (nextSegNo == endSegNo) *tli_p = sendTimeLineNextTLI; } diff --git a/src/test/perl/PostgresNode.pm b/src/test/perl/PostgresNode.pm index 980f1f1533..a08c71b549 100644 --- a/src/test/perl/PostgresNode.pm +++ b/src/test/perl/PostgresNode.pm @@ -2138,6 +2138,42 @@ sub pg_recvlogical_upto =pod +=item $node->current_log_position() + +Return the current position of server log. + +=cut + +sub current_log_position +{ + my $self = shift; + + return (stat $self->logfile)[7]; +} + +=pod + +=item $node->find_in_log($pattern, $startpos) + +Returns whether the $pattern occurs after $startpos in the server log. + +=cut + +sub find_in_log +{ + my ($self, $pattern, $startpos) = @_; + + $startpos = 0 unless defined $startpos; + my $log = TestLib::slurp_file($self->logfile); + return 0 if (length($log) <= $startpos); + + $log = substr($log, $startpos); + + return $log =~ m/$pattern/; +} + +=pod + =back =cut diff --git a/src/test/recovery/t/001_stream_rep.pl b/src/test/recovery/t/001_stream_rep.pl index 778f11b28b..8d2b24fe55 100644 --- a/src/test/recovery/t/001_stream_rep.pl +++ b/src/test/recovery/t/001_stream_rep.pl @@ -2,8 +2,9 @@ use strict; use warnings; use PostgresNode; +use Time::HiRes qw(usleep); use TestLib; -use Test::More tests => 36; +use Test::More tests => 37; # Initialize master node my $node_master = get_new_node('master'); @@ -409,3 +410,41 @@ ok( ($phys_restart_lsn_pre cmp $phys_restart_lsn_post) == 0, my $master_data = $node_master->data_dir; ok(!-f "$master_data/pg_wal/$segment_removed", "WAL segment $segment_removed recycled after physical slot advancing"); + +# +# Check if timeline-increment works while reading a historic timeline. +my $node_primary_2 = get_new_node('primary_2'); +# archiving is needed to create .paritial segment +$node_primary_2->init(allows_streaming => 1, has_archiving => 1); +$node_primary_2->start; +$node_primary_2->backup($backup_name); +my $node_standby_3 = get_new_node('standby_3'); +$node_standby_3->init_from_backup($node_primary_2, $backup_name, + has_streaming => 1); +$node_primary_2->stop; +$node_primary_2->set_standby_mode; # increment primary timeline +$node_primary_2->start; +$node_primary_2->promote; +my $logstart = $node_standby_3->current_log_position(); +$node_standby_3->start; + +my $success = 0; +for (my $i = 0 ; $i < 1000; $i++) +{ + if ($node_standby_3->find_in_log( + "requested WAL segment [0-9A-F]+ has already been removed", + $logstart)) + { + last; + } + elsif ($node_standby_3->find_in_log( + "End of WAL reached on timeline", + $logstart)) + { + $success = 1; + last; + } + usleep(100_000); +} + +ok($success, 'Timeline increment while reading a historic timeline'); diff --git a/src/test/recovery/t/019_replslot_limit.pl b/src/test/recovery/t/019_replslot_limit.pl index a7231dcd47..8b3c5de057 100644 --- a/src/test/recovery/t/019_replslot_limit.pl +++ b/src/test/recovery/t/019_replslot_limit.pl @@ -165,19 +165,17 @@ $node_master->wait_for_catchup($node_standby, 'replay', $start_lsn); $node_standby->stop; -ok( !find_in_log( - $node_standby, - "requested WAL segment [0-9A-F]+ has already been removed"), +ok( !$node_standby->find_in_log( + "requested WAL segment [0-9A-F]+ has already been removed"), 'check that required WAL segments are still available'); # Advance WAL again, the slot loses the oldest segment. -my $logstart = get_log_size($node_master); +my $logstart = $node_master->current_log_position(); advance_wal($node_master, 7); $node_master->safe_psql('postgres', "CHECKPOINT;"); # WARNING should be issued -ok( find_in_log( - $node_master, +ok( $node_master->find_in_log( "invalidating slot \"rep1\" because its restart_lsn [0-9A-F/]+ exceeds max_slot_wal_keep_size", $logstart), 'check that the warning is logged'); @@ -190,14 +188,13 @@ is($result, "rep1|f|t|lost|", 'check that the slot became inactive and the state "lost" persists'); # The standby no longer can connect to the master -$logstart = get_log_size($node_standby); +$logstart = $node_standby->current_log_position(); $node_standby->start; my $failed = 0; for (my $i = 0; $i < 10000; $i++) { - if (find_in_log( - $node_standby, + if ($node_standby->find_in_log( "requested WAL segment [0-9A-F]+ has already been removed", $logstart)) { @@ -264,25 +261,3 @@ sub advance_wal } return; } - -# return the size of logfile of $node in bytes -sub get_log_size -{ - my ($node) = @_; - - return (stat $node->logfile)[7]; -} - -# find $pat in logfile of $node after $off-th byte -sub find_in_log -{ - my ($node, $pat, $off) = @_; - - $off = 0 unless defined $off; - my $log = TestLib::slurp_file($node->logfile); - return 0 if (length($log) <= $off); - - $log = substr($log, $off); - - return $log =~ m/$pat/; -} -- 2.27.0 ----Next_Part(Thu_Jan__7_16_32_36_2021_122)---- ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v5 02/14] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 44bf38be3c9..a9ba2bdfb88 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -108,6 +108,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -760,16 +770,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; scanstate->worker_snapshot = NULL; /* -- 2.37.2 --6kjpcnqyi64ibp5i Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v5-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v11 02/17] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226b..c64530674b 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --owzzsiozz6hgpp7e Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v11-0003-Push-BitmapHeapScan-skip-fetch-optimization-into.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v8 02/17] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226b..c64530674b 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --xqq4defy3uncu6k6 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v8-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v13 02/16] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226b..c64530674b 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --cuuqjeyokkhgd736 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v13-0003-Push-BitmapHeapScan-skip-fetch-optimization-into.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v16 02/18] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() instead of in ExecInitBitmapHeapScan(). This is a preliminary step to pushing the skip fetch optimization into heap AM code. Author: Melanie Plageman Reviewed-by: Andres Freund, Heikki Linnakangas, Tomas Vondra Discussion: https://postgr.es/m/CAAKRu_ZwCwWFeL_H3ia26bP2e7HiKLWt0ZmGXPVwPO6uXq0vaA%40mail.gmail.com --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index c8c466e3c5..2148a21531 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -743,16 +753,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --e3xl7h75mzefinno Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v16-0003-Push-BitmapHeapScan-skip-fetch-optimization-into.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v7 02/13] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226bf..c64530674bd 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --kqqpqghcwbcc3dt5 Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v7-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v9 02/17] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226b..c64530674b 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --7mdtsjmrzitrgzgx Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v9-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v12 02/17] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226bf..c64530674bd 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --6jpz2j246qmht4bt Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v12-0003-Push-BitmapHeapScan-skip-fetch-optimization-into.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v10 02/17] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 93fdcd226b..c64530674b 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --3o7pc6dfau5a5hry Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v10-0003-Push-BitmapHeapScan-skip-fetch-optimization-into.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v3 02/13] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 44bf38be3c9..a9ba2bdfb88 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -108,6 +108,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -760,16 +770,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; scanstate->worker_snapshot = NULL; /* -- 2.37.2 --fa5b4qdlc6zixc7z Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v3-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v4 02/14] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 44bf38be3c9..a9ba2bdfb88 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -108,6 +108,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -760,16 +770,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; scanstate->worker_snapshot = NULL; /* -- 2.37.2 --5aaqsqqhbq27q3qo Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v4-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v15 02/13] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() instead of in ExecInitBitmapHeapScan(). This is a preliminary step to pushing the skip fetch optimization into heap AM code. Author: Melanie Plageman Reviewed-by: Andres Freund, Heikki Linnakangas, Tomas Vondra Discussion: https://postgr.es/m/CAAKRu_ZwCwWFeL_H3ia26bP2e7HiKLWt0ZmGXPVwPO6uXq0vaA%40mail.gmail.com --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index c8c466e3c5..2148a21531 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -743,16 +753,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --pbix6fw3h4kvmjae Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v15-0003-Push-BitmapHeapScan-skip-fetch-optimization-into.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
* [PATCH v6 02/14] BitmapHeapScan set can_skip_fetch later @ 2024-02-13 19:38 Melanie Plageman <melanieplageman@gmail.com> 0 siblings, 0 replies; 14+ messages in thread From: Melanie Plageman @ 2024-02-13 19:38 UTC (permalink / raw) Set BitmapHeapScanState->can_skip_fetch in BitmapHeapNext() when !BitmapHeapScanState->initialized instead of in ExecInitBitmapHeapScan(). This is a preliminary step to removing can_skip_fetch from BitmapHeapScanState and setting it in table AM specific code. --- src/backend/executor/nodeBitmapHeapscan.c | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/backend/executor/nodeBitmapHeapscan.c b/src/backend/executor/nodeBitmapHeapscan.c index 6d756001fdb..05cf610f9b4 100644 --- a/src/backend/executor/nodeBitmapHeapscan.c +++ b/src/backend/executor/nodeBitmapHeapscan.c @@ -105,6 +105,16 @@ BitmapHeapNext(BitmapHeapScanState *node) */ if (!node->initialized) { + /* + * We can potentially skip fetching heap pages if we do not need any + * columns of the table, either for checking non-indexable quals or + * for returning data. This test is a bit simplistic, as it checks + * the stronger condition that there's no qual or return tlist at all. + * But in most cases it's probably not worth working harder than that. + */ + node->can_skip_fetch = (node->ss.ps.plan->qual == NIL && + node->ss.ps.plan->targetlist == NIL); + if (!pstate) { tbm = (TIDBitmap *) MultiExecProcNode(outerPlanState(node)); @@ -742,16 +752,7 @@ ExecInitBitmapHeapScan(BitmapHeapScan *node, EState *estate, int eflags) scanstate->shared_tbmiterator = NULL; scanstate->shared_prefetch_iterator = NULL; scanstate->pstate = NULL; - - /* - * We can potentially skip fetching heap pages if we do not need any - * columns of the table, either for checking non-indexable quals or for - * returning data. This test is a bit simplistic, as it checks the - * stronger condition that there's no qual or return tlist at all. But in - * most cases it's probably not worth working harder than that. - */ - scanstate->can_skip_fetch = (node->scan.plan.qual == NIL && - node->scan.plan.targetlist == NIL); + scanstate->can_skip_fetch = false; /* * Miscellaneous initialization -- 2.40.1 --w4wcjcocxsm37usi Content-Type: text/x-diff; charset=us-ascii Content-Disposition: attachment; filename="v6-0003-Push-BitmapHeapScan-skip-fetch-optimization-into-.patch" ^ permalink raw reply [nested|flat] 14+ messages in thread
end of thread, other threads:[~2024-02-13 19:38 UTC | newest] Thread overview: 14+ messages (download: mbox mbox.gz follow: Atom feed) -- links below jump to the message on this page -- 2021-01-05 04:34 [PATCH] Fix timeline-tracking failure while sending a historic timeline Kyotaro Horiguchi <horikyoga.ntt@gmail.com> 2024-02-13 19:38 [PATCH v5 02/14] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v11 02/17] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v8 02/17] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v13 02/16] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v16 02/18] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v7 02/13] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v9 02/17] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v12 02/17] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v10 02/17] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v3 02/13] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v4 02/14] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v15 02/13] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com> 2024-02-13 19:38 [PATCH v6 02/14] BitmapHeapScan set can_skip_fetch later Melanie Plageman <melanieplageman@gmail.com>
This inbox is served by agora; see mirroring instructions for how to clone and mirror all data and code used for this inbox