AuthorRepository    authorRepo = new JdbcAuthorRepository(cm);
GenreRepository     genreRepo  = new JdbcGenreRepository(cm);
AudiobookRepository bookRepo   = new JdbcAudiobookRepository(cm);

Author author = new Author("Іван", "Франко");
Genre  genre  = new Genre("Проза");
Audiobook book = new Audiobook("Захар Беркут", author, genre);

// Три окремих INSERT — три окремих транзакції
authorRepo.save(author);  // BEGIN; INSERT INTO authors...; COMMIT
genreRepo.save(genre);    // BEGIN; INSERT INTO genres...;  COMMIT
bookRepo.save(book);      // BEGIN; INSERT INTO audiobooks...; COMMIT

✅ INSERT INTO authors   → COMMIT (автор існує у БД)
✅ INSERT INTO genres    → COMMIT (жанр існує у БД)
❌ INSERT INTO audiobooks → ROLLBACK (книга НЕ збережена)

INSERT authors     (перед INSERT audiobooks, що містить author_id FK)
INSERT genres      (перед INSERT audiobooks, що містить genre_id FK)
INSERT audiobooks  (після authors і genres)
UPDATE ...         (в будь-якому порядку)
DELETE audiobooks  (перед DELETE authors/genres через FK)
DELETE authors     (після DELETE audiobooks)
DELETE genres      (після DELETE audiobooks)

package com.example.audiobook.persistence;

/**
 * Контракт Unit of Work: реєстр змін бізнес-транзакції.
 * <p>
 * Unit of Work накопичує усі зміни, виконані протягом бізнес-операції,
 * і записує їх в БД в одній JDBC-транзакції при {@link #commit()}.
 * <p>
 * <b>Типовий цикл використання:</b>
 * <pre>{@code
 * UnitOfWork uow = new JdbcUnitOfWork(connectionManager);
 * try {
 *     Author author = new Author("Тарас", "Шевченко");
 *     uow.registerNew(author);
 *
 *     Genre genre = uow.load(genreId); // завантажити існуючий
 *     genre.setDescription("...");
 *     uow.registerDirty(genre);
 *
 *     uow.commit();
 * } catch (Exception e) {
 *     uow.rollback();
 *     throw e;
 * }
 * }</pre>
 */
public interface UnitOfWork {

    /**
     * Реєструє новий об'єкт для вставки до БД при {@link #commit()}.
     * Об'єкт не повинен мати запису у БД — при {@code commit()} буде виконано {@code INSERT}.
     *
     * @param entity новий об'єкт
     * @throws IllegalStateException якщо об'єкт вже зареєстрований в іншій категорії
     */
    void registerNew(Object entity);

    /**
     * Реєструє існуючий об'єкт як змінений (dirty).
     * При {@link #commit()} буде виконано {@code UPDATE}.
     * Повторний виклик для вже зареєстрованого «брудного» об'єкта ігнорується.
     *
     * @param entity змінений об'єкт
     */
    void registerDirty(Object entity);

    /**
     * Реєструє об'єкт для видалення з БД при {@link #commit()}.
     * При {@link #commit()} буде виконано {@code DELETE}.
     * Якщо об'єкт був у списку {@code new} — просто видаляється з нього (без SQL).
     *
     * @param entity об'єкт для видалення
     */
    void registerDeleted(Object entity);

    /**
     * Реєструє об'єкт як «чистий» (щойно завантажений з БД, незмінений).
     * Використовується Identity Map для реєстрації завантажених об'єктів.
     *
     * @param entity завантажений об'єкт
     */
    void registerClean(Object entity);

    /**
     * Фіксує всі зміни в одній JDBC-транзакції.
     * <p>
     * Порядок виконання: INSERT (new) → UPDATE (dirty) → DELETE (deleted).
     * Після успішного commit очищає всі списки.
     *
     * @throws com.example.audiobook.db.DatabaseException якщо виникає помилка SQL
     */
    void commit();

    /**
     * Відміняє всі зміни JDBC-транзакції та очищає всі списки.
     * Викликається в блоці {@code catch} при виникненні будь-якого виключення.
     */
    void rollback();
}

