Add transaction-level advisory locks.

They share the same locking namespace with the existing session-level
advisory locks, but they are automatically released at the end of the
current transaction and cannot be released explicitly via unlock
functions.

Marko Tiikkaja, reviewed by me.

1 files changed, 153 insertions, 1 deletions

diff --git a/src/backend/utils/adt/lockfuncs.c b/src/backend/utils/adt/lockfuncs.c
index 8e369826cec..c6c948ce5e7 100644
--- a/src/backend/utils/adt/lockfuncs.c
+++ b/src/backend/utils/adt/lockfuncs.c
@@ -422,6 +422,23 @@ pg_advisory_lock_int8(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_advisory_xact_lock(int8) - acquire xact scoped
+ * exclusive lock on an int8 key
+ */
+Datum
+pg_advisory_xact_lock_int8(PG_FUNCTION_ARGS)
+{
+	int64		key = PG_GETARG_INT64(0);
+	LOCKTAG		tag;
+
+	SET_LOCKTAG_INT64(tag, key);
+
+	(void) LockAcquire(&tag, ExclusiveLock, false, false);
+
+	PG_RETURN_VOID();
+}
+
+/*
  * pg_advisory_lock_shared(int8) - acquire share lock on an int8 key
  */
 Datum
@@ -438,6 +455,23 @@ pg_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_advisory_xact_lock_shared(int8) - acquire xact scoped
+ * share lock on an int8 key
+ */
+Datum
+pg_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS)
+{
+	int64		key = PG_GETARG_INT64(0);
+	LOCKTAG		tag;
+
+	SET_LOCKTAG_INT64(tag, key);
+
+	(void) LockAcquire(&tag, ShareLock, false, false);
+
+	PG_RETURN_VOID();
+}
+
+/*
  * pg_try_advisory_lock(int8) - acquire exclusive lock on an int8 key, no wait
  *
  * Returns true if successful, false if lock not available
@@ -457,6 +491,26 @@ pg_try_advisory_lock_int8(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_try_advisory_xact_lock(int8) - acquire xact scoped
+ * exclusive lock on an int8 key, no wait
+ *
+ * Returns true if successful, false if lock not available
+ */
+Datum
+pg_try_advisory_xact_lock_int8(PG_FUNCTION_ARGS)
+{
+	int64		key = PG_GETARG_INT64(0);
+	LOCKTAG		tag;
+	LockAcquireResult res;
+
+	SET_LOCKTAG_INT64(tag, key);
+
+	res = LockAcquire(&tag, ExclusiveLock, false, true);
+
+	PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
+}
+
+/*
  * pg_try_advisory_lock_shared(int8) - acquire share lock on an int8 key, no wait
  *
  * Returns true if successful, false if lock not available
@@ -476,6 +530,26 @@ pg_try_advisory_lock_shared_int8(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_try_advisory_xact_lock_shared(int8) - acquire xact scoped
+ * share lock on an int8 key, no wait
+ *
+ * Returns true if successful, false if lock not available
+ */
+Datum
+pg_try_advisory_xact_lock_shared_int8(PG_FUNCTION_ARGS)
+{
+	int64		key = PG_GETARG_INT64(0);
+	LOCKTAG		tag;
+	LockAcquireResult res;
+
+	SET_LOCKTAG_INT64(tag, key);
+
+	res = LockAcquire(&tag, ShareLock, false, true);
+
+	PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
+}
+
+/*
  * pg_advisory_unlock(int8) - release exclusive lock on an int8 key
  *
  * Returns true if successful, false if lock was not held
@@ -531,6 +605,24 @@ pg_advisory_lock_int4(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_advisory_xact_lock(int4, int4) - acquire xact scoped
+ * exclusive lock on 2 int4 keys
+ */
+Datum
+pg_advisory_xact_lock_int4(PG_FUNCTION_ARGS)
+{
+	int32		key1 = PG_GETARG_INT32(0);
+	int32		key2 = PG_GETARG_INT32(1);
+	LOCKTAG		tag;
+
+	SET_LOCKTAG_INT32(tag, key1, key2);
+
+	(void) LockAcquire(&tag, ExclusiveLock, false, false);
+
+	PG_RETURN_VOID();
+}
+
+/*
  * pg_advisory_lock_shared(int4, int4) - acquire share lock on 2 int4 keys
  */
 Datum
@@ -548,6 +640,24 @@ pg_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_advisory_xact_lock_shared(int4, int4) - acquire xact scoped
+ * share lock on 2 int4 keys
+ */
+Datum
+pg_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS)
+{
+	int32		key1 = PG_GETARG_INT32(0);
+	int32		key2 = PG_GETARG_INT32(1);
+	LOCKTAG		tag;
+
+	SET_LOCKTAG_INT32(tag, key1, key2);
+
+	(void) LockAcquire(&tag, ShareLock, false, false);
+
+	PG_RETURN_VOID();
+}
+
+/*
  * pg_try_advisory_lock(int4, int4) - acquire exclusive lock on 2 int4 keys, no wait
  *
  * Returns true if successful, false if lock not available
@@ -568,6 +678,27 @@ pg_try_advisory_lock_int4(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_try_advisory_xact_lock(int4, int4) - acquire xact scoped
+ * exclusive lock on 2 int4 keys, no wait
+ *
+ * Returns true if successful, false if lock not available
+ */
+Datum
+pg_try_advisory_xact_lock_int4(PG_FUNCTION_ARGS)
+{
+	int32		key1 = PG_GETARG_INT32(0);
+	int32		key2 = PG_GETARG_INT32(1);
+	LOCKTAG		tag;
+	LockAcquireResult res;
+
+	SET_LOCKTAG_INT32(tag, key1, key2);
+
+	res = LockAcquire(&tag, ExclusiveLock, false, true);
+
+	PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
+}
+
+/*
  * pg_try_advisory_lock_shared(int4, int4) - acquire share lock on 2 int4 keys, no wait
  *
  * Returns true if successful, false if lock not available
@@ -588,6 +719,27 @@ pg_try_advisory_lock_shared_int4(PG_FUNCTION_ARGS)
 }
 
 /*
+ * pg_try_advisory_xact_lock_shared(int4, int4) - acquire xact scoped
+ * share lock on 2 int4 keys, no wait
+ *
+ * Returns true if successful, false if lock not available
+ */
+Datum
+pg_try_advisory_xact_lock_shared_int4(PG_FUNCTION_ARGS)
+{
+	int32		key1 = PG_GETARG_INT32(0);
+	int32		key2 = PG_GETARG_INT32(1);
+	LOCKTAG		tag;
+	LockAcquireResult res;
+
+	SET_LOCKTAG_INT32(tag, key1, key2);
+
+	res = LockAcquire(&tag, ShareLock, false, true);
+
+	PG_RETURN_BOOL(res != LOCKACQUIRE_NOT_AVAIL);
+}
+
+/*
  * pg_advisory_unlock(int4, int4) - release exclusive lock on 2 int4 keys
  *
  * Returns true if successful, false if lock was not held
@@ -633,7 +785,7 @@ pg_advisory_unlock_shared_int4(PG_FUNCTION_ARGS)
 Datum
 pg_advisory_unlock_all(PG_FUNCTION_ARGS)
 {
-	LockReleaseAll(USER_LOCKMETHOD, true);
+	LockReleaseSession(USER_LOCKMETHOD);
 
 	PG_RETURN_VOID();
 }