head	1.14;
access;
symbols
	REL8_2_BETA3:1.3;
locks; strict;
comment	@# @;


1.14
date	2006.11.17.16.38.44;	author momjian;	state dead;
branches;
next	1.13;

1.13
date	2006.11.17.13.29.53;	author momjian;	state Exp;
branches;
next	1.12;

1.12
date	2006.11.17.09.00.03;	author neilc;	state Exp;
branches;
next	1.11;

1.11
date	2006.11.17.08.46.53;	author meskes;	state Exp;
branches;
next	1.10;

1.10
date	2006.11.17.04.52.46;	author momjian;	state Exp;
branches;
next	1.9;

1.9
date	2006.11.16.21.45.25;	author momjian;	state Exp;
branches;
next	1.8;

1.8
date	2006.11.16.21.43.33;	author momjian;	state Exp;
branches;
next	1.7;

1.7
date	2006.11.16.18.25.58;	author momjian;	state Exp;
branches;
next	1.6;

1.6
date	2006.11.15.01.09.08;	author momjian;	state Exp;
branches;
next	1.5;

1.5
date	2006.11.14.22.25.15;	author momjian;	state Exp;
branches;
next	1.4;

1.4
date	2006.11.14.21.43.00;	author momjian;	state Exp;
branches;
next	1.3;

1.3
date	2006.10.27.12.40.26;	author momjian;	state Exp;
branches;
next	1.2;

1.2
date	2006.10.26.17.07.03;	author momjian;	state Exp;
branches;
next	1.1;

1.1
date	2006.10.26.15.32.45;	author momjian;	state Exp;
branches;
next	;


desc
@@


1.14
log
@Rename replication section "High Availability and Load Balancing".
@
text
@<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.13 2006/11/17 13:29:53 momjian Exp $ -->

