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;

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