{"canonical_url":"https://engineer.company/uk/glossary/transaction/","content_markdown":"# Транзакція\n\n## Що це таке\n\nТранзакція — це група змін, яку база даних застосовує як одне ціле: або\nнабирають чинності всі, або жодна. Коли її треба відрізнити від платежу, який\nтеж називають транзакцією, пишуть «транзакція бази даних». Підручник PostgreSQL\nпояснює суть так: кілька кроків об'єднуються в одну операцію за принципом «все\nабо нічого», а проміжних станів ніхто інший не бачить.\n\nУ PostgreSQL транзакція починається з `BEGIN` і закінчується або `COMMIT`, який\nфіксує зміни й робить їх видимими для інших сеансів, або `ROLLBACK`, який їх\nвідкидає. Інструкція, надіслана окремо, теж виконується всередині транзакції:\nPostgreSQL неявно обгортає її в `BEGIN` і, якщо все минуло успішно, у `COMMIT`.\nДовга транзакція може поставити точку збереження командою `SAVEPOINT`, а згодом\nповернутися до неї через `ROLLBACK TO`: усе, що зроблено після неї,\nвідкидається, а попередня робота лишається.\n\nГарантії транзакції підсумовує абревіатура ACID. Атомарність означає, що\nтранзакція виконується повністю або не виконується зовсім, і жоден напівготовий\nрезультат не переживає збою. Узгодженість означає, що оголошені для даних\nобмеження виконуються після фіксації, а транзакцію, яка порушила б одне з них,\nбуде відкочено. Ізольованість означає, що зміни транзакції лишаються невидимими\nдля паралельних транзакцій, доки її не зафіксовано. Довговічність означає, що\nзафіксована зміна переживе аварію сервера.\n\nІзоляція має рівні, і стандарт SQL визначає чотири: Read Uncommitted, Read Committed, Repeatable Read і Serializable. PostgreSQL починає кожну транзакцію на рівні Read Committed, якщо не вказано інше, а його Read Uncommitted поводиться точнісінько як Read Committed. На Read Committed кожна інструкція бачить дані, зафіксовані до її початку, тож два запити в одній транзакції можуть побачити різні числа. На Repeatable Read уся транзакція працює з одного знімка, зробленого під час виконання першої інструкції, яка не керує транзакцією. Serializable іде ще далі: паралельні транзакції дають той самий результат, ніби виконувалися одна за одною.\n\n## Чому це важливо\n\nМайже кожна дія, яку варто записати, зачіпає більше ніж один рядок. Замовлення —\nце рядок в одній таблиці, списання залишку в іншій і запис у реєстрі. Без\nтранзакції збій, тайм-аут чи порушене обмеження між другою і третьою\nінструкціями лишить замовлення, під яке так і не списали товар, або списаний\nтовар під замовлення, якого не існує. Згодом хтось натрапить на це у звіті й\nвиправлятиме вручну. З транзакцією такого проміжного стану ніхто ніколи не\nпобачить, і гарантує це база даних, а не застосунок.\n\nДруга причина — паралельність. Два запити, що прийшли одночасно, виконуються\nпліч-о-пліч: рівень ізоляції визначає, що бачить кожен із них, а блокування —\nхто з них чекатиме. Саме тут команди найчастіше дивуються: якщо обгорнути код у\n`BEGIN` і `COMMIT`, це саме собою не завадить двом запитам прочитати той самий\nбаланс і обом його витратити. На Read Committed кожна інструкція читає те, що\nбуло зафіксовано на момент її початку, тож між перевіркою в одній інструкції та\nзаписом у наступній може вклинитися фіксація іншого сеансу. Перевірка має або\nспершу заблокувати рядок, або стати частиною запису.\n\nУ транзакцій є й ціна, і платять її часом. Блокування рядків, які беруть `UPDATE`, `DELETE` і `SELECT ... FOR UPDATE`, зазвичай тримаються до кінця транзакції; відкат до точки збереження знімає блокування, отримані після цієї точки. Сеанс, якому потрібне конфліктне блокування, має чекати, якщо тільки очікування не зупинить тайм-аут, скасування чи розв'язання взаємоблокування. Відкрита транзакція також не дає `VACUUM` прибрати старі версії рядків, які їй ще можуть знадобитися, тож транзакція, забута відкритою на години, роздуває таблиці. Тому питання проєктування ніколи не зводиться лише до того, чи потрібна транзакція. Важливо, де пролягають її межі й як мало відбувається між ними.\n\nНарешті, звичайна локальна транзакція бази даних сама собою не охоплює зовнішніх ефектів. Виклик платіжного провайдера, лист чи повідомлення, опубліковане в окремій черзі, не скасовуються відкатом бази даних. Координація інших систем потребує додаткового проєктування; обгортки з `BEGIN` недостатньо. Вирішити, що опиниться всередині межі і як зовнішній світ дізнається про фіксацію, — це більша частина роботи над транзакцією.\n\n## Як це виглядає на практиці\n\nУчасник програми лояльності витрачає 250 балів на квиток у кіно. Три речі мають\nстатися разом: гаманець втрачає бали, реєстр фіксує причину, і з'являється запис\nпро обмін. Як одна транзакція це виглядає так:\n\n```sql\nBEGIN;\n\nUPDATE wallet\nSET    points = points - 250\nWHERE  member_id = 42\nAND    points \u003e= 250\nRETURNING points;\n-- рядка не повернуто: балів замало, тож ROLLBACK і стоп\n\nINSERT INTO points_entry (member_id, delta, reason)\nVALUES (42, -250, 'обмін: квиток у кіно');\n\nINSERT INTO redemption (member_id, reward_id)\nVALUES (42, 7);\n\nCOMMIT;\n```\n\n`UPDATE` блокує рядок гаманця учасника 42. До `COMMIT` будь-який інший сеанс, що\nчитає гаманець, бачить старий баланс, бо блокування рядків не заважають читанню,\nа незафіксовані зміни невидимі. Друге списання для того самого учасника,\nнадіслане за мить з іншої вкладки, доходить до власного `UPDATE` і чекає. Коли\nперша транзакція фіксується, PostgreSQL на рівні Read Committed ще раз перевіряє\nумову `WHERE` другої на рядку в його новому стані. Якщо лишилося тільки 100\nбалів, умова не виконується, рядок не повертається, і другий запит відкочується,\nнічого не записавши. Якщо ж збій станеться на останньому `INSERT` — скажімо,\nвинагороду 7 зняли з пропозиції і зовнішній ключ її не пропускає, — клієнт\nвідкочує транзакцію, і бали лишаються рівно там, де були.\n\nСаме так побудовано\n[систему лояльності з лігами й бейджами](/uk/portfolio/built-a-loyalty-wallet-leagues-and-badges/).\nКожна зміна гаманця там спершу блокує його рядок і лише потім читає, тож другий\nзапит чекає, доки завершиться перший, замість того щоб змагатися з ним. А\nоскільки гаманець лежить у тій самій базі даних, що й усе інше, баланс і те, що\nна нього куплено, фіксуються разом або не фіксуються зовсім. Сторінка відверто\nназиває ціну: блокування рядків — повільніший варіант, за конкуренції записи\nвиконуються почергово, зате учасник не витратить ті самі бали двічі.\n\nНотатка про те,\n[як продати останній квиток рівно один раз](/uk/notes/selling-limited-stock-without-overselling/),\nвипробовує той самий інструмент флеш-розпродажем. Її виправлення об'єднує\nперевірку залишку і списання в один умовний `UPDATE`, бо блокування, яке\nтримається, поки застосунок думає між `SELECT` і `UPDATE`, змушує наступного\nпокупця чекати кожну мілісекунду цього часу. Першим у її списку подальшої роботи\nстоїть правило не пускати в транзакцію нічого зовнішнього: виклику оплати,\nHTTP-запиту чи надісланому повідомленню місце до неї або після неї.\n\n## Де виникають проблеми\n\n**Сеанс простоює всередині транзакції, і все за ним чекає.** Застосунок відкриває транзакцію, оновлює рядок, а потім чекає на повільний API, на наступний клік користувача або на фоновий процес, який упав, так і не надіславши `COMMIT`. Його блокування лишаються, а коли тайм-аути вимкнені, PostgreSQL змушує сеанс, якому потрібне конфліктне блокування, чекати без обмежень, якщо тільки не виявить взаємоблокування або очікування не буде скасовано. Документація прямо називає поганою ідеєю тримати транзакцію відкритою, поки триває очікування введення від користувача. `pg_stat_activity` показує такі сеанси зі станом `idle in transaction`, а `xact_start` — коли почалася транзакція:\n\n```sql\nSELECT pid, now() - xact_start AS open_for, state, query\nFROM pg_stat_activity\nWHERE state LIKE 'idle in transaction%'\nORDER BY xact_start;\n```\n\nВинесіть повільну роботу з транзакції й задайте серверу межу, щоб забута\nтранзакція не тримала блокування годинами. `idle_in_transaction_session_timeout`\nзавершує будь-який сеанс, що простоює у відкритій транзакції довше за задане\nзначення. За замовчуванням параметр дорівнює 0, тобто вимкнений, тож його треба\nзадати явно, наприклад для ролі застосунку:\n`ALTER ROLE app SET idle_in_transaction_session_timeout = '30s';`.\n\n**Два запити витрачають той самий баланс.** Код читає значення однією\nінструкцією, ухвалює рішення в застосунку, а результат записує іншою. Два сеанси\nчитають те саме число, обидва проходять перевірку й обидва записують, тож одна\nзміна мовчки затирає іншу. Обгортка з `BEGIN` на рівні Read Committed цьому не\nзапобігає. Зробіть перевірку частиною запису, додавши умову в `UPDATE`, як у\nприкладі вище, або заблокуйте рядок перед читанням через\n`SELECT ... FOR UPDATE`, і тоді другий сеанс чекатиме на перший.\n\n**Під навантаженням на Repeatable Read чи Serializable з'являються помилки.** На\nцих рівнях PostgreSQL відхиляє транзакцію, яка порушила б обіцянку рівня, і\nповідомляє про помилку серіалізації, SQLSTATE `40001`, з повідомленнями на\nкшталт `could not serialize access due to concurrent update`. Це не баг, а\nзадум, і документація прямо каже, що застосунки на цих рівнях мають бути готові\nповторити транзакцію. Перехоплюйте `40001` і запускайте всю транзакцію заново\nвід `BEGIN`, разом із читаннями, бо рішення в ній ухвалено на даних, які відтоді\nзмінилися. Якщо повторити лише ту інструкцію, що впала, повториться й помилка.\n\n**Дві транзакції потрапляють у взаємоблокування.** Одна блокує замовлення 1, а\nпотім замовлення 2, інша — замовлення 2, а потім 1, і кожна чекає на іншу.\nPostgreSQL виявляє цикл і перериває одну з транзакцій, щоб інша могла\nзавершитися, а яку саме — передбачити важко. Документація радить, щоб кожен шлях\nу коді брав блокування в тому самому порядку, наприклад оновлював рядки за\nзростанням первинного ключа, а транзакцію, перервану через взаємоблокування,\nповторював.\n\n**Лист іде за замовленням, яке відкотили.** Застосунок надсилає підтвердження чи\nпублікує подію зсередини транзакції, а потім наступна інструкція падає. Відкат\nприбирає замовлення, але лист уже не повернеш. Записуйте повідомлення в таблицю\noutbox у тій самій транзакції, що й зміну, яку воно описує, і нехай окремий\nпроцес надсилає його вже після фіксації. Тоді повідомлення існує рівно тоді,\nколи існує замовлення.\n\n## Що почитати далі\n\n- [Transactions](https://www.postgresql.org/docs/current/tutorial-transactions.html)\n  — розділ підручника PostgreSQL: атомарність, неявні транзакції й точки\n  збереження на прикладі банківського переказу.\n- [Transaction Isolation](https://www.postgresql.org/docs/current/transaction-iso.html)\n  — чотири стандартні рівні, що бачить кожен із них у PostgreSQL, і помилки\n  серіалізації, після яких транзакцію треба повторити.\n- [Explicit Locking](https://www.postgresql.org/docs/current/explicit-locking.html)\n  — блокування рядків і таблиць, як довго вони тримаються, як PostgreSQL виявляє\n  взаємоблокування і як їм запобігти.\n- [Client Connection Defaults](https://www.postgresql.org/docs/current/runtime-config-client.html)\n  — `default_transaction_isolation`, `idle_in_transaction_session_timeout`,\n  `lock_timeout` та інші обмеження сеансу.\n- [Routine Vacuuming](https://www.postgresql.org/docs/current/routine-vacuuming.html)\n  — чому старі версії рядків лишаються, доки їх може бачити хоч одна транзакція,\n  і що довгі відкриті транзакції роблять із прибиранням.\n\n\u003chttps://engineer.company/uk/glossary/transaction/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Як транзакція в базі даних об'єднує кілька змін в одну: фіксація й відкат, рівні ізоляції, блокування рядків і п'ять типових збоїв.","formats":{"gemtext":"https://engineer.company/uk/glossary/transaction/index.gmi","gopher":"https://engineer.company/uk/glossary/transaction/gophermap","html":"https://engineer.company/uk/glossary/transaction/","json":"https://engineer.company/uk/glossary/transaction/index.json","markdown":"https://engineer.company/uk/glossary/transaction/index.md","pdf":"https://engineer.company/uk/glossary/transaction/index.pdf"},"kind":"page","language":"uk","title":"Що таке транзакція?","url":"https://engineer.company/uk/glossary/transaction/","version":1}