mirror of https://github.com/postgres/postgres
Commit a8fd13cab0 added support for prepared transactions to built-in
logical replication via a new option "two_phase" for a subscription. The
"two_phase" option was not allowed with the existing streaming option.
This commit permits the combination of "streaming" and "two_phase"
subscription options. It extends the pgoutput plugin and the subscriber
side code to add the prepare API for streaming transactions which will
apply the changes accumulated in the spool-file at prepare time.
Author: Peter Smith and Ajin Cherian
Reviewed-by: Vignesh C, Amit Kapila, Greg Nancarrow
Tested-By: Haiying Tang
Discussion: https://postgr.es/m/02DA5F5E-CECE-4D9C-8B4B-418077E2C010@postgrespro.ru
Discussion: https://postgr.es/m/CAMGcDxeqEpWj3fTXwqhSwBdXd2RS9jzwWscO-XbeCfso6ts3+Q@mail.gmail.com
pull/68/head
Amit Kapila
4 years ago
parent
6424337073
commit
63cf61cdeb
@ -0,0 +1,284 @@ |
|||||||
|
|
||||||
|
# Copyright (c) 2021, PostgreSQL Global Development Group |
||||||
|
|
||||||
|
# Test logical replication of 2PC with streaming. |
||||||
|
use strict; |
||||||
|
use warnings; |
||||||
|
use PostgresNode; |
||||||
|
use TestLib; |
||||||
|
use Test::More tests => 18; |
||||||
|
|
||||||
|
############################### |
||||||
|
# Setup |
||||||
|
############################### |
||||||
|
|
||||||
|
# Initialize publisher node |
||||||
|
my $node_publisher = PostgresNode->new('publisher'); |
||||||
|
$node_publisher->init(allows_streaming => 'logical'); |
||||||
|
$node_publisher->append_conf('postgresql.conf', qq( |
||||||
|
max_prepared_transactions = 10 |
||||||
|
logical_decoding_work_mem = 64kB |
||||||
|
)); |
||||||
|
$node_publisher->start; |
||||||
|
|
||||||
|
# Create subscriber node |
||||||
|
my $node_subscriber = PostgresNode->new('subscriber'); |
||||||
|
$node_subscriber->init(allows_streaming => 'logical'); |
||||||
|
$node_subscriber->append_conf('postgresql.conf', qq( |
||||||
|
max_prepared_transactions = 10 |
||||||
|
)); |
||||||
|
$node_subscriber->start; |
||||||
|
|
||||||
|
# Create some pre-existing content on publisher |
||||||
|
$node_publisher->safe_psql('postgres', "CREATE TABLE test_tab (a int primary key, b varchar)"); |
||||||
|
$node_publisher->safe_psql('postgres', "INSERT INTO test_tab VALUES (1, 'foo'), (2, 'bar')"); |
||||||
|
|
||||||
|
# Setup structure on subscriber (columns a and b are compatible with same table name on publisher) |
||||||
|
$node_subscriber->safe_psql('postgres', |
||||||
|
"CREATE TABLE test_tab (a int primary key, b text, c timestamptz DEFAULT now(), d bigint DEFAULT 999)"); |
||||||
|
|
||||||
|
# Setup logical replication (streaming = on) |
||||||
|
my $publisher_connstr = $node_publisher->connstr . ' dbname=postgres'; |
||||||
|
$node_publisher->safe_psql('postgres', "CREATE PUBLICATION tap_pub FOR TABLE test_tab"); |
||||||
|
|
||||||
|
my $appname = 'tap_sub'; |
||||||
|
$node_subscriber->safe_psql('postgres', " |
||||||
|
CREATE SUBSCRIPTION tap_sub |
||||||
|
CONNECTION '$publisher_connstr application_name=$appname' |
||||||
|
PUBLICATION tap_pub |
||||||
|
WITH (streaming = on, two_phase = on)"); |
||||||
|
|
||||||
|
# Wait for subscriber to finish initialization |
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# Also wait for initial table sync to finish |
||||||
|
my $synced_query = |
||||||
|
"SELECT count(1) = 0 FROM pg_subscription_rel WHERE srsubstate NOT IN ('r', 's');"; |
||||||
|
$node_subscriber->poll_query_until('postgres', $synced_query) |
||||||
|
or die "Timed out while waiting for subscriber to synchronize data"; |
||||||
|
|
||||||
|
# Also wait for two-phase to be enabled |
||||||
|
my $twophase_query = |
||||||
|
"SELECT count(1) = 0 FROM pg_subscription WHERE subtwophasestate NOT IN ('e');"; |
||||||
|
$node_subscriber->poll_query_until('postgres', $twophase_query) |
||||||
|
or die "Timed out while waiting for subscriber to enable twophase"; |
||||||
|
|
||||||
|
############################### |
||||||
|
# Check initial data was copied to subscriber |
||||||
|
############################### |
||||||
|
my $result = $node_subscriber->safe_psql('postgres', "SELECT count(*), count(c), count(d = 999) FROM test_tab"); |
||||||
|
is($result, qq(2|2|2), 'check initial data was copied to subscriber'); |
||||||
|
|
||||||
|
############################### |
||||||
|
# Test 2PC PREPARE / COMMIT PREPARED. |
||||||
|
# 1. Data is streamed as a 2PC transaction. |
||||||
|
# 2. Then do commit prepared. |
||||||
|
# |
||||||
|
# Expect all data is replicated on subscriber side after the commit. |
||||||
|
############################### |
||||||
|
|
||||||
|
# check that 2PC gets replicated to subscriber |
||||||
|
# Insert, update and delete enough rows to exceed the 64kB limit. |
||||||
|
$node_publisher->safe_psql('postgres', q{ |
||||||
|
BEGIN; |
||||||
|
INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(3, 5000) s(i); |
||||||
|
UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0; |
||||||
|
DELETE FROM test_tab WHERE mod(a,3) = 0; |
||||||
|
PREPARE TRANSACTION 'test_prepared_tab';}); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is in prepared state on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(1), 'transaction is prepared on subscriber'); |
||||||
|
|
||||||
|
# 2PC transaction gets committed |
||||||
|
$node_publisher->safe_psql('postgres', "COMMIT PREPARED 'test_prepared_tab';"); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is committed on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*), count(c), count(d = 999) FROM test_tab"); |
||||||
|
is($result, qq(3334|3334|3334), 'Rows inserted by 2PC have committed on subscriber, and extra columns contain local defaults'); |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(0), 'transaction is committed on subscriber'); |
||||||
|
|
||||||
|
############################### |
||||||
|
# Test 2PC PREPARE / ROLLBACK PREPARED. |
||||||
|
# 1. Table is deleted back to 2 rows which are replicated on subscriber. |
||||||
|
# 2. Data is streamed using 2PC. |
||||||
|
# 3. Do rollback prepared. |
||||||
|
# |
||||||
|
# Expect data rolls back leaving only the original 2 rows. |
||||||
|
############################### |
||||||
|
|
||||||
|
# First, delete the data except for 2 rows (will be replicated) |
||||||
|
$node_publisher->safe_psql('postgres', "DELETE FROM test_tab WHERE a > 2;"); |
||||||
|
|
||||||
|
# Then insert, update and delete enough rows to exceed the 64kB limit. |
||||||
|
$node_publisher->safe_psql('postgres', q{ |
||||||
|
BEGIN; |
||||||
|
INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(3, 5000) s(i); |
||||||
|
UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0; |
||||||
|
DELETE FROM test_tab WHERE mod(a,3) = 0; |
||||||
|
PREPARE TRANSACTION 'test_prepared_tab';}); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is in prepared state on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(1), 'transaction is prepared on subscriber'); |
||||||
|
|
||||||
|
# 2PC transaction gets aborted |
||||||
|
$node_publisher->safe_psql('postgres', "ROLLBACK PREPARED 'test_prepared_tab';"); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is aborted on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*), count(c), count(d = 999) FROM test_tab"); |
||||||
|
is($result, qq(2|2|2), 'Rows inserted by 2PC are rolled back, leaving only the original 2 rows'); |
||||||
|
|
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(0), 'transaction is aborted on subscriber'); |
||||||
|
|
||||||
|
############################### |
||||||
|
# Check that 2PC COMMIT PREPARED is decoded properly on crash restart. |
||||||
|
# 1. insert, update and delete enough rows to exceed the 64kB limit. |
||||||
|
# 2. Then server crashes before the 2PC transaction is committed. |
||||||
|
# 3. After servers are restarted the pending transaction is committed. |
||||||
|
# |
||||||
|
# Expect all data is replicated on subscriber side after the commit. |
||||||
|
# Note: both publisher and subscriber do crash/restart. |
||||||
|
############################### |
||||||
|
|
||||||
|
$node_publisher->safe_psql('postgres', q{ |
||||||
|
BEGIN; |
||||||
|
INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(3, 5000) s(i); |
||||||
|
UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0; |
||||||
|
DELETE FROM test_tab WHERE mod(a,3) = 0; |
||||||
|
PREPARE TRANSACTION 'test_prepared_tab';}); |
||||||
|
|
||||||
|
$node_subscriber->stop('immediate'); |
||||||
|
$node_publisher->stop('immediate'); |
||||||
|
|
||||||
|
$node_publisher->start; |
||||||
|
$node_subscriber->start; |
||||||
|
|
||||||
|
# commit post the restart |
||||||
|
$node_publisher->safe_psql('postgres', "COMMIT PREPARED 'test_prepared_tab';"); |
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check inserts are visible |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*), count(c), count(d = 999) FROM test_tab"); |
||||||
|
is($result, qq(3334|3334|3334), 'Rows inserted by 2PC have committed on subscriber, and extra columns contain local defaults'); |
||||||
|
|
||||||
|
############################### |
||||||
|
# Do INSERT after the PREPARE but before ROLLBACK PREPARED. |
||||||
|
# 1. Table is deleted back to 2 rows which are replicated on subscriber. |
||||||
|
# 2. Data is streamed using 2PC. |
||||||
|
# 3. A single row INSERT is done which is after the PREPARE. |
||||||
|
# 4. Then do a ROLLBACK PREPARED. |
||||||
|
# |
||||||
|
# Expect the 2PC data rolls back leaving only 3 rows on the subscriber |
||||||
|
# (the original 2 + inserted 1). |
||||||
|
############################### |
||||||
|
|
||||||
|
# First, delete the data except for 2 rows (will be replicated) |
||||||
|
$node_publisher->safe_psql('postgres', "DELETE FROM test_tab WHERE a > 2;"); |
||||||
|
|
||||||
|
# Then insert, update and delete enough rows to exceed the 64kB limit. |
||||||
|
$node_publisher->safe_psql('postgres', q{ |
||||||
|
BEGIN; |
||||||
|
INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(3, 5000) s(i); |
||||||
|
UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0; |
||||||
|
DELETE FROM test_tab WHERE mod(a,3) = 0; |
||||||
|
PREPARE TRANSACTION 'test_prepared_tab';}); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is in prepared state on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(1), 'transaction is prepared on subscriber'); |
||||||
|
|
||||||
|
# Insert a different record (now we are outside of the 2PC transaction) |
||||||
|
# Note: the 2PC transaction still holds row locks so make sure this insert is for a separate primary key |
||||||
|
$node_publisher->safe_psql('postgres', "INSERT INTO test_tab VALUES (99999, 'foobar')"); |
||||||
|
|
||||||
|
# 2PC transaction gets aborted |
||||||
|
$node_publisher->safe_psql('postgres', "ROLLBACK PREPARED 'test_prepared_tab';"); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is aborted on subscriber, |
||||||
|
# but the extra INSERT outside of the 2PC still was replicated |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*), count(c), count(d = 999) FROM test_tab"); |
||||||
|
is($result, qq(3|3|3), 'check the outside insert was copied to subscriber'); |
||||||
|
|
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(0), 'transaction is aborted on subscriber'); |
||||||
|
|
||||||
|
############################### |
||||||
|
# Do INSERT after the PREPARE but before COMMIT PREPARED. |
||||||
|
# 1. Table is deleted back to 2 rows which are replicated on subscriber. |
||||||
|
# 2. Data is streamed using 2PC. |
||||||
|
# 3. A single row INSERT is done which is after the PREPARE. |
||||||
|
# 4. Then do a COMMIT PREPARED. |
||||||
|
# |
||||||
|
# Expect 2PC data + the extra row are on the subscriber |
||||||
|
# (the 3334 + inserted 1 = 3335). |
||||||
|
############################### |
||||||
|
|
||||||
|
# First, delete the data except for 2 rows (will be replicated) |
||||||
|
$node_publisher->safe_psql('postgres', "DELETE FROM test_tab WHERE a > 2;"); |
||||||
|
|
||||||
|
# Then insert, update and delete enough rows to exceed the 64kB limit. |
||||||
|
$node_publisher->safe_psql('postgres', q{ |
||||||
|
BEGIN; |
||||||
|
INSERT INTO test_tab SELECT i, md5(i::text) FROM generate_series(3, 5000) s(i); |
||||||
|
UPDATE test_tab SET b = md5(b) WHERE mod(a,2) = 0; |
||||||
|
DELETE FROM test_tab WHERE mod(a,3) = 0; |
||||||
|
PREPARE TRANSACTION 'test_prepared_tab';}); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is in prepared state on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(1), 'transaction is prepared on subscriber'); |
||||||
|
|
||||||
|
# Insert a different record (now we are outside of the 2PC transaction) |
||||||
|
# Note: the 2PC transaction still holds row locks so make sure this insert is for a separare primary key |
||||||
|
$node_publisher->safe_psql('postgres', "INSERT INTO test_tab VALUES (99999, 'foobar')"); |
||||||
|
|
||||||
|
# 2PC transaction gets committed |
||||||
|
$node_publisher->safe_psql('postgres', "COMMIT PREPARED 'test_prepared_tab';"); |
||||||
|
|
||||||
|
$node_publisher->wait_for_catchup($appname); |
||||||
|
|
||||||
|
# check that transaction is committed on subscriber |
||||||
|
$result = $node_subscriber->safe_psql('postgres', |
||||||
|
"SELECT count(*), count(c), count(d = 999) FROM test_tab"); |
||||||
|
is($result, qq(3335|3335|3335), 'Rows inserted by 2PC (as well as outside insert) have committed on subscriber, and extra columns contain local defaults'); |
||||||
|
|
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_prepared_xacts;"); |
||||||
|
is($result, qq(0), 'transaction is committed on subscriber'); |
||||||
|
|
||||||
|
############################### |
||||||
|
# check all the cleanup |
||||||
|
############################### |
||||||
|
|
||||||
|
$node_subscriber->safe_psql('postgres', "DROP SUBSCRIPTION tap_sub"); |
||||||
|
|
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_subscription"); |
||||||
|
is($result, qq(0), 'check subscription was dropped on subscriber'); |
||||||
|
|
||||||
|
$result = $node_publisher->safe_psql('postgres', "SELECT count(*) FROM pg_replication_slots"); |
||||||
|
is($result, qq(0), 'check replication slot was dropped on publisher'); |
||||||
|
|
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_subscription_rel"); |
||||||
|
is($result, qq(0), 'check subscription relation status was dropped on subscriber'); |
||||||
|
|
||||||
|
$result = $node_subscriber->safe_psql('postgres', "SELECT count(*) FROM pg_replication_origin"); |
||||||
|
is($result, qq(0), 'check replication origin was dropped on subscriber'); |
||||||
|
|
||||||
|
$node_subscriber->stop('fast'); |
||||||
|
$node_publisher->stop('fast'); |
||||||
Loading…
Reference in new issue