io.delta.kernel.internal.replay

Class ConflictChecker

Object

io.delta.kernel.internal.replay.ConflictChecker

public class ConflictChecker
extends Object

Class containing the conflict resolution logic when writing to a Delta table.

Currently, the support is to allow blind appends. Later on this can be extended to add support for read-after-write scenarios.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ConflictChecker.TransactionRebaseState Class containing the rebase state from winning transactions that the current transaction needs to rebase against before attempting the commit.

Method Summary

Modifier and Type	Method and Description
ConflictChecker.TransactionRebaseState	resolveConflicts(Engine engine)
static ConflictChecker.TransactionRebaseState	resolveConflicts(Engine engine, SnapshotImpl snapshot, long attemptVersion, TransactionImpl transaction) Resolve conflicts between the losing transaction and the winning transactions and return a rebase state that the losing transaction needs to rebase against before attempting the commit.

Methods inherited from class Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

resolveConflicts

public static ConflictChecker.TransactionRebaseState resolveConflicts(Engine engine,
                                                                      SnapshotImpl snapshot,
                                                                      long attemptVersion,
                                                                      TransactionImpl transaction)
                                                               throws ConcurrentWriteException

Resolve conflicts between the losing transaction and the winning transactions and return a rebase state that the losing transaction needs to rebase against before attempting the commit.

Parameters:

engine - Engine instance to use

snapshot - SnapshotImpl of the table when the losing transaction has started

transaction - TransactionImpl that encountered the conflict (a.k.a the losing transaction)

Returns:

ConflictChecker.TransactionRebaseState that the losing transaction needs to rebase against

Throws:

ConcurrentWriteException - if there are logical conflicts between the losing transaction and the winning transactions that cannot be resolved.

resolveConflicts

public ConflictChecker.TransactionRebaseState resolveConflicts(Engine engine)
                                                        throws ConcurrentWriteException

Throws:

ConcurrentWriteException