Make executeOnce public

Signed-off-by: Graham <gpe@openrs2.org>

db/src/main/kotlin/org/openrs2/db/Database.kt

@@ -79,7 +79,14 @@ public class Database(
         throw AssertionError()
     }
 
-    private fun <T> executeOnce(transaction: Transaction<T>): T {
+    /**
+     * Executes a [Transaction]. If the transaction fails due to deadlock, it
+     * is not retried. This method should therefore only be used if the
+     * [Transaction.execute] method has side effects.
+     * @param transaction the transaction.
+     * @return the result returned by [Transaction.execute].
+     */
+    public fun <T> executeOnce(transaction: Transaction<T>): T {
         dataSource.connection.use { connection ->
             val oldAutoCommit = connection.autoCommit
             connection.autoCommit = false

db/src/test/kotlin/org/openrs2/db/DatabaseTest.kt

@@ -44,6 +44,19 @@ class DatabaseTest {
         assertEquals(0, elapsed)
     }
 
+    @Test
+    fun testSuccessfulOnce() {
+        val result = database.executeOnce { connection ->
+            connection.prepareStatement("VALUES 12345").use { stmt ->
+                val rows = stmt.executeQuery()
+                assertTrue(rows.next())
+                return@executeOnce rows.getInt(1)
+            }
+        }
+
+        assertEquals(12345, result)
+    }
+
     @Test
     fun testDeadlockRetry() = runBlockingTest {
         var attempts = 0
@@ -68,6 +81,20 @@ class DatabaseTest {
         assertEquals(10, elapsed)
     }
 
+    @Test
+    fun testDeadlockOnce() {
+        var attempts = 0
+
+        assertFailsWith<DeadlockException> {
+            database.executeOnce<Unit> {
+                attempts++
+                throw DeadlockException()
+            }
+        }
+
+        assertEquals(1, attempts)
+    }
+
     @Test
     fun testDeadlockFailure() {
         var attempts = 0
@@ -100,6 +127,20 @@ class DatabaseTest {
         assertEquals(1, attempts)
     }
 
+    @Test
+    fun testNonDeadlockFailureOnce() {
+        var attempts = 0
+
+        assertFailsWith<TestException> {
+            database.executeOnce<Unit> {
+                attempts++
+                throw TestException()
+            }
+        }
+
+        assertEquals(1, attempts)
+    }
+
     @Test
     fun testDeadlockCauseChain() = runBlockingTest {
         var attempts = 0