[
https://issues.apache.org/jira/browse/IGNITE-15086?page=com.atlassian.jira.plugin.system.issuetabpanels:all-tabpanel
]
Vyacheslav Koptilin updated IGNITE-15086:
-----------------------------------------
Description:
Design a public tx API.
The proposed design includes async and sync APIs to execute a transaction.
The transaction facade looks like this:
{code:java}
/**
* Ignite Transactions facade.
*/
public interface IgniteTransactions {
/**
* Begins the transaction.
*
* @return The future.
*/
CompletableFuture<Transaction> beginAsync();
/**
* Synchronously executes a closure within a transaction.
* <p>
* If the closure is executed normally (no exceptions), the transaction is
automatically committed.
*
* @param clo The closure.
*/
void runInTransaction(Consumer<Transaction> clo);
}
{code}
Transacton interface:
{code:java}
/**
* The transaction.
*/
public interface Transaction {
/**
* Synchronously commits a transaction.
* Does nothing if it's already finished by committing or rolling back.
*/
void commit();
/**
* Asynchronously commits a transaction.
* Does nothing if it's already finished by committing or rolling back.
*
* @return The future.
*/
CompletableFuture<Void> commitAsync();
/**
* Synchronously rolls back a transaction.
* Does nothing if it's already finished by committing or rolling back.
*/
void rollback();
/**
* Asynchronously rolls back a transaction.
* Does nothing if it's already finished by committing or rolling back.
*
* @return The future.
*/
CompletableFuture<Void> rollbackAsync();
}
{code}
Example of synchronous transaction:
{code:java}
igniteTransactions.runInTransaction(tx -> {
Table txTable = table.withTransaction(tx); // table view enlisted
in the transaction.
txTable.upsertAsync(...);
tx.commit();
});
{code}
Example of asynchronous transaction:
{code:java}
igniteTransactions.beginAsync()
.thenApply(tx -> accounts.withTransaction(tx))
.thenCompose(txTbl -> txTbl.upsertAsync(...).thenApply(i ->
txTbl.transaction()))
.thenCompose(Transaction::commitAsync);
{code}
was:
Design a public tx API.
The proposed design includes async and sync APIs to execute a transaction.
The transaction facade looks like this:
{code}
/**
* Ignite Transactions facade.
*/
public interface IgniteTransactions {
/**
* Begins the transaction.
*
* @return The future.
*/
CompletableFuture<Transaction> beginAsync();
/**
* Synchronously executes a closure within a transaction.
* <p>
* If the closure is executed normally (no exceptions), the transaction is
automatically committed.
*
* @param clo The closure.
*/
void runInTransaction(Consumer<Transaction> clo);
}
{code}
> Design a public tx API
> ----------------------
>
> Key: IGNITE-15086
> URL: https://issues.apache.org/jira/browse/IGNITE-15086
> Project: Ignite
> Issue Type: Task
> Reporter: Alexey Scherbakov
> Assignee: Alexey Scherbakov
> Priority: Major
> Labels: iep-61, ignite-3
> Time Spent: 1h 20m
> Remaining Estimate: 0h
>
> Design a public tx API.
> The proposed design includes async and sync APIs to execute a transaction.
> The transaction facade looks like this:
> {code:java}
> /**
> * Ignite Transactions facade.
> */
> public interface IgniteTransactions {
> /**
> * Begins the transaction.
> *
> * @return The future.
> */
> CompletableFuture<Transaction> beginAsync();
> /**
> * Synchronously executes a closure within a transaction.
> * <p>
> * If the closure is executed normally (no exceptions), the transaction
> is automatically committed.
> *
> * @param clo The closure.
> */
> void runInTransaction(Consumer<Transaction> clo);
> }
> {code}
> Transacton interface:
> {code:java}
> /**
> * The transaction.
> */
> public interface Transaction {
> /**
> * Synchronously commits a transaction.
> * Does nothing if it's already finished by committing or rolling back.
> */
> void commit();
> /**
> * Asynchronously commits a transaction.
> * Does nothing if it's already finished by committing or rolling back.
> *
> * @return The future.
> */
> CompletableFuture<Void> commitAsync();
> /**
> * Synchronously rolls back a transaction.
> * Does nothing if it's already finished by committing or rolling back.
> */
> void rollback();
> /**
> * Asynchronously rolls back a transaction.
> * Does nothing if it's already finished by committing or rolling back.
> *
> * @return The future.
> */
> CompletableFuture<Void> rollbackAsync();
> }
> {code}
> Example of synchronous transaction:
> {code:java}
> igniteTransactions.runInTransaction(tx -> {
> Table txTable = table.withTransaction(tx); // table view enlisted
> in the transaction.
> txTable.upsertAsync(...);
> tx.commit();
> });
> {code}
> Example of asynchronous transaction:
> {code:java}
> igniteTransactions.beginAsync()
> .thenApply(tx -> accounts.withTransaction(tx))
> .thenCompose(txTbl -> txTbl.upsertAsync(...).thenApply(i ->
> txTbl.transaction()))
> .thenCompose(Transaction::commitAsync);
> {code}
--
This message was sent by Atlassian Jira
(v8.3.4#803005)
