Understanding Unit of Work and Transactions with PHP Examples

When building applications that interact with a database, ensuring data consistency and integrity is critical. Two essential concepts that help achieve this are the Unit of Work pattern and Transactions. Let’s dive into what they are, their differences, and how to implement them in PHP.

What is a Unit of Work?

A Unit of Work is a design pattern that tracks changes made to objects during a business transaction and ensures that these changes are persisted to the database as a single operation. Think of it as a “shopping cart” for database operations: you add items (changes) to the cart and commit them all at once.

Key Features of Unit of Work:

1. Change Tracking: Keeps track of new, updated, and deleted objects.
2. Batch Operations: Groups multiple operations into a single transaction to minimize database calls.
3. Atomicity: Ensures that either all operations succeed or none are applied.

What is a Transaction?

A Transaction is a lower-level concept provided by databases to ensure a sequence of operations is performed as a single, atomic unit. Transactions adhere to the ACID properties:

1. Atomicity: All operations succeed or fail together.
2. Consistency: The database remains in a valid state before and after the transaction.
3. Isolation: Concurrent transactions do not interfere with each other.
4. Durability: Once a transaction is committed, its changes are permanent.

Relationship Between Unit of Work and Transactions

The Unit of Work pattern operates at the application level, managing object changes in memory. When it’s time to save these changes to the database, the Unit of Work uses Transactions to ensure atomicity and consistency.

PHP Implementation Examples

Example 1: Implementing Transactions in PHP

Here’s a basic example of managing database transactions with PDO:

function transferFunds($fromAccountId, $toAccountId, $amount) {
    $pdo = new PDO('mysql:host=localhost;dbname=example', 'root', 'password');
    $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);

    try {
        // Start the transaction
        $pdo->beginTransaction();

        // Deduct from the source account
        $stmt = $pdo->prepare("UPDATE accounts SET balance = balance - ? WHERE id = ?");
        $stmt->execute([$amount, $fromAccountId]);

        // Add to the destination account
        $stmt = $pdo->prepare("UPDATE accounts SET balance = balance + ? WHERE id = ?");
        $stmt->execute([$amount, $toAccountId]);

        // Commit the transaction
        $pdo->commit();

        echo "Transaction successful!";
    } catch (Exception $e) {
        // Roll back the transaction if something goes wrong
        $pdo->rollBack();
        echo "Transaction failed: " . $e->getMessage();
    }
}

This ensures that either both updates succeed, or neither is applied.

Example 2: Implementing Unit of Work in PHP

Let’s build a simple Unit of Work class to track and persist changes:

class UnitOfWork {
    private $pdo;
    private $newEntities = [];
    private $updatedEntities = [];
    private $deletedEntities = [];

    public function __construct(PDO $pdo) {
        $this->pdo = $pdo;
    }

    public function registerNew($entity) {
        $this->newEntities[] = $entity;
    }

    public function registerUpdated($entity) {
        $this->updatedEntities[] = $entity;
    }

    public function registerDeleted($entity) {
        $this->deletedEntities[] = $entity;
    }

    public function commit() {
        try {
            $this->pdo->beginTransaction();

            // Persist new entities
            foreach ($this->newEntities as $entity) {
                $this->insert($entity);
            }

            // Update modified entities
            foreach ($this->updatedEntities as $entity) {
                $this->update($entity);
            }

            // Delete removed entities
            foreach ($this->deletedEntities as $entity) {
                $this->delete($entity);
            }

            $this->pdo->commit();
        } catch (Exception $e) {
            $this->pdo->rollBack();
            throw $e;
        }
    }

    private function insert($entity) {
        // Example insert logic
        $stmt = $this->pdo->prepare("INSERT INTO table (name, value) VALUES (?, ?)");
        $stmt->execute([$entity['name'], $entity['value']]);
    }

    private function update($entity) {
        // Example update logic
        $stmt = $this->pdo->prepare("UPDATE table SET value = ? WHERE id = ?");
        $stmt->execute([$entity['value'], $entity['id']]);
    }

    private function delete($entity) {
        // Example delete logic
        $stmt = $this->pdo->prepare("DELETE FROM table WHERE id = ?");
        $stmt->execute([$entity['id']]);
    }
}

// Usage
$pdo = new PDO('mysql:host=localhost;dbname=example', 'root', 'password');
$unitOfWork = new UnitOfWork($pdo);

$unitOfWork->registerNew(['name' => 'New Item', 'value' => '123']);
$unitOfWork->registerUpdated(['id' => 1, 'value' => '456']);
$unitOfWork->registerDeleted(['id' => 2]);

$unitOfWork->commit();

This implementation batches all changes (insert, update, delete) and commits them as a single transaction.

When to Use Unit of Work and Transactions

• Use Transactions when working directly with database queries to ensure ACID compliance.
• Use Unit of Work when managing multiple objects in memory and need to persist changes efficiently.

Conclusion

Understanding and implementing the Unit of Work pattern and Transactions can greatly improve the reliability and consistency of your database operations. Transactions ensure atomicity at the database level, while Unit of Work simplifies tracking and persisting changes at the application level. Together, they form a powerful combination for managing complex business logic.

By using PHP’s PDO or a modern ORM, you can implement these concepts to build robust, maintainable applications.