Name chosen per pghackers discussion around 6/22/01.
+
+
+ ShareUpdateExclusiveLock
+
+
+ Acquired by VACUUM (without )
+ and LOCK TABLE table
+ for
+ statements.
+
+
+ Conflicts with ShareUpdateExclusiveLock, ShareLock,
+ ShareRowExclusiveLock, ExclusiveLock and AccessExclusiveLock modes.
+
+
+
+
ShareLock
- Conflicts with RowExclusiveLock, ShareRowExclusiveLock,
+ Conflicts with RowExclusiveLock, ShareUpdateExclusiveLock,
+ ShareRowExclusiveLock,
ExclusiveLock and AccessExclusiveLock modes.
- Conflicts with RowExclusiveLock, ShareLock, ShareRowExclusiveLock,
+ Conflicts with RowExclusiveLock, ShareUpdateExclusiveLock,
+ ShareLock, ShareRowExclusiveLock,
ExclusiveLock and AccessExclusiveLock modes.
- Conflicts with RowShareLock, RowExclusiveLock, ShareLock,
+ Conflicts with RowShareLock, RowExclusiveLock,
+ ShareUpdateExclusiveLock, ShareLock,
ShareRowExclusiveLock, ExclusiveLock and AccessExclusiveLock
modes.
Acquired by ALTER TABLE,
DROP TABLE,
- VACUUM and LOCK TABLE
+ VACUUM FULL and LOCK TABLE
statements.
Conflicts with all modes (AccessShareLock, RowShareLock,
- RowExclusiveLock, ShareLock,
+ RowExclusiveLock, ShareUpdateExclusiveLock, ShareLock,
ShareRowExclusiveLock, ExclusiveLock and AccessExclusiveLock).
- 1999-07-20
+ 2001-07-09
LOCK [ TABLE ] name
-LOCK [ TABLE ] name IN [ ROW | ACCESS ] { SHARE | EXCLUSIVE } MODE
-LOCK [ TABLE ] name IN SHARE ROW EXCLUSIVE MODE
+LOCK [ TABLE ] name IN lockmode MODE
+
+where lockmode is one of:
+
+ ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE |
+ SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE
1999-06-09
-
</div>
<div class="diff ctx"> Inputs</div>
<div class="diff ctx">
This is the least restrictive lock mode. It conflicts only with
ACCESS EXCLUSIVE mode. It is used to protect a table from being
modified by concurrent ALTER TABLE,
- DROP TABLE and VACUUM
+ DROP TABLE and VACUUM FULL
commands.
+
+ SHARE UPDATE EXCLUSIVE MODE
+
+
+ Automatically acquired by VACUUM (without
+ ).
+
+
+
+ Conflicts with SHARE UPDATE EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE,
+ EXCLUSIVE and
+ ACCESS EXCLUSIVE modes. This mode protects a table against
+ concurrent schema changes and VACUUMs.
+
+
+
+
SHARE MODE
- Conflicts with ROW EXCLUSIVE, SHARE ROW EXCLUSIVE, EXCLUSIVE and
+ Conflicts with ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE,
+ SHARE ROW EXCLUSIVE, EXCLUSIVE and
ACCESS EXCLUSIVE modes. This mode protects a table against
- concurrent updates.
+ concurrent data updates.
- This is like EXCLUSIVE MODE, but allows SHARE ROW locks
+ This is like EXCLUSIVE MODE, but allows ROW SHARE locks
by others.
- Conflicts with ROW EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE,
- EXCLUSIVE and ACCESS EXCLUSIVE modes.
+ Conflicts with ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE, SHARE,
+ SHARE ROW EXCLUSIVE, EXCLUSIVE and ACCESS EXCLUSIVE modes.
- Conflicts with ROW SHARE, ROW EXCLUSIVE, SHARE, SHARE ROW EXCLUSIVE,
+ Conflicts with ROW SHARE, ROW EXCLUSIVE, SHARE UPDATE EXCLUSIVE,
+ SHARE, SHARE ROW EXCLUSIVE,
EXCLUSIVE and ACCESS EXCLUSIVE modes.
Automatically acquired by ALTER TABLE,
- DROP TABLE, VACUUM statements.
- This is the most restrictive lock mode which conflicts with all other
- lock modes and protects a locked table from any concurrent operations.
+ DROP TABLE, VACUUM FULL
+ statements.
+ This is the most restrictive lock mode which
+ protects a locked table from any concurrent operations.
lock mode option).
+
+ Conflicts with all lock modes.
+
EXCLUSIVE
- Exclusive lock that prevents other locks from being granted.
+ An exclusive lock prevents other locks of the same type from being
+ granted. (Note: ROW EXCLUSIVE mode does not follow this naming
+ convention perfectly, since it is shared at the level of the table;
+ it is exclusive only with respect to specific rows that are being
+ updated.)
SHARE
- Allows others to share lock. Prevents EXCLUSIVE locks.
+ A shared lock allows others to also hold the same type of lock,
+ but prevents the corresponding EXCLUSIVE lock from being granted.
-
-
- If EXCLUSIVE or SHARE are not specified, EXCLUSIVE is assumed.
- Locks exist for the duration of the transaction.
-
-
- Except for ACCESS SHARE/EXCLUSIVE lock modes, all other
-
Postgres lock modes and the
+ Except for ACCESS SHARE, ACCESS EXCLUSIVE, and SHARE UPDATE EXCLUSIVE lock
+
modes, the Postgres lock modes and the
LOCK TABLE syntax are compatible with those
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.233 2001/06/30 22:03:25 petere Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 2.234 2001/07/09 22:18:33 tgl Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
%type createdb_opt_list, createdb_opt_item
%type opt_lock, lock_type
-%type opt_lmode, opt_force
+%type opt_force
%type user_createdb_clause, user_createuser_clause
%type user_passwd_clause
}
;
-opt_lock: IN lock_type MODE { $$ = $2; }
+opt_lock: IN lock_type MODE { $$ = $2; }
| /*EMPTY*/ { $$ = AccessExclusiveLock; }
;
-lock_type: SHARE ROW EXCLUSIVE { $$ = ShareRowExclusiveLock; }
- | ROW opt_lmode { $$ = ($2? RowShareLock: RowExclusiveLock); }
- | ACCESS opt_lmode { $$ = ($2? AccessShareLock: AccessExclusiveLock); }
- | opt_lmode { $$ = ($1? ShareLock: ExclusiveLock); }
- ;
-
-opt_lmode: SHARE { $$ = TRUE; }
- | EXCLUSIVE { $$ = FALSE; }
+lock_type: ACCESS SHARE { $$ = AccessShareLock; }
+ | ROW SHARE { $$ = RowShareLock; }
+ | ROW EXCLUSIVE { $$ = RowExclusiveLock; }
+ | SHARE UPDATE EXCLUSIVE { $$ = ShareUpdateExclusiveLock; }
+ | SHARE { $$ = ShareLock; }
+ | SHARE ROW EXCLUSIVE { $$ = ShareRowExclusiveLock; }
+ | EXCLUSIVE { $$ = ExclusiveLock; }
+ | ACCESS EXCLUSIVE { $$ = AccessExclusiveLock; }
;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.48 2001/06/22 00:04:59 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lmgr.c,v 1.49 2001/07/09 22:18:33 tgl Exp $
*
*-------------------------------------------------------------------------
*/
(1 << ExclusiveLock) | (1 << AccessExclusiveLock),
/* RowExclusiveLock */
- (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
- (1 << AccessExclusiveLock),
+ (1 << ShareLock) | (1 << ShareRowExclusiveLock) |
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock),
+
+ /* ShareUpdateExclusiveLock */
+ (1 << ShareUpdateExclusiveLock) |
+ (1 << ShareLock) | (1 << ShareRowExclusiveLock) |
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock),
/* ShareLock */
- (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) |
- (1 << RowExclusiveLock) | (1 << AccessExclusiveLock),
+ (1 << RowExclusiveLock) | (1 << ShareUpdateExclusiveLock) |
+ (1 << ShareRowExclusiveLock) |
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock),
/* ShareRowExclusiveLock */
- (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) |
- (1 << ShareLock) | (1 << RowExclusiveLock) | (1 << AccessExclusiveLock),
+ (1 << RowExclusiveLock) | (1 << ShareUpdateExclusiveLock) |
+ (1 << ShareLock) | (1 << ShareRowExclusiveLock) |
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock),
/* ExclusiveLock */
- (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
- (1 << RowExclusiveLock) | (1 << RowShareLock) | (1 << AccessExclusiveLock),
+ (1 << RowShareLock) |
+ (1 << RowExclusiveLock) | (1 << ShareUpdateExclusiveLock) |
+ (1 << ShareLock) | (1 << ShareRowExclusiveLock) |
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock),
/* AccessExclusiveLock */
- (1 << ExclusiveLock) | (1 << ShareRowExclusiveLock) | (1 << ShareLock) |
- (1 << RowExclusiveLock) | (1 << RowShareLock) |
- (1 << AccessExclusiveLock) | (1 << AccessShareLock)
+ (1 << AccessShareLock) | (1 << RowShareLock) |
+ (1 << RowExclusiveLock) | (1 << ShareUpdateExclusiveLock) |
+ (1 << ShareLock) | (1 << ShareRowExclusiveLock) |
+ (1 << ExclusiveLock) | (1 << AccessExclusiveLock)
};
2,
/* RowExclusiveLock */
3,
- /* ShareLock */
+ /* ShareUpdateExclusiveLock */
4,
- /* ShareRowExclusiveLock */
+ /* ShareLock */
5,
- /* ExclusiveLock */
+ /* ShareRowExclusiveLock */
6,
+ /* ExclusiveLock */
+ 7,
/* AccessExclusiveLock */
- 7
+ 8
};
LOCKMETHOD LockTableId = (LOCKMETHOD) NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.90 2001/06/27 23:31:39 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/storage/lmgr/lock.c,v 1.91 2001/07/09 22:18:33 tgl Exp $
*
* NOTES
* Outside modules can create a lock table and acquire/release
"AccessShareLock",
"RowShareLock",
"RowExclusiveLock",
+ "ShareUpdateExclusiveLock",
"ShareLock",
"ShareRowExclusiveLock",
"ExclusiveLock",
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: lmgr.h,v 1.31 2001/06/22 00:04:59 tgl Exp $
+ * $Id: lmgr.h,v 1.32 2001/07/09 22:18:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#define AccessShareLock 1 /* SELECT */
#define RowShareLock 2 /* SELECT FOR UPDATE */
#define RowExclusiveLock 3 /* INSERT, UPDATE, DELETE */
-#define ShareLock 4 /* CREATE INDEX */
-#define ShareRowExclusiveLock 5 /* like EXCLUSIVE MODE, allows
- * SHARE ROW */
-#define ExclusiveLock 6 /* blocks ROW SHARE/SELECT...FOR
+#define ShareUpdateExclusiveLock 4 /* VACUUM (non-FULL) */
+#define ShareLock 5 /* CREATE INDEX */
+#define ShareRowExclusiveLock 6 /* like EXCLUSIVE MODE, but allows
+ * ROW SHARE */
+#define ExclusiveLock 7 /* blocks ROW SHARE/SELECT...FOR
* UPDATE */
-#define AccessExclusiveLock 7 /* ALTER TABLE, DROP TABLE,
- * VACUUM, and unqualified LOCK
+#define AccessExclusiveLock 8 /* ALTER TABLE, DROP TABLE,
+ * VACUUM FULL, and unqualified LOCK
* TABLE */
/*
* Portions Copyright (c) 1996-2001, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
- * $Id: lock.h,v 1.50 2001/06/27 23:31:39 tgl Exp $
+ * $Id: lock.h,v 1.51 2001/07/09 22:18:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typedef int LOCKMETHOD;
/* MAX_LOCKMODES cannot be larger than the # of bits in LOCKMASK */
-#define MAX_LOCKMODES 8
+#define MAX_LOCKMODES 10
/*
* MAX_LOCK_METHODS corresponds to the number of spin locks allocated in
*
* prio -- each lockmode has a priority, so, for example, waiting
* writers can be given priority over readers (to avoid
- * starvation).
+ * starvation). XXX this field is not actually used at present!
*
* masterlock -- synchronizes access to the table
*/
%type createdb_opt_list opt_encoding OptInherit Geometric
%type DropdbStmt ClusterStmt grantee RevokeStmt Bit bit
%type GrantStmt privileges operation_commalist operation PosAllConst
-%type opt_cursor opt_lmode ConstraintsSetStmt comment_tg AllConst
+%type opt_cursor ConstraintsSetStmt comment_tg AllConst
%type case_expr when_clause_list case_default case_arg when_clause
%type select_clause opt_select_limit select_limit_value ConstraintTimeSpec
%type select_offset_value ReindexStmt join_type opt_boolean
| /*EMPTY*/ { $$ = EMPTY;}
;
-lock_type: SHARE ROW EXCLUSIVE { $$ = make_str("share row exclusive"); }
- | ROW opt_lmode { $$ = cat2_str(make_str("row"), $2);}
- | ACCESS opt_lmode { $$ = cat2_str(make_str("access"), $2);}
- | opt_lmode { $$ = $1; }
- ;
-
-opt_lmode: SHARE { $$ = make_str("share"); }
- | EXCLUSIVE { $$ = make_str("exclusive"); }
- ;
+lock_type: ACCESS SHARE { $$ = make_str("access share"); }
+ | ROW SHARE { $$ = make_str("access share"); }
+ | ROW EXCLUSIVE { $$ = make_str("row exclusive"); }
+ | SHARE UPDATE EXCLUSIVE { $$ = make_str("share update exclusive"); }
+ | SHARE { $$ = make_str("share"); }
+ | SHARE ROW EXCLUSIVE { $$ = make_str("share row exclusive"); }
+ | EXCLUSIVE { $$ = make_str("exclusive"); }
+ | ACCESS EXCLUSIVE { $$ = make_str("access exclusive"); }
+ ;
/*****************************************************************************
*
projects / postgresql.git / commitdiff