rserv/misc/rserv_init.pl

#!/usr/bin/perl -w
##############################################################################
#
# Script:   rserv_init.pl
#
# Author:   Grant McLean <grant@catalyst.net.nz>
#
# Description:
#
# Initialises the database tables and triggers required on a replication
# master.  Run this script with no arguments for a usage message.
#
# Note this script uses 'Pg', the native Postgres Perl API rather than DBD::Pg
# for compatibility with the standard RServ scripts.
#

use strict;
use Getopt::Std;
use Pod::Usage;

use Pg;

use lib '/usr/lib/postgresql/share/contrib/';

use RServ;


##############################################################################
#                   G L O B A L   V A R I A B L E S
##############################################################################

our $rserv_base = $0;
$rserv_base =~ s{[^/]*$}{RServ};

our $master_sql = "$rserv_base/master.sql";
our $slave_sql  = "$rserv_base/slave.sql";
our $db_changed = 0;


##############################################################################
# Parse command line arguments and handle errors
#

our %opt;
getopts('mst:h:u:p:o?', \%opt) or pod2usage(-exitstatus => 1, -verbose => 0);

pod2usage(-exitstatus => 0, -verbose => 2) if($opt{'?'});

unless(@ARGV) {
  pod2usage(
    -exitstatus => 1, -verbose => 0, 
    -message => 'You must specify the database name'
  );
}

my $cmd_count = 0;
foreach (qw(m s t)) { $cmd_count++ if exists $opt{$_}; }
if($cmd_count != 1) {
  print "$cmd_count\n";
  pod2usage(
    -exitstatus => 1, -verbose => 0, 
    -message =>
    'You must specify one of: -m for MASTER, -s for SLAVE or -t for TRIGGER'
  );
}

$opt{d} = shift(@ARGV);


##############################################################################
# Connect to database and 'do the business'
#

my $conn = db_connect();

if(exists $opt{t}) {
  toggle_app_triggers($conn, $opt{t});
  exit;
}

check_repl_tables($conn);
my %table_map = get_unique_columns($conn);
init_repl_tables($conn);

if($opt{m}) {
  init_repl_triggers($conn, %table_map);
}
elsif($opt{s}) {
  init_slave_tables($conn, %table_map);
  toggle_app_triggers($conn, 'off');
}

exit(0);


##############################################################################
#                        S U B R O U T I N E S
##############################################################################

sub abort {
  my($message) = @_;

  print "$message\nOperation aborted - ";
  if($db_changed) {
    print "warning: some updates were applied!\n";
  }
  else {
    print "no action taken\n";
  }
  exit(1);
}


##############################################################################
# Connect to database
#

sub db_connect {

  my $conn_str = "dbname=$opt{d}";

  $conn_str .= " host=$opt{h}"     if(defined($opt{h}));
  $conn_str .= " user=$opt{u}"     if(defined($opt{u}));
  $conn_str .= " password=$opt{p}" if(defined($opt{p}));


  my $conn = Pg::connectdb($conn_str);

  if(!ref($conn)  or  $conn->status != PGRES_CONNECTION_OK) {
    abort "Pg::connectdb($conn_str) failed.";
  }

  return $conn;
}


##############################################################################
# Determine whether replication structures have already been set up - bail out
# if they have and -o (overwrite) was not specified.
# 

sub check_repl_tables {
  my($conn) = @_;

  my $relname = $opt{m} ? '_rserv_tables_' : '_rserv_slave_tables_';

  my $result = $conn->exec(qq(
    select count(*) from pg_class where relname = '$relname'
  ));

  abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);

  my($count) = $result->fetchrow;

  if($count > 0) {
    print "Replication structures have already been set up in this database";
    abort "" unless($opt{o});
    print " - Overwriting\n";
  }

}


##############################################################################
# Initialise replication structures.
# 

sub init_repl_tables {
  my($conn) = @_;

  print "Creating replication tables\n";

  my $sql_file = $opt{m} ? $master_sql : $slave_sql;

  local($/) = ';';
  local(*SQL);
  open(SQL, '<', $sql_file) or abort "open($sql_file) failed: $!";

  while(<SQL>) {
    s/\s*--.*$//mg;       # Strip comments
    s/(^\s+|\s+$)//sg;    # Strip leading+trainling whitespace
    next unless /\S/;     # Skip empty queries

    my $sql = $_;
    my $result = $conn->exec($sql);
    $db_changed = 1;

    if($result->resultStatus ne PGRES_COMMAND_OK) {
      if($sql !~ /^drop\b/i) {
        abort $conn->errorMessage . "\n$sql";
      }
    }
  }

}


