}
my $node = PostgreSQL::Test::Cluster->new('main');
-$node->init('auth_extra' => [ '--create-role', 'regress_user1' ]);
+$node->init('auth_extra' => [ '--create-role' => 'regress_user1' ]);
$node->append_conf('postgresql.conf',
"session_preload_libraries = 'auto_explain'");
$node->append_conf('postgresql.conf', "auto_explain.log_min_duration = 0");
# Untar.
my $extract_path = PostgreSQL::Test::Utils::tempdir;
- system_or_bail($tar, 'xf', $backup_dir . '/' . $prefix . 'base.tar',
- '-C', $extract_path);
+ system_or_bail(
+ $tar,
+ 'xf' => $backup_dir . '/' . $prefix . 'base.tar',
+ '-C' => $extract_path);
# Verify.
$node->command_ok(
'-D' => $node->data_dir,
'template0'
],
- '<',
- $ENV{share_contrib_dir} . '/sepgsql.sql');
+ '<' => $ENV{share_contrib_dir} . '/sepgsql.sql');
ok($result, 'sepgsql installation script');
}
my $stderr;
my $oldestkeptwalfile = '00000001000000370000000E';
- my $result =
- IPC::Run::run [ 'pg_archivecleanup', '-d', '-n', $tempdir,
- $oldestkeptwalfile ],
- '2>', \$stderr;
+ my $result = IPC::Run::run [
+ 'pg_archivecleanup', '--debug', '--dry-run', $tempdir,
+ $oldestkeptwalfile
+ ],
+ '2>' => \$stderr;
ok($result, "pg_archivecleanup dry run: exit code 0");
for my $walpair (@walfiles_verbose)
[ 'pg_resetwal', $node->data_dir ],
qr/not proceeding because control file values were guessed/,
'does not run when control file values were guessed');
-command_ok([ 'pg_resetwal', '-f', $node->data_dir ],
+command_ok(
+ [ 'pg_resetwal', '--force', $node->data_dir ],
'runs with force when control file values were guessed');
done_testing();
'--target-pgdata' => $primary_pgdata,
'--no-sync',
],
- '2>>',
- "$standby_pgdata/tst_both_dir/file1");
+ '2>>' => "$standby_pgdata/tst_both_dir/file1");
ok(!$ret, 'Error out on copying growing file');
# Ensure that the files are of different size, the final error message should
my $cmd = shift;
my $dbname = shift || 'postgres';
- system_or_bail 'psql', '-q', '--no-psqlrc', '-d',
- $node_primary->connstr($dbname), '-c', "$cmd";
+ system_or_bail 'psql', '--quiet', '--no-psqlrc',
+ '--dbname' => $node_primary->connstr($dbname),
+ '--command' => $cmd;
return;
}
my $cmd = shift;
my $dbname = shift || 'postgres';
- system_or_bail 'psql', '-q', '--no-psqlrc', '-d',
- $node_standby->connstr($dbname), '-c', "$cmd";
+ system_or_bail 'psql', '--quiet', '--no-psqlrc',
+ '--dbname' => $node_standby->connstr($dbname),
+ '--command' => $cmd;
return;
}
# we want just the output, no formatting
my $result = run [
- 'psql', '-q', '-A', '-t', '--no-psqlrc', '-d',
- $node_primary->connstr('postgres'),
- '-c', $query
+ 'psql', '--quiet', '--no-align', '--tuples-only', '--no-psqlrc',
+ '--dbname' => $node_primary->connstr('postgres'),
+ '--command' => $query
],
- '>', \$stdout, '2>', \$stderr;
+ '>' => \$stdout,
+ '2>' => \$stderr;
is($result, 1, "$test_name: psql exit code");
is($stderr, '', "$test_name: psql no stderr");
$node_primary->init(
allows_streaming => 1,
extra => $extra,
- auth_extra => [ '--create-role', 'rewind_user' ]);
+ auth_extra => [ '--create-role' => 'rewind_user' ]);
# Set wal_keep_size to prevent WAL segment recycling after enforced
# checkpoints in the tests.
# Load the dump using the "postgres" database as "regression" does
# not exist yet, and we are done here.
- $oldnode->command_ok([ 'psql', '-X', '-f', $olddumpfile, 'postgres' ],
+ $oldnode->command_ok(
+ [ 'psql', '--no-psqlrc', '--file' => $olddumpfile, 'postgres' ],
'loaded old dump file');
}
else
my @command_args = ();
for my $upcmd (@{ $adjust_cmds->{$updb} })
{
- push @command_args, '-c', $upcmd;
+ push @command_args, '--command' => $upcmd;
}
# For simplicity, use the newer version's psql to issue the commands.
$newnode->command_ok(
[
- 'psql', '-X', '-v', 'ON_ERROR_STOP=1',
- '-d', $oldnode->connstr($updb),
+ 'psql', '--no-psqlrc',
+ '--set' => 'ON_ERROR_STOP=1',
+ '--dbname' => $oldnode->connstr($updb),
@command_args,
],
"ran version adaptation commands for database $updb");
# Take a dump before performing the upgrade as a base comparison. Note
# that we need to use pg_dumpall from the new node here.
my @dump_command = (
- 'pg_dumpall', '--no-sync', '-d', $oldnode->connstr('postgres'),
- '-f', $dump1_file);
+ 'pg_dumpall', '--no-sync',
+ '--dbname' => $oldnode->connstr('postgres'),
+ '--file' => $dump1_file);
# --extra-float-digits is needed when upgrading from a version older than 11.
push(@dump_command, '--extra-float-digits', '0')
if ($oldnode->pg_version < 12);
command_checks_all(
[
'pg_upgrade', '--no-sync',
- '-d', $oldnode->data_dir,
- '-D', $newnode->data_dir,
- '-b', $oldbindir . '/does/not/exist/',
- '-B', $newbindir,
- '-s', $newnode->host,
- '-p', $oldnode->port,
- '-P', $newnode->port,
+ '--old-datadir' => $oldnode->data_dir,
+ '--new-datadir' => $newnode->data_dir,
+ '--old-bindir' => $oldbindir . '/does/not/exist/',
+ '--new-bindir' => $newbindir,
+ '--socketdir' => $newnode->host,
+ '--old-port' => $oldnode->port,
+ '--new-port' => $newnode->port,
$mode, '--check',
],
1,
command_checks_all(
[
'pg_upgrade', '--no-sync',
- '-d', $oldnode->data_dir,
- '-D', $newnode->data_dir,
- '-b', $oldbindir,
- '-B', $newbindir,
- '-s', $newnode->host,
- '-p', $oldnode->port,
- '-P', $newnode->port,
+ '--old-datadir' => $oldnode->data_dir,
+ '--new-datadir' => $newnode->data_dir,
+ '--old-bindir' => $oldbindir,
+ '--new-bindir' => $newbindir,
+ '--socketdir' => $newnode->host,
+ '--old-port' => $oldnode->port,
+ '--new-port' => $newnode->port,
$mode, '--check',
],
1,
# --check command works here, cleans up pg_upgrade_output.d.
command_ok(
[
- 'pg_upgrade', '--no-sync', '-d', $oldnode->data_dir,
- '-D', $newnode->data_dir, '-b', $oldbindir,
- '-B', $newbindir, '-s', $newnode->host,
- '-p', $oldnode->port, '-P', $newnode->port,
+ 'pg_upgrade', '--no-sync',
+ '--old-datadir' => $oldnode->data_dir,
+ '--new-datadir' => $newnode->data_dir,
+ '--old-bindir' => $oldbindir,
+ '--new-bindir' => $newbindir,
+ '--socketdir' => $newnode->host,
+ '--old-port' => $oldnode->port,
+ '--new-port' => $newnode->port,
$mode, '--check',
],
'run of pg_upgrade --check for new instance');
# Actual run, pg_upgrade_output.d is removed at the end.
command_ok(
[
- 'pg_upgrade', '--no-sync', '-d', $oldnode->data_dir,
- '-D', $newnode->data_dir, '-b', $oldbindir,
- '-B', $newbindir, '-s', $newnode->host,
- '-p', $oldnode->port, '-P', $newnode->port,
+ 'pg_upgrade', '--no-sync',
+ '--old-datadir' => $oldnode->data_dir,
+ '--new-datadir' => $newnode->data_dir,
+ '--old-bindir' => $oldbindir,
+ '--new-bindir' => $newbindir,
+ '--socketdir' => $newnode->host,
+ '--old-port' => $oldnode->port,
+ '--new-port' => $newnode->port,
$mode,
],
'run of pg_upgrade for new instance');
# Second dump from the upgraded instance.
@dump_command = (
- 'pg_dumpall', '--no-sync', '-d', $newnode->connstr('postgres'),
- '-f', $dump2_file);
+ 'pg_dumpall', '--no-sync',
+ '--dbname' => $newnode->connstr('postgres'),
+ '--file' => $dump2_file);
# --extra-float-digits is needed when upgrading from a version older than 11.
-push(@dump_command, '--extra-float-digits', '0')
+push(@dump_command, '--extra-float-digits' => '0')
if ($oldnode->pg_version < 12);
$newnode->command_ok(\@dump_command, 'dump after running pg_upgrade');
# Setup a common pg_upgrade command to be used by all the test cases
my @pg_upgrade_cmd = (
'pg_upgrade', '--no-sync',
- '-d', $oldpub->data_dir,
- '-D', $newpub->data_dir,
- '-b', $oldpub->config_data('--bindir'),
- '-B', $newpub->config_data('--bindir'),
- '-s', $newpub->host,
- '-p', $oldpub->port,
- '-P', $newpub->port,
+ '--old-datadir' => $oldpub->data_dir,
+ '--new-datadir' => $newpub->data_dir,
+ '--old-bindir' => $oldpub->config_data('--bindir'),
+ '--new-bindir' => $newpub->config_data('--bindir'),
+ '--socketdir' => $newpub->host,
+ '--old-port' => $oldpub->port,
+ '--new-port' => $newpub->port,
$mode);
# In a VPATH build, we'll be started in the source directory, but we want
# Set the old cluster's default char signedness to unsigned for test.
command_ok(
- [ 'pg_resetwal', '--char-signedness', 'unsigned', '-f', $old->data_dir ],
+ [
+ 'pg_resetwal',
+ '--char-signedness' => 'unsigned',
+ '--force',
+ $old->data_dir
+ ],
"set old cluster's default char signedness to unsigned");
# Check if the value is successfully updated.
command_checks_all(
[
'pg_upgrade', '--no-sync',
- '-d', $old->data_dir,
- '-D', $new->data_dir,
- '-b', $old->config_data('--bindir'),
- '-B', $new->config_data('--bindir'),
- '-s', $new->host,
- '-p', $old->port,
- '-P', $new->port,
- '--set-char-signedness', 'signed',
+ '--old-datadir' => $old->data_dir,
+ '--new-datadir' => $new->data_dir,
+ '--old-bindir' => $old->config_data('--bindir'),
+ '--new-bindir' => $new->config_data('--bindir'),
+ '--socketdir' => $new->host,
+ '--old-port' => $old->port,
+ '--new-port' => $new->port,
+ '--set-char-signedness' => 'signed',
$mode
],
1,
command_ok(
[
'pg_upgrade', '--no-sync',
- '-d', $old->data_dir,
- '-D', $new->data_dir,
- '-b', $old->config_data('--bindir'),
- '-B', $new->config_data('--bindir'),
- '-s', $new->host,
- '-p', $old->port,
- '-P', $new->port,
+ '--old-datadir' => $old->data_dir,
+ '--new-datadir' => $new->data_dir,
+ '--old-bindir' => $old->config_data('--bindir'),
+ '--new-bindir' => $new->config_data('--bindir'),
+ '--socketdir' => $new->host,
+ '--old-port' => $old->port,
+ '--new-port' => $new->port,
$mode
],
'run of pg_upgrade');
my ($format, $algorithm) = @_;
my $backup_path = $primary->backup_dir . '/' . $format . '/' . $algorithm;
my @backup = (
- 'pg_basebackup', '-D', $backup_path,
- '--manifest-checksums', $algorithm, '--no-sync', '-cfast');
- my @verify = ('pg_verifybackup', '-e', $backup_path);
+ 'pg_basebackup',
+ '--pgdata' => $backup_path,
+ '--manifest-checksums' => $algorithm,
+ '--no-sync',
+ '--checkpoint' => 'fast');
+ my @verify = ('pg_verifybackup', '--exit-on-error', $backup_path);
if ($format eq 'tar')
{
# Add switch to get a tar-format backup
- push @backup, ('-F', 't');
+ push @backup, ('--format' => 'tar');
# Add switch to skip WAL verification, which is not yet supported for
# tar-format backups
- push @verify, ('-n');
+ push @verify, ('--no-parse-wal');
}
# A backup with a bogus algorithm should fail.
# Construct base.tar with what's left.
chdir($backup_path) || die "chdir: $!";
- command_ok([ $tar, '-cf', "$tar_backup_path/base.tar", '.' ]);
+ command_ok([ $tar, '-cf' => "$tar_backup_path/base.tar", '.' ]);
chdir($cwd) || die "chdir: $!";
# Now check that the backup no longer verifies. We must use -n
# here, because pg_waldump can't yet read WAL from a tarfile.
command_fails_like(
- [ 'pg_verifybackup', '-n', $tar_backup_path ],
+ [ 'pg_verifybackup', '--no-parse-wal', $tar_backup_path ],
$scenario->{'fails_like'},
"corrupt backup fails verification: $name");
# Verify that when --ignore is not used, both problems are reported.
$result = IPC::Run::run [ 'pg_verifybackup', $backup_path ],
- '>', \$stdout, '2>', \$stderr;
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok(!$result, "multiple problems: fails");
like(
$stderr,
|| $tc->{'decompress_program'} eq '');
# Take a server-side backup.
- my @backup = (
- 'pg_basebackup', '--no-sync',
- '-cfast', '--target',
- "server:$backup_path", '-Xfetch');
- push @backup, @{ $tc->{'backup_flags'} };
- $primary->command_ok(\@backup,
+ $primary->command_ok(
+ [
+ 'pg_basebackup', '--no-sync',
+ '--checkpoint' => 'fast',
+ '--target' => "server:$backup_path",
+ '--wal-method' => 'fetch',
+ @{ $tc->{'backup_flags'} },
+ ],
"server side backup, compression $method");
"found expected backup files, compression $method");
# Verify tar backup.
- $primary->command_ok([ 'pg_verifybackup', '-n', '-e', $backup_path ],
+ $primary->command_ok(
+ [
+ 'pg_verifybackup', '--no-parse-wal',
+ '--exit-on-error', $backup_path,
+ ],
"verify backup, compression $method");
# Cleanup.
skip "$method compression not supported by this build", 2
if !$tc->{'enabled'};
- # Take backup with server compression enabled.
- my @backup = (
- 'pg_basebackup', '-D', $backup_path,
- '-Xfetch', '--no-sync', '-cfast', '-Fp');
- push @backup, @{ $tc->{'backup_flags'} };
-
- my @verify = ('pg_verifybackup', '-e', $backup_path);
-
# A backup with a valid compression method should work.
my $backup_stdout = '';
my $backup_stderr = '';
- my $backup_result = $primary->run_log(\@backup, '>', \$backup_stdout,
- '2>', \$backup_stderr);
+ my $backup_result = $primary->run_log(
+ [
+ 'pg_basebackup',
+ '--pgdata' => $backup_path,
+ '--wal-method' => 'fetch',
+ '--no-sync',
+ '--checkpoint' => 'fast',
+ '--format' => 'plain',
+ @{ $tc->{'backup_flags'} },
+ ],
+ '>' => \$backup_stdout,
+ '2>' => \$backup_stderr);
if ($backup_stdout ne '')
{
print "# standard output was:\n$backup_stdout";
}
# Make sure that it verifies OK.
- $primary->command_ok(\@verify,
+ $primary->command_ok(
+ [ 'pg_verifybackup', '--exit-on-error', $backup_path ],
"backup verified, compression method \"$method\"");
}
|| $tc->{'decompress_program'} eq '');
# Take a client-side backup.
- my @backup = (
- 'pg_basebackup', '-D', $backup_path,
- '-Xfetch', '--no-sync', '-cfast', '-Ft');
- push @backup, @{ $tc->{'backup_flags'} };
my $backup_stdout = '';
my $backup_stderr = '';
- my $backup_result = $primary->run_log(\@backup, '>', \$backup_stdout,
- '2>', \$backup_stderr);
+ my $backup_result = $primary->run_log(
+ [
+ 'pg_basebackup', '--no-sync',
+ '--pgdata' => $backup_path,
+ '--wal-method' => 'fetch',
+ '--checkpoint' => 'fast',
+ '--format' => 'tar',
+ @{ $tc->{'backup_flags'} }
+ ],
+ '>' => \$backup_stdout,
+ '2>' => \$backup_stderr);
if ($backup_stdout ne '')
{
print "# standard output was:\n$backup_stdout";
$lsn2++;
my $new_start = sprintf("%s/%X", $part1, $lsn2);
- my (@cmd, $stdout, $stderr, $result);
+ my ($stdout, $stderr);
- @cmd = (
+ my $result = IPC::Run::run [
'pg_waldump',
'--start' => $new_start,
- $node->data_dir . '/pg_wal/' . $start_walfile);
- $result = IPC::Run::run \@cmd, '>', \$stdout, '2>', \$stderr;
+ $node->data_dir . '/pg_wal/' . $start_walfile
+ ],
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok($result, "runs with start segment and start LSN specified");
like($stderr, qr/first record is after/, 'info message printed');
}
local $Test::Builder::Level = $Test::Builder::Level + 1;
my @opts = @_;
- my (@cmd, $stdout, $stderr, $result, @lines);
+ my ($stdout, $stderr);
- @cmd = (
+ my $result = IPC::Run::run [
'pg_waldump',
'--path' => $node->data_dir,
'--start' => $start_lsn,
- '--end' => $end_lsn);
- push @cmd, @opts;
- $result = IPC::Run::run \@cmd, '>', \$stdout, '2>', \$stderr;
+ '--end' => $end_lsn,
+ @opts
+ ],
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok($result, "pg_waldump @opts: runs ok");
is($stderr, '', "pg_waldump @opts: no stderr");
- @lines = split /\n/, $stdout;
+ my @lines = split /\n/, $stdout;
ok(@lines > 0, "pg_waldump @opts: some lines are output");
return @lines;
}
{
my ($stderr);
- run_log([ 'pgbench', '--jobs' => '2', '--bad-option' ], '2>', \$stderr);
+ run_log([ 'pgbench', '--jobs' => '2', '--bad-option' ], '2>' => \$stderr);
$nthreads = 1 if $stderr =~ m/threads are not supported on this platform/;
}
# cleanup from prior runs
unlink $filename;
append_to_file($filename, $$files{$fn});
- push @cmd, '-f', $filename;
+ push @cmd, '--file' => $filename;
}
}
command_checks_all(\@cmd, $stat, $out, $err, $name);
my ($stdout, $stderr);
my $result;
- $result = IPC::Run::run [ 'psql', "--help=$arg" ], '>', \$stdout, '2>',
- \$stderr;
+ $result = IPC::Run::run [ 'psql', "--help=$arg" ],
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok($result, "psql --help=$arg exit code 0");
isnt($stdout, '', "psql --help=$arg goes to stdout");
is($stderr, '', "psql --help=$arg nothing to stderr");
local %ENV = $node->_get_env();
my ($stdin, $stdout, $stderr);
-my $h = IPC::Run::start([ 'psql', '-X', '-v', 'ON_ERROR_STOP=1' ],
- \$stdin, \$stdout, \$stderr);
+my $h = IPC::Run::start(
+ [
+ 'psql', '--no-psqlrc', '--set' => 'ON_ERROR_STOP=1',
+ ],
+ '<' => \$stdin,
+ '>' => \$stdout,
+ '2>' => \$stderr);
# Send sleep command and wait until the server has registered it
$stdin = "select pg_sleep($PostgreSQL::Test::Utils::timeout_default);\n";
%ENV = (%ENV, %envvars);
my $cmd = [ 'libpq_uri_regress', $uri ];
- $result{exit} = IPC::Run::run $cmd, '>', \$result{stdout}, '2>',
- \$result{stderr};
+ $result{exit} = IPC::Run::run $cmd,
+ '>' => \$result{stdout},
+ '2>' => \$result{stderr};
chomp($result{stdout});
chomp($result{stderr});
my ($ret, $stdout, $stderr) = $node->psql(
'postgres',
'',
- extra_params => [ '-w', '-c', 'SELECT current_enc()' ],
+ extra_params => [
+ '--no-password', '--command' => 'SELECT current_enc()',
+ ],
connstr => "$connstr_full",
on_error_stop => 0);
$primary->append_conf('postgresql.conf', 'track_commit_timestamp = off');
$primary->restart;
-system_or_bail('pg_ctl', '-D', $standby->data_dir, 'promote');
+system_or_bail('pg_ctl', '--pgdata' => $standby->data_dir, 'promote');
$standby->safe_psql('postgres', "create table t11()");
my $standby_ts = $standby->safe_psql('postgres',
for my $testname (@tests)
{
- my @extraargs = ('-r', $numrows);
+ my @extraargs = ('-r' => $numrows);
my $cmptrace = grep(/^$testname$/,
qw(simple_pipeline nosync multi_pipelines prepared singlerow
pipeline_abort pipeline_idle transaction
"$PostgreSQL::Test::Utils::tmp_check/traces/$testname.trace";
if ($cmptrace)
{
- push @extraargs, "-t", $traceout;
+ push @extraargs, "-t" => $traceout;
}
# Execute the test
$node->append_conf('postgresql.conf', "ssl_passphrase.passphrase = 'blurfl'");
# try to start the server again
-my $ret =
- PostgreSQL::Test::Utils::system_log('pg_ctl', '-D', $node->data_dir, '-l',
- $node->logfile, 'start');
+my $ret = PostgreSQL::Test::Utils::system_log(
+ 'pg_ctl',
+ '--pgdata' => $node->data_dir,
+ '--log' => $node->logfile,
+ 'start');
# with a bad passphrase the server should not start
binary_upgrade => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/binary_upgrade.sql", '--schema-only',
- '--binary-upgrade', '--dbname=postgres',
+ '--file' => "$tempdir/binary_upgrade.sql",
+ '--schema-only', '--binary-upgrade',
+ '--dbname' => 'postgres',
],
},
clean => {
dump_cmd => [
- 'pg_dump', "--file=$tempdir/clean.sql",
- '-c', '--no-sync',
- '--dbname=postgres',
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/clean.sql",
+ '--clean',
+ '--dbname' => 'postgres',
],
},
clean_if_exists => {
dump_cmd => [
- 'pg_dump',
- '--no-sync',
- "--file=$tempdir/clean_if_exists.sql",
- '-c',
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/clean_if_exists.sql",
+ '--clean',
'--if-exists',
- '--encoding=UTF8', # no-op, just tests that option is accepted
+ '--encoding' => 'UTF8', # no-op, just tests that it is accepted
'postgres',
],
},
createdb => {
dump_cmd => [
- 'pg_dump',
- '--no-sync',
- "--file=$tempdir/createdb.sql",
- '-C',
- '-R', # no-op, just for testing
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/createdb.sql",
+ '--create',
+ '--no-reconnect', # no-op, just for testing
'postgres',
],
},
data_only => {
dump_cmd => [
- 'pg_dump',
- '--no-sync',
- "--file=$tempdir/data_only.sql",
- '-a',
- '-v', # no-op, just make sure it works
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/data_only.sql",
+ '--data-only',
+ '--verbose', # no-op, just make sure it works
'postgres',
],
},
defaults => {
- dump_cmd => [ 'pg_dump', '-f', "$tempdir/defaults.sql", 'postgres', ],
+ dump_cmd => [
+ 'pg_dump',
+ '--file' => "$tempdir/defaults.sql",
+ 'postgres',
+ ],
},
defaults_custom_format => {
test_key => 'defaults',
compile_option => 'gzip',
dump_cmd => [
- 'pg_dump', '--no-sync', '-Fc', '-Z6',
- "--file=$tempdir/defaults_custom_format.dump", 'postgres',
+ 'pg_dump', '--no-sync',
+ '--format' => 'custom',
+ '--compress' => 6,
+ '--file' => "$tempdir/defaults_custom_format.dump",
+ 'postgres',
],
restore_cmd => [
'pg_restore',
- "--file=$tempdir/defaults_custom_format.sql",
+ '--file' => "$tempdir/defaults_custom_format.sql",
"$tempdir/defaults_custom_format.dump",
],
},
defaults_dir_format => {
test_key => 'defaults',
dump_cmd => [
- 'pg_dump', '--no-sync', '-Fd',
- "--file=$tempdir/defaults_dir_format", 'postgres',
+ 'pg_dump', '--no-sync',
+ '--format' => 'directory',
+ '--file' => "$tempdir/defaults_dir_format",
+ 'postgres',
],
restore_cmd => [
'pg_restore',
- "--file=$tempdir/defaults_dir_format.sql",
+ '--file' => "$tempdir/defaults_dir_format.sql",
"$tempdir/defaults_dir_format",
],
},
defaults_parallel => {
test_key => 'defaults',
dump_cmd => [
- 'pg_dump', '--no-sync', '-Fd', '-j2',
- "--file=$tempdir/defaults_parallel", 'postgres',
+ 'pg_dump', '--no-sync',
+ '--format' => 'directory',
+ '--jobs' => 2,
+ '--file' => "$tempdir/defaults_parallel",
+ 'postgres',
],
restore_cmd => [
'pg_restore',
- "--file=$tempdir/defaults_parallel.sql",
+ '--file' => "$tempdir/defaults_parallel.sql",
"$tempdir/defaults_parallel",
],
},
defaults_tar_format => {
test_key => 'defaults',
dump_cmd => [
- 'pg_dump', '--no-sync', '-Ft',
- "--file=$tempdir/defaults_tar_format.tar", 'postgres',
+ 'pg_dump', '--no-sync',
+ '--format' => 'tar',
+ '--file' => "$tempdir/defaults_tar_format.tar",
+ 'postgres',
],
restore_cmd => [
'pg_restore',
- "--file=$tempdir/defaults_tar_format.sql",
+ '--file' => "$tempdir/defaults_tar_format.sql",
"$tempdir/defaults_tar_format.tar",
],
},
exclude_table => {
dump_cmd => [
'pg_dump',
- '--exclude-table=regress_table_dumpable',
- "--file=$tempdir/exclude_table.sql",
+ '--exclude-table' => 'regress_table_dumpable',
+ '--file' => "$tempdir/exclude_table.sql",
'postgres',
],
},
extension_schema => {
dump_cmd => [
- 'pg_dump', '--schema=public',
- "--file=$tempdir/extension_schema.sql", 'postgres',
+ 'pg_dump',
+ '--schema' => 'public',
+ '--file' => "$tempdir/extension_schema.sql",
+ 'postgres',
],
},
pg_dumpall_globals => {
dump_cmd => [
'pg_dumpall', '--no-sync',
- "--file=$tempdir/pg_dumpall_globals.sql", '-g',
+ '--file' => "$tempdir/pg_dumpall_globals.sql",
+ '--globals-only',
],
},
no_privs => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/no_privs.sql", '-x',
+ '--file' => "$tempdir/no_privs.sql",
+ '--no-privileges',
'postgres',
],
},
no_owner => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/no_owner.sql", '-O',
+ '--file' => "$tempdir/no_owner.sql",
+ '--no-owner',
'postgres',
],
},
privileged_internals => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/privileged_internals.sql",
+ '--file' => "$tempdir/privileged_internals.sql",
# these two tables are irrelevant to the test case
- '--exclude-table=regress_pg_dump_schema.external_tab',
- '--exclude-table=regress_pg_dump_schema.extdependtab',
- '--username=regress_dump_login_role', 'postgres',
+ '--exclude-table' => 'regress_pg_dump_schema.external_tab',
+ '--exclude-table' => 'regress_pg_dump_schema.extdependtab',
+ '--username' => 'regress_dump_login_role',
+ 'postgres',
],
},
schema_only => {
dump_cmd => [
- 'pg_dump', '--no-sync', "--file=$tempdir/schema_only.sql",
- '-s', 'postgres',
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/schema_only.sql",
+ '--schema-only', 'postgres',
],
},
section_pre_data => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/section_pre_data.sql", '--section=pre-data',
+ '--file' => "$tempdir/section_pre_data.sql",
+ '--section' => 'pre-data',
'postgres',
],
},
section_data => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/section_data.sql", '--section=data',
+ '--file' => "$tempdir/section_data.sql",
+ '--section' => 'data',
'postgres',
],
},
section_post_data => {
dump_cmd => [
- 'pg_dump', '--no-sync', "--file=$tempdir/section_post_data.sql",
- '--section=post-data', 'postgres',
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/section_post_data.sql",
+ '--section' => 'post-data',
+ 'postgres',
],
},
with_extension => {
dump_cmd => [
- 'pg_dump', '--no-sync', "--file=$tempdir/with_extension.sql",
- '--extension=test_pg_dump', 'postgres',
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/with_extension.sql",
+ '--extension' => 'test_pg_dump',
+ 'postgres',
],
},
exclude_extension => {
dump_cmd => [
'pg_dump', '--no-sync',
- "--file=$tempdir/exclude_extension.sql",
- '--exclude-extension=test_pg_dump', 'postgres',
+ '--file' => "$tempdir/exclude_extension.sql",
+ '--exclude-extension' => 'test_pg_dump',
+ 'postgres',
],
},
exclude_extension_filter => {
dump_cmd => [
'pg_dump',
'--no-sync',
- "--file=$tempdir/exclude_extension_filter.sql",
- "--filter=$tempdir/exclude_extension_filter.txt",
+ '--file' => "$tempdir/exclude_extension_filter.sql",
+ '--filter' => "$tempdir/exclude_extension_filter.txt",
'postgres',
],
},
# plpgsql in the list blocks the dump of extension test_pg_dump
without_extension => {
dump_cmd => [
- 'pg_dump', '--no-sync', "--file=$tempdir/without_extension.sql",
- '--extension=plpgsql', 'postgres',
+ 'pg_dump', '--no-sync',
+ '--file' => "$tempdir/without_extension.sql",
+ '--extension' => 'plpgsql',
+ 'postgres',
],
},
dump_cmd => [
'pg_dump',
'--no-sync',
- "--file=$tempdir/without_extension_explicit_schema.sql",
- '--extension=plpgsql',
- '--schema=public',
+ '--file' => "$tempdir/without_extension_explicit_schema.sql",
+ '--extension' => 'plpgsql',
+ '--schema' => 'public',
'postgres',
],
},
dump_cmd => [
'pg_dump',
'--no-sync',
- "--file=$tempdir/without_extension_internal_schema.sql",
- '--extension=plpgsql',
- '--schema=regress_pg_dump_schema',
+ '--file' => "$tempdir/without_extension_internal_schema.sql",
+ '--extension' => 'plpgsql',
+ '--schema' => 'regress_pg_dump_schema',
'postgres',
],
},);
# Create a PG instance to test actually dumping from
my $node = PostgreSQL::Test::Cluster->new('main');
-$node->init('auth_extra' => [ '--create-role', 'regress_dump_login_role' ]);
+$node->init('auth_extra' => [ '--create-role' => 'regress_dump_login_role' ]);
$node->start;
my $port = $node->port;
if ($interactive)
{
$run = IPC::Run::start $psql_params,
- '<pty<', \$psql->{stdin}, '>pty>', \$psql->{stdout}, '2>',
- \$psql->{stderr},
+ '<pty<' => \$psql->{stdin},
+ '>pty>' => \$psql->{stdout},
+ '2>' => \$psql->{stderr},
$psql->{timeout};
}
else
{
$run = IPC::Run::start $psql_params,
- '<', \$psql->{stdin}, '>', \$psql->{stdout}, '2>', \$psql->{stderr},
+ '<' => \$psql->{stdin},
+ '>' => \$psql->{stdout},
+ '2>' => \$psql->{stderr},
$psql->{timeout};
}
or !defined $ENV{INITDB_TEMPLATE})
{
note("initializing database system by running initdb");
- PostgreSQL::Test::Utils::system_or_bail('initdb', '-D', $pgdata, '-A',
- 'trust', '-N', @{ $params{extra} });
+ PostgreSQL::Test::Utils::system_or_bail(
+ 'initdb', '--no-sync',
+ '--pgdata' => $pgdata,
+ '--auth' => 'trust',
+ @{ $params{extra} });
}
else
{
print "# Taking pg_basebackup $backup_name from node \"$name\"\n";
PostgreSQL::Test::Utils::system_or_bail(
- 'pg_basebackup', '-D',
- $backup_path, '-h',
- $self->host, '-p',
- $self->port, '--checkpoint',
- 'fast', '--no-sync',
+ 'pg_basebackup', '--no-sync',
+ '--pgdata' => $backup_path,
+ '--host' => $self->host,
+ '--port' => $self->port,
+ '--checkpoint' => 'fast',
@{ $params{backup_options} });
print "# Backup finished\n";
return;
}
local %ENV = $self->_get_env();
- my @combineargs = ('pg_combinebackup', '-d');
+ my @combineargs = ('pg_combinebackup', '--debug');
if (exists $params{tablespace_map})
{
while (my ($olddir, $newdir) = each %{ $params{tablespace_map} })
{
push @combineargs, $params{combine_mode};
}
- push @combineargs, @prior_backup_path, $backup_path, '-o', $data_path;
+ push @combineargs, @prior_backup_path, $backup_path,
+ '--output' => $data_path;
PostgreSQL::Test::Utils::system_or_bail(@combineargs);
}
elsif (defined $params{tar_program})
{
mkdir($data_path) || die "mkdir $data_path: $!";
- PostgreSQL::Test::Utils::system_or_bail($params{tar_program}, 'xf',
- $backup_path . '/base.tar',
- '-C', $data_path);
PostgreSQL::Test::Utils::system_or_bail(
- $params{tar_program}, 'xf',
- $backup_path . '/pg_wal.tar', '-C',
- $data_path . '/pg_wal');
+ $params{tar_program},
+ 'xf' => $backup_path . '/base.tar',
+ '-C' => $data_path);
+ PostgreSQL::Test::Utils::system_or_bail(
+ $params{tar_program},
+ 'xf' => $backup_path . '/pg_wal.tar',
+ '-C' => $data_path . '/pg_wal');
# We need to generate a tablespace_map file.
open(my $tsmap, ">", "$data_path/tablespace_map")
my $newdir = $params{tablespace_map}{$tsoid};
mkdir($newdir) || die "mkdir $newdir: $!";
- PostgreSQL::Test::Utils::system_or_bail($params{tar_program},
- 'xf', $backup_path . '/' . $tstar,
- '-C', $newdir);
+ PostgreSQL::Test::Utils::system_or_bail(
+ $params{tar_program},
+ 'xf' => $backup_path . '/' . $tstar,
+ '-C' => $newdir);
my $escaped_newdir = $newdir;
$escaped_newdir =~ s/\\/\\\\/g;
# -w is now the default but having it here does no harm and helps
# compatibility with older versions.
$ret = PostgreSQL::Test::Utils::system_log(
- 'pg_ctl', '-w', '-D', $self->data_dir,
- '-l', $self->logfile, '-o', "--cluster-name=$name",
+ 'pg_ctl', '--wait',
+ '--pgdata' => $self->data_dir,
+ '--log' => $self->logfile,
+ '--options' => "--cluster-name=$name",
'start');
if ($ret != 0)
return 1 unless defined $self->{_pid};
print "### Stopping node \"$name\" using mode $mode\n";
- my @cmd = ('pg_ctl', '-D', $pgdata, '-m', $mode, 'stop');
+ my @cmd = ('pg_ctl', '--pgdata' => $pgdata, '--mode' => $mode, 'stop');
if ($params{timeout})
{
- push(@cmd, ('--timeout', $params{timeout}));
+ push(@cmd, ('--timeout' => $params{timeout}));
}
$ret = PostgreSQL::Test::Utils::system_log(@cmd);
local %ENV = $self->_get_env();
print "### Reloading node \"$name\"\n";
- PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata,
+ PostgreSQL::Test::Utils::system_or_bail(
+ 'pg_ctl',
+ '--pgdata' => $pgdata,
'reload');
return;
}
# -w is now the default but having it here does no harm and helps
# compatibility with older versions.
- $ret = PostgreSQL::Test::Utils::system_log('pg_ctl', '-w', '-D',
- $self->data_dir, '-l', $self->logfile, 'restart');
+ $ret = PostgreSQL::Test::Utils::system_log(
+ 'pg_ctl', '--wait',
+ '--pgdata' => $self->data_dir,
+ '--log' => $self->logfile,
+ 'restart');
if ($ret != 0)
{
local %ENV = $self->_get_env();
print "### Promoting node \"$name\"\n";
- PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata, '-l',
- $logfile, 'promote');
+ PostgreSQL::Test::Utils::system_or_bail(
+ 'pg_ctl',
+ '--pgdata' => $pgdata,
+ '--log' => $logfile,
+ 'promote');
return;
}
local %ENV = $self->_get_env();
print "### Rotating log in node \"$name\"\n";
- PostgreSQL::Test::Utils::system_or_bail('pg_ctl', '-D', $pgdata, '-l',
- $logfile, 'logrotate');
+ PostgreSQL::Test::Utils::system_or_bail(
+ 'pg_ctl',
+ '--pgdata' => $pgdata,
+ '--log' => $logfile,
+ 'logrotate');
return;
}
my @psql_params = (
$self->installed_command('psql'),
- '-XAtq', '-d', $psql_connstr, '-f', '-');
+ '--no-psqlrc', '--no-align', '--tuples-only', '--quiet',
+ '--dbname' => $psql_connstr,
+ '--file' => '-');
# If the caller wants an array and hasn't passed stdout/stderr
# references, allocate temporary ones to capture them so we
$params{on_error_stop} = 1 unless defined $params{on_error_stop};
$params{on_error_die} = 0 unless defined $params{on_error_die};
- push @psql_params, '-v', 'ON_ERROR_STOP=1' if $params{on_error_stop};
+ push @psql_params, '--variable' => 'ON_ERROR_STOP=1'
+ if $params{on_error_stop};
push @psql_params, @{ $params{extra_params} }
if defined $params{extra_params};
{
local $@;
eval {
- my @ipcrun_opts = (\@psql_params, '<', \$sql);
- push @ipcrun_opts, '>', $stdout if defined $stdout;
- push @ipcrun_opts, '2>', $stderr if defined $stderr;
+ my @ipcrun_opts = (\@psql_params, '<' => \$sql);
+ push @ipcrun_opts, '>' => $stdout if defined $stdout;
+ push @ipcrun_opts, '2>' => $stderr if defined $stderr;
push @ipcrun_opts, $timeout if defined $timeout;
IPC::Run::run @ipcrun_opts;
my @psql_params = (
$self->installed_command('psql'),
- '-XAtq', '-d', $psql_connstr, '-f', '-');
+ '--no-psqlrc', '--no-align',
+ '--tuples-only', '--quiet',
+ '--dbname' => $psql_connstr,
+ '--file' => '-');
$params{on_error_stop} = 1 unless defined $params{on_error_stop};
$params{wait} = 1 unless defined $params{wait};
$timeout = $params{timeout} if defined $params{timeout};
- push @psql_params, '-v', 'ON_ERROR_STOP=1' if $params{on_error_stop};
+ push @psql_params, '--set' => 'ON_ERROR_STOP=1' if $params{on_error_stop};
push @psql_params, @{ $params{extra_params} }
if defined $params{extra_params};
my @psql_params = (
$self->installed_command('psql'),
- '-XAt', '-d', $self->connstr($dbname));
+ '--no-psqlrc', '--no-align', '--tuples-only',
+ '--dbname' => $self->connstr($dbname));
push @psql_params, @{ $params{extra_params} }
if defined $params{extra_params};
for my $fn (sort keys %$files)
{
my $filename = $self->basedir . '/' . $fn;
- push @file_opts, '-f', $filename;
+ push @file_opts, '--file' => $filename;
# cleanup file weight
$filename =~ s/\@\d+$//;
$expected = 't' unless defined($expected); # default value
my $cmd = [
- $self->installed_command('psql'), '-XAt',
- '-d', $self->connstr($dbname)
+ $self->installed_command('psql'), '--no-psqlrc',
+ '--no-align', '--tuples-only',
+ '--dbname' => $self->connstr($dbname)
];
my ($stdout, $stderr);
my $max_attempts = 10 * $PostgreSQL::Test::Utils::timeout_default;
while ($attempts < $max_attempts)
{
- my $result = IPC::Run::run $cmd, '<', \$query,
- '>', \$stdout, '2>', \$stderr;
+ my $result = IPC::Run::run $cmd,
+ '<' => \$query,
+ '>' => \$stdout,
+ '2>' => \$stderr;
chomp($stdout);
chomp($stderr);
my @cmd = (
$self->installed_command('pg_recvlogical'),
- '-S', $slot_name, '--dbname', $self->connstr($dbname));
- push @cmd, '--endpos', $endpos;
- push @cmd, '-f', '-', '--no-loop', '--start';
+ '--slot' => $slot_name,
+ '--dbname' => $self->connstr($dbname),
+ '--endpos' => $endpos,
+ '--file' => '-',
+ '--no-loop', '--start');
while (my ($k, $v) = each %plugin_options)
{
croak "= is not permitted to appear in replication option name"
if ($k =~ qr/=/);
- push @cmd, "-o", "$k=$v";
+ push @cmd, "--option" => "$k=$v";
}
my $timeout;
{
local $@;
eval {
- IPC::Run::run(\@cmd, ">", \$stdout, "2>", \$stderr, $timeout);
+ IPC::Run::run(\@cmd, '>' => \$stdout, '2>' => \$stderr, $timeout);
$ret = $?;
};
my $exc_save = $@;
$handle = IPC::Run::start(
[
- 'pg_recvlogical', '-d',
- $self->connstr($dbname), '-P',
- 'test_decoding', '-S',
- $slot_name, '--create-slot'
+ 'pg_recvlogical',
+ '--dbname' => $self->connstr($dbname),
+ '--plugin' => 'test_decoding',
+ '--slot' => $slot_name,
+ '--create-slot'
],
- '>',
- \$stdout,
- '2>',
- \$stderr);
+ '>' => \$stdout,
+ '2>' => \$stderr);
# Arrange for the xl_running_xacts record for which pg_recvlogical is
# waiting.
my ($host, $hostaddr, $realm) = @_;
my ($stdout, $krb5_version);
- run_log [ $krb5_config, '--version' ], '>', \$stdout
+ run_log [ $krb5_config, '--version' ], '>' => \$stdout
or BAIL_OUT("could not execute krb5-config");
BAIL_OUT("Heimdal is not supported") if $stdout =~ m/heimdal/;
$stdout =~ m/Kerberos 5 release ([0-9]+\.[0-9]+)/
command_fails(['initdb', '--invalid-option'],
'command fails with invalid option');
my $tempdir = PostgreSQL::Test::Utils::tempdir;
- command_ok('initdb', '-D', $tempdir);
+ command_ok('initdb', '--pgdata' => $tempdir);
# Miscellanea
print "on Windows" if $PostgreSQL::Test::Utils::windows_os;
return
$Config{osname} eq 'linux'
&& $Config{archname} =~ /^sparc/
- && !run_log([ qw(df -x ext4), $tmp_check ], '>', '/dev/null', '2>&1');
+ && !run_log([ qw(df -x ext4), $tmp_check ], '&>' => '/dev/null');
}
=pod
{
my ($cmd) = @_;
my ($stdout, $stderr);
- my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
+ my $result = IPC::Run::run $cmd, '>' => \$stdout, '2>' => \$stderr;
chomp($stdout);
chomp($stderr);
return ($stdout, $stderr);
my ($header_path, $regexp) = @_;
my ($stdout, $stderr);
- my $result = IPC::Run::run [ 'pg_config', '--includedir-server' ], '>',
- \$stdout, '2>', \$stderr
+ my $result = IPC::Run::run [ 'pg_config', '--includedir-server' ],
+ '>' => \$stdout,
+ '2>' => \$stderr
or die "could not execute pg_config";
chomp($stdout);
$stdout =~ s/\r$//;
{
my ($regexp) = @_;
my ($stdout, $stderr);
- my $result = IPC::Run::run [ 'pg_config', '--includedir' ], '>',
- \$stdout, '2>', \$stderr
+ my $result = IPC::Run::run [ 'pg_config', '--includedir' ],
+ '>' => \$stdout,
+ '2>' => \$stderr
or die "could not execute pg_config";
chomp($stdout);
$stdout =~ s/\r$//;
my ($cmd) = @_;
my ($stdout, $stderr);
print("# Running: $cmd --help\n");
- my $result = IPC::Run::run [ $cmd, '--help' ], '>', \$stdout, '2>',
- \$stderr;
+ my $result = IPC::Run::run [ $cmd, '--help' ],
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok($result, "$cmd --help exit code 0");
isnt($stdout, '', "$cmd --help goes to stdout");
is($stderr, '', "$cmd --help nothing to stderr");
my ($cmd) = @_;
my ($stdout, $stderr);
print("# Running: $cmd --version\n");
- my $result = IPC::Run::run [ $cmd, '--version' ], '>', \$stdout, '2>',
- \$stderr;
+ my $result = IPC::Run::run [ $cmd, '--version' ],
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok($result, "$cmd --version exit code 0");
isnt($stdout, '', "$cmd --version goes to stdout");
is($stderr, '', "$cmd --version nothing to stderr");
my ($cmd) = @_;
my ($stdout, $stderr);
print("# Running: $cmd --not-a-valid-option\n");
- my $result = IPC::Run::run [ $cmd, '--not-a-valid-option' ], '>',
- \$stdout,
- '2>', \$stderr;
+ my $result = IPC::Run::run [ $cmd, '--not-a-valid-option' ],
+ '>' => \$stdout,
+ '2>' => \$stderr;
ok(!$result, "$cmd with invalid option nonzero exit code");
isnt($stderr, '', "$cmd with invalid option prints error message");
return;
my ($cmd, $expected_stdout, $test_name) = @_;
my ($stdout, $stderr);
print("# Running: " . join(" ", @{$cmd}) . "\n");
- my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
+ my $result = IPC::Run::run $cmd, '>' => \$stdout, '2>' => \$stderr;
ok($result, "$test_name: exit code 0");
is($stderr, '', "$test_name: no stderr");
like($stdout, $expected_stdout, "$test_name: matches");
my $stdoutfile = File::Temp->new();
my $stderrfile = File::Temp->new();
print("# Running: " . join(" ", @{$cmd}) . "\n");
- my $result = IPC::Run::run $cmd, '>', $stdoutfile, '2>', $stderrfile;
+ my $result = IPC::Run::run $cmd, '>' => $stdoutfile, '2>' => $stderrfile;
$stdout = slurp_file($stdoutfile);
$stderr = slurp_file($stderrfile);
ok($result, "$test_name: exit code 0");
my ($cmd, $expected_stderr, $test_name) = @_;
my ($stdout, $stderr);
print("# Running: " . join(" ", @{$cmd}) . "\n");
- my $result = IPC::Run::run $cmd, '>', \$stdout, '2>', \$stderr;
+ my $result = IPC::Run::run $cmd, '>' => \$stdout, '2>' => \$stderr;
ok(!$result, "$test_name: exit code not 0");
like($stderr, $expected_stderr, "$test_name: matches");
return;
# run command
my ($stdout, $stderr);
print("# Running: " . join(" ", @{$cmd}) . "\n");
- IPC::Run::run($cmd, '>', \$stdout, '2>', \$stderr);
+ IPC::Run::run($cmd, '>' => \$stdout, '2>' => \$stderr);
# See http://perldoc.perl.org/perlvar.html#%24CHILD_ERROR
my $ret = $?;
my $node = PostgreSQL::Test::Cluster->new('primary');
$node->init(
'auth_extra' => [
- '--create-role', 'regress_regular,regress_reserved,regress_superuser'
+ '--create-role' =>
+ 'regress_regular,regress_reserved,regress_superuser',
]);
$node->append_conf('postgresql.conf', "max_connections = 6");
$node->append_conf('postgresql.conf', "reserved_connections = 2");
return $node->background_psql(
'postgres',
on_error_die => 1,
- extra_params => [ '-U', $user ]);
+ extra_params => [ '--username' => $user ]);
}
# Like connect_fails(), except that we also wait for the failed backend to
# and it needs proper authentication configuration.
$node_primary->init(
allows_streaming => 1,
- auth_extra => [ '--create-role', 'repl_role' ]);
+ auth_extra => [ '--create-role' => 'repl_role' ]);
$node_primary->start;
my $backup_name = 'my_backup';
# we connected to. Note we must pass the SQL command via the command
# line not stdin, else Perl may spit up trying to write to stdin of
# an already-failed psql process.
- my ($ret, $stdout, $stderr) =
- $node1->psql('postgres', undef,
- extra_params => [ '-d', $connstr, '-c', 'SHOW port;' ]);
+ my ($ret, $stdout, $stderr) = $node1->psql(
+ 'postgres',
+ undef,
+ extra_params => [
+ '--dbname' => $connstr,
+ '--command' => 'SHOW port;',
+ ]);
if ($status == 0)
{
is( $status == $ret && $stdout eq $target_port,
my ($ret, $stdout, $stderr) = $node_primary->psql(
'postgres', 'SHOW ALL;',
on_error_die => 1,
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
ok($ret == 0, "SHOW ALL with replication role and physical replication");
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres', 'SHOW ALL;',
on_error_die => 1,
- extra_params => [ '-d', $connstr_db ]);
+ extra_params => [ '--dbname' => $connstr_db ]);
ok($ret == 0, "SHOW ALL with replication role and logical replication");
# Test SHOW with a user-settable parameter
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres', 'SHOW work_mem;',
on_error_die => 1,
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
ok( $ret == 0,
"SHOW with user-settable parameter, replication role and physical replication"
);
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres', 'SHOW work_mem;',
on_error_die => 1,
- extra_params => [ '-d', $connstr_db ]);
+ extra_params => [ '--dbname' => $connstr_db ]);
ok( $ret == 0,
"SHOW with user-settable parameter, replication role and logical replication"
);
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres', 'SHOW primary_conninfo;',
on_error_die => 1,
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
ok( $ret == 0,
"SHOW with superuser-settable parameter, replication role and physical replication"
);
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres', 'SHOW primary_conninfo;',
on_error_die => 1,
- extra_params => [ '-d', $connstr_db ]);
+ extra_params => [ '--dbname' => $connstr_db ]);
ok( $ret == 0,
"SHOW with superuser-settable parameter, replication role and logical replication"
);
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres',
'READ_REPLICATION_SLOT non_existent_slot;',
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
ok($ret == 0, "READ_REPLICATION_SLOT exit code 0 on success");
like($stdout, qr/^\|\|$/,
"READ_REPLICATION_SLOT returns NULL values if slot does not exist");
$node_primary->psql(
'postgres',
"CREATE_REPLICATION_SLOT $slotname PHYSICAL RESERVE_WAL;",
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
($ret, $stdout, $stderr) = $node_primary->psql(
'postgres',
"READ_REPLICATION_SLOT $slotname;",
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
ok($ret == 0, "READ_REPLICATION_SLOT success with existing slot");
like($stdout, qr/^physical\|[^|]*\|1$/,
"READ_REPLICATION_SLOT returns tuple with slot information");
$node_primary->psql(
'postgres',
"DROP_REPLICATION_SLOT $slotname;",
- extra_params => [ '-d', $connstr_rep ]);
+ extra_params => [ '--dbname' => $connstr_rep ]);
note "switching to physical replication slot";
my ($sigchld_bb_stdin, $sigchld_bb_stdout, $sigchld_bb_stderr) = ('', '', '');
my $sigchld_bb = IPC::Run::start(
[
- 'psql', '-X', '-c', "BASE_BACKUP (CHECKPOINT 'fast', MAX_RATE 32);",
- '-c', 'SELECT pg_backup_stop()',
- '-d', $connstr
+ 'psql', '--no-psqlrc',
+ '--command' => "BASE_BACKUP (CHECKPOINT 'fast', MAX_RATE 32);",
+ '--command' => 'SELECT pg_backup_stop()',
+ '--dbname' => $connstr
],
- '<',
- \$sigchld_bb_stdin,
- '>',
- \$sigchld_bb_stdout,
- '2>',
- \$sigchld_bb_stderr,
+ '<' => \$sigchld_bb_stdin,
+ '>' => \$sigchld_bb_stdout,
+ '2>' => \$sigchld_bb_stderr,
$sigchld_bb_timeout);
# The cancellation is issued once the database files are streamed and
my $pg_recvlogical = IPC::Run::start(
[
- 'pg_recvlogical', '-d', $node_primary->connstr('otherdb'),
- '-S', 'otherdb_slot', '-f', '-', '--start'
+ 'pg_recvlogical',
+ '--dbname' => $node_primary->connstr('otherdb'),
+ '--slot' => 'otherdb_slot',
+ '--file' => '-',
+ '--start'
]);
$node_primary->poll_query_until('otherdb',
"SELECT EXISTS (SELECT 1 FROM pg_replication_slots WHERE slot_name = 'otherdb_slot' AND active_pid IS NOT NULL)"
my ($killme_stdin, $killme_stdout, $killme_stderr) = ('', '', '');
my $killme = IPC::Run::start(
[
- 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1', '-f', '-', '-d',
- $node->connstr('postgres')
+ 'psql', '--no-psqlrc', '--quiet', '--no-align', '--tuples-only',
+ '--set' => 'ON_ERROR_STOP=1',
+ '--file' => '-',
+ '--dbname' => $node->connstr('postgres')
],
- '<',
- \$killme_stdin,
- '>',
- \$killme_stdout,
- '2>',
- \$killme_stderr,
+ '<' => \$killme_stdin,
+ '>' => \$killme_stdout,
+ '2>' => \$killme_stderr,
$psql_timeout);
# Need a second psql to check if crash-restart happened.
my ($monitor_stdin, $monitor_stdout, $monitor_stderr) = ('', '', '');
my $monitor = IPC::Run::start(
[
- 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1', '-f', '-', '-d',
- $node->connstr('postgres')
+ 'psql', '--no-psqlrc', '--quiet', '--no-align', '--tuples-only',
+ '--set' => 'ON_ERROR_STOP=1',
+ '--file', '-', '--dbname' => $node->connstr('postgres')
],
- '<',
- \$monitor_stdin,
- '>',
- \$monitor_stdout,
- '2>',
- \$monitor_stderr,
+ '<' => \$monitor_stdin,
+ '>' => \$monitor_stdout,
+ '2>' => \$monitor_stderr,
$psql_timeout);
#create table, insert row that should survive
# Log "ipcs" diffs on a best-effort basis, swallowing any error.
my $ipcs_before = "$tempdir/ipcs_before";
-eval { run_log [ 'ipcs', '-am' ], '>', $ipcs_before; };
+eval { run_log [ 'ipcs', '-am' ], '>' => $ipcs_before; };
sub log_ipcs
{
- eval { run_log [ 'ipcs', '-am' ], '|', [ 'diff', $ipcs_before, '-' ] };
+ eval { run_log [ 'ipcs', '-am' ], '|' => [ 'diff', $ipcs_before, '-' ] };
return;
}
my ($stdout, $stderr);
my $slow_client = IPC::Run::start(
[
- 'psql', '-X', '-qAt', '-d', $gnat->connstr('postgres'),
- '-c', $slow_query
+ 'psql', '--no-psqlrc', '--quiet', '--no-align', '--tuples-only',
+ '--dbname' => $gnat->connstr('postgres'),
+ '--command' => $slow_query
],
- '<',
- \undef,
- '>',
- \$stdout,
- '2>',
- \$stderr,
+ '<' => \undef,
+ '>' => \$stdout,
+ '2>' => \$stderr,
IPC::Run::timeout(5 * $PostgreSQL::Test::Utils::timeout_default));
ok( $gnat->poll_query_until(
'postgres',
# to check uncommitted changes being replicated and such.
my %psql_primary = (stdin => '', stdout => '', stderr => '');
$psql_primary{run} = IPC::Run::start(
- [ 'psql', '-XA', '-f', '-', '-d', $node_primary->connstr('postgres') ],
- '<',
- \$psql_primary{stdin},
- '>',
- \$psql_primary{stdout},
- '2>',
- \$psql_primary{stderr},
+ [
+ 'psql', '--no-psqlrc', '--no-align',
+ '--file' => '-',
+ '--dbname' => $node_primary->connstr('postgres'),
+ ],
+ '<' => \$psql_primary{stdin},
+ '>' => \$psql_primary{stdout},
+ '2>' => \$psql_primary{stderr},
$psql_timeout);
my %psql_standby = ('stdin' => '', 'stdout' => '', 'stderr' => '');
$psql_standby{run} = IPC::Run::start(
- [ 'psql', '-XA', '-f', '-', '-d', $node_standby->connstr('postgres') ],
- '<',
- \$psql_standby{stdin},
- '>',
- \$psql_standby{stdout},
- '2>',
- \$psql_standby{stderr},
+ [
+ 'psql', '--no-psqlrc', '--no-align',
+ '--file' => '-',
+ '--dbname' => $node_standby->connstr('postgres'),
+ ],
+ '<' => \$psql_standby{stdin},
+ '>' => \$psql_standby{stdout},
+ '2>' => \$psql_standby{stderr},
$psql_timeout);
#
my ($killme_stdin, $killme_stdout, $killme_stderr) = ('', '', '');
my $killme = IPC::Run::start(
[
- 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1', '-f', '-', '-d',
- $node->connstr('postgres')
+ 'psql', '--no-psqlrc', '--quiet', '--no-align', '--tuples-only',
+ '--set' => 'ON_ERROR_STOP=1',
+ '--file' => '-',
+ '--dbname' => $node->connstr('postgres')
],
- '<',
- \$killme_stdin,
- '>',
- \$killme_stdout,
- '2>',
- \$killme_stderr,
+ '<' => \$killme_stdin,
+ '>' => \$killme_stdout,
+ '2>' => \$killme_stderr,
$psql_timeout);
# Get backend pid
my ($killme_stdin2, $killme_stdout2, $killme_stderr2) = ('', '', '');
my $killme2 = IPC::Run::start(
[
- 'psql', '-X', '-qAt', '-v', 'ON_ERROR_STOP=1', '-f', '-', '-d',
- $node->connstr('postgres')
+ 'psql', '--no-psqlrc', '--quiet', '--no-align', '--tuples-only',
+ '--set' => 'ON_ERROR_STOP=1',
+ '--file' => '-',
+ '--dbname' => $node->connstr('postgres')
],
- '<',
- \$killme_stdin2,
- '>',
- \$killme_stdout2,
- '2>',
- \$killme_stderr2,
+ '<' => \$killme_stdin2,
+ '>' => \$killme_stdout2,
+ '2>' => \$killme_stderr2,
$psql_timeout);
# Insert one tuple and leave the transaction open
my %psql_primary = (stdin => '', stdout => '', stderr => '');
$psql_primary{run} = IPC::Run::start(
- [ 'psql', '-XA', '-f', '-', '-d', $node_primary->connstr('postgres') ],
- '<',
- \$psql_primary{stdin},
- '>',
- \$psql_primary{stdout},
- '2>',
- \$psql_primary{stderr},
+ [
+ 'psql', '--no-psqlrc', '--no-align',
+ '--file' => '-',
+ '--dbname' => $node_primary->connstr('postgres')
+ ],
+ '<' => \$psql_primary{stdin},
+ '>' => \$psql_primary{stdout},
+ '2>' => \$psql_primary{stderr},
$psql_timeout);
my %psql_standby = ('stdin' => '', 'stdout' => '', 'stderr' => '');
$psql_standby{run} = IPC::Run::start(
- [ 'psql', '-XA', '-f', '-', '-d', $node_standby->connstr('postgres') ],
- '<',
- \$psql_standby{stdin},
- '>',
- \$psql_standby{stdout},
- '2>',
- \$psql_standby{stderr},
+ [
+ 'psql', '--no-psqlrc', '--no-align',
+ '--file' => '-',
+ '--dbname' => $node_standby->connstr('postgres')
+ ],
+ '<' => \$psql_standby{stdin},
+ '>' => \$psql_standby{stdout},
+ '2>' => \$psql_standby{stderr},
$psql_timeout);
my $active_slot = $slot_prefix . 'activeslot';
$slot_user_handle = IPC::Run::start(
[
- 'pg_recvlogical', '-d',
- $node->connstr('testdb'), '-S',
- qq($active_slot), '-o',
- 'include-xids=0', '-o',
- 'skip-empty-xacts=1', '--no-loop',
- '--start', '-f',
- '-'
+ 'pg_recvlogical',
+ '--dbname' => $node->connstr('testdb'),
+ '--slot' => $active_slot,
+ '--option' => 'include-xids=0',
+ '--option' => 'skip-empty-xacts=1',
+ '--file' => '-',
+ '--no-loop',
+ '--start',
],
- '>',
- $to_stdout,
- '2>',
- $to_stderr,
+ '>' => $to_stdout,
+ '2>' => $to_stderr,
IPC::Run::timeout($default_timeout));
if ($wait)
'subscriber_stdout' => '',
'subscriber_stderr' => '');
$psql_subscriber{run} = IPC::Run::start(
- [ 'psql', '-XA', '-f', '-', '-d', $node_subscriber->connstr('postgres') ],
- '<',
- \$psql_subscriber{subscriber_stdin},
- '>',
- \$psql_subscriber{subscriber_stdout},
- '2>',
- \$psql_subscriber{subscriber_stderr},
+ [
+ '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));
##################################################
# This is only needed on Windows machines that don't use UNIX sockets.
$publisher->init(
allows_streaming => 'logical',
- auth_extra => [ '--create-role', 'repl_role' ]);
+ auth_extra => [ '--create-role' => 'repl_role' ]);
# Disable autovacuum to avoid generating xid during stats update as otherwise
# the new XID could then be replicated to standby at some random point making
# slots at primary lag behind standby during slot sync.
my ($killme_stdin, $killme_stdout, $killme_stderr) = ('', '', '');
my $killme = IPC::Run::start(
[
- 'psql', '-XAtq', '-v', 'ON_ERROR_STOP=1', '-f', '-', '-d',
- $node_standby->connstr('postgres')
+ 'psql', '--no-psqlrc', '--no-align', '--tuples-only', '--quiet',
+ '--set' => 'ON_ERROR_STOP=1',
+ '--file' => '-',
+ '--dbname' => $node_standby->connstr('postgres')
],
- '<',
- \$killme_stdin,
- '>',
- \$killme_stdout,
- '2>',
- \$killme_stderr,
+ '<' => \$killme_stdin,
+ '>' => \$killme_stdout,
+ '2>' => \$killme_stderr,
$psql_timeout);
$killme_stdin .= q[
SELECT pg_backend_pid();
# check result matches, adding any diff to $diffs_file
my $result =
run_log([ 'diff', @diffopts, "$test_src.stdout", "$test.out" ],
- '>>', $diffs_file);
+ '>>' => $diffs_file);
ok($result, "pg_bsd_indent output matches for $test");
}
projects / thirdparty / postgresql.git / commitdiff
