diff --git a/src/test/recovery/meson.build b/src/test/recovery/meson.build index 8d20488952e..b3ecc32b5e6 100644 --- a/src/test/recovery/meson.build +++ b/src/test/recovery/meson.build @@ -10,56 +10,7 @@ tests += { 'enable_injection_points': get_option('injection_points') ? 'yes' : 'no', }, 'tests': [ - 't/001_stream_rep.pl', - 't/002_archiving.pl', - 't/003_recovery_targets.pl', - 't/004_timeline_switch.pl', - 't/005_replay_delay.pl', - 't/006_logical_decoding.pl', - 't/007_sync_rep.pl', - 't/008_fsm_truncation.pl', - 't/009_twophase.pl', - 't/010_logical_decoding_timelines.pl', - 't/012_subtransactions.pl', - 't/013_crash_restart.pl', - 't/014_unlogged_reinit.pl', - 't/015_promotion_pages.pl', - 't/016_min_consistency.pl', - 't/017_shm.pl', - 't/018_wal_optimize.pl', - 't/019_replslot_limit.pl', - 't/020_archive_status.pl', - 't/021_row_visibility.pl', - 't/022_crash_temp_files.pl', - 't/023_pitr_prepared_xact.pl', - 't/024_archive_recovery.pl', - 't/025_stuck_on_old_timeline.pl', - 't/026_overwrite_contrecord.pl', - 't/027_stream_regress.pl', - 't/028_pitr_timelines.pl', - 't/029_stats_restart.pl', - 't/030_stats_cleanup_replica.pl', - 't/031_recovery_conflict.pl', - 't/032_relfilenode_reuse.pl', - 't/033_replay_tsp_drops.pl', - 't/034_create_database.pl', 't/035_standby_logical_decoding.pl', - 't/036_truncated_dropped.pl', - 't/037_invalid_database.pl', - 't/038_save_logical_slots_shutdown.pl', - 't/039_end_of_wal.pl', - 't/040_standby_failover_slots_sync.pl', - 't/041_checkpoint_at_promote.pl', - 't/042_low_level_backup.pl', - 't/043_no_contrecord_switch.pl', - 't/044_invalidate_inactive_slots.pl', - 't/045_archive_restartpoint.pl', - 't/046_checkpoint_logical_slot.pl', - 't/047_checkpoint_physical_slot.pl', - 't/048_vacuum_horizon_floor.pl', - 't/049_wait_for_lsn.pl', - 't/050_redo_segment_missing.pl', - 't/051_effective_wal_level.pl', ], }, } diff --git a/src/test/recovery/t/035_standby_logical_decoding.pl b/src/test/recovery/t/035_standby_logical_decoding.pl index d264a698ff6..8bca0d0dec3 100644 --- a/src/test/recovery/t/035_standby_logical_decoding.pl +++ b/src/test/recovery/t/035_standby_logical_decoding.pl @@ -22,7 +22,6 @@ my $node_primary = PostgreSQL::Test::Cluster->new('primary'); my $node_standby = PostgreSQL::Test::Cluster->new('standby'); my $node_cascading_standby = PostgreSQL::Test::Cluster->new('cascading_standby'); -my $node_subscriber = PostgreSQL::Test::Cluster->new('subscriber'); my $default_timeout = $PostgreSQL::Test::Utils::timeout_default; my $res; @@ -329,6 +328,9 @@ $node_primary->backup($backup_name); # WAL. An insert into flush_wal outside transaction does guarantee a flush. $node_primary->psql('testdb', q[CREATE TABLE flush_wal();]); +# Create the injection_points extension +$node_primary->safe_psql('testdb', 'CREATE EXTENSION injection_points;'); + ####################### # Initialize standby node ####################### @@ -344,347 +346,20 @@ $node_standby->append_conf( $node_standby->start; $node_primary->wait_for_replay_catchup($node_standby); -####################### -# Initialize subscriber node -####################### -$node_subscriber->init; -$node_subscriber->start; - -my %psql_subscriber = ( - 'subscriber_stdin' => '', - 'subscriber_stdout' => '', - 'subscriber_stderr' => ''); -$psql_subscriber{run} = IPC::Run::start( - [ - 'psql', '--no-psqlrc', '--no-align', - '--file' => '-', - '--dbname' => $node_subscriber->connstr('postgres') - ], - '<' => \$psql_subscriber{subscriber_stdin}, - '>' => \$psql_subscriber{subscriber_stdout}, - '2>' => \$psql_subscriber{subscriber_stderr}, - IPC::Run::timeout($default_timeout)); - -################################################## -# Test that the standby requires hot_standby to be -# enabled for pre-existing logical slots. -################################################## - -# create the logical slots -$node_standby->create_logical_slot_on_standby($node_primary, 'restart_test'); -$node_standby->stop; -$node_standby->append_conf('postgresql.conf', qq[hot_standby = off]); - -# Use run_log instead of $node_standby->start because this test expects -# that the server ends with an error during startup. -run_log( - [ - 'pg_ctl', - '--pgdata' => $node_standby->data_dir, - '--log' => $node_standby->logfile, - 'start', - ]); - -# wait for postgres to terminate -foreach my $i (0 .. 10 * $PostgreSQL::Test::Utils::timeout_default) -{ - last if !-f $node_standby->data_dir . '/postmaster.pid'; - usleep(100_000); -} - -# Confirm that the server startup fails with an expected error -my $logfile = slurp_file($node_standby->logfile()); -like( - $logfile, - qr/FATAL: .* logical replication slot ".*" exists on the standby, but "hot_standby" = "off"/, - "the standby ends with an error during startup because hot_standby was disabled" -); -$node_standby->adjust_conf('postgresql.conf', 'hot_standby', 'on'); -$node_standby->start; -$node_standby->safe_psql('postgres', - qq[SELECT pg_drop_replication_slot('restart_test')]); - -################################################## -# Test that logical decoding on the standby -# behaves correctly. -################################################## - -# create the logical slots -create_logical_slots($node_standby, 'behaves_ok_'); - -$node_primary->safe_psql('testdb', - qq[CREATE TABLE decoding_test(x integer, y text);]); -$node_primary->safe_psql('testdb', - qq[INSERT INTO decoding_test(x,y) SELECT s, s::text FROM generate_series(1,10) s;] -); - -$node_primary->wait_for_replay_catchup($node_standby); - -my $result = $node_standby->safe_psql('testdb', - qq[SELECT pg_logical_slot_get_changes('behaves_ok_activeslot', NULL, NULL);] -); - -# test if basic decoding works -is(scalar(my @foobar = split /^/m, $result), - 14, 'Decoding produced 14 rows (2 BEGIN/COMMIT and 10 rows)'); - -# Insert some rows and verify that we get the same results from pg_recvlogical -# and the SQL interface. -$node_primary->safe_psql('testdb', - qq[INSERT INTO decoding_test(x,y) SELECT s, s::text FROM generate_series(1,4) s;] -); - -my $expected = q{BEGIN -table public.decoding_test: INSERT: x[integer]:1 y[text]:'1' -table public.decoding_test: INSERT: x[integer]:2 y[text]:'2' -table public.decoding_test: INSERT: x[integer]:3 y[text]:'3' -table public.decoding_test: INSERT: x[integer]:4 y[text]:'4' -COMMIT}; - -$node_primary->wait_for_replay_catchup($node_standby); - -my $stdout_sql = $node_standby->safe_psql('testdb', - qq[SELECT data FROM pg_logical_slot_peek_changes('behaves_ok_activeslot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');] -); - -is($stdout_sql, $expected, 'got expected output from SQL decoding session'); - -my $endpos = $node_standby->safe_psql('testdb', - "SELECT lsn FROM pg_logical_slot_peek_changes('behaves_ok_activeslot', NULL, NULL) ORDER BY lsn DESC LIMIT 1;" -); - -# Insert some rows after $endpos, which we won't read. -$node_primary->safe_psql('testdb', - qq[INSERT INTO decoding_test(x,y) SELECT s, s::text FROM generate_series(5,50) s;] -); - -$node_primary->wait_for_replay_catchup($node_standby); - -my $stdout_recv = $node_standby->pg_recvlogical_upto( - 'testdb', 'behaves_ok_activeslot', $endpos, $default_timeout, - 'include-xids' => '0', - 'skip-empty-xacts' => '1'); -chomp($stdout_recv); -is($stdout_recv, $expected, - 'got same expected output from pg_recvlogical decoding session'); - -$node_standby->poll_query_until('testdb', - "SELECT EXISTS (SELECT 1 FROM pg_replication_slots WHERE slot_name = 'behaves_ok_activeslot' AND active_pid IS NULL)" -) or die "slot never became inactive"; - -$stdout_recv = $node_standby->pg_recvlogical_upto( - 'testdb', 'behaves_ok_activeslot', $endpos, $default_timeout, - 'include-xids' => '0', - 'skip-empty-xacts' => '1'); -chomp($stdout_recv); -is($stdout_recv, '', 'pg_recvlogical acknowledged changes'); - -$node_primary->safe_psql('postgres', 'CREATE DATABASE otherdb'); - -# Wait for catchup to ensure that the new database is visible to other sessions -# on the standby. -$node_primary->wait_for_replay_catchup($node_standby); - -($result, $stdout, $stderr) = $node_standby->psql('otherdb', - "SELECT lsn FROM pg_logical_slot_peek_changes('behaves_ok_activeslot', NULL, NULL) ORDER BY lsn DESC LIMIT 1;" -); -like( - $stderr, - qr/replication slot "behaves_ok_activeslot" was not created in this database/, - "replaying logical slot from another database fails"); - -################################################## -# Test that we can subscribe on the standby with the publication -# created on the primary. -################################################## - -# Create a table on the primary -$node_primary->safe_psql('postgres', - "CREATE TABLE tab_rep (a int primary key)"); - -# Create a table (same structure) on the subscriber node -$node_subscriber->safe_psql('postgres', - "CREATE TABLE tab_rep (a int primary key)"); - -# Create a publication on the primary -$node_primary->safe_psql('postgres', - "CREATE PUBLICATION tap_pub for table tab_rep"); - -$node_primary->wait_for_replay_catchup($node_standby); - -# Subscribe on the standby -my $standby_connstr = $node_standby->connstr . ' dbname=postgres'; - -# Not using safe_psql() here as it would wait for activity on the primary -# and we wouldn't be able to launch pg_log_standby_snapshot() on the primary -# while waiting. -# psql_subscriber() allows to not wait synchronously. -$psql_subscriber{subscriber_stdin} .= qq[CREATE SUBSCRIPTION tap_sub - CONNECTION '$standby_connstr' - PUBLICATION tap_pub - WITH (copy_data = off);]; -$psql_subscriber{subscriber_stdin} .= "\n"; - -$psql_subscriber{run}->pump_nb(); - -# Log the standby snapshot to speed up the subscription creation -$node_primary->log_standby_snapshot($node_standby, 'tap_sub'); - -# Explicitly shut down psql instance gracefully - to avoid hangs -# or worse on windows -$psql_subscriber{subscriber_stdin} .= "\\q\n"; -$psql_subscriber{run}->finish; - -$node_subscriber->wait_for_subscription_sync($node_standby, 'tap_sub'); - -# Insert some rows on the primary -$node_primary->safe_psql('postgres', - qq[INSERT INTO tab_rep select generate_series(1,10);]); - -$node_primary->wait_for_replay_catchup($node_standby); -$node_standby->wait_for_catchup('tap_sub'); - -# Check that the subscriber can see the rows inserted in the primary -$result = - $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM tab_rep"); -is($result, qq(10), 'check replicated inserts after subscription on standby'); - -# We do not need the subscription and the subscriber anymore -$node_subscriber->safe_psql('postgres', "DROP SUBSCRIPTION tap_sub"); -$node_subscriber->stop; - -# Create the injection_points extension -$node_primary->safe_psql('testdb', 'CREATE EXTENSION injection_points;'); - -################################################## -# Recovery conflict: Invalidate conflicting slots, including in-use slots -# Scenario 1: hot_standby_feedback off and vacuum FULL -# -# In passing, ensure that replication slot stats are not removed when the -# active slot is invalidated, and check that an error occurs when -# attempting to alter the invalid slot. -################################################## - -# One way to produce recovery conflict is to create/drop a relation and -# launch a vacuum full on pg_class with hot_standby_feedback turned off on -# the standby. -reactive_slots_change_hfs_and_wait_for_xmins('behaves_ok_', 'vacuum_full_', - 0, 1); - -# Ensure that replication slot stats are not empty before triggering the -# conflict. -$node_primary->safe_psql('testdb', - qq[INSERT INTO decoding_test(x,y) SELECT 100,'100';]); - -$node_standby->poll_query_until('testdb', - qq[SELECT total_txns > 0 FROM pg_stat_replication_slots WHERE slot_name = 'vacuum_full_activeslot'] -) or die "replication slot stats of vacuum_full_activeslot not updated"; - -# This should trigger the conflict -wait_until_vacuum_can_remove( - 'full', 'CREATE TABLE conflict_test(x integer, y text); - DROP TABLE conflict_test;', 'pg_class'); - -# Check invalidation in the logfile and in pg_stat_database_conflicts -check_for_invalidation('vacuum_full_', 1, 'with vacuum FULL on pg_class'); - -# Verify reason for conflict is 'rows_removed' in pg_replication_slots -check_slots_conflict_reason('vacuum_full_', 'rows_removed'); - -# Attempting to alter an invalidated slot should result in an error -($result, $stdout, $stderr) = $node_standby->psql( - 'postgres', - qq[ALTER_REPLICATION_SLOT vacuum_full_inactiveslot (failover);], - replication => 'database'); -ok( $stderr =~ - /ERROR: can no longer access replication slot "vacuum_full_inactiveslot"/ - && $stderr =~ - /DETAIL: This replication slot has been invalidated due to "rows_removed"./, - "invalidated slot cannot be altered"); - -# Ensure that replication slot stats are not removed after invalidation. -is( $node_standby->safe_psql( - 'testdb', - qq[SELECT total_txns > 0 FROM pg_stat_replication_slots WHERE slot_name = 'vacuum_full_activeslot'] - ), - 't', - 'replication slot stats not removed after invalidation'); - -$handle = - make_slot_active($node_standby, 'vacuum_full_', 0, \$stdout, \$stderr); - -# We are not able to read from the slot as it has been invalidated -check_pg_recvlogical_stderr($handle, - "can no longer access replication slot \"vacuum_full_activeslot\""); - -# Attempt to copy an invalidated logical replication slot -($result, $stdout, $stderr) = $node_standby->psql( - 'postgres', - qq[select pg_copy_logical_replication_slot('vacuum_full_inactiveslot', 'vacuum_full_inactiveslot_copy');], - replication => 'database'); -like( - $stderr, - qr/ERROR: cannot copy invalidated replication slot "vacuum_full_inactiveslot"/, - "invalidated slot cannot be copied"); - -# Set hot_standby_feedback to on -change_hot_standby_feedback_and_wait_for_xmins(1, 1); - -################################################## -# Verify that invalidated logical slots stay invalidated across a restart. -################################################## -$node_standby->restart; - -# Verify reason for conflict is retained across a restart. -check_slots_conflict_reason('vacuum_full_', 'rows_removed'); - -################################################## -# Verify that invalidated logical slots do not lead to retaining WAL. -################################################## - -# Get the restart_lsn from an invalidated slot -my $restart_lsn = $node_standby->safe_psql( - 'postgres', - "SELECT restart_lsn FROM pg_replication_slots - WHERE slot_name = 'vacuum_full_activeslot' AND conflicting;" -); - -chomp($restart_lsn); - -# As pg_walfile_name() can not be executed on the standby, -# get the WAL file name associated to this lsn from the primary -my $walfile_name = $node_primary->safe_psql('postgres', - "SELECT pg_walfile_name('$restart_lsn')"); - -chomp($walfile_name); - -# Generate some activity and switch WAL file on the primary -$node_primary->advance_wal(1); -$node_primary->safe_psql('postgres', "checkpoint;"); - -# Wait for the standby to catch up -$node_primary->wait_for_replay_catchup($node_standby); - -# Request a checkpoint on the standby to trigger the WAL file(s) removal -$node_standby->safe_psql('postgres', 'checkpoint;'); - -# Verify that the WAL file has not been retained on the standby -my $standby_walfile = $node_standby->data_dir . '/pg_wal/' . $walfile_name; -ok(!-f "$standby_walfile", - "invalidated logical slots do not lead to retaining WAL"); - ################################################## # Recovery conflict: Invalidate conflicting slots, including in-use slots # Scenario 2: conflict due to row removal with hot_standby_feedback off. ################################################## +for (my $i = 0; $i < 100; $i++) { + # get the position to search from in the standby logfile my $logstart = -s $node_standby->logfile; # One way to produce recovery conflict is to create/drop a relation and # launch a vacuum on pg_class with hot_standby_feedback turned off on the # standby. -reactive_slots_change_hfs_and_wait_for_xmins('vacuum_full_', 'row_removal_', +reactive_slots_change_hfs_and_wait_for_xmins('row_removal_', 'row_removal_', 0, 1); # This should trigger the conflict @@ -705,6 +380,9 @@ $handle = check_pg_recvlogical_stderr($handle, "can no longer access replication slot \"row_removal_activeslot\""); +} +my $logstart; + ################################################## # Recovery conflict: Same as Scenario 2 but on a shared catalog table # Scenario 3: conflict due to row removal with hot_standby_feedback off. @@ -841,221 +519,4 @@ check_pg_recvlogical_stderr($handle, # Turn hot_standby_feedback back on change_hot_standby_feedback_and_wait_for_xmins(1, 1); -################################################## -# Recovery conflict: Invalidate conflicting slots, including in-use slots -# Scenario 6: incorrect wal_level on primary. -################################################## - -# get the position to search from in the standby logfile -$logstart = -s $node_standby->logfile; - -# drop the logical slots -drop_logical_slots('pruning_'); - -# create the logical slots -create_logical_slots($node_standby, 'wal_level_'); - -$handle = - make_slot_active($node_standby, 'wal_level_', 1, \$stdout, \$stderr); - -# reset stat: easier to check for confl_active_logicalslot in pg_stat_database_conflicts -$node_standby->psql('testdb', q[select pg_stat_reset();]); - -# Make primary wal_level replica. This will trigger slot conflict. -$node_primary->append_conf( - 'postgresql.conf', q[ -wal_level = 'replica' -]); -$node_primary->restart; - -$node_primary->wait_for_replay_catchup($node_standby); - -# Check invalidation in the logfile and in pg_stat_database_conflicts -check_for_invalidation('wal_level_', $logstart, 'due to wal_level'); - -# Verify reason for conflict is 'wal_level_insufficient' in pg_replication_slots -check_slots_conflict_reason('wal_level_', 'wal_level_insufficient'); - -$handle = - make_slot_active($node_standby, 'wal_level_', 0, \$stdout, \$stderr); -# We are not able to read from the slot as it requires effective_wal_level >= logical on -# the primary server -check_pg_recvlogical_stderr($handle, - "logical decoding on standby requires \"effective_wal_level\" >= \"logical\" on the primary" -); - -# Restore primary wal_level -$node_primary->append_conf( - 'postgresql.conf', q[ -wal_level = 'logical' -]); -$node_primary->restart; -$node_primary->wait_for_replay_catchup($node_standby); - -$handle = - make_slot_active($node_standby, 'wal_level_', 0, \$stdout, \$stderr); -# as the slot has been invalidated we should not be able to read -check_pg_recvlogical_stderr($handle, - "can no longer access replication slot \"wal_level_activeslot\""); - -################################################## -# DROP DATABASE should drop its slots, including active slots. -################################################## - -# drop the logical slots -drop_logical_slots('wal_level_'); - -# create the logical slots -create_logical_slots($node_standby, 'drop_db_'); - -$handle = make_slot_active($node_standby, 'drop_db_', 1, \$stdout, \$stderr); - -# Create a slot on a database that would not be dropped. This slot should not -# get dropped. -$node_standby->create_logical_slot_on_standby($node_primary, 'otherslot', - 'postgres'); - -# dropdb on the primary to verify slots are dropped on standby -$node_primary->safe_psql('postgres', q[DROP DATABASE testdb]); - -$node_primary->wait_for_replay_catchup($node_standby); - -is( $node_standby->safe_psql( - 'postgres', - q[SELECT EXISTS(SELECT 1 FROM pg_database WHERE datname = 'testdb')]), - 'f', - 'database dropped on standby'); - -check_slots_dropped('drop_db', $handle); - -is($node_standby->slot('otherslot')->{'slot_type'}, - 'logical', 'otherslot on standby not dropped'); - -# Cleanup : manually drop the slot that was not dropped. -$node_standby->psql('postgres', - q[SELECT pg_drop_replication_slot('otherslot')]); - -################################################## -# Test standby promotion and logical decoding behavior -# after the standby gets promoted. -################################################## - -$node_standby->reload; - -$node_primary->psql('postgres', q[CREATE DATABASE testdb]); -$node_primary->safe_psql('testdb', - qq[CREATE TABLE decoding_test(x integer, y text);]); - -# Wait for the standby to catchup before initializing the cascading standby -$node_primary->wait_for_replay_catchup($node_standby); - -# Create a physical replication slot on the standby. -# Keep this step after the "Verify that invalidated logical slots do not lead -# to retaining WAL" test (as the physical slot on the standby could prevent the -# WAL file removal). -$node_standby->safe_psql('testdb', - qq[SELECT * FROM pg_create_physical_replication_slot('$standby_physical_slotname');] -); - -# Initialize cascading standby node -$node_standby->backup($backup_name); -$node_cascading_standby->init_from_backup( - $node_standby, $backup_name, - has_streaming => 1, - has_restoring => 1); -$node_cascading_standby->append_conf( - 'postgresql.conf', - qq[primary_slot_name = '$standby_physical_slotname' - hot_standby_feedback = on]); -$node_cascading_standby->start; - -# create the logical slots -create_logical_slots($node_standby, 'promotion_'); - -# Wait for the cascading standby to catchup before creating the slots -$node_standby->wait_for_replay_catchup($node_cascading_standby, - $node_primary); - -# create the logical slots on the cascading standby too -create_logical_slots($node_cascading_standby, 'promotion_'); - -# Make slots actives -$handle = - make_slot_active($node_standby, 'promotion_', 1, \$stdout, \$stderr); -my $cascading_handle = - make_slot_active($node_cascading_standby, 'promotion_', 1, - \$cascading_stdout, \$cascading_stderr); - -# Insert some rows before the promotion -$node_primary->safe_psql('testdb', - qq[INSERT INTO decoding_test(x,y) SELECT s, s::text FROM generate_series(1,4) s;] -); - -# Wait for both standbys to catchup -$node_primary->wait_for_replay_catchup($node_standby); -$node_standby->wait_for_replay_catchup($node_cascading_standby, - $node_primary); - -# promote -$node_standby->promote; - -# insert some rows on promoted standby -$node_standby->safe_psql('testdb', - qq[INSERT INTO decoding_test(x,y) SELECT s, s::text FROM generate_series(5,7) s;] -); - -# Wait for the cascading standby to catchup -$node_standby->wait_for_replay_catchup($node_cascading_standby); - -$expected = q{BEGIN -table public.decoding_test: INSERT: x[integer]:1 y[text]:'1' -table public.decoding_test: INSERT: x[integer]:2 y[text]:'2' -table public.decoding_test: INSERT: x[integer]:3 y[text]:'3' -table public.decoding_test: INSERT: x[integer]:4 y[text]:'4' -COMMIT -BEGIN -table public.decoding_test: INSERT: x[integer]:5 y[text]:'5' -table public.decoding_test: INSERT: x[integer]:6 y[text]:'6' -table public.decoding_test: INSERT: x[integer]:7 y[text]:'7' -COMMIT}; - -# check that we are decoding pre and post promotion inserted rows -$stdout_sql = $node_standby->safe_psql('testdb', - qq[SELECT data FROM pg_logical_slot_peek_changes('promotion_inactiveslot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');] -); - -is($stdout_sql, $expected, - 'got expected output from SQL decoding session on promoted standby'); - -# check that we are decoding pre and post promotion inserted rows -# with pg_recvlogical that has started before the promotion -my $pump_timeout = IPC::Run::timer($PostgreSQL::Test::Utils::timeout_default); - -ok(pump_until($handle, $pump_timeout, \$stdout, qr/^.*COMMIT.*COMMIT$/s), - 'got 2 COMMIT from pg_recvlogical output'); - -chomp($stdout); -is($stdout, $expected, - 'got same expected output from pg_recvlogical decoding session'); - -# check that we are decoding pre and post promotion inserted rows on the cascading standby -$stdout_sql = $node_cascading_standby->safe_psql('testdb', - qq[SELECT data FROM pg_logical_slot_peek_changes('promotion_inactiveslot', NULL, NULL, 'include-xids', '0', 'skip-empty-xacts', '1');] -); - -is($stdout_sql, $expected, - 'got expected output from SQL decoding session on cascading standby'); - -# check that we are decoding pre and post promotion inserted rows -# with pg_recvlogical that has started before the promotion on the cascading standby -ok( pump_until( - $cascading_handle, $pump_timeout, - \$cascading_stdout, qr/^.*COMMIT.*COMMIT$/s), - 'got 2 COMMIT from pg_recvlogical output'); - -chomp($cascading_stdout); -is($cascading_stdout, $expected, - 'got same expected output from pg_recvlogical decoding session on cascading standby' -); - done_testing();