Rewrite logic to two keyed lock

Author: antonkomarev

src/Locker/PostgresAdvisoryLockModeEnum.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cog\DbLocker\Locker;
+
+/**
+ * PostgresAdvisoryLockTypeEnum defines the type of advisory lock acquisition.
+ *
+ * - NonBlocking: Attempt to acquire the lock without blocking (PG_TRY_ADVISORY_LOCK, PG_TRY_ADVISORY_XACT_LOCK).
+ * - Blocking: Acquire the lock, blocking until it becomes available (PG_ADVISORY_LOCK, PG_ADVISORY_XACT_LOCK).
+ */
+enum PostgresAdvisoryLockTypeEnum
+{
+    case NonBlocking;
+    case Blocking;
+}

src/Locker/PostgresAdvisoryLockTypeEnum.php

@@ -20,30 +20,64 @@
 final class PostgresAdvisoryLocker
 {
     /**
-     * Acquire an advisory lock with configurable scope and mode.
+     * Acquire an advisory lock with configurable scope, mode and behavior.
      */
     public function acquireLock(
         PDO $dbConnection,
         PostgresLockId $postgresLockId,
         PostgresAdvisoryLockScopeEnum $scope = PostgresAdvisoryLockScopeEnum::Transaction,
-        PostgresAdvisoryLockModeEnum $mode = PostgresAdvisoryLockModeEnum::Try,
+        PostgresAdvisoryLockTypeEnum $type = PostgresAdvisoryLockTypeEnum::NonBlocking,
+        PostgresLockModeEnum $mode = PostgresLockModeEnum::Exclusive,
     ): bool {
         if ($scope === PostgresAdvisoryLockScopeEnum::Transaction && $dbConnection->inTransaction() === false) {
             throw new LogicException(
                 "Transaction-level advisory lock `$postgresLockId->humanReadableValue` cannot be acquired outside of transaction",
             );
         }
 
-        $sql = match ([$scope, $mode]) {
-            [PostgresAdvisoryLockScopeEnum::Transaction, PostgresAdvisoryLockModeEnum::Try] =>
-                'SELECT PG_TRY_ADVISORY_XACT_LOCK(:class_id, :object_id); -- ' . $postgresLockId->humanReadableValue,
-            [PostgresAdvisoryLockScopeEnum::Transaction, PostgresAdvisoryLockModeEnum::Block] =>
-                'SELECT PG_ADVISORY_XACT_LOCK(:class_id, :object_id); -- ' . $postgresLockId->humanReadableValue,
-            [PostgresAdvisoryLockScopeEnum::Session, PostgresAdvisoryLockModeEnum::Try] =>
-                'SELECT PG_TRY_ADVISORY_LOCK(:class_id, :object_id); -- ' . $postgresLockId->humanReadableValue,
-            [PostgresAdvisoryLockScopeEnum::Session, PostgresAdvisoryLockModeEnum::Block] =>
-                'SELECT PG_ADVISORY_LOCK(:class_id, :object_id); -- ' . $postgresLockId->humanReadableValue,
+        $sql = match ([$scope, $type, $mode]) {
+            [
+                PostgresAdvisoryLockScopeEnum::Transaction,
+                PostgresAdvisoryLockTypeEnum::NonBlocking,
+                PostgresLockModeEnum::Exclusive,
+            ] => 'SELECT PG_TRY_ADVISORY_XACT_LOCK(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Transaction,
+                PostgresAdvisoryLockTypeEnum::Blocking,
+                PostgresLockModeEnum::Exclusive,
+            ] => 'SELECT PG_ADVISORY_XACT_LOCK(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Transaction,
+                PostgresAdvisoryLockTypeEnum::NonBlocking,
+                PostgresLockModeEnum::Share,
+            ] => 'SELECT PG_TRY_ADVISORY_XACT_LOCK_SHARE(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Transaction,
+                PostgresAdvisoryLockTypeEnum::Blocking,
+                PostgresLockModeEnum::Share,
+            ] => 'SELECT PG_ADVISORY_XACT_LOCK_SHARE(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Session,
+                PostgresAdvisoryLockTypeEnum::NonBlocking,
+                PostgresLockModeEnum::Exclusive,
+            ] => 'SELECT PG_TRY_ADVISORY_LOCK(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Session,
+                PostgresAdvisoryLockTypeEnum::Blocking,
+                PostgresLockModeEnum::Exclusive,
+            ] => 'SELECT PG_ADVISORY_LOCK(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Session,
+                PostgresAdvisoryLockTypeEnum::NonBlocking,
+                PostgresLockModeEnum::Share,
+            ] => 'SELECT PG_TRY_ADVISORY_LOCK_SHARE(:class_id, :object_id);',
+            [
+                PostgresAdvisoryLockScopeEnum::Session,
+                PostgresAdvisoryLockTypeEnum::Blocking,
+                PostgresLockModeEnum::Share,
+            ] => 'SELECT PG_ADVISORY_LOCK_SHARE(:class_id, :object_id);',
         };
+        $sql .= " -- $postgresLockId->humanReadableValue";
 
         $statement = $dbConnection->prepare($sql);
         $statement->execute(
@@ -57,7 +91,7 @@ public function acquireLock(
     }
 
     /**
-     * Release session-level lock.
+     * Release session level advisory lock.
      */
     public function releaseLock(
         PDO $dbConnection,
@@ -84,7 +118,7 @@ public function releaseLock(
     }
 
     /**
-     * Release all session-level locks.
+     * Release all session level advisory locks held by the current session.
      */
     public function releaseAllLocks(
         PDO $dbConnection,

src/Locker/PostgresAdvisoryLocker.php

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Cog\DbLocker\Locker;
+
+/**
+ * PostgresLockModeEnum defines the access mode of advisory lock acquisition.
+ */
+enum PostgresLockModeEnum: string
+{
+    case Exclusive = 'ExclusiveLock';
+    case Share = 'ShareLock';
+}

src/Locker/PostgresLockModeEnum.php

@@ -13,15 +13,13 @@
 
 namespace Cog\Test\DbLocker\Integration;
 
+use Cog\DbLocker\Locker\PostgresLockModeEnum;
 use Cog\DbLocker\LockId\PostgresLockId;
 use PDO;
 use PHPUnit\Framework\TestCase;
 
 abstract class AbstractIntegrationTestCase extends TestCase
 {
-    private const MODE_EXCLUSIVE = 'ExclusiveLock';
-    private const MODE_SHARE = 'ShareLock';
-
     protected function tearDown(): void
     {
         $this->closeAllPostgresPdoConnections();
@@ -110,7 +108,7 @@ private function findPostgresAdvisoryLockInConnection(
                 'lock_object_id' => $postgresLockId->objectId,
                 'lock_object_subid' => 2, // Using two keyed locks
                 'connection_pid' => $dbConnection->pgsqlGetPid(),
-                'mode' => self::MODE_EXCLUSIVE,
+                'mode' => PostgresLockModeEnum::Exclusive->value,
             ],
         );
 
@@ -137,7 +135,7 @@ private function findAllPostgresAdvisoryLocks(): array
         );
         $statement->execute(
             [
-                'mode' => self::MODE_EXCLUSIVE,
+                'mode' => PostgresLockModeEnum::Exclusive->value,
             ],
         );