##############################################################################
# For each table in the database, determine the name of the column that can be
# used as a unique identifier.  On success, returns a hash of table name to
# column name mappings.  Aborts on failure (ie: if a table has no unique
# column)
# 

sub get_unique_columns {
  my($conn) = @_;

  print "Determining unique column for each table\n";

  my $result = $conn->exec(qq(
    select relname
    from pg_class
    where relkind = 'r'
    and relname not like 'pg%'
    and relname not like '_rserv%'
    order by relname
  ));

  abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);

  my @table_names = ();
  my($name);
  while(($name) = $result->fetchrow) {
    push @table_names, $name;
  }

  my %unique_key = ();
  my @unindexed  = ();
  foreach $name (@table_names) {
    $unique_key{$name} = find_unique_key($conn, $name);
    push @unindexed, $name unless($unique_key{$name});
  }

  if(@unindexed) {
    my $message =
         "The following table(s) have no unique column\n  " .
         join("\n  ", @unindexed);
    #abort $message;
    print $message, "\n";
  }

  return(%unique_key);
}


##############################################################################
# Initialise replication triggers.
# 

sub init_repl_triggers {
  my($conn, %unique_key) = @_;

  print "Creating replication triggers\n";

  my $cmnd = "$rserv_base/MasterAddTable";
  $cmnd .= " --host=$opt{h}"     if($opt{h});
  $cmnd .= " --user=$opt{u}"     if($opt{u});
  $cmnd .= " --password=$opt{p}" if($opt{p});
  $cmnd .= " $opt{d}";

  foreach my $name (sort keys %unique_key) {
    next unless $unique_key{$name};  # debugging only
    printf "  Table: %-28s  Column: %s\n", $name, $unique_key{$name} ;

    my $sql = qq(drop trigger _rserv_trigger_t_ on $name);
    my $result = $conn->exec($sql);

    system "$cmnd $name $unique_key{$name}\n";
  }

}


##############################################################################
# Insert rows into _rserv_slave_tables mapping table name to unique column 
# name.
# 

sub init_slave_tables {
  my($conn, %unique_key) = @_;

  print "Initialising slave tables\n";

  my $cmnd = "$rserv_base/SlaveAddTable";
  $cmnd .= " --host=$opt{h}"     if($opt{h});
  $cmnd .= " --user=$opt{u}"     if($opt{u});
  $cmnd .= " --password=$opt{p}" if($opt{p});
  $cmnd .= " $opt{d}";

  foreach my $name (sort keys %unique_key) {
    next unless $unique_key{$name};  # debugging only
    printf "  Table: %-28s  Column: %s\n", $name, $unique_key{$name} ;
    system "$cmnd $name $unique_key{$name}\n";
  }

}


##############################################################################
# Enable/disable all application triggers - ie: triggers that are not used by
# RServ and are not PostgreSQL integrity constraints.
# 

sub toggle_app_triggers {
  my($conn, $flag) = @_;

  my $bool;
  if(lc($flag) eq 'on') {
    print "Enabling Application Triggers\n";
    $bool = 't';
  }
  elsif(lc($flag) eq 'off') {
    print "Disabling Application Triggers\n";
    $bool = 'f';
  }
  else {
    abort "Triggers can only be toggled to 'on' or 'off'";
  }

  my $sql = qq(
    update pg_trigger
    set tgenabled = '$bool'
    where not tgisconstraint
    and not tgname like 'pg%'
    and not tgname like '_rserv_%'
  );

  my $result = $conn->exec($sql);

  if($result->resultStatus ne PGRES_COMMAND_OK) {
    abort $conn->errorMessage . "\n$sql";
  }

}


##############################################################################
# For a given table name, returns the name of a column which has a unique
# index.  Dies if there is no unique index.
# 