package com.example.audiobook.persistence;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.db.DatabaseException;
import com.example.audiobook.domain.Author;
import com.example.audiobook.domain.Genre;
import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.repository.AuthorRepository;
import com.example.audiobook.repository.AudiobookRepository;
import com.example.audiobook.repository.GenreRepository;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.SequencedSet;

/**
 * JDBC-реалізація {@link UnitOfWork}.
 * <p>
 * Підтримує три внутрішніх списки об'єктів (new, dirty, deleted)
 * і виконує усі зміни в одній JDBC-транзакції при {@link #commit()}.
 * <p>
 * <b>Архітектурне рішення щодо порядку списків:</b>
 * Використовуємо {@link LinkedHashSet} замість звичайного {@code Set} або {@code List}:
 * <ul>
 *   <li>Як {@code Set}: гарантує відсутність дублікатів (один об'єкт не може бути
 *       зареєстрований двічі у тому ж списку).</li>
 *   <li>Як {@code LinkedHash}: зберігає порядок вставки, що важливо для INSERT
 *       (батьківські сутності перед дочірніми).</li>
 * </ul>
 */
public class JdbcUnitOfWork implements UnitOfWork {

    private final ConnectionManager connectionManager;

    // Репозиторії для виконання SQL-операцій
    // Передаються ззовні — UoW не знає, як саме виконується SQL
    private final AuthorRepository    authorRepository;
    private final GenreRepository     genreRepository;
    private final AudiobookRepository audiobookRepository;

    // Три списки відстеження змін
    // LinkedHashSet: порядок вставки + без дублікатів
    private final SequencedSet<Object> newEntities     = new LinkedHashSet<>();
    private final SequencedSet<Object> dirtyEntities   = new LinkedHashSet<>();
    private final SequencedSet<Object> deletedEntities = new LinkedHashSet<>();

    public JdbcUnitOfWork(
            ConnectionManager connectionManager,
            AuthorRepository authorRepository,
            GenreRepository genreRepository,
            AudiobookRepository audiobookRepository) {
        this.connectionManager   = connectionManager;
        this.authorRepository    = authorRepository;
        this.genreRepository     = genreRepository;
        this.audiobookRepository = audiobookRepository;
    }

    @Override
    public void registerNew(Object entity) {
        // Об'єкт не може бути одночасно «новим» і «видаленим»
        if (deletedEntities.contains(entity)) {
            throw new IllegalStateException(
                "Неможливо зареєструвати як новий об'єкт, що вже позначений для видалення: "
                + entity);
        }
        // Якщо вже «брудний» — не додаємо, але й не кидаємо виключення
        if (dirtyEntities.contains(entity)) {
            return;
        }
        newEntities.add(entity);
    }

    @Override
    public void registerDirty(Object entity) {
        // Новий об'єкт може стати «брудним» тільки якщо він вже у БД
        if (newEntities.contains(entity)) {
            // Вже буде INSERT — окремий UPDATE не потрібен
            return;
        }
        if (deletedEntities.contains(entity)) {
            throw new IllegalStateException(
                "Неможливо оновити об'єкт, що вже позначений для видалення: " + entity);
        }
        dirtyEntities.add(entity);
    }

    @Override
    public void registerDeleted(Object entity) {
        // Якщо об'єкт був «новим» (ще не збережений у БД) — просто прибираємо
        if (newEntities.remove(entity)) {
            return; // Жодного SQL не потрібно
        }
        dirtyEntities.remove(entity); // Прибрати з dirty — видалення замінює оновлення
        deletedEntities.add(entity);
    }

    @Override
    public void registerClean(Object entity) {
        // Чисті об'єкти не потребують жодних SQL-операцій
        // Цей метод може використовуватись Identity Map для обліку
    }