<chapter id="failover">
 <title>Failover, Replication, Load Balancing, and Clustering Options</title>

 <indexterm><primary>failover</></>
 <indexterm><primary>replication</></>
 <indexterm><primary>load balancing</></>
 <indexterm><primary>clustering</></>

 <para>
  Database servers can work together to allow a second server to
  quickly take over if the primary server fails (failover), or to
  allow several computers to serve the same data (load balancing).
  Ideally, database servers could work together seamlessly.  Web
  servers serving static web pages can be combined quite easily by
  merely load-balancing web requests to multiple machines.  In
  fact, read-only database servers can be combined relatively easily
  too.  Unfortunately, most database servers have a read/write mix
  of requests, and read/write servers are much harder to combine.
  This is because though read-only data needs to be placed on each
  server only once, a write to any server has to be propagated to
  all servers so that future read requests to those servers return
  consistent results.
 </para>

 <para>
  This synchronization problem is the fundamental difficulty for servers
  working together.  Because there is no single solution that eliminates
  the impact of the sync problem for all use cases, there are multiple
  solutions.  Each solution addresses this problem in a different way, and
  minimizes its impact for a specific workload.
 </para>

 <para>
  Some solutions deal with synchronization by allowing only one
  server to modify the data.  Servers that can modify data are
  called read/write or "master" servers.  Servers that can reply
  to read-only queries are called "slave" servers.  Servers that
  cannot be accessed until they are changed to master servers are
  called "standby" servers.
 </para>

 <para>
  Some failover and load balancing solutions are synchronous, meaning that
  a data-modifying transaction is not considered committed until all
  servers have committed the transaction.  This guarantees that a failover
  will not lose any data and that all load-balanced servers will return
  consistent results with no propagation delay. Asynchronous updating has
  a small delay between the time of commit and its propagation to the
  other servers, opening the possibility that some transactions might be
  lost in the switch to a backup server, and that load balanced servers
  might return slightly stale results.  Asynchronous communication is used
  when synchronous would be too slow.
 </para>

 <para>
  Solutions can also be categorized by their granularity.  Some solutions
  can deal only with an entire database server, while others allow control
  at the per-table or per-database level.
 </para>

 <para>
  Performance must be considered in any failover or load balancing
  choice.  There is usually a tradeoff between functionality and
  performance.  For example, a full synchronous solution over a slow
  network might cut performance by more than half, while an asynchronous
  one might have a minimal performance impact.
 </para>

 <para>
  The remainder of this section outlines various failover, replication,
  and load balancing solutions.
 </para>

 <variablelist>

 <varlistentry>
  <term>Shared Disk Failover</term>
  <listitem>

   <para>
    Shared disk failover avoids synchronization overhead by having only one
    copy of the database.  It uses a single disk array that is shared by
    multiple servers.  If the main database server fails, the standby server
    is able to mount and start the database as though it was recovering from
    a database crash.  This allows rapid failover with no data loss.
   </para>

   <para>
    Shared hardware functionality is common in network storage
    devices.  Using a network file system is also possible, though
    care must be taken that the file system has full POSIX behavior.
    One significant limitation of this method is that if the shared
    disk array fails or becomes corrupt, the primary and standby
    servers are both nonfunctional.  Another issue is that the
    standby server should never access the shared storage while
    the primary server is running.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Warm Standby Using Point-In-Time Recovery</term>
  <listitem>

   <para>
    A warm standby server (see <xref linkend="warm-standby">) can
    be kept current by reading a stream of write-ahead log (WAL)
    records.  If the main server fails, the warm standby contains
    almost all of the data of the main server, and can be quickly
    made the new master database server.  This is asynchronous and
    can only be done for the entire database server.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Master/Slave Replication</term>
  <listitem>

   <para>
    A master/slave replication setup sends all data modification
    queries to the master server.  The master server asynchronously
    sends data changes to the slave server.  The slave can answer
    read-only queries while the master server is running.  The
    slave server is ideal for data warehouse queries.
   </para>

   <para>
    Slony-I is an example of this type of replication, with per-table
    granularity, and support for multiple slaves.  Because it
    updates the slave server asynchronously (in batches), there is
    possible data loss during fail over.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Query Broadcasting</term>
  <listitem>

   <para>
    In query broadcasting, a program intercepts every SQL query
    and sends it to all servers.  Each server operates independently.
    Read-only queries can be sent to a single server because there
    is no need for all servers to process it.
   </para>

   <para>
    One limitation of this solution is that functions like
    <function>random()</>, <function>CURRENT_TIMESTAMP</>, and
    sequences can have different values on different servers.  This
    is because each server operates independently, and because SQL
    queries are broadcast (and not actual modified rows).  If this
    is unacceptable, applications must query such values from a
    single server and then use those values in write queries.
    Also, care must be taken that all transactions either commit
    or abort on all servers, perhaps using two-phase commit (<xref
    linkend="sql-prepare-transaction"
    endterm="sql-prepare-transaction-title"> and <xref
    linkend="sql-commit-prepared" endterm="sql-commit-prepared-title">.
    Pgpool is an example of this type of replication.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Multi-Master Replication Using Clustering</term>
  <listitem>

   <para>
    In clustering, each server can accept write requests, and
    modified data is transmitted from the original server to every
    other server before each transaction commits.  Heavy write
    activity can cause excessive locking, leading to poor performance.
    In fact, write performance is often worse than that of a single
    server.  Read requests can be sent to any server.  Clustering
    is best for mostly read workloads, though its big advantage
    is that any server can accept write requests &mdash; there is
    no need to partition workloads between master and slave servers,
    and because the changes are sent from one server to another,
    there is not a problem with non-deterministic functions like
    <function>random()</>.
   </para>

   <para>
    Clustering is implemented by <productname>Oracle</> in their
    <productname><acronym>RAC</></> product.  <productname>PostgreSQL</>
    does not offer this type of load balancing, though
    <productname>PostgreSQL</> two-phase commit (<xref
    linkend="sql-prepare-transaction"
    endterm="sql-prepare-transaction-title"> and <xref
    linkend="sql-commit-prepared" endterm="sql-commit-prepared-title">)
    can be used to implement this in application code or middleware.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Data Partitioning</term>
  <listitem>

   <para>
    Data partitioning splits tables into data sets.  Each set can
    be modified by only one server.  For example, data can be
    partitioned by offices, e.g. London and Paris, with a server
    in each office.  If queries combining London and Paris data
    are necessary, an application can query both servers, or
    master/slave replication can be used to keep a read-only copy
    of the other office's data on each server.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Clustering For Parallel Query Execution</term>
  <listitem>

   <para>
    This allows multiple servers to work concurrently on a single
    query.  One possible way this could work is for the data to be
    split among servers and for each server to execute its part of
    the query and results sent to a central server to be combined
    and returned to the user.  There currently is no
    <productname>PostgreSQL</> open source solution for this.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Commercial Solutions</term>
  <listitem>

   <para>
    Because <productname>PostgreSQL</> is open source and easily
    extended, a number of companies have taken <productname>PostgreSQL</>
    and created commercial closed-source solutions with unique
    failover, replication, and load balancing capabilities.
   </para>
  </listitem>
 </varlistentry>

 </variablelist>

</chapter>
@


1.13
log
@Data Partitioning documentation section reduced and moved to the end.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.12 2006/11/17 09:00:03 neilc Exp $ -->
@


1.12
log
@Fix a typo.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.11 2006/11/17 08:46:53 meskes Exp $ -->
d140 1
a140 38
  <term>Data Partitioning</term>
  <listitem>

   <para>
    Data partitioning splits tables into data sets.  Each set can
    be modified by only one server.  For example, data can be
    partitioned by offices, e.g. London and Paris.  While London
    and Paris servers have all data records, only London can modify
    London records, and Paris can only modify Paris records.  This
    is similar to the "Master/Slave Replication" item above, except
    that instead of having a read/write server and a read-only
    server, each server has a read/write data set and a read-only
    data set.
   </para>

   <para>
    Such partitioning provides both failover and load balancing.  Failover
    is achieved because the data resides on both servers, and this is an
    ideal way to enable failover if the servers share a slow communication
    channel. Load balancing is possible because read requests can go to any
    of the servers, and write requests are split among the servers.  Of
    course, the communication to keep all the servers up-to-date adds
    overhead, so ideally the write load should be low, or localized as in
    the London/Paris example above.
   </para>

   <para>
    Data partitioning is usually handled by application code, though rules
    and triggers can be used to keep the read-only data sets current.  Slony-I
    can also be used in such a setup.  While Slony-I replicates only entire
    tables, London and Paris can be placed in separate tables, and
    inheritance can be used to access both tables using a single table name.
   </para>
  </listitem>
 </varlistentry>

 <varlistentry>
  <term>Multi-Master Replication Using Query Broadcasting</term>
d144 4
a147 5
    One way to do multi-master replication is by having a program
    intercept every SQL query and send it to all servers.  Each
    server operates independently.  Read-only queries can be sent
    to a single server because there is no need for all servers to
    process it.
d201 16
@


1.11
log
@Fixed small typo, missing 'l' in 'Cluserting'
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.10 2006/11/17 04:52:46 momjian Exp $ -->
d124 1
a124 1
    queries to the master server.  The master server asynchonously
@


1.10
log
@Use more standard terms for replication, ideas from Markus Schiltknecht.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.9 2006/11/16 21:45:25 momjian Exp $ -->
d207 1
a207 1
  <term>Multi-Master Replication Using Custering</term>
@


1.9
log
@Mention two-phase commit for having all transactions commit on all servers.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.8 2006/11/16 21:43:33 momjian Exp $ -->
d12 1
a12 1
  Database servers can work together to allow a backup server to
d38 4
a41 7
  called read/write or "master" server.  Servers with read-only
  data are called backup or "slave" servers.  As you will see below,
  these terms cover a variety of implementations.  Some servers
  are masters of some data sets, and slave of others.  Some slaves
  cannot be accessed until they are changed to master servers,
  while other slaves can reply to read-only queries while they are
  slaves.
d85 1
a85 1
    multiple servers.  If the main database server fails, the backup server
d91 8
a98 4
    Shared hardware functionality is common in network storage devices.  One
    significant limitation of this method is that if the shared disk array
    fails or becomes corrupt, the primary and backup servers are both
    nonfunctional.
d119 1
a119 1
  <term>Continuously Running Replication Server</term>
d123 5
a127 5
    A continuously running replication server allows the backup server to
    answer read-only queries while the master server is running.  It
    receives a continuous stream of write activity from the master server.
    Because the backup server can be used for read-only database requests,
    it is ideal for data warehouse queries.
d132 3
a134 2
    granularity.  It updates the backup server in batches, so the replication
    is asynchronous and might lose data during a fail over.
d149 4
a152 4
    is similar to the "Continuously Running Replication Server"
    item above, except that instead of having a read/write server
    and a read-only server, each server has a read/write data set
    and a read-only data set.
d166 1
a166 1
    <para>
d177 1
a177 1
  <term>Query Broadcast Load Balancing</term>
d181 5
a185 7
    Query broadcast load balancing is accomplished by having a
    program intercept every SQL query and send it to all servers.
    This is unique because most replication solutions have the write
    server propagate its changes to the other servers.  With query
    broadcasting, each server operates independently.  Read-only
    queries can be sent to a single server because there is no need
    for all servers to process it.
d207 1
a207 1
  <term>Clustering For Load Balancing</term>
d210 6
a215 6
    <para>
    In clustering, each server can accept write requests, and modified
    data is transmitted from the original server to every other
    server before each transaction commits.  Heavy write activity
    can cause excessive locking, leading to poor performance.  In
    fact, write performance is often worse than that of a single
d217 6
a222 3
    is best for mostly read workloads, though its big advantage is
    that any server can accept write requests &mdash; there is no need
    to partition workloads between read/write and read-only servers.
@


1.8
log
@Reconfigure failover/replication doc items to be varlist entries, rather
than new sections, so they appear all on the same web page.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.7 2006/11/16 18:25:58 momjian Exp $ -->
d195 7
a201 3
    single server and then use those values in write queries.  Also,
    care must be taken that all transactions either commit or abort
    on all servers  Pgpool is an example of this type of replication.
@


1.7
log
@Clarify replication items, and define some terms.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.6 2006/11/15 01:09:08 momjian Exp $ -->
d79 1
a79 2
 <sect1 id="shared-disk-failover">
  <title>Shared Disk Failover</title>
d81 179
a259 159
  <para>
   Shared disk failover avoids synchronization overhead by having only one
   copy of the database.  It uses a single disk array that is shared by
   multiple servers.  If the main database server fails, the backup server
   is able to mount and start the database as though it was recovering from
   a database crash.  This allows rapid failover with no data loss.
  </para>

  <para>
   Shared hardware functionality is common in network storage devices.  One
   significant limitation of this method is that if the shared disk array
   fails or becomes corrupt, the primary and backup servers are both
   nonfunctional.
  </para>
 </sect1>

 <sect1 id="warm-standby-using-point-in-time-recovery">
  <title>Warm Standby Using Point-In-Time Recovery</title>

  <para>
   A warm standby server (see <xref linkend="warm-standby">) can
   be kept current by reading a stream of write-ahead log (WAL)
   records.  If the main server fails, the warm standby contains
   almost all of the data of the main server, and can be quickly
   made the new master database server.  This is asynchronous and
   can only be done for the entire database server.
  </para>
 </sect1>

 <sect1 id="continuously-running-replication-server">
  <title>Continuously Running Replication Server</title>

  <para>
   A continuously running replication server allows the backup server to
   answer read-only queries while the master server is running.  It
   receives a continuous stream of write activity from the master server.
   Because the backup server can be used for read-only database requests,
   it is ideal for data warehouse queries.
  </para>

  <para>
   Slony-I is an example of this type of replication, with per-table
   granularity.  It updates the backup server in batches, so the replication
   is asynchronous and might lose data during a fail over.
  </para>
 </sect1>

 <sect1 id="data-partitioning">
  <title>Data Partitioning</title>

  <para>
   Data partitioning splits tables into data sets.  Each set can
   be modified by only one server.  For example, data can be
   partitioned by offices, e.g. London and Paris.  While London
   and Paris servers have all data records, only London can modify
   London records, and Paris can only modify Paris records.  This
   is similar to section <xref
   linkend="continuously-running-replication-server"> above, except
   that instead of having a read/write server and a read-only server,
   each server has a read/write data set and a read-only data
   set.
  </para>

  <para>
   Such partitioning provides both failover and load balancing.  Failover
   is achieved because the data resides on both servers, and this is an
   ideal way to enable failover if the servers share a slow communication
   channel. Load balancing is possible because read requests can go to any
   of the servers, and write requests are split among the servers.  Of
   course, the communication to keep all the servers up-to-date adds
   overhead, so ideally the write load should be low, or localized as in
   the London/Paris example above.
  </para>

  <para>
   Data partitioning is usually handled by application code, though rules
   and triggers can be used to keep the read-only data sets current.  Slony-I
   can also be used in such a setup.  While Slony-I replicates only entire
   tables, London and Paris can be placed in separate tables, and
   inheritance can be used to access both tables using a single table name.
  </para>
 </sect1>

 <sect1 id="query-broadcast-load-balancing">
  <title>Query Broadcast Load Balancing</title>

  <para>
   Query broadcast load balancing is accomplished by having a
   program intercept every SQL query and send it to all servers.
   This is unique because most replication solutions have the write
   server propagate its changes to the other servers.  With query
   broadcasting, each server operates independently.  Read-only
   queries can be sent to a single server because there is no need
   for all servers to process it.
  </para>

  <para>
   One limitation of this solution is that functions like
   <function>random()</>, <function>CURRENT_TIMESTAMP</>, and
   sequences can have different values on different servers.  This
   is because each server operates independently, and because SQL
   queries are broadcast (and not actual modified rows).  If this
   is unacceptable, applications must query such values from a
   single server and then use those values in write queries.  Also,
   care must be taken that all transactions either commit or abort
   on all servers  Pgpool is an example of this type of replication.
  </para>
 </sect1>

 <sect1 id="clustering-for-load-balancing">
  <title>Clustering For Load Balancing</title>

  <para>
   In clustering, each server can accept write requests, and modified
   data is transmitted from the original server to every other
   server before each transaction commits.  Heavy write activity
   can cause excessive locking, leading to poor performance.  In
   fact, write performance is often worse than that of a single
   server.  Read requests can be sent to any server.  Clustering
   is best for mostly read workloads, though its big advantage is
   that any server can accept write requests &mdash; there is no need
   to partition workloads between read/write and read-only servers.
  </para>

  <para>
   Clustering is implemented by <productname>Oracle</> in their
   <productname><acronym>RAC</></> product.  <productname>PostgreSQL</>
   does not offer this type of load balancing, though
   <productname>PostgreSQL</> two-phase commit (<xref
   linkend="sql-prepare-transaction"
   endterm="sql-prepare-transaction-title"> and <xref
   linkend="sql-commit-prepared" endterm="sql-commit-prepared-title">)
   can be used to implement this in application code or middleware.
  </para>
 </sect1>

 <sect1 id="clustering-for-parallel-query-execution">
  <title>Clustering For Parallel Query Execution</title>

  <para>
   This allows multiple servers to work concurrently on a single
   query.  One possible way this could work is for the data to be
   split among servers and for each server to execute its part of
   the query and results sent to a central server to be combined
   and returned to the user.  There currently is no
   <productname>PostgreSQL</> open source solution for this.
  </para>
 </sect1>

 <sect1 id="commercial-solutions">
  <title>Commercial Solutions</title>

  <para>
   Because <productname>PostgreSQL</> is open source and easily
   extended, a number of companies have taken <productname>PostgreSQL</>
   and created commercial closed-source solutions with unique
   failover, replication, and load balancing capabilities.
  </para>
 </sect1>
@


1.6
log
@Improve broadcast wording for failover/clustering documentation.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.5 2006/11/14 22:25:15 momjian Exp $ -->
d36 12
d133 10
a142 5
   Data partitioning splits tables into data sets.  Each set can only be
   modified by one server.  For example, data can be partitioned by
   offices, e.g. London and Paris.  While London and Paris servers have all
   data records, only London can modify London records, and Paris can only
   modify Paris records.
d146 1
a146 1
   Such partitioning implements both failover and load balancing.  Failover
@


1.5
log
@Fix xrefs for failover changes.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.4 2006/11/14 21:43:00 momjian Exp $ -->
d152 7
a158 6
   Query broadcast load balancing is accomplished by having a program
   intercept every query and send it to all servers.  Read-only queries can
   be sent to a single server because there is no need for all servers to
   process it.  This is unusual because most replication solutions have
   each write server propagate its changes to the other servers.  With
   query broadcasting, each server operates independently.
d162 1
a162 1
   Because each server operates independently, functions like
d164 7
a170 6
   sequences can have different values on different servers.  If
   this is unacceptable, applications must query such values from
   a single server and then use those values in write queries.
   Also, care must also be taken that all transactions either commit
   or abort on all servers  Pgpool is an example of this type of
   replication.
d178 5
a182 5
   In clustering, each server can accept write requests, and these
   write requests are broadcast from the original server to all
   other servers before each transaction commits.  Heavy write
   activity can cause excessive locking, leading to poor performance.
   In fact, write performance is often worse than that of a single
d185 1
a185 1
   that any server can accept write requests --- there is no need
@


1.4
log
@Update failover docs, per suggestions from Chris Browne.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.3 2006/10/27 12:40:26 momjian Exp $ -->
d192 4
a195 3
   linkend="sql-prepare-transaction-title"> and <xref linkend=
   "sql-commit-prepared-title">) can be used to implement this in
   application code or middleware.