sub find_unique_key {
  my($conn, $table) = @_;

  return 'replication_id' if(has_replication_id($conn, $table));

  my $result = $conn->exec(qq(
    select pgi.indkey
    from pg_class pgc, pg_index pgi
    where pgc.oid = pgi.indrelid
    and pgi.indisunique 
    and pgc.relname = '$table'
  ));

  abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);

  my $att_num;
  my($keys, @key);
  while(($keys) = $result->fetchrow) {
    @key = split(/\s+/, $keys);
    next if(@key != 1);
    next if($key[0] < 1);
    $att_num = $key[0] unless(defined($att_num));
    $att_num = $key[0] if($key[0] < $att_num);
  }

  return unless defined($att_num);


  $result = $conn->exec(qq(
    select pga.attname
    from pg_class pgc, pg_attribute pga
    where pgc.oid = pga.attrelid
    and pgc.relname = '$table'
    and pgc.relkind = 'r'
    and attnum = $att_num
  ));

  abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);

  my($att_name) = $result->fetchrow;
  
  abort "Error getting column name for $table.$att_num" unless($att_name);

  return $att_name;
}


##############################################################################
# For a given table name, returns true if the table has a column called 
# 'replication_id' or false otherwise.
# 

sub has_replication_id {
  my($conn, $table) = @_;

  my $result = $conn->exec(qq(
    select count(*)
    from pg_class pgc, pg_attribute pga
    where pgc.oid = pga.attrelid
    and pgc.relname = '$table'
    and pgc.relkind = 'r'
    and pga.attname = 'replication_id'
  ));

  abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);

  my($count) = $result->fetchrow;
  
  return $count;

}


__END__

=head1 NAME

rserv_init.pl - Initialise structures for replication master or slave

=head1 SYNOPSIS

rserv_init.pl [options] (-m | -s | -t on/off) database

Options:

   -m           master mode
   -s           slave mode
   -t flag      turn application triggers 'on' or 'off'
   -h host      host where database should be created
   -u user      Postgres user which should create the database
   -p password  Postgres user's password
   -o           replace existing replication tables if present
   -?           detailed help message

=head1 DESCRIPTION

This script is used to prepare a database for replication using RServ.

It must be invoked with a database name and either '-m' to initialise
replication structures for a master or '-s' to initialise replication
structures for a slave.

Initialising a master will create the following tables and will also
create a trigger on every table to log updates:

 _rserv_tables_   stores name of unique column for each table
 _rserv_log_      tracks which rows of each table have been updated
 _rserv_servers_  details of slave servers (not used?)
 _rserv_sync_     tracks which updates have been seen by each slave

Initialising a slave will create the following tables:

 _rserv_slave_tables_ stores name of unique column for each table
 _rserv_slave_sync_   tracks which updates this slave has seen

=head1 OPTIONS

=over 4

=item B<-m>

Initialise structures for a replication MASTER.

=item B<-s>

Initialise structures for a replication SLAVE.

=item B<-t 'on' | 'off'>

Enable or disable application triggers (ie: all triggers that are not used by
RServ and are not PostgreSQL integrity constraints).

=item B<-h hostname>

Host on which database should be created (default is local host).

=item B<-u username>

Postgres user which should be used to create the database (defaults to current
user).

=item B<-p password>

Postgres user's password.

=item B<-o>

** WARNING ** This is a very dangerous option - do not enable it unless you
understand the implications.

This option causes the existing replication tables to be dropped and replaced
with new tables.  This is useful in testing but would have the effect of 
breaking the syncronisation with any slave(s).

=item B<-?>

Prints a detailed help message and exits.

=back

=cut

