like the next higher one.
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/mvcc.sgml,v 2.40 2003/11/04 09:55:38 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/mvcc.sgml,v 2.41 2003/11/06 22:08:14 petere Exp $
-->
<chapter id="mvcc">
</table>
<para>
- <productname>PostgreSQL</productname>
- offers the Read Committed and Serializable isolation levels.
+ In <productname>PostgreSQL</productname>, you can use all four
+ possible transaction isolation levels. Internally, there are only
+ two distinct isolation levels, which correspond to the levels Read
+ Committed and Serializable. When you select the level Read
+ Uncommitted you really get Read Committed, and when you select
+ Repeatable Read you really get Serializable, so the actual
+ isolation level may be stricter than what you select. This is
+ permitted by the SQL standard: the four isolation levels only
+ define which phenomena must not happen, they do not define which
+ phenomena must happen. The reason that PostgreSQL only provides
+ two isolation levels is that this is the only sensible way to map
+ the isolation levels to the multiversion concurrency control
+ architecture. The behavior of the available isolation levels is
+ detailed in the following subsections.
+ </para>
+
+ <para>
+ To set the transaction isolation level of a transaction, use the
+ command <xref linkend="sql-set-transaction">.
</para>
<sect2 id="xact-read-committed">
-<!-- $Header: /cvsroot/pgsql/doc/src/sgml/ref/set_transaction.sgml,v 1.17 2003/09/11 21:42:20 momjian Exp $ -->
+<!-- $Header: /cvsroot/pgsql/doc/src/sgml/ref/set_transaction.sgml,v 1.18 2003/11/06 22:08:14 petere Exp $ -->
<refentry id="SQL-SET-TRANSACTION">
<refmeta>
<refentrytitle id="SQL-SET-TRANSACTION-TITLE">SET TRANSACTION</refentrytitle>
<refsynopsisdiv>
<synopsis>
SET TRANSACTION
- [ ISOLATION LEVEL { READ COMMITTED | SERIALIZABLE } ] [ READ WRITE | READ ONLY ]
+ [ ISOLATION LEVEL { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE } ]
+ [ READ WRITE | READ ONLY ]
+
SET SESSION CHARACTERISTICS AS TRANSACTION
- [ ISOLATION LEVEL { READ COMMITTED | SERIALIZABLE } ] [ READ WRITE | READ ONLY ]
+ [ ISOLATION LEVEL { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE } ]
+ [ READ WRITE | READ ONLY ]
</synopsis>
</refsynopsisdiv>
</varlistentry>
</variablelist>
- The transaction isolation level cannot be set after the first query
- or data-modification statement (<command>SELECT</command>,
+ The level <literal>READ UNCOMMITTED</literal> is mapped to
+ <literal>READ COMMITTED</literal>, the level <literal>REPEATABLE
+ READ</literal> is mapped to <literal>SERIALIZABLE</literal>, The
+ transaction isolation level cannot be set after the first query or
+ data-modification statement (<command>SELECT</command>,
<command>INSERT</command>, <command>DELETE</command>,
<command>UPDATE</command>, <command>FETCH</command>,
<command>COPY</command>) of a transaction has been executed. See
<para>
Both commands are defined in the <acronym>SQL</acronym> standard.
<literal>SERIALIZABLE</literal> is the default transaction
- isolation level in the standard; in <productname>PostgreSQL</productname> the default is
- ordinarily <literal>READ COMMITTED</literal>, but you can change it as
- described above. <productname>PostgreSQL</productname> does not
- provide the isolation levels <literal>READ UNCOMMITTED</literal>
- and <literal>REPEATABLE READ</literal>. Because of multiversion
- concurrency control, the <literal>SERIALIZABLE</literal> level is
- not truly serializable. See <xref linkend="mvcc"> for details.
+ isolation level in the standard; in
+ <productname>PostgreSQL</productname> the default is ordinarily
+ <literal>READ COMMITTED</literal>, but you can change it as
+ described above. Because of multiversion concurrency control, the
+ <literal>SERIALIZABLE</literal> level is not truly
+ serializable. See <xref linkend="mvcc"> for details.
</para>
<para>
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/ref/start_transaction.sgml,v 1.7 2003/09/09 18:28:53 tgl Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/ref/start_transaction.sgml,v 1.8 2003/11/06 22:08:14 petere Exp $
PostgreSQL documentation
-->
<refsynopsisdiv>
<synopsis>
-START TRANSACTION [ ISOLATION LEVEL { READ COMMITTED | SERIALIZABLE } ] [ READ WRITE | READ ONLY ]
+START TRANSACTION
+ [ ISOLATION LEVEL { READ UNCOMMITTED | READ COMMITTED | REPEATABLE READ | SERIALIZABLE } ]
+ [ READ WRITE | READ ONLY ]
</synopsis>
</refsynopsisdiv>
<!--
-$Header: /cvsroot/pgsql/doc/src/sgml/runtime.sgml,v 1.216 2003/11/04 09:55:38 petere Exp $
+$Header: /cvsroot/pgsql/doc/src/sgml/runtime.sgml,v 1.217 2003/11/06 22:08:14 petere Exp $
-->
<Chapter Id="runtime">
<term><varname>default_transaction_isolation</varname> (<type>string</type>)</term>
<listitem>
<para>
- Each SQL transaction has an isolation level, which can be either
- <quote>read committed</quote> or <quote>serializable</quote>.
- This parameter controls the default isolation level of each new
- transaction. The default is <quote>read committed</quote>.
+ Each SQL transaction has an isolation level, which can be
+ either <quote>read uncommitted</quote>, <quote>read
+ committed</quote>, <quote>repeatable read</quote>, or
+ <quote>serializable</quote>. This parameter controls the
+ default isolation level of each new transaction. The default
+ is <quote>read committed</quote>.
</para>
<para>
F051 Basic date and time 08 LOCALTIMESTAMP YES
F052 Intervals and datetime arithmetic YES
F081 UNION and EXCEPT in views YES
-F111 Isolation levels other than SERIALIZABLE NO
-F111 Isolation levels other than SERIALIZABLE 01 READ UNCOMMITTED isolation level NO
+F111 Isolation levels other than SERIALIZABLE YES
+F111 Isolation levels other than SERIALIZABLE 01 READ UNCOMMITTED isolation level YES behaves like READ COMMITTED
F111 Isolation levels other than SERIALIZABLE 02 READ COMMITTED isolation level YES
-F111 Isolation levels other than SERIALIZABLE 03 REPEATABLE READ isolation level NO
+F111 Isolation levels other than SERIALIZABLE 03 REPEATABLE READ isolation level YES behaves like SERIALIZABLE
F121 Basic diagnostics management NO
F121 Basic diagnostics management 01 GET DIAGNOSTICS statement NO
F121 Basic diagnostics management 02 SET TRANSACTION statement: DIAGNOSTICS SIZE clause NO
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.159 2003/10/02 06:34:03 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/trigger.c,v 1.160 2003/11/06 22:08:14 petere Exp $
*
*-------------------------------------------------------------------------
*/
case HeapTupleUpdated:
ReleaseBuffer(buffer);
- if (XactIsoLevel == XACT_SERIALIZABLE)
+ if (IsXactIsoLevelSerializable)
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.88 2003/09/25 06:57:59 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/commands/variable.c,v 1.89 2003/11/06 22:08:14 petere Exp $
*
*-------------------------------------------------------------------------
*/
if (doit)
XactIsoLevel = XACT_SERIALIZABLE;
}
+ else if (strcmp(value, "repeatable read") == 0)
+ {
+ if (doit)
+ XactIsoLevel = XACT_REPEATABLE_READ;
+ }
else if (strcmp(value, "read committed") == 0)
{
if (doit)
XactIsoLevel = XACT_READ_COMMITTED;
}
+ else if (strcmp(value, "read uncommitted") == 0)
+ {
+ if (doit)
+ XactIsoLevel = XACT_READ_UNCOMMITTED;
+ }
else if (strcmp(value, "default") == 0)
{
if (doit)
const char *
show_XactIsoLevel(void)
{
- if (XactIsoLevel == XACT_SERIALIZABLE)
- return "serializable";
- else
- return "read committed";
+ switch (XactIsoLevel)
+ {
+ case XACT_READ_UNCOMMITTED:
+ return "read uncommitted";
+ case XACT_READ_COMMITTED:
+ return "read committed";
+ case XACT_REPEATABLE_READ:
+ return "repeatable read";
+ case XACT_SERIALIZABLE:
+ return "serializable";
+ default:
+ return "bogus";
+ }
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.220 2003/10/01 21:30:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execMain.c,v 1.221 2003/11/06 22:08:14 petere Exp $
*
*-------------------------------------------------------------------------
*/
break;
case HeapTupleUpdated:
- if (XactIsoLevel == XACT_SERIALIZABLE)
+ if (IsXactIsoLevelSerializable)
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
break;
case HeapTupleUpdated:
- if (XactIsoLevel == XACT_SERIALIZABLE)
+ if (IsXactIsoLevelSerializable)
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
break;
case HeapTupleUpdated:
- if (XactIsoLevel == XACT_SERIALIZABLE)
+ if (IsXactIsoLevelSerializable)
ereport(ERROR,
(errcode(ERRCODE_T_R_SERIALIZATION_FAILURE),
errmsg("could not serialize access due to concurrent update")));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.436 2003/10/02 06:34:04 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.437 2003/11/06 22:08:14 petere Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
DATABASE DAY_P DEALLOCATE DEC DECIMAL_P DECLARE DEFAULT DEFAULTS
DEFERRABLE DEFERRED DEFINER DELETE_P DELIMITER DELIMITERS
- DESC DISTINCT DO DOMAIN_P DOUBLE_P DROP
+ DESC DISTINCT DO DOMAIN_P DOUBLE_P DROP
EACH ELSE ENCODING ENCRYPTED END_P ESCAPE EXCEPT EXCLUDING
EXCLUSIVE EXECUTE EXISTS EXPLAIN EXTERNAL EXTRACT
PRECISION PRESERVE PREPARE PRIMARY
PRIOR PRIVILEGES PROCEDURAL PROCEDURE
- READ REAL RECHECK REFERENCES REINDEX RELATIVE_P RENAME REPLACE
+ READ REAL RECHECK REFERENCES REINDEX RELATIVE_P RENAME REPEATABLE REPLACE
RESET RESTART RESTRICT RETURNS REVOKE RIGHT ROLLBACK ROW ROWS
RULE
TO TOAST TRAILING TRANSACTION TREAT TRIGGER TRIM TRUE_P
TRUNCATE TRUSTED TYPE_P
- UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL
+ UNCOMMITTED UNENCRYPTED UNION UNIQUE UNKNOWN UNLISTEN UNTIL
UPDATE USAGE USER USING
VACUUM VALID VALIDATOR VALUES VARCHAR VARYING
{ $$ = makeAConst($1); }
;
-iso_level: READ COMMITTED { $$ = "read committed"; }
+iso_level: READ UNCOMMITTED { $$ = "read uncommitted"; }
+ | READ COMMITTED { $$ = "read committed"; }
+ | REPEATABLE READ { $$ = "repeatable read"; }
| SERIALIZABLE { $$ = "serializable"; }
;
| REINDEX
| RELATIVE_P
| RENAME
+ | REPEATABLE
| REPLACE
| RESET
| RESTART
| TRUNCATE
| TRUSTED
| TYPE_P
+ | UNCOMMITTED
| UNENCRYPTED
| UNKNOWN
| UNLISTEN
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.141 2003/08/04 02:40:01 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.142 2003/11/06 22:08:15 petere Exp $
*
*-------------------------------------------------------------------------
*/
{"reindex", REINDEX},
{"relative", RELATIVE_P},
{"rename", RENAME},
+ {"repeatable", REPEATABLE},
{"replace", REPLACE},
{"reset", RESET},
{"restart", RESTART},
{"truncate", TRUNCATE},
{"trusted", TRUSTED},
{"type", TYPE_P},
+ {"uncommitted", UNCOMMITTED},
{"unencrypted", UNENCRYPTED},
{"union", UNION},
{"unique", UNIQUE},
*
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.63 2003/10/31 03:58:20 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/adt/ri_triggers.c,v 1.64 2003/11/06 22:08:15 petere Exp $
*
* ----------
*/
* rows under current snapshot that wouldn't be visible per the
* transaction snapshot).
*/
- if (XactIsoLevel == XACT_SERIALIZABLE)
+ if (IsXactIsoLevelSerializable)
{
useCurrentSnapshot = detectNewRows;
}
* Written by Peter Eisentraut <peter_e@gmx.net>.
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.164 2003/10/18 22:59:09 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/misc/guc.c,v 1.165 2003/11/06 22:08:15 petere Exp $
*
*--------------------------------------------------------------------
*/
{"default_transaction_isolation", PGC_USERSET, CLIENT_CONN_STATEMENT,
gettext_noop("Sets the transaction isolation level of each new transaction."),
gettext_noop("Each SQL transaction has an isolation level, which "
- "can be either \"read committed\" or \"serializable\".")
+ "can be either \"read uncommitted\", \"read committed\", \"repeatable read\", or \"serializable\".")
},
&default_iso_level_string,
"read committed", assign_defaultxactisolevel, NULL
if (doit)
DefaultXactIsoLevel = XACT_SERIALIZABLE;
}
+ else if (strcasecmp(newval, "repeatable read") == 0)
+ {
+ if (doit)
+ DefaultXactIsoLevel = XACT_REPEATABLE_READ;
+ }
else if (strcasecmp(newval, "read committed") == 0)
{
if (doit)
DefaultXactIsoLevel = XACT_READ_COMMITTED;
}
+ else if (strcasecmp(newval, "read uncommitted") == 0)
+ {
+ if (doit)
+ DefaultXactIsoLevel = XACT_READ_UNCOMMITTED;
+ }
else
return NULL;
return newval;
* Portions Copyright (c) 1994, Regents of the University of California
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.70 2003/10/01 21:30:52 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/time/tqual.c,v 1.71 2003/11/06 22:08:15 petere Exp $
*
*-------------------------------------------------------------------------
*/
return;
}
- if (XactIsoLevel == XACT_SERIALIZABLE)
+ if (IsXactIsoLevelSerializable)
QuerySnapshot = SerializableSnapshot;
else
QuerySnapshot = GetSnapshotData(&QuerySnapshotData, false);
*
* Copyright (c) 2000-2003, PostgreSQL Global Development Group
*
- * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.91 2003/10/30 21:37:38 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/bin/psql/tab-complete.c,v 1.92 2003/11/06 22:08:15 petere Exp $
*/
/*----------------------------------------------------------------------
"ABORT", "ALTER", "ANALYZE", "BEGIN", "CHECKPOINT", "CLOSE", "CLUSTER", "COMMENT",
"COMMIT", "COPY", "CREATE", "DEALLOCATE", "DECLARE", "DELETE", "DROP", "EXECUTE",
"EXPLAIN", "FETCH", "GRANT", "INSERT", "LISTEN", "LOAD", "LOCK", "MOVE", "NOTIFY",
- "PREPARE", "REINDEX", "RESET", "REVOKE", "ROLLBACK", "SELECT", "SET", "SHOW",
+ "PREPARE", "REINDEX", "RESET", "REVOKE", "ROLLBACK", "SELECT", "SET", "SHOW", "START",
"TRUNCATE", "UNLISTEN", "UPDATE", "VACUUM", NULL
};
strcasecmp(prev_wd, "SHOW") == 0)
COMPLETE_WITH_LIST(pgsql_variables);
/* Complete "SET TRANSACTION" */
- else if ((strcasecmp(prev2_wd, "SET") == 0 &&
- strcasecmp(prev_wd, "TRANSACTION") == 0) ||
- (strcasecmp(prev4_wd, "SESSION") == 0 &&
- strcasecmp(prev3_wd, "CHARACTERISTICS") == 0 &&
- strcasecmp(prev2_wd, "AS") == 0 &&
- strcasecmp(prev_wd, "TRANSACTION") == 0))
+ else if ((strcasecmp(prev2_wd, "SET") == 0
+ && strcasecmp(prev_wd, "TRANSACTION") == 0)
+ || (strcasecmp(prev2_wd, "START") == 0
+ && strcasecmp(prev_wd, "TRANSACTION") == 0)
+ || (strcasecmp(prev4_wd, "SESSION") == 0
+ && strcasecmp(prev3_wd, "CHARACTERISTICS") == 0
+ && strcasecmp(prev2_wd, "AS") == 0
+ && strcasecmp(prev_wd, "TRANSACTION") == 0))
{
static const char * const my_list[] =
{"ISOLATION", "READ", NULL};
COMPLETE_WITH_LIST(my_list);
}
- else if (strcasecmp(prev3_wd, "SET") == 0 &&
- strcasecmp(prev2_wd, "TRANSACTION") == 0 &&
- strcasecmp(prev_wd, "ISOLATION") == 0)
+ else if ((strcasecmp(prev3_wd, "SET") == 0
+ || strcasecmp(prev3_wd, "START") == 0
+ || (strcasecmp(prev4_wd, "CHARACTERISTICS") == 0
+ && strcasecmp(prev3_wd, "AS") == 0))
+ && strcasecmp(prev2_wd, "TRANSACTION") == 0
+ && strcasecmp(prev_wd, "ISOLATION") == 0)
COMPLETE_WITH_CONST("LEVEL");
- else if ((strcasecmp(prev4_wd, "SET") == 0 ||
- strcasecmp(prev4_wd, "AS") == 0) &&
- strcasecmp(prev3_wd, "TRANSACTION") == 0 &&
- strcasecmp(prev2_wd, "ISOLATION") == 0 &&
- strcasecmp(prev_wd, "LEVEL") == 0)
+ else if ((strcasecmp(prev4_wd, "SET") == 0
+ || strcasecmp(prev4_wd, "START") == 0
+ || strcasecmp(prev4_wd, "AS") == 0)
+ && strcasecmp(prev3_wd, "TRANSACTION") == 0
+ && strcasecmp(prev2_wd, "ISOLATION") == 0
+ && strcasecmp(prev_wd, "LEVEL") == 0)
{
static const char * const my_list[] =
- {"READ", "SERIALIZABLE", NULL};
+ {"READ", "REPEATABLE", "SERIALIZABLE", NULL};
COMPLETE_WITH_LIST(my_list);
}
strcasecmp(prev3_wd, "ISOLATION") == 0 &&
strcasecmp(prev2_wd, "LEVEL") == 0 &&
strcasecmp(prev_wd, "READ") == 0)
- COMPLETE_WITH_CONST("COMMITTED");
+ {
+ static const char * const my_list[] =
+ {"UNCOMMITTED", "COMMITTED", NULL};
+
+ COMPLETE_WITH_LIST(my_list);
+ }
+ else if (strcasecmp(prev4_wd, "TRANSACTION") == 0 &&
+ strcasecmp(prev3_wd, "ISOLATION") == 0 &&
+ strcasecmp(prev2_wd, "LEVEL") == 0 &&
+ strcasecmp(prev_wd, "REPEATABLE") == 0)
+ COMPLETE_WITH_CONST("READ");
else if ((strcasecmp(prev3_wd, "SET") == 0 ||
strcasecmp(prev3_wd, "AS") == 0) &&
strcasecmp(prev2_wd, "TRANSACTION") == 0 &&
}
}
+/* START TRANSACTION */
+ else if (strcasecmp(prev_wd, "START") == 0)
+ COMPLETE_WITH_CONST("TRANSACTION");
+
/* TRUNCATE */
else if (strcasecmp(prev_wd, "TRUNCATE") == 0)
COMPLETE_WITH_SCHEMA_QUERY(Query_for_list_of_tables, NULL);
* Portions Copyright (c) 1996-2003, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: xact.h,v 1.57 2003/10/16 16:50:41 tgl Exp $
+ * $Id: xact.h,v 1.58 2003/11/06 22:08:15 petere Exp $
*
*-------------------------------------------------------------------------
*/
/*
* Xact isolation levels
*/
-#define XACT_DIRTY_READ 0 /* not implemented */
+#define XACT_READ_UNCOMMITTED 0
#define XACT_READ_COMMITTED 1
-#define XACT_REPEATABLE_READ 2 /* not implemented */
+#define XACT_REPEATABLE_READ 2
#define XACT_SERIALIZABLE 3
extern int DefaultXactIsoLevel;
extern int XactIsoLevel;
+/*
+ * We only implement two distinct levels, so this is a convenience to
+ * check which level we're really using internally.
+ */
+#define IsXactIsoLevelSerializable ((XactIsoLevel == XACT_REPEATABLE_READ || XactIsoLevel == XACT_SERIALIZABLE))
+
/* Xact read-only state */
extern bool DefaultXactReadOnly;
extern bool XactReadOnly;
projects / postgresql / commitdiff