Transactions

database.transaction(() -> {
  // Anything that happens in here is part of the transaction.
  // If an exception bubbles out, the transaction will be rolled back.
});

database.transaction(() -> {
  // Pull initial account balances
  BigDecimal balance1 = database.query("SELECT balance FROM account WHERE id = :id")
    .bind("id", 1)
    .fetchObject(BigDecimal.class)
    .orElseThrow();
  BigDecimal balance2 = database.query("SELECT balance FROM account WHERE id = :id")
    .bind("id", 2)
    .fetchObject(BigDecimal.class)
    .orElseThrow();
  
  // Debit one and credit the other 
  balance1 = balance1.subtract(amount);
  balance2 = balance2.add(amount);

  // Persist changes
  database.query("UPDATE account SET balance = :balance WHERE id = :id")
    .bind("balance", balance1)
    .bind("id", 1)
    .execute();
  database.query("UPDATE account SET balance = :balance WHERE id = :id")
    .bind("balance", balance2)
    .bind("id", 2)
    .execute();
});

// For convenience, transactional operations may return values
Optional<BigDecimal> newBalance = database.transaction(() -> {
  // Make some changes
  database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
    .bind("id", 1)
    .execute();
  database.query("UPDATE account SET balance = balance + 10 WHERE id = :id")
    .bind("id", 2)
    .execute();

  // Return the new value
  return database.query("SELECT balance FROM account WHERE id = :id")
    .bind("id", 2)
    .fetchObject(BigDecimal.class);
});

// Gets a handle to the current transaction, if any.
Optional<Transaction> transaction = database.currentTransaction();

// Output is "false"
out.println(transaction.isPresent());

database.transaction(() -> {
  // A transaction only exists for the life of the closure
  Optional<Transaction> actualTransaction = database.currentTransaction();

  // Output is "true"
  out.println(actualTransaction.isPresent());
});

database.transaction(() -> {
  database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
    .bind("id", 1)
    .execute();

  // Get a handle to the current transaction
  Transaction transaction = database.currentTransaction().orElseThrow();

  try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
    CompletableFuture.runAsync(() -> {
      // In a different thread and participating in the existing transaction.
      // No commit or rollback will occur when the closure completes, but if an 
      // exception bubbles out the transaction will be marked as rollback-only
      database.participate(transaction, () -> {
        database.query("UPDATE account SET balance = balance + 10 WHERE id = :id")
          .bind("id", 2)
          .execute();
      });
    }, executor).join();
  }
});

// Any exception that bubbles out will cause a rollback
database.transaction(() -> {
  database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
    .bind("id", 1)
    .execute();
  throw new IllegalStateException("Something's wrong!");
});

// You may mark a transaction as rollback-only, and it will roll back 
// after the closure execution has completed
database.transaction(() -> {
  database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
    .bind("id", 1)
    .execute();

  // Hmm...I changed my mind
  Transaction transaction = database.currentTransaction().orElseThrow();
  transaction.setRollbackOnly(true);
});

// You may roll back part of a transaction with a savepoint
database.transaction(() -> {
  Transaction transaction = database.currentTransaction().orElseThrow();

  try {
    transaction.withSavepoint(() -> {
      database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
        .bind("id", 1)
        .execute();

      // Hmm...I changed my mind about this part of the transaction
      throw new IllegalStateException("Undo the savepoint work");
    });
  } catch (IllegalStateException ignored) {
    // Work inside the savepoint was rolled back, and the outer transaction continues
  }
});

database.transaction(() -> {
  database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
    .bind("id", 1)
    .execute();

  // This transaction will commit
  database.transaction(() -> {
    database.query("UPDATE account SET balance = balance + 10 WHERE id = :id")
      .bind("id", 2)
      .execute();
  });

  // This transaction will not!
  throw new IllegalStateException("I should not have used nested transactions here...");
});