1	dpavlin	1.1	#!/usr/bin/perl -w
2			##############################################################################
3			#
4			# Script: rserv_init.pl
5			#
6			# Author: Grant McLean <grant@catalyst.net.nz>
7			#
8			# Description:
9			#
10			# Initialises the database tables and triggers required on a replication
11			# master. Run this script with no arguments for a usage message.
12			#
13			# Note this script uses 'Pg', the native Postgres Perl API rather than DBD::Pg
14			# for compatibility with the standard RServ scripts.
15			#
16
17			use strict;
18			use Getopt::Std;
19			use Pod::Usage;
20
21			use Pg;
22
23			use lib '/usr/lib/postgresql/share/contrib/';
24
25			use RServ;
26
27
28			##############################################################################
29			# G L O B A L V A R I A B L E S
30			##############################################################################
31
32			our $rserv_base = $0;
33			$rserv_base =~ s{[^/]*$}{RServ};
34
35			our $master_sql = "$rserv_base/master.sql";
36			our $slave_sql = "$rserv_base/slave.sql";
37			our $db_changed = 0;
38
39
40			##############################################################################
41			# Parse command line arguments and handle errors
42			#
43
44			our %opt;
45			getopts('mst:h:u:p:o?', \%opt) or pod2usage(-exitstatus => 1, -verbose => 0);
46
47			pod2usage(-exitstatus => 0, -verbose => 2) if($opt{'?'});
48
49			unless(@ARGV) {
50			pod2usage(
51			-exitstatus => 1, -verbose => 0,
52			-message => 'You must specify the database name'
53			);
54			}
55
56			my $cmd_count = 0;
57			foreach (qw(m s t)) { $cmd_count++ if exists $opt{$_}; }
58			if($cmd_count != 1) {
59			print "$cmd_count\n";
60			pod2usage(
61			-exitstatus => 1, -verbose => 0,
62			-message =>
63			'You must specify one of: -m for MASTER, -s for SLAVE or -t for TRIGGER'
64			);
65			}
66
67			$opt{d} = shift(@ARGV);
68
69
70			##############################################################################
71			# Connect to database and 'do the business'
72			#
73
74			my $conn = db_connect();
75
76			if(exists $opt{t}) {
77			toggle_app_triggers($conn, $opt{t});
78			exit;
79			}
80
81			check_repl_tables($conn);
82			my %table_map = get_unique_columns($conn);
83			init_repl_tables($conn);
84
85			if($opt{m}) {
86			init_repl_triggers($conn, %table_map);
87			}
88			elsif($opt{s}) {
89			init_slave_tables($conn, %table_map);
90			toggle_app_triggers($conn, 'off');
91			}
92
93			exit(0);
94
95
96
97			##############################################################################
98			# S U B R O U T I N E S
99			##############################################################################
100
101			sub abort {
102			my($message) = @_;
103
104			print "$message\nOperation aborted - ";
105			if($db_changed) {
106			print "warning: some updates were applied!\n";
107			}
108			else {
109			print "no action taken\n";
110			}
111			exit(1);
112			}
113
114
115			##############################################################################
116			# Connect to database
117			#
118
119			sub db_connect {
120
121			my $conn_str = "dbname=$opt{d}";
122
123			$conn_str .= " host=$opt{h}" if(defined($opt{h}));
124			$conn_str .= " user=$opt{u}" if(defined($opt{u}));
125			$conn_str .= " password=$opt{p}" if(defined($opt{p}));
126
127
128			my $conn = Pg::connectdb($conn_str);
129
130			if(!ref($conn) or $conn->status != PGRES_CONNECTION_OK) {
131			abort "Pg::connectdb($conn_str) failed.";
132			}
133
134			return $conn;
135			}
136
137
138			##############################################################################
139			# Determine whether replication structures have already been set up - bail out
140			# if they have and -o (overwrite) was not specified.
141			#
142
143			sub check_repl_tables {
144			my($conn) = @_;
145
146			my $relname = $opt{m} ? '_rserv_tables_' : '_rserv_slave_tables_';
147
148			my $result = $conn->exec(qq(
149			select count(*) from pg_class where relname = '$relname'
150			));
151
152			abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);
153
154			my($count) = $result->fetchrow;
155
156			if($count > 0) {
157			print "Replication structures have already been set up in this database";
158			abort "" unless($opt{o});
159			print " - Overwriting\n";
160			}
161
162			}
163
164
165			##############################################################################
166			# Initialise replication structures.
167			#
168
169			sub init_repl_tables {
170			my($conn) = @_;
171
172			print "Creating replication tables\n";
173
174			my $sql_file = $opt{m} ? $master_sql : $slave_sql;
175
176			local($/) = ';';
177			local(*SQL);
178			open(SQL, '<', $sql_file) or abort "open($sql_file) failed: $!";
179
180			while(<SQL>) {
181			s/\s--.$//mg; # Strip comments
182			s/(^\s+\|\s+$)//sg; # Strip leading+trainling whitespace
183			next unless /\S/; # Skip empty queries
184
185			my $sql = $_;
186			my $result = $conn->exec($sql);
187			$db_changed = 1;
188
189			if($result->resultStatus ne PGRES_COMMAND_OK) {
190			if($sql !~ /^drop\b/i) {
191			abort $conn->errorMessage . "\n$sql";
192			}
193			}
194			}
195
196			}
197
198
199
200			##############################################################################
201			# For each table in the database, determine the name of the column that can be
202			# used as a unique identifier. On success, returns a hash of table name to
203			# column name mappings. Aborts on failure (ie: if a table has no unique
204			# column)
205			#
206
207			sub get_unique_columns {
208			my($conn) = @_;
209
210			print "Determining unique column for each table\n";
211
212			my $result = $conn->exec(qq(
213			select relname
214			from pg_class
215			where relkind = 'r'
216			and relname not like 'pg%'
217			and relname not like '_rserv%'
218			order by relname
219			));
220
221			abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);
222
223			my @table_names = ();
224			my($name);
225			while(($name) = $result->fetchrow) {
226			push @table_names, $name;
227			}
228
229			my %unique_key = ();
230			my @unindexed = ();
231			foreach $name (@table_names) {
232			$unique_key{$name} = find_unique_key($conn, $name);
233			push @unindexed, $name unless($unique_key{$name});
234			}
235
236			if(@unindexed) {
237			my $message =
238			"The following table(s) have no unique column\n " .
239			join("\n ", @unindexed);
240			#abort $message;
241			print $message, "\n";
242			}
243
244			return(%unique_key);
245			}
246
247
248			##############################################################################
249			# Initialise replication triggers.
250			#
251
252			sub init_repl_triggers {
253			my($conn, %unique_key) = @_;
254
255			print "Creating replication triggers\n";
256
257			my $cmnd = "$rserv_base/MasterAddTable";
258			$cmnd .= " --host=$opt{h}" if($opt{h});
259			$cmnd .= " --user=$opt{u}" if($opt{u});
260			$cmnd .= " --password=$opt{p}" if($opt{p});
261			$cmnd .= " $opt{d}";
262
263			foreach my $name (sort keys %unique_key) {
264			next unless $unique_key{$name}; # debugging only
265			printf " Table: %-28s Column: %s\n", $name, $unique_key{$name} ;
266
267			my $sql = qq(drop trigger _rserv_trigger_t_ on $name);
268			my $result = $conn->exec($sql);
269
270			system "$cmnd $name $unique_key{$name}\n";
271			}
272
273			}
274
275
276			##############################################################################
277			# Insert rows into _rserv_slave_tables mapping table name to unique column
278			# name.
279			#
280
281			sub init_slave_tables {
282			my($conn, %unique_key) = @_;
283
284			print "Initialising slave tables\n";
285
286			my $cmnd = "$rserv_base/SlaveAddTable";
287			$cmnd .= " --host=$opt{h}" if($opt{h});
288			$cmnd .= " --user=$opt{u}" if($opt{u});
289			$cmnd .= " --password=$opt{p}" if($opt{p});
290			$cmnd .= " $opt{d}";
291
292			foreach my $name (sort keys %unique_key) {
293			next unless $unique_key{$name}; # debugging only
294			printf " Table: %-28s Column: %s\n", $name, $unique_key{$name} ;
295			system "$cmnd $name $unique_key{$name}\n";
296			}
297
298			}
299
300
301			##############################################################################
302			# Enable/disable all application triggers - ie: triggers that are not used by
303			# RServ and are not PostgreSQL integrity constraints.
304			#
305
306			sub toggle_app_triggers {
307			my($conn, $flag) = @_;
308
309			my $bool;
310			if(lc($flag) eq 'on') {
311			print "Enabling Application Triggers\n";
312			$bool = 't';
313			}
314			elsif(lc($flag) eq 'off') {
315			print "Disabling Application Triggers\n";
316			$bool = 'f';
317			}
318			else {
319			abort "Triggers can only be toggled to 'on' or 'off'";
320			}
321
322			my $sql = qq(
323			update pg_trigger
324			set tgenabled = '$bool'
325			where not tgisconstraint
326			and not tgname like 'pg%'
327			and not tgname like '_rserv_%'
328			);
329
330			my $result = $conn->exec($sql);
331
332			if($result->resultStatus ne PGRES_COMMAND_OK) {
333			abort $conn->errorMessage . "\n$sql";
334			}
335
336			}
337
338
339			##############################################################################
340			# For a given table name, returns the name of a column which has a unique
341			# index. Dies if there is no unique index.
342			#
343
344			sub find_unique_key {
345			my($conn, $table) = @_;
346
347			return 'replication_id' if(has_replication_id($conn, $table));
348
349			my $result = $conn->exec(qq(
350			select pgi.indkey
351			from pg_class pgc, pg_index pgi
352			where pgc.oid = pgi.indrelid
353			and pgi.indisunique
354			and pgc.relname = '$table'
355			));
356
357			abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);
358
359			my $att_num;
360			my($keys, @key);
361			while(($keys) = $result->fetchrow) {
362			@key = split(/\s+/, $keys);
363			next if(@key != 1);
364			next if($key[0] < 1);
365			$att_num = $key[0] unless(defined($att_num));
366			$att_num = $key[0] if($key[0] < $att_num);
367			}
368
369			return unless defined($att_num);
370
371
372			$result = $conn->exec(qq(
373			select pga.attname
374			from pg_class pgc, pg_attribute pga
375			where pgc.oid = pga.attrelid
376			and pgc.relname = '$table'
377			and pgc.relkind = 'r'
378			and attnum = $att_num
379			));
380
381			abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);
382
383			my($att_name) = $result->fetchrow;
384
385			abort "Error getting column name for $table.$att_num" unless($att_name);
386
387			return $att_name;
388			}
389
390
391			##############################################################################
392			# For a given table name, returns true if the table has a column called
393			# 'replication_id' or false otherwise.
394			#
395
396			sub has_replication_id {
397			my($conn, $table) = @_;
398
399			my $result = $conn->exec(qq(
400			select count(*)
401			from pg_class pgc, pg_attribute pga
402			where pgc.oid = pga.attrelid
403			and pgc.relname = '$table'
404			and pgc.relkind = 'r'
405			and pga.attname = 'replication_id'
406			));
407
408			abort $conn->errorMessage if($result->resultStatus ne PGRES_TUPLES_OK);
409
410			my($count) = $result->fetchrow;
411
412			return $count;
413
414			}
415
416
417			__END__
418
419			=head1 NAME
420
421			rserv_init.pl - Initialise structures for replication master or slave
422
423			=head1 SYNOPSIS
424
425			rserv_init.pl [options] (-m \| -s \| -t on/off) database
426
427			Options:
428
429			-m master mode
430			-s slave mode
431			-t flag turn application triggers 'on' or 'off'
432			-h host host where database should be created
433			-u user Postgres user which should create the database
434			-p password Postgres user's password
435			-o replace existing replication tables if present
436			-? detailed help message
437
438			=head1 DESCRIPTION
439
440			This script is used to prepare a database for replication using RServ.
441
442			It must be invoked with a database name and either '-m' to initialise
443			replication structures for a master or '-s' to initialise replication
444			structures for a slave.
445
446			Initialising a master will create the following tables and will also
447			create a trigger on every table to log updates:
448
449			_rserv_tables_ stores name of unique column for each table
450			_rserv_log_ tracks which rows of each table have been updated
451			_rserv_servers_ details of slave servers (not used?)
452			_rserv_sync_ tracks which updates have been seen by each slave
453
454			Initialising a slave will create the following tables:
455
456			_rserv_slave_tables_ stores name of unique column for each table
457			_rserv_slave_sync_ tracks which updates this slave has seen
458
459			=head1 OPTIONS
460
461			=over 4
462
463			=item B<-m>
464
465			Initialise structures for a replication MASTER.
466
467			=item B<-s>
468
469			Initialise structures for a replication SLAVE.
470
471			=item B<-t 'on' \| 'off'>
472
473			Enable or disable application triggers (ie: all triggers that are not used by
474			RServ and are not PostgreSQL integrity constraints).
475
476			=item B<-h hostname>
477
478			Host on which database should be created (default is local host).
479
480			=item B<-u username>
481
482			Postgres user which should be used to create the database (defaults to current
483			user).
484
485			=item B<-p password>
486
487			Postgres user's password.
488
489			=item B<-o>
490
491			WARNING This is a very dangerous option - do not enable it unless you
492			understand the implications.
493
494			This option causes the existing replication tables to be dropped and replaced
495			with new tables. This is useful in testing but would have the effect of
496			breaking the syncronisation with any slave(s).
497
498			=item B<-?>
499
500			Prints a detailed help message and exits.
501
502			=back
503
504			=cut
505