Ответ
Уровни изоляции транзакций — это настройка в СУБД, которая определяет, насколько одна транзакция "видит" изменения, сделанные в других параллельных транзакциях. Это компромисс между согласованностью данных и производительностью.
Стандарт SQL определяет 4 основных уровня, каждый из которых решает определенные проблемы конкурентного доступа:
- Read Uncommitted: Самый слабый уровень. Позволяет читать незафиксированные ("грязные") данные. Используется редко из-за непредсказуемых результатов.
- Read Committed: Предотвращает "грязное чтение". Транзакция видит только те данные, которые были зафиксированы (committed) до её начала. Это уровень по умолчанию для многих СУБД (например, PostgreSQL, Oracle).
- Repeatable Read: Предотвращает "грязное" и "неповторяемое чтение" (non-repeatable read). Если транзакция читает одну и ту же строку несколько раз, она получит один и тот же результат. Уровень по умолчанию в MySQL.
- Serializable: Самый строгий уровень. Гарантирует полную изоляцию транзакций, как если бы они выполнялись последовательно. Предотвращает все аномалии, включая "фантомное чтение" (phantom reads), но может снижать производительность и приводить к ошибкам сериализации.
Как работать в Go:
В Go уровень изоляции можно указать при создании транзакции с помощью sql.TxOptions. Пакет database/sql предоставляет константы для стандартных уровней.
import (
"context"
"database/sql"
"log"
)
func performTransaction(db *sql.DB) {
ctx := context.Background()
// Начинаем транзакцию с уровнем изоляции Repeatable Read
tx, err := db.BeginTx(ctx, &sql.TxOptions{
Isolation: sql.LevelRepeatableRead,
})
if err != nil {
log.Fatal(err)
}
// Выполняем операции внутри транзакции
_, err = tx.ExecContext(ctx, "UPDATE accounts SET balance = balance - 100 WHERE id = 1")
if err != nil {
// Если произошла ошибка, откатываем транзакцию
tx.Rollback()
log.Fatal(err)
}
// Если все успешно, фиксируем транзакцию
if err := tx.Commit(); err != nil {
log.Fatal(err)
}
}Ответ 18+ 🔞
А, ну это ж про транзакции, блядь! Уровни изоляции, ёпта! Это такая штука, когда твоя база данных решает, насколько она будет тебе подыгрывать, пока ты там со своими запросами извиваешься, как уж на сковородке.
Представь, сука: у тебя два клиента одновременно пытаются с одного счёта деньги снять. Один уже списал, но ещё не подтвердил, а второй уже пытается проверить баланс. И вот тут-то, блядь, и начинается цирк с конями! Чтобы такого пиздеца не было, и придумали эти уровни — компромисс, блядь, между тем, чтобы данные не разъебались, и чтобы система не легла, как корова от переедания.
Их там, этих уровней, целых четыре штуки, как в подъезде этажей:
-
Read Uncommitted — это, блядь, уровень полного распиздяйства. Транзакция видит ВСЁ, даже то, что другой чувак ещё не зафиксировал, только начал писать. Это как подслушивать разговор в сортире — информации дохуя, но половина может оказаться ложной. Используется редко, ибо можно такого насмотреться, что потом неделю отходить.
-
Read Committed — уже построже. Тут тебе показывают только то, что уже официально зафиксировано, как приговор суда. Никаких "грязных" данных, только чистенькие, проверенные. В PostgreSQL и Oracle, например, это уровень по умолчанию — народ любит стабильность, блядь.
-
Repeatable Read — вот это уже серьёзно, сука! Если ты в транзакции прочитал какую-то строку, то можешь быть уверен, что до конца своей работы ты будешь видеть её в одном и том же виде. Как будто заморозил время, блядь. В MySQL, например, это стандарт — они там любят, чтобы всё было предсказуемо.
-
Serializable — это, блядь, уровень параноика. Полная изоляция! Все транзакции выполняются так, будто они идут одна за другой, как солдаты на параде. Никаких фантомов, никаких сюрпризов. Но и производительность, сука, может упасть ниже плинтуса, потому что система начинает всех тормозить, чтобы никто никому не мешал.
А теперь, блядь, как с этим в Go работать? Да элементарно, ёпта! В пакете database/sql всё уже придумали за нас. Берёшь контекст, создаёшь транзакцию с нужными опциями — и вперёд!
import (
"context"
"database/sql"
"log"
)
func performTransaction(db *sql.DB) {
ctx := context.Background()
// Начинаем транзакцию с уровнем изоляции Repeatable Read
tx, err := db.BeginTx(ctx, &sql.TxOptions{
Isolation: sql.LevelRepeatableRead,
})
if err != nil {
log.Fatal(err)
}
// Выполняем операции внутри транзакции
_, err = tx.ExecContext(ctx, "UPDATE accounts SET balance = balance - 100 WHERE id = 1")
if err != nil {
// Если произошла ошибка, откатываем транзакцию
tx.Rollback()
log.Fatal(err)
}
// Если все успешно, фиксируем транзакцию
if err := tx.Commit(); err != nil {
log.Fatal(err)
}
}Вот и вся магия, блядь! Главное — не забывать откатываться, если что-то пошло не так, а то накосячишь и будешь потом, как Герасим, смотреть в пустой мешок и думать: "Что же я, мудак, сделал?"