    /**
     * Фіксує всі зміни в одній JDBC-транзакції.
     * <p>
     * <b>Порядок виконання строго визначений:</b>
     * <ol>
     *   <li>INSERT нових сутностей (authors → genres → audiobooks)</li>
     *   <li>UPDATE змінених сутностей</li>
     *   <li>DELETE видалених сутностей (audiobooks → genres → authors)</li>
     * </ol>
     * Цей порядок забезпечує дотримання FK-обмежень.
     */
    @Override
    public void commit() {
        Connection conn = null;
        try {
            conn = connectionManager.getConnection();
            conn.setAutoCommit(false); // починаємо транзакцію явно

            // Крок 1: INSERT нових об'єктів у правильному порядку
            insertAll(conn);

            // Крок 2: UPDATE змінених об'єктів
            updateAll(conn);

            // Крок 3: DELETE видалених об'єктів у зворотному порядку FK
            deleteAll(conn);

            conn.commit(); // ← єдиний COMMIT для всіх операцій
            clearAll();    // очистити реєстри після успішної фіксації

        } catch (SQLException e) {
            rollbackQuietly(conn);
            throw new DatabaseException("UnitOfWork.commit() failed: " + e.getMessage(), e);
        } catch (Exception e) {
            rollbackQuietly(conn);
            throw e;
        } finally {
            closeQuietly(conn);
        }
    }

    @Override
    public void rollback() {
        // Відміна всіх ще не записаних змін — просто очистити реєстри
        // JDBC-транзакція відкатується у commit() при виключенні
        clearAll();
    }

    // ─── Приватні методи виконання SQL ────────────────────────────────────────

    /**
     * Виконує INSERT для всіх нових об'єктів у порядку залежностей:
     * Author → Genre → Audiobook.
     * FK: audiobooks.author_id → authors.id, audiobooks.genre_id → genres.id.
     */
    private void insertAll(Connection conn) {
        // Спочатку батьківські таблиці
        for (Object entity : newEntities) {
            if (entity instanceof Author a)    authorRepository.save(a);
        }
        for (Object entity : newEntities) {
            if (entity instanceof Genre g)     genreRepository.save(g);
        }
        // Потім дочірні таблиці
        for (Object entity : newEntities) {
            if (entity instanceof Audiobook b) audiobookRepository.save(b);
        }
    }

    /**
     * Виконує UPDATE для всіх змінених об'єктів.
     * Порядок між UPDATE-операціями некритичний для FK.
     */
    private void updateAll(Connection conn) {
        for (Object entity : dirtyEntities) {
            if (entity instanceof Author a)    authorRepository.update(a);
            else if (entity instanceof Genre g)     genreRepository.update(g);
            else if (entity instanceof Audiobook b) audiobookRepository.update(b);
        }
    }

    /**
     * Виконує DELETE у зворотному порядку відносно INSERT:
     * Audiobook → Genre → Author.
     * Спочатку дочірні записи, що мають FK на батьківські.
     */
    private void deleteAll(Connection conn) {
        // Спочатку дочірні
        for (Object entity : deletedEntities) {
            if (entity instanceof Audiobook b) audiobookRepository.deleteById(b.getId());
        }
        // Потім батьківські
        for (Object entity : deletedEntities) {
            if (entity instanceof Genre g)     genreRepository.deleteById(g.getId());
        }
        for (Object entity : deletedEntities) {
            if (entity instanceof Author a)    authorRepository.deleteById(a.getId());
        }
    }

    /** Очищає всі три реєстри після commit або rollback. */
    private void clearAll() {
        newEntities.clear();
        dirtyEntities.clear();
        deletedEntities.clear();
    }

    /** Тихо виконує ROLLBACK, ігноруючи виключення (для блоків catch/finally). */
    private void rollbackQuietly(Connection conn) {
        if (conn != null) {
            try {
                conn.rollback();
            } catch (SQLException ignored) {
                // Логування, але не перекидати — маскує оригінальне виключення
            }
        }
    }

    /** Тихо закриває з'єднання у блоці finally. */
    private void closeQuietly(Connection conn) {
        if (conn != null) {
            try {
                conn.setAutoCommit(true); // відновити режим auto-commit
                conn.close();
            } catch (SQLException ignored) {}
        }
    }

    // ─── Доступ до стану для тестів та діагностики ───────────────────────────

    public int newCount()     { return newEntities.size(); }
    public int dirtyCount()   { return dirtyEntities.size(); }
    public int deletedCount() { return deletedEntities.size(); }
}

// Приклад: створити і одразу відмовитися
Author tempAuthor = new Author("Тимчасовий", "Автор");
uow.registerNew(tempAuthor);

// Передумали
uow.registerDeleted(tempAuthor);
// tempAuthor видалений з newEntities — жодного INSERT не буде