// If not specified, DEFAULT is assumed (whatever your DBMS prefers)
database.transaction(TransactionOptions.withIsolation(TransactionIsolation.SERIALIZABLE).build(), () -> {
  database.query("UPDATE account SET balance = balance - 10 WHERE id = :id")
    .bind("id", 1)
    .execute();
  database.query("UPDATE account SET balance = balance + 10 WHERE id = :id")
    .bind("id", 2)
    .execute();
});

database.transaction(TransactionOptions.withReadOnly(true).build(), () -> {
  List<Account> accounts = database.query("SELECT * FROM account")
    .fetchList(Account.class);
});

database.transaction(
  TransactionOptions.withIsolation(TransactionIsolation.REPEATABLE_READ)
    .readOnly(true)
    .build(),
  () -> {
    List<Account> accounts = database.query("SELECT * FROM account")
      .fetchList(Account.class);
  });

// Business logic
class EmployeeService {
  public void giveEveryoneRaises() {
    database.query("UPDATE employee SET salary = salary * 2")
      .execute();
    payrollSystem.startLengthyWarmupProcess();

    // Only send emails after the current transaction ends
    database.currentTransaction().get().addPostTransactionOperation((transactionResult) -> {
      if(transactionResult == TransactionResult.COMMITTED) {
        // Successful commit? email everyone with the good news
        for(Employee employee : findAllEmployees())
          sendCongratulationsEmail(employee);
      } else if(transactionResult == TransactionResult.ROLLED_BACK) {
        // Rolled back? We can clean up
        payrollSystem.cancelLengthyWarmupProcess();	
      } else if(transactionResult == TransactionResult.IN_DOUBT) {
        // Commit was attempted but the final database outcome is unknown.
        // Avoid commit-only side effects and reconcile separately.
        payrollSystem.queueReconciliation();
      }
    });
  }
	
  // Rest of implementation elided
}

// Servlet filter which wraps requests in transactions
class DatabaseTransactionFilter implements Filter {
  @Override
  public void doFilter(ServletRequest servletRequest,
                       ServletResponse servletResponse,
                       FilterChain filterChain) throws IOException, ServletException {
    database.transaction(() -> {
      // Above business logic would happen somewhere down the filter chain
      filterChain.doFilter(servletRequest, servletResponse);

      // Business logic has completed at this point but post-transaction
      // operations will not run until the closure exits
    });

    // By this point, post-transaction operations will have been run
  }

  // Rest of implementation elided
}

RetryPolicy retryPolicy = RetryPolicy.ofMaxAttempts(
  3,
  RetryPolicy.Backoff.fixed(Duration.ofMillis(25)),
  RetryPolicy.Condition.serializationFailureOrDeadlock());

TransactionRetryResult<Void> retryResult = database.transactionWithRetry(retryPolicy, () -> {
  database.query("""
      UPDATE account
      SET balance = balance - :amount
      WHERE account_id = :accountId
      """)
    .bind("accountId", accountId)
    .bind("amount", amount)
    .execute();
});

// Risky: the email may send more than once
database.transactionWithRetry(retryPolicy, () -> {
  database.query("UPDATE orders SET status = 'PAID' WHERE order_id = :orderId")
    .bind("orderId", orderId)
    .execute();

  emailClient.sendReceipt(orderId);
});

TransactionRetryResult<ReceiptEmail> retryResult = database.transactionWithRetry(retryPolicy, () -> {
  database.query("UPDATE orders SET status = 'PAID' WHERE order_id = :orderId")
    .bind("orderId", orderId)
    .execute();

  return Optional.of(new ReceiptEmail(orderId));
});

retryResult.getValue().ifPresent(emailClient::sendReceipt);

for (DatabaseException failure : retryResult.getFailures()) {
  logger.info("Recovered transaction failure", failure);
}

RetryPolicy exponentialRetryPolicy = RetryPolicy.ofMaxAttempts(
  5,
  RetryPolicy.Backoff.exponential(
    Duration.ofMillis(25),
    Duration.ofSeconds(1)),
  RetryPolicy.Condition.serializationFailureOrDeadlock());