ssi_doc-v2.patch

*** a/doc/src/sgml/mvcc.sgml
--- b/doc/src/sgml/mvcc.sgml
***************
*** 516,522 **** ERROR:  could not serialize access due to concurrent update
  
     <para>
      The <firstterm>Serializable</firstterm> isolation level provides the strictest transaction
!     isolation.  This level emulates serial transaction execution,
      as if transactions had been executed one after another, serially,
      rather than concurrently.  However, like the Repeatable Read level,
      applications using this level must
--- 516,522 ----
  
     <para>
      The <firstterm>Serializable</firstterm> isolation level provides the strictest transaction
!     isolation.  This level emulates serial transaction execution for all committed transactions;
      as if transactions had been executed one after another, serially,
      rather than concurrently.  However, like the Repeatable Read level,
      applications using this level must
***************
*** 572,577 **** ERROR:  could not serialize access due to read/write dependencies among transact
--- 572,591 ----
     </para>
  
     <para>
+     When relying on Serializable transactions to prevent anomalies, it is
+     important that any data read from a permanent user table not be
+     considered valid until the transaction which read it has successfully
+     committed.  This is true even for read-only transactions, except that
+     data read within a <firstterm>deferrable</firstterm> read-only
+     transaction is known to be valid as soon as it is read, because such a
+     transaction waits until it can acquire a snapshot guaranteed to be free
+     from such problems before starting to read any data.  In all other cases
+     applications must not depend on results read during a transaction that
+     later aborted; instead, they should retry the transaction until it
+     succeeds.
+    </para>
+ 
+    <para>
      To guarantee true serializability <productname>PostgreSQL</productname>
      uses <firstterm>predicate locking</>, which means that it keeps locks
      which allow it to determine when a write would have had an impact on