@


1.3
log
@Fix typo in docs.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.2 2006/10/26 17:07:03 momjian Exp $ -->
d111 1
a111 1
   Slony is an example of this type of replication, with per-table
d141 2
a142 2
   and triggers can be used to keep the read-only data sets current.  Slony
   can also be used in such a setup.  While Slony replicates only entire
d161 7
a167 5
   This can be complex to set up because functions like random()
   and CURRENT_TIMESTAMP will have different values on different
   servers, and sequences should be consistent across servers.
   Care must also be taken that all transactions either commit or
   abort on all servers  Pgpool is an example of this type of
d178 11
a188 3
   other servers before each transaction commits.  Under heavy
   load, this can cause excessive locking and performance degradation.
   It is implemented by <productname>Oracle</> in their
d191 4
a194 2
   <productname>PostgreSQL</> two-phase commit can be used to
   implement this in application code or middleware.
d202 6
a207 6
   This allows multiple servers to work on a single query.  One
   possible way this could work is for the data to be split among
   servers and for each server to execute its part of the query
   and results sent to a central server to be combined and returned
   to the user.  There currently is no <productname>PostgreSQL</>
   open source solution for this.
@


1.2
log
@Fix spelling mistake in docs.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 1.1 2006/10/26 15:32:45 momjian Exp $ -->
d63 1
a63 1
  This remainder of this section outlines various failover, replication,
@


1.1
log
@Add missing file for documentation section on failover, replication,
load balancing, and clustering options.
@
text
@d1 1
a1 1
<!-- $PostgreSQL: pgsql/doc/src/sgml/failover.sgml,v 2.91 2006/10/23 18:10:30 petere Exp $ -->
d112 1
a112 1
   granularity.  It updates the backup server in batches, so the repliation
@

