Need a distributed transaction?
├── Need strong consistency (financial core) → XA mode (poor performance)
├── Eventual consistency is sufficient
│   ├── Transaction execution time > 10 seconds → SAGA mode (state machine)
│   ├── High concurrency + willing to implement Confirm/Cancel → TCC mode
│   └── 80% of scenarios (default recommendation) → AT mode (zero intrusion)

-- ✅ Every business database must have an undo_log table
CREATE TABLE IF NOT EXISTS undo_log (
    id BIGINT NOT NULL AUTO_INCREMENT,
    branch_id BIGINT NOT NULL,
    xid VARCHAR(128) NOT NULL,
    context VARCHAR(128) NOT NULL,
    rollback_info LONGBLOB NOT NULL,
    log_status INT NOT NULL,
    log_created DATETIME NOT NULL,
    log_modified DATETIME NOT NULL,
    PRIMARY KEY (id),
    UNIQUE KEY ux_undo_log (xid, branch_id)
) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4;

// ✅ AT mode: annotations only, with no business-logic intrusion
@Service
public class OrderService {
    @GlobalTransactional(timeoutMills = 300000, rollbackFor = Exception.class)
    public void createOrder(OrderDTO dto) {
        orderService.create(dto);           // Remote service A (local transaction)
        inventoryService.deduct(dto);       // Remote service B (local transaction)
        accountService.debit(dto);          // Remote service C (local transaction)
        // If any step fails → all are automatically rolled back (based on undo_log)
    }
}

@LocalTCC
public interface AccountTccAction {
    @TwoPhaseBusinessAction(
        name = "accountTcc",
        commitMethod = "confirm",
        rollbackMethod = "cancel",
        useTCCFence = true  // ← Seata 1.5.1+ automatically handles idempotency, suspension, and empty rollback
    )
    boolean prepare(BusinessActionContext ctx,
        @BusinessActionContextParameter(paramName = "accountDTO") AccountDTO dto);

    // ✅ Confirm must be idempotent (can be executed repeatedly without changing the result)
    boolean confirm(BusinessActionContext ctx);

    // ✅ Cancel must be an idempotent compensation (it may arrive before Try executes = empty rollback)
    boolean cancel(BusinessActionContext ctx);
}

// SAGA uses a state machine engine and orchestrates long-running transactions through JSON configuration
// Each step has a forward action (serviceMethod) and a compensation action (compensateMethod)

// Applicable scenarios: order fulfillment, approval workflows, and logistics tracking
// Compensation order must be executed in strict reverse order
// Compensation operations must be idempotent and retryable

@GlobalLock
@Transactional
public Order getOrder(Long orderId) {
    // ✅ FOR UPDATE + @GlobalLock prevents dirty reads in AT mode
    return orderMapper.selectForUpdate(orderId);
}

<select id="selectForUpdate" resultMap="BaseResultMap">
    SELECT * FROM orders WHERE id = #{id} FOR UPDATE
</select>