MVCC va VACUUM: qatorni o'chirdingiz, jadval esa kichraymadi
PostgreSQL'da UPDATE aslida yangi qator yozadi, DELETE esa hech narsani o'chirmaydi. Dead tuple, bloat, autovacuum va bitta unutilgan tranzaksiya butun bazani qanday shishirishini ichkaridan ko'ramiz.
Muammo: million qator o'chdi, disk esa bo'shamadi
Tasavvur qiling: events jadvalida bir necha million qator bor, ularning yarmi eski va keraksiz. Tungi Celery task yozasiz, u eski yozuvlarni DELETE qiladi. Ertalab pg_relation_size() bilan tekshirasiz — jadval hajmi bir baytga ham kamaymagan. Yoki boshqa holat: har bir to'lovda orders jadvalidagi statusni yangilaysiz, qatorlar soni deyarli o'zgarmaydi, lekin jadval va uning indekslari haftadan haftaga kattalashib boradi, oddiy SELECT esa sekinlashadi.
Bu bug emas. Bu PostgreSQL'ning eng asosiy mexanizmi — MVCC — va uning "farroshi" VACUUM qanday ishlashining natijasi. Bugun shuni ichkaridan ko'ramiz: qator versiyalari, xmin/xmax, dead tuple, bloat, autovacuum sozlamalari va nega bitta unutilgan tranzaksiya butun bazaga zarar yetkazadi.
Sodda tasavvur nega noto'g'ri
Ko'pchilik bazani shunday tasavvur qiladi: UPDATE qatorni joyida o'zgartiradi, DELETE uni diskdan o'chiradi va joy darhol bo'shaydi. Agar shunday bo'lganida, bir tranzaksiya qatorni o'zgartirayotgan paytda boshqasi uni o'qish uchun lock kutishi kerak bo'lardi: o'quvchi yozuvchini, yozuvchi o'quvchini to'sib qo'yardi.
PostgreSQL boshqa yo'lni tanlagan: o'quvchilar yozuvchilarni bloklamaydi va aksincha. Buning narxi shuki, bitta mantiqiy qatorning bir nechta fizik versiyasi bir vaqtda diskda yashaydi. Har bir tranzaksiya o'z snapshot'iga (ma'lumotlarning ma'lum bir paytdagi "surati") qarab, qaysi versiya unga ko'rinishini hal qiladi. Eski versiyalar esa hech kimga kerak bo'lmay qolganidan keyin ham o'z-o'zidan yo'qolmaydi — ularni kimdir tozalashi kerak.
MVCC ichkaridan: xmin, xmax va tuple versiyalari
PostgreSQL'da jadvaldagi har bir fizik qator — tuple — o'z header'ida bir nechta yashirin maydon saqlaydi. Eng muhimlari:
xmin— bu versiyani yaratgan (INSERT yoki UPDATE qilgan) tranzaksiyaning ID'si (XID);xmax— bu versiyani o'chirgan yoki yangilagan tranzaksiya ID'si (0bo'lsa, hali hech kim tegmagan; bu maydon qator lock qilinganda ham ishlatiladi);ctid— versiyaning fizik manzili:(sahifa raqami, sahifadagi o'rni).
Bu ustunlarni oddiy SELECT bilan ko'rish mumkin:
CREATE TABLE accounts (
id bigint PRIMARY KEY,
balance numeric(14, 2) NOT NULL
);
INSERT INTO accounts VALUES (1, 100.00);
SELECT ctid, xmin, xmax, * FROM accounts;
-- ctid | xmin | xmax | id | balance
-- (0,1) | 755 | 0 | 1 | 100.00
UPDATE accounts SET balance = 150.00 WHERE id = 1;
SELECT ctid, xmin, xmax, * FROM accounts;
-- ctid | xmin | xmax | id | balance
-- (0,2) | 756 | 0 | 1 | 150.00
E'tibor bering: ctid (0,1) dan (0,2) ga o'zgardi. UPDATE qatorni joyida o'zgartirmadi — u yangi versiya yozdi, eskisining xmax maydoniga esa o'z XID'ini qo'ydi. Ya'ni UPDATE aslida INSERT + DELETE. XID raqamlari sizda boshqacha bo'ladi, mohiyat esa bir xil.
Eski versiya hali ham sahifada turibdi. Uni pageinspect kengaytmasi bilan ko'rish mumkin (superuser huquqi kerak):
CREATE EXTENSION IF NOT EXISTS pageinspect;
SELECT lp, t_xmin, t_xmax, t_ctid
FROM heap_page_items(get_raw_page('accounts', 0));
-- lp | t_xmin | t_xmax | t_ctid
-- 1 | 755 | 756 | (0,2)
-- 2 | 756 | 0 | (0,2)
Birinchi versiyaning t_xmax maydonida 756 turibdi, t_ctid esa yangi versiyaga ishora qiladi. DELETE ham xuddi shunday ishlaydi, faqat yangi versiya yozilmaydi: qatorning xmax maydoni to'ldiriladi, xolos. Ma'lumot diskda qoladi.
Ko'rinish qoidasi soddalashtirilgan holda shunday: xmin tranzaksiyasi commit bo'lgan va snapshot uchun "o'tmishda" bo'lsa, xmax esa bo'sh yoki snapshot'ga ko'rinmaydigan (hali commit qilinmagan, rollback bo'lgan yoki snapshot'dan keyin boshlangan) tranzaksiyaga tegishli bo'lsa, versiya sizga ko'rinadi.
Dead tuple va bloat
Versiyaning xmax tranzaksiyasi commit bo'lgan va endi hech bir ochiq tranzaksiya uni ko'rishi mumkin bo'lmasa, u dead tuple'ga aylanadi. U disk joyini egallaydi, sahifalarni to'ldiradi, Seq Scan uni baribir o'qib o'tadi, indekslarda esa unga ishora qiluvchi yozuvlar qoladi.
Dead tuple'lar to'planib, jadval yoki indeks foydali ma'lumotdan ancha katta bo'lib ketishi bloat deyiladi. Buni o'zingiz takrorlab ko'rishingiz mumkin:
CREATE TABLE events AS
SELECT g AS id, now() AS created_at, 'pending'::text AS status
FROM generate_series(1, 1000000) AS g;
SELECT pg_size_pretty(pg_relation_size('events')); -- A
UPDATE events SET status = 'done';
SELECT pg_size_pretty(pg_relation_size('events')); -- ~2 x A
VACUUM events;
SELECT pg_size_pretty(pg_relation_size('events')); -- still ~2 x A
UPDATE events SET status = 'archived';
SELECT pg_size_pretty(pg_relation_size('events')); -- roughly the same: freed space reused
Nima bo'ldi? Birinchi UPDATE har bir qatorning yangi versiyasini yozdi. Eski sahifalar to'la bo'lgani uchun yangi versiyalar yangi sahifalarga tushdi va jadval qariyb ikki baravar kattalashdi. VACUUM dead tuple'larni tozaladi, lekin fayl kichraymadi: bo'shagan joy free space map'ga (FSM) yoziladi va keyingi INSERT/UPDATE'lar uchun qayta ishlatiladi. Oxirgi qadam shuni ko'rsatadi — ikkinchi UPDATE deyarli hajm qo'shmaydi. Raqamlarni o'zingiz o'lchab ko'ring, ular PostgreSQL versiyasi va qator kengligiga qarab farq qiladi.
Oddiy VACUUM joyni operatsion tizimga qaytarmaydi, uni jadvalning o'zi ichida qayta ishlatish uchun belgilaydi. Faqat fayl oxiridagi butunlay bo'sh sahifalar kesib tashlanadi.
Joyni haqiqatan qaytarish uchun VACUUM FULL kerak: u jadvalni yangi faylga to'liq qayta yozadi, lekin butun jarayon davomida ACCESS EXCLUSIVE lock ushlab turadi — jadvalni na o'qib, na yozib bo'ladi. Production'da odatda pg_repack kengaytmasi ishlatiladi: u ham jadvalni qayta yozadi, lekin faqat qisqa lock'lar bilan.
VACUUM yana ikki muhim ishni bajaradi: visibility map'ni yangilaydi (index-only scan samarali ishlashi uchun kerak) va eski versiyalarni "muzlatadi" (freeze) — bu haqda pastroqda.
HOT update: arzonroq yangilash
Agar UPDATE hech qanday indekslangan ustunga tegmasa va o'sha sahifada yangi versiya uchun joy bo'lsa, PostgreSQL HOT (heap-only tuple) update qiladi: yangi versiya o'sha sahifaga yoziladi, indekslarga yangi yozuv qo'shilmaydi. Bunday zanjirlarni PostgreSQL sahifani o'qish paytida, VACUUM'ni kutmasdan ham qisman tozalay oladi (page pruning). Shuning uchun tez-tez yangilanadigan jadvallarda fillfactorni kamaytirish (masalan, 90) va keraksiz indekslardan qochish foydali: status ustuniga qo'shilgan har bir indeks shu ustundagi UPDATE'larni HOT bo'lishdan mahrum qiladi.
Autovacuum qachon ishga tushadi
Qo'lda VACUUM yurgizish shart emas — buni autovacuum daemon qiladi. U har autovacuum_naptime da bazalarni aylanib chiqadi va jadvalni quyidagi shart bajarilganda vacuum qiladi:
n_dead_tup > autovacuum_vacuum_threshold + autovacuum_vacuum_scale_factor * reltuples
Asosiy sozlamalar va ularning default qiymatlari:
| Parametr | Default | Nima qiladi |
|---|---|---|
autovacuum_vacuum_threshold |
50 | dead tuple'lar uchun bazaviy chegara |
autovacuum_vacuum_scale_factor |
0.2 | jadval hajmining qancha ulushi qo'shiladi |
autovacuum_vacuum_insert_threshold |
1000 | faqat INSERT bo'ladigan jadvallar uchun (PG 13+) |
autovacuum_analyze_scale_factor |
0.1 | ANALYZE qachon ishga tushishi |
autovacuum_naptime |
1min | tekshiruvlar orasidagi pauza |
autovacuum_max_workers |
3 | bir vaqtda ishlaydigan worker'lar |
autovacuum_vacuum_cost_delay |
2ms | diskni ortiqcha yuklamaslik uchun pauza |
autovacuum_freeze_max_age |
200 million | majburiy anti-wraparound vacuum chegarasi |
Muammo scale_factor = 0.2 da. 10 million qatorli jadval uchun autovacuum taxminan 2 million dead tuple to'planganidan keyingina boshlanadi. Katta va tez o'zgaruvchan jadvallar uchun bu juda kech. Yechim — global sozlamalarga tegmasdan, aynan shu jadval uchun parametrlarni o'zgartirish. Django'da buni migratsiya orqali qilish qulay:
# orders/migrations/0013_order_autovacuum.py
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [("orders", "0012_order_psp_id")]
operations = [
migrations.RunSQL(
sql="""
ALTER TABLE orders_order SET (
autovacuum_vacuum_scale_factor = 0.01,
autovacuum_vacuum_threshold = 1000,
autovacuum_analyze_scale_factor = 0.02,
fillfactor = 90
);
""",
reverse_sql="""
ALTER TABLE orders_order RESET (
autovacuum_vacuum_scale_factor,
autovacuum_vacuum_threshold,
autovacuum_analyze_scale_factor,
fillfactor
);
""",
),
]
fillfactor faqat yangi yoziladigan sahifalarga ta'sir qiladi; mavjud sahifalar jadval qayta yozilgandagina (VACUUM FULL yoki pg_repack) qayta taqsimlanadi. Yana bir nuqta: autovacuum "cost" mexanizmi bilan ataylab sekinlashtiriladi. Agar katta jadvalda u dead tuple paydo bo'lish tezligiga yetisha olmasa, autovacuum_vacuum_cost_limitni oshirishga to'g'ri keladi.
Uzoq tranzaksiya: butun bazaning dushmani
VACUUM dead tuple'ni faqat hech bir tranzaksiya uni ko'ra olmasa o'chira oladi. PostgreSQL buni xmin horizon orqali aniqlaydi: hali ham ishlab turgan eng eski tranzaksiya yoki snapshot. Agar bitta sessiya bir soat oldin tranzaksiya ochib, uni yopishni unutgan bo'lsa, shu bir soat ichida bazadagi barcha jadvallarda paydo bo'lgan dead tuple'lar tozalanmaydi. Autovacuum ishlaydi, CPU va disk sarflaydi, lekin hech narsani o'chira olmaydi — VACUUM VERBOSE chiqishida bunday qatorlar "dead but not yet removable" deb ko'rsatiladi.
Django loyihasida bu ko'pincha shunday ko'rinadi:
# orders/tasks.py — WRONG: the transaction stays open during every HTTP call
import requests
from celery import shared_task
from django.db import transaction
from .models import Order
PSP_URL = "https://psp.example.com/status/{}"
@shared_task
def sync_orders():
with transaction.atomic():
for order in Order.objects.filter(status="pending"):
resp = requests.get(PSP_URL.format(order.psp_id), timeout=10)
order.status = resp.json()["status"]
order.save(update_fields=["status"])
Bu task har bir buyurtma uchun tashqi API'ga murojaat qiladi va butun sikl bitta transaction.atomic() ichida. API sekinlashsa, tranzaksiya daqiqalab ochiq turadi. To'g'ri yo'l — tarmoq chaqiruvlarini tranzaksiyadan tashqariga chiqarish va faqat yozishni qisqa tranzaksiyaga o'rash:
# orders/tasks.py — FIXED: network outside, short transaction only for writes
import requests
from celery import shared_task
from django.db import transaction
from .models import Order
PSP_URL = "https://psp.example.com/status/{}"
@shared_task
def sync_orders(batch_size=200):
# one short SELECT in autocommit mode
pending = list(
Order.objects.filter(status="pending")
.order_by("id")
.values_list("id", "psp_id")[:batch_size]
)
# slow network calls, no transaction open
results = {}
for order_id, psp_id in pending:
resp = requests.get(PSP_URL.format(psp_id), timeout=10)
resp.raise_for_status()
results[order_id] = resp.json()["status"]
# short transaction just for the writes
with transaction.atomic():
for order_id, status in results.items():
Order.objects.filter(id=order_id, status="pending").update(status=status)
ATOMIC_REQUESTS = True bilan ham xuddi shu xavf bor: view ichidagi sekin tashqi chaqiruv butun request davomida tranzaksiyani ochiq ushlab turadi.
Horizon'ni kim ushlab turganini qanday topish mumkin:
SELECT pid,
usename,
state,
now() - xact_start AS xact_age,
backend_xid,
backend_xmin,
left(query, 60) AS last_query
FROM pg_stat_activity
WHERE xact_start IS NOT NULL
ORDER BY xact_start
LIMIT 10;
SELECT slot_name, active, xmin, catalog_xmin
FROM pg_replication_slots;
SELECT gid, prepared, owner
FROM pg_prepared_xacts;
backend_xmin yoki backend_xid eski bo'lgan, state = 'idle in transaction' holatidagi sessiyalar — asosiy gumondorlar. Ro'yxatga ishlatilmayotgan replication slot'lar, unutilgan prepared tranzaksiyalar va hot_standby_feedback = on bo'lgan replikadagi uzoq analitik so'rovlar ham kiradi — ular ham horizon'ni orqada ushlab turadi.
Himoya sifatida timeout'larni Django sozlamalarida bering:
# settings.py
DATABASES = {
"default": {
"ENGINE": "django.db.backends.postgresql",
"NAME": "shop",
"USER": "shop",
"HOST": "127.0.0.1",
"PORT": "5432",
"OPTIONS": {
"options": (
"-c idle_in_transaction_session_timeout=60s "
"-c statement_timeout=30s"
),
},
}
}
Agar PgBouncer transaction mode orqali ulansangiz, startup options serverga yetib bormasligi mumkin; u holda shu qiymatlarni rol darajasida o'rnating: ALTER ROLE shop SET idle_in_transaction_session_timeout = '60s';.
Katta UPDATE va DELETE'ni bo'laklab bajarish
Butun jadvalni bitta so'rov bilan yangilash (Event.objects.update(status="done")) — bu bitta uzun tranzaksiya va bir zumda millionlab dead tuple degani. Bunday backfill'larni kichik batch'larga bo'ling:
# events/backfill.py
import time
from django.db import connection, transaction
from .models import Event
def backfill_status(batch_size=5_000, vacuum_every=20):
last_id = 0
batches = 0
while True:
with transaction.atomic():
ids = list(
Event.objects.filter(id__gt=last_id, status="pending")
.order_by("id")
.values_list("id", flat=True)[:batch_size]
)
if not ids:
break
Event.objects.filter(id__in=ids).update(status="done")
last_id = ids[-1]
batches += 1
if batches % vacuum_every == 0:
# VACUUM cannot run inside a transaction block; here we are in autocommit
with connection.cursor() as cursor:
cursor.execute("VACUUM (ANALYZE) events_event")
time.sleep(0.1) # let replicas and autovacuum breathe
Batch'lar dead tuple'larning umumiy sonini kamaytirmaydi, lekin har bir tranzaksiya qisqa bo'ladi, horizon oldinga siljiydi va VACUUM orada bo'shatgan joy keyingi batch'larda qayta ishlatiladi. VACUUM tranzaksiya bloki ichida ishlamaydi, shuning uchun u atomic() dan tashqarida, autocommit rejimida chaqirilgan.
Kuzatish: pg_stat_user_tables
Har bir jadval bo'yicha statistika pg_stat_user_tables view'ida turadi:
SELECT relname,
n_live_tup,
n_dead_tup,
round(100.0 * n_dead_tup / nullif(n_live_tup + n_dead_tup, 0), 1) AS dead_pct,
n_tup_upd,
n_tup_hot_upd,
last_autovacuum,
autovacuum_count,
pg_size_pretty(pg_total_relation_size(relid)) AS total_size
FROM pg_stat_user_tables
ORDER BY n_dead_tup DESC
LIMIT 10;
Nimaga qarash kerak:
n_dead_tupdoimiy o'sib borsa valast_autovacuumeski bo'lsa — autovacuum yetishmayapti yoki horizon ushlab turilgan;n_tup_hot_upd / n_tup_updnisbati past bo'lsa — UPDATE'lar indeksli ustunlarga tegyapti yoki sahifalarda joy yo'q;autovacuum_counttez o'syapti, lekinn_dead_tupkamaymayapti — deyarli har doim uzoq tranzaksiya yoki slot aybdor.
Bu raqamlar taxminiy, ular statistika tizimidan olinadi. Aniq bloat'ni bilish uchun pgstattuple kengaytmasi bor: SELECT * FROM pgstattuple('events'); dead tuple va bo'sh joy foizini aniq ko'rsatadi, lekin jadvalni to'liq o'qib chiqadi — katta jadvalda ehtiyot bo'ling.
Transaction ID wraparound haqida qisqacha
XID — 32 bitli son. Taxminan 4 milliard qiymat aylanma tarzda ishlatiladi va har bir tranzaksiya uchun taxminan 2 milliardi "o'tmish", qolgani "kelajak" hisoblanadi. Agar eski qatorlar muzlatilmasa, bir kun ular "kelajakdagi" tranzaksiya yaratgandek ko'rinib, ko'rinmay qolishi mumkin edi. Buning oldini olish uchun VACUUM yetarlicha eski versiyalarni frozen deb belgilaydi.
Jadval relfrozenxid ining yoshi autovacuum_freeze_max_age (default 200 million) dan oshsa, autovacuum o'chirilgan bo'lsa ham majburiy anti-wraparound vacuum ishga tushadi. PostgreSQL 14 dan boshlab vacuum_failsafe_age (default 1.6 milliard) ga yetilganda VACUUM cost cheklovlarini olib tashlab, eng muhim ishni tezroq bajaradi. Shunda ham ulgurmasa, PostgreSQL avval ogohlantirish beradi, keyin ma'lumotni himoya qilish uchun yangi XID berishni to'xtatadi — yozish to'xtaydi. Bunga odatda uzoq tranzaksiyalar va unutilgan slot'lar vacuum'ni uzoq vaqt to'sib qo'ygan bazalarda duch kelinadi.
SELECT datname, age(datfrozenxid) AS xid_age
FROM pg_database
ORDER BY xid_age DESC;
SELECT c.oid::regclass AS table_name,
age(c.relfrozenxid) AS xid_age
FROM pg_class c
WHERE c.relkind IN ('r', 'm', 't')
ORDER BY xid_age DESC
LIMIT 10;
Bu qiymatlarni monitoring'ga qo'shib, autovacuum_freeze_max_age dan sezilarli oshganda alert berish yetarli.
Production'da uchraydigan tuzoqlar
- VACUUM FULL'ni "tozalash" uchun ishga tushirish. U jadvalni to'liq lock qiladi. Production'da
pg_repack, indeks bloat'i uchun esaREINDEX CONCURRENTLYxavfsizroq. - Navbat (queue) jadvallari. Outbox, task yoki event jadvallarida qatorlar tez qo'shilib, tez o'chiriladi. Ularga agressiv autovacuum sozlamalarini bering; juda katta hajmlarda partitioning qilib, eski partition'ni
DELETEo'rnigaDETACH/DROPqiling. - Tez-tez yangilanadigan "issiq" qator. Masalan, bitta hisoblagich qatori sekundiga ko'p marta yangilansa, uning dead versiyalari to'planadi. HOT va pruning yordam beradi, lekin ochiq uzoq tranzaksiya bo'lsa, ular ham ojiz.
autovacuum_enabled = false. Bu sozlamani qo'yib unutish oson. Bloat to'xtovsiz o'sadi, wraparound himoyasi esa baribir eng noqulay paytda majburiy vacuum boshlaydi.- Shell va debugging.
manage.py shellyoki Jupyter'da ochilganatomic()blok,breakpoint()da to'xtab qolgan tranzaksiya — tayyoridle in transactionsessiyasi. - Katta DELETE'dan keyin ANALYZE'ni unutish. Planner statistikasi eskirib qoladi;
VACUUM (ANALYZE)ikkalasini birga bajaradi. - Indeks bloat'i. B-tree sahifasidagi bo'shagan joy faqat o'sha kalit diapazoniga tushadigan yangi yozuvlar uchun ishlatiladi. Indeks hajmini jadvaldan alohida kuzating (
pg_relation_size('indeks_nomi')).
Checklist
- Katta va tez o'zgaruvchan jadvallar uchun
autovacuum_vacuum_scale_factorni jadval darajasida kamaytiring. - Tarmoq chaqiruvlari, fayl yuklash va sekin hisob-kitoblarni
transaction.atomic()dan tashqariga chiqaring. idle_in_transaction_session_timeoutvastatement_timeoutni o'rnating.pg_stat_activitydagi eng eskixact_start,backend_xminhamdapg_replication_slotsni monitoring qiling.pg_stat_user_tablesdan_dead_tup,last_autovacuumva HOT nisbatini kuzating.- Backfill va ommaviy o'chirishlarni batch'larga bo'ling.
age(datfrozenxid)uchun alert qo'ying.VACUUM FULLo'rnigapg_repackdan foydalaning.
Xulosa
PostgreSQL'da UPDATE yangi versiya yozadi, DELETE esa faqat xmax ni belgilaydi; eski versiyalarni VACUUM tozalaydi va joyni qayta ishlatishga beradi, lekin diskka qaytarmaydi. Autovacuum odatda yetarli, ammo katta jadvallar uchun sozlashni talab qiladi va uzoq ochiq tranzaksiya oldida ojiz. Tranzaksiyalarni qisqa saqlang, pg_stat_user_tables va pg_stat_activity ni kuzating — bloat muammolarining aksariyatini shu ikki odat bilan oldini olish mumkin.
// izohlar
Izohlar yuklanmoqda...