conn.setAutoCommit(false) → BEGIN TRANSACTION
  INSERT all new entities     (у порядку FK: батьки до дітей)
  UPDATE all dirty entities   (порядок некритичний)
  DELETE all deleted entities (у зворотному порядку FK: діти до батьків)
conn.commit()                → COMMIT
clearAll()                   → очистити реєстри

// Ітерація 1: тільки Author (батьківська таблиця)
for (Object entity : newEntities) {
    if (entity instanceof Author a) authorRepository.save(a);
}
// Ітерація 2: тільки Genre (батьківська таблиця)
for (Object entity : newEntities) {
    if (entity instanceof Genre g) genreRepository.save(g);
}
// Ітерація 3: тільки Audiobook (дочірня таблиця, має FK на author та genre)
for (Object entity : newEntities) {
    if (entity instanceof Audiobook b) audiobookRepository.save(b);
}

Author author = loadedFromDb.get(0);
author.setFirstName("Новий");  // Змінили
// Якщо забути registerDirty — UPDATE не виконається!
uow.commit(); // → UPDATE для цього автора не буде

package com.example.audiobook.persistence;

import com.example.audiobook.domain.Author;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

/**
 * Snapshot-Based Change Tracker для сутності Author.
 * <p>
 * При завантаженні зберігає «знімок» полів об'єкта.
 * При {@link #findDirty()} порівнює поточний стан з знімком
 * і автоматично виявляє змінені об'єкти — без явного registerDirty().
 * <p>
 * У реальних ORM (Hibernate) цю роль виконує {@code EntityEntry}
 * із збереженим {@code Object[] loadedState}.
 */
public class AuthorChangeTracker {

    /**
     * Незмінний знімок стану автора на момент завантаження.
     * Зберігаємо лише поля, що змінюються (не id).
     */
    private record AuthorSnapshot(
        String firstName,
        String lastName,
        String bio,
        String imagePath
    ) {
        /** Створити знімок з поточного стану автора. */
        static AuthorSnapshot of(Author author) {
            return new AuthorSnapshot(
                author.getFirstName(),
                author.getLastName(),
                author.getBio(),
                author.getImagePath()
            );
        }

        /** Порівняти знімок з поточним станом автора. */
        boolean isDirty(Author author) {
            return !java.util.Objects.equals(firstName, author.getFirstName())
                || !java.util.Objects.equals(lastName, author.getLastName())
                || !java.util.Objects.equals(bio, author.getBio())
                || !java.util.Objects.equals(imagePath, author.getImagePath());
        }
    }

    /** Зберігаємо знімки: id → snapshot. */
    private final Map<UUID, AuthorSnapshot> snapshots = new HashMap<>();

    /** Зберігаємо відстежувані об'єкти: id → entity. */
    private final Map<UUID, Author> trackedEntities = new HashMap<>();

    /**
     * Починає відстежування об'єкта.
     * Викликається після {@code findById()} або {@code findAll()}.
     *
     * @param author завантажений об'єкт
     */
    public void track(Author author) {
        snapshots.put(author.getId(), AuthorSnapshot.of(author));
        trackedEntities.put(author.getId(), author);
    }

    /**
     * Автоматично знаходить об'єкти, що змінилися відносно знімка.
     * Не потребує явного registerDirty() від клієнтського коду.
     *
     * @return список авторів, чий стан відрізняється від знімка
     */
    public java.util.List<Author> findDirty() {
        return trackedEntities.values().stream()
            .filter(author -> {
                AuthorSnapshot snapshot = snapshots.get(author.getId());
                return snapshot != null && snapshot.isDirty(author);
            })
            .toList();
    }

    /**
     * Оновлює знімок після успішного UPDATE.
     * Після цього об'єкт вважається «чистим» до наступної зміни.
     *
     * @param author автор, що щойно був збережений
     */
    public void updateSnapshot(Author author) {
        snapshots.put(author.getId(), AuthorSnapshot.of(author));
    }

    /** Припиняє відстежування об'єкта (після DELETE або в кінці сесії). */
    public void untrack(UUID authorId) {
        snapshots.remove(authorId);
        trackedEntities.remove(authorId);
    }

    /** Очищує всі знімки (в кінці UoW-сесії). */
    public void clear() {
        snapshots.clear();
        trackedEntities.clear();
    }
}

// Розширений UnitOfWork зі snapshot-tracking (спрощено)
public class SnapshotUnitOfWork {

    private final AuthorChangeTracker tracker = new AuthorChangeTracker();
    private final AuthorRepository repo;

    // При завантаженні — автоматично починаємо відстежування
    public Author loadAuthor(UUID id) {
        Author author = repo.findById(id).orElseThrow();
        tracker.track(author); // запам'ятовуємо знімок
        return author;
    }

    public void commit() {
        // Автоматично знаходимо "брудні" об'єкти — БЕЗ registerDirty()!
        List<Author> dirty = tracker.findDirty();
        // Виконуємо UPDATE для кожного
        for (Author author : dirty) {
            repo.update(author);
            tracker.updateSnapshot(author); // оновлюємо знімок
        }
        // ... і решта операцій (insert, delete)
    }
}

// З snapshot tracking — НЕ ПОТРІБЕН registerDirty()
Author author = uow.loadAuthor(id);
author.setFirstName("Нове ім'я");    // просто міняємо поле
author.setBio("Нова біографія");     // ще одна зміна

uow.commit(); // UoW сам знайде, що author змінився → UPDATE

package com.example.audiobook.persistence;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.domain.Author;
import com.example.audiobook.domain.Genre;
import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.repository.*;

import java.util.Optional;
import java.util.UUID;

/**
 * Session — координатор Identity Map і Unit of Work.
 * <p>
 * Об'єднує кешування (Identity Map) і відстеження змін (Unit of Work)
 * в єдину «сесію роботи з БД».
 * <p>
 * Цей клас є спрощеною аналогією {@code EntityManager} у JPA
 * або {@code Session} у Hibernate.
 */
public class Session {

    private final JdbcUnitOfWork  unitOfWork;
    private final IdentityMap<UUID, Author>    authorMap    = new IdentityMap<>();
    private final IdentityMap<UUID, Genre>     genreMap     = new IdentityMap<>();
    private final IdentityMap<UUID, Audiobook> audiobookMap = new IdentityMap<>();

    private final AuthorRepository    authorRepo;
    private final GenreRepository     genreRepo;
    private final AudiobookRepository audiobookRepo;

    public Session(ConnectionManager cm,
                   AuthorRepository authorRepo,
                   GenreRepository genreRepo,
                   AudiobookRepository audiobookRepo) {
        this.authorRepo    = authorRepo;
        this.genreRepo     = genreRepo;
        this.audiobookRepo = audiobookRepo;
        this.unitOfWork = new JdbcUnitOfWork(cm, authorRepo, genreRepo, audiobookRepo);
    }

    // ─── Author ──────────────────────────────────────────────────────────────

    /**
     * Завантажує автора з БД або повертає з Identity Map.
     * Завантажений об'єкт реєструється як «чистий» у Unit of Work.
     */
    public Optional<Author> findAuthor(UUID id) {
        Optional<Author> cached = authorMap.get(id);
        if (cached.isPresent()) {
            return cached;           // Identity Map: cache hit
        }
        Optional<Author> fromDb = authorRepo.findById(id);
        fromDb.ifPresent(author -> {
            authorMap.put(id, author);     // Identity Map: реєструємо
            unitOfWork.registerClean(author); // UoW: позначаємо як чистий
        });
        return fromDb;
    }

    /**
     * Реєструє нового автора для збереження.
     * Автор додається до Identity Map (щоб findAuthor вже знаходив його)
     * і до Unit of Work (щоб при commit виконався INSERT).
     */
    public void persistAuthor(Author author) {
        authorMap.put(author.getId(), author);  // Identity Map
        unitOfWork.registerNew(author);          // Unit of Work
    }

    /**
     * Позначає автора як змінений.
     * Клієнт зобов'язаний викликати після кожної зміни полів
     * (або використовуйте snapshot tracking для автоматичного виявлення).
     */
    public void updateAuthor(Author author) {
        // Identity Map вже містить посилання на той самий об'єкт
        // (завдяки тому, що findAuthor повертає кешований екземпляр)
        unitOfWork.registerDirty(author);
    }

    /**
     * Позначає автора для видалення.
     */
    public void removeAuthor(Author author) {
        authorMap.remove(author.getId());    // видаляємо з Identity Map
        unitOfWork.registerDeleted(author);  // Unit of Work виконає DELETE при commit
    }

    // ─── Аналогічні методи для Genre та Audiobook (скорочено) ────────────────

    public Optional<Genre> findGenre(UUID id) {
        return genreMap.get(id).or(() -> genreRepo.findById(id).map(g -> {
            genreMap.put(id, g);
            unitOfWork.registerClean(g);
            return g;
        }));
    }

    public void persistGenre(Genre genre) {
        genreMap.put(genre.getId(), genre);
        unitOfWork.registerNew(genre);
    }

    // ─── Транзакційні операції ────────────────────────────────────────────────

    /**
     * Фіксує всі зміни в одній JDBC-транзакції.
     * Після успіху очищає UoW-реєстри (але НЕ Identity Map — кеш залишається).
     */
    public void commit() {
        unitOfWork.commit();
        // Identity Map залишається — після commit об'єкти ті самі,
        // і findAuthor/findGenre і далі повертатимуть кешовані об'єкти
    }

    /**
     * Відміняє всі незафіксовані зміни.
     * Очищає UoW-реєстри, але НЕ Identity Map (кеш залишається валідним).
     */
    public void rollback() {
        unitOfWork.rollback();
        // Увага: після rollback об'єкти у Identity Map можуть мати
        // зміни, що не потрапили у БД. Для повної коректності —
        // очистити і Identity Map теж, або перевантажити змінені об'єкти.
    }

    /**
     * Повністю закриває сесію: очищає UoW і Identity Map.
     */
    public void close() {
        unitOfWork.rollback();
        authorMap.clear();
        genreMap.clear();
        audiobookMap.clear();
    }
}

// Клієнтський код використовує тільки Session
Session session = new Session(cm, authorRepo, genreRepo, audiobookRepo);
try {
    Author author = session.findAuthor(id).orElseThrow();
    author.setFirstName("Оновлене ім'я");
    session.updateAuthor(author);

    Genre newGenre = new Genre("Нова поезія");
    session.persistGenre(newGenre);

    session.commit(); // один COMMIT для обох операцій
} catch (Exception e) {
    session.rollback();
} finally {
    session.close();
}

package com.example.audiobook;

import com.example.audiobook.db.ConnectionManager;
import com.example.audiobook.db.DatabaseException;
import com.example.audiobook.domain.Author;
import com.example.audiobook.domain.Audiobook;
import com.example.audiobook.domain.Genre;
import com.example.audiobook.persistence.JdbcUnitOfWork;
import com.example.audiobook.repository.jdbc.*;

import java.math.BigDecimal;

public class Main {

    public static void main(String[] args) {
        ConnectionManager cm = ConnectionManager.forH2("./data/audiobook_db");

        JdbcAuthorRepository    authorRepo = new JdbcAuthorRepository(cm);
        JdbcGenreRepository     genreRepo  = new JdbcGenreRepository(cm);
        JdbcAudiobookRepository bookRepo   = new JdbcAudiobookRepository(cm);

        JdbcUnitOfWork uow = new JdbcUnitOfWork(cm, authorRepo, genreRepo, bookRepo);

        // ── Сценарій 1: Успішна атомарна реєстрація ─────────────────────────
        System.out.println("=== Сценарій 1: Успішна транзакція ===");

        Author  franko = new Author("Іван", "Франко");
        Genre   proza  = new Genre("Проза");
        Audiobook zakhar = new Audiobook("Захар Беркут", franko, proza);
        zakhar.setPrice(new BigDecimal("109.50"));
        zakhar.setYear(1883);

        // Реєструємо всі три об'єкти — нічого не записується у БД
        uow.registerNew(franko);
        uow.registerNew(proza);
        uow.registerNew(zakhar);

        System.out.println("Зареєстровано: new=" + uow.newCount()
            + ", dirty=" + uow.dirtyCount()
            + ", deleted=" + uow.deletedCount());
        // Зареєстровано: new=3, dirty=0, deleted=0

        try {
            uow.commit(); // ← один BEGIN/COMMIT для трьох INSERT
            System.out.println("✓ Всі три сутності збережено атомарно");
        } catch (DatabaseException e) {
            uow.rollback();
            System.err.println("❌ Помилка: " + e.getMessage());
        }

        // ── Сценарій 2: Часткові зміни — UPDATE + DELETE ─────────────────────
        System.out.println("\n=== Сценарій 2: UPDATE + DELETE у одній транзакції ===");

        // Завантажуємо існуючі об'єкти
        Author loadedFranko   = authorRepo.findById(franko.getId()).orElseThrow();
        Audiobook loadedZakhar = bookRepo.findById(zakhar.getId()).orElseThrow();

        // Оновлюємо автора
        loadedFranko.setBio("Видатний письменник, поет і мислитель (1856–1916).");
        uow.registerDirty(loadedFranko);

        // Видаляємо книгу (для прикладу)
        uow.registerDeleted(loadedZakhar);

        System.out.println("Зареєстровано: new=" + uow.newCount()
            + ", dirty=" + uow.dirtyCount()
            + ", deleted=" + uow.deletedCount());
        // Зареєстровано: new=0, dirty=1, deleted=1

        try {
            uow.commit(); // UPDATE authors + DELETE audiobooks — один COMMIT
            System.out.println("✓ UPDATE і DELETE виконані атомарно");
        } catch (DatabaseException e) {
            uow.rollback();
            System.err.println("❌ Помилка: " + e.getMessage());
        }

        // ── Сценарій 3: Демонстрація rollback ───────────────────────────────
        System.out.println("\n=== Сценарій 3: Rollback при помилці ===");

        Author  lesia    = new Author("Леся", "Українка");
        Genre   drama    = new Genre("Драма");
        // Навмисно зіпсований об'єкт — NULL-поле, що порушує NOT NULL у схемі
        Audiobook broken = new Audiobook(null, lesia, drama); // title=null → помилка

        uow.registerNew(lesia);
        uow.registerNew(drama);
        uow.registerNew(broken);

        try {
            uow.commit();
        } catch (DatabaseException e) {
            System.out.println("✓ Перехоплено виключення — автоматичний rollback");
            System.out.println("  Причина: " + e.getMessage());
            // Ні Леся, ні Драма, ні книга не потрапили у БД — повний rollback!
        }

        // Перевірка: Леся не збережена (FK на неіснуючий батьківський запис відкочено)
        boolean lesiaExists = authorRepo.existsById(lesia.getId());
        System.out.println("  Леся у БД: " + lesiaExists); // false

        // ── Сценарій 4: New → Deleted без SQL ────────────────────────────────
        System.out.println("\n=== Сценарій 4: Відмова від нового об'єкта без SQL ===");

        Author tempAuthor = new Author("Тимчасовий", "Автор");
        uow.registerNew(tempAuthor);
        System.out.println("Зареєстровано як new: " + uow.newCount()); // 1

        uow.registerDeleted(tempAuthor); // видаляємо ще до commit
        System.out.println("Після registerDeleted, new: " + uow.newCount()); // 0

        uow.commit(); // порожній commit — нічого не робить
        System.out.println("✓ Commit без SQL-запитів (об'єкт скасований до збереження)");

        cm.close();
    }
}

Author author = authorRepo.findById(id).orElseThrow();
author.setBio("Нова біографія");
// Забули: uow.registerDirty(author);
uow.commit(); // UPDATE не виконається — зміна втрачена!

commit():
  getConnection()           ← з'єднання вилучено з пулу
  INSERT × N                ← займає час
  UPDATE × M                ← займає час
  DELETE × K                ← займає час
  conn.commit()
  conn.close()              ← з'єднання повернуто у пул
  ↑ Все цей час інші потоки можуть чекати на вільне з'єднання!

// Схема з версіонуванням
// ALTER TABLE authors ADD COLUMN version INTEGER DEFAULT 0

// UPDATE з перевіркою версії:
UPDATE authors
SET first_name = ?, last_name = ?, bio = ?, version = version + 1
WHERE id = ? AND version = ?  -- перевірка: чи не змінив хтось інший?
-- Якщо affected rows = 0 → хтось встиг змінити першим → OptimisticLockException