Barcha yozuvlar
Dasturlash

Migratsiya saytni qotirganda: lock navbati, NOT VALID, CONCURRENTLY va ikki deploy qoidasi

Bir millisekundlik ALTER TABLE ham butun saytni to'xtatishi mumkin. Qaysi DDL jadvalni qulflaydi, NOT NULL ustunni, index'ni va ustun o'chirishni Django'da trafikni to'xtatmasdan qanday o'tkazish kerak.

Oddiy reliz tasavvur qiling. Order modeliga bitta nullable maydon qo'shasiz, makemigrations ikki qatorlik migratsiya yaratadi, CI esa yangi pod'lar ishga tushishidan oldin migrate ni bajaradi. ALTER TABLE ning o'zi millisekundlarda tugaydi. Lekin keyingi yarim daqiqa davomida buyurtmalarga tegadigan har bir sahifa qotib qoladi, connection pool to'lib ketadi, health check'lar yiqila boshlaydi.

Odatiy ma'noda hech narsa "sekin" ishlamadi. Migratsiya shunchaki PostgreSQL'dan noto'g'ri paytda lock so'radi va butun ilova uning orqasidan navbatga turib qoldi. Bu maqola aynan shu haqda: bu nega sodir bo'ladi, qaysi DDL buyruqlari haqiqatan xavfli va Django'da sxemani trafikni to'xtatmasdan qanday o'zgartirish mumkin. NOT NULL ustun qo'shish, index qurish, ustunni o'chirish va nomini o'zgartirish, hamda har bir migratsiyada bo'lishi kerak bo'lgan bitta sozlama, lock_timeout ni ko'rib chiqamiz.

"Bor-yo'g'i bitta ALTER TABLE" nega muammo keltiradi

PostgreSQL'da deyarli har bir ALTER TABLE jadvalga ACCESS EXCLUSIVE lock oladi. Bu eng kuchli lock (qulf): u hamma narsa bilan, hatto ACCESS SHARE ushlab turadigan oddiy SELECT bilan ham to'qnashadi.

Sodda tasavvur shunday: "ALTER bir zumda tugaydi, demak lock ham bir zumlik". Bu tasavvurni ikki narsa buzadi.

Birinchisi, ba'zi buyruqlar bir zumda tugamaydi. Ular ACCESS EXCLUSIVE ni ushlab turgan holda butun jadvalni qayta yozadi yoki har bir qatorni o'qib chiqadi. Katta jadvalda bu o'sha jadval uchun bir necha daqiqalik to'liq to'xtash degani.

Ikkinchisi kutilmaganroq: bir zumlik buyruq ham lock'ni kutishi kerak, kutayotgan paytda esa o'zidan keyin kelgan hammani to'sib qo'yadi. PostgreSQL lock'larni navbat tartibida beradi. Agar uzun hisobot yoki unutilgan transaction ACCESS SHARE ni ushlab turgan bo'lsa, sizning ALTER kutadi. ACCESS SHARE so'ragan har bir yangi query endi kutayotgan ACCESS EXCLUSIVE so'rovi bilan to'qnashadi va bajarilish o'rniga ALTER ning orqasidan navbatga turadi.

-- session 1: a long report or a forgotten open transaction
BEGIN;
SELECT count(*) FROM shop_order;  -- holds ACCESS SHARE until COMMIT

-- session 2: the migration
ALTER TABLE shop_order ADD COLUMN note text;  -- waits for ACCESS EXCLUSIVE

-- session 3: an ordinary request from the site
SELECT * FROM shop_order WHERE id = 42;  -- now waits too, behind session 2

3-sessiya odatda bir zumda bajariladi. Endi esa u 1-sessiya transaction'ni ochiq tutgancha kutadi. Yuklamasi bor saytda bu har bir worker qotib qolishini anglatadi: bir millisekundlik migratsiya tufayli to'liq uzilish.

DDL'ning xavfi faqat qancha vaqt ishlashida emas, balki lock'ni qancha kutishida ham, chunki hamma uning orqasidan navbatga turadi.

Bu holat yuz berayotganda kim kimni to'sayotganini mana bu query ko'rsatadi:

SELECT pid,
       pg_blocking_pids(pid) AS blocked_by,
       state,
       now() - xact_start AS xact_age,
       left(query, 60) AS query
FROM pg_stat_activity
WHERE datname = current_database()
  AND state <> 'idle'
ORDER BY xact_start;

Qaysi DDL nimani qulflaydi

PostgreSQL 16+ uchun amaliy xarita. "Bir zumda" katalog o'zgarishini bildiradi; "skan" har bir qator o'qilishini; "qayta yozish" jadvalning yangi nusxasi yozilishini.

Amal Lock Narxi
ADD COLUMN nullable, default'siz ACCESS EXCLUSIVE bir zumda
ADD COLUMN ... DEFAULT <konstanta> ACCESS EXCLUSIVE bir zumda (PG 11 dan)
ADD COLUMN ... DEFAULT <volatile> (now(), gen_random_uuid()) ACCESS EXCLUSIVE qayta yozish
ALTER COLUMN ... TYPE ACCESS EXCLUSIVE odatda qayta yozish (varchar ni kengaytirish, varchar → text kabi istisnolar bor)
ALTER COLUMN ... SET NOT NULL ACCESS EXCLUSIVE skan (valid CHECK (col IS NOT NULL) bo'lsa, o'tkazib yuboriladi)
ADD CONSTRAINT ... CHECK / FOREIGN KEY ACCESS EXCLUSIVE / SHARE ROW EXCLUSIVE skan
ADD CONSTRAINT ... NOT VALID yuqoridagidek bir zumda
VALIDATE CONSTRAINT SHARE UPDATE EXCLUSIVE skan, lekin o'qish va yozish davom etadi
CREATE INDEX SHARE index quriladi, yozish to'xtaydi
CREATE INDEX CONCURRENTLY SHARE UPDATE EXCLUSIVE sekinroq, yozish davom etadi
DROP COLUMN, RENAME COLUMN ACCESS EXCLUSIVE bir zumda

Jadvaldan ikki qoida kelib chiqadi. Birinchisi: ACCESS EXCLUSIVE ostida skan qiladigan yoki qayta yozadigan hamma narsani bosqichlarga bo'lish kerak, og'ir ish esa kuchsizroq lock ostida bajarilsin. Ikkinchisi: navbat sababli bir zumlik amallarga ham lock_timeout kerak. Ikkinchisidan boshlaymiz, chunki u eng arzon yechim.

lock_timeout: saytni qotirgandan ko'ra tez yiqilgan yaxshi

lock_timeout buyruq lock'ni qancha kutishi mumkinligini cheklaydi. Belgilangan vaqtda lock olinmasa, buyruq canceling statement due to lock timeout xatosi bilan yiqiladi, transaction rollback bo'ladi va uning orqasidagi navbat bo'shaydi. Qayta ishga tushiriladigan yiqilgan migratsiya qotib qolgan saytdan ancha yaxshi.

PostgreSQL'da Django har bir migratsiyani transaction ichida bajaradi (atomic = False bo'lmasa), shuning uchun SET LOCAL aynan shu migratsiyaga ta'sir qiladi va commit'da o'z-o'zidan bekor bo'ladi:

# shop/migrations/0002_order_total_tiyin.py
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [("shop", "0001_initial")]

    operations = [
        migrations.RunSQL(
            "SET LOCAL lock_timeout = '3s'",
            reverse_sql="SET LOCAL lock_timeout = '3s'",
        ),
        migrations.AddField(
            model_name="order",
            name="total_tiyin",
            field=models.BigIntegerField(null=True),
        ),
    ]

statement_timeout boshqa narsa ekanini unutmang: u bajarilishning umumiy vaqtini, ishning o'zini ham qo'shib, cheklaydi. DDL uchun asosan lock_timeout kerak; backfill uchun esa ehtimol ikkalasi ham kerak emas.

Lock timeout kutilgan natija bo'lgani uchun deploy taslim bo'lmasdan qayta urinishi kerak. Qo'pol, ammo ishlaydigan variant:

for attempt in 1 2 3 4 5; do
  python manage.py migrate --noinput && break
  echo "migrate failed (attempt $attempt), retrying in 10s..."
  sleep 10
done

Bu skript faqat lock timeout'da emas, istalgan xatoda qayta urinadi, shuning uchun urinishlar sonini kichik tuting va qayta-qayta yiqilsa logga qarang. Yana bir narsa: bitta migratsiya ichida lock'lar to'planib boradi. Migratsiya uchta jadvalga tegsa, uchala lock'ni ham commit'gacha ushlab turadi. Kichik migratsiyalar bu oynani qisqa saqlaydi.

NOT NULL ustunni xavfsiz qo'shish

Avval yaxshi xabar. PostgreSQL 11 dan beri konstanta default bilan ADD COLUMN ... NOT NULL DEFAULT 'UZS' jadvalni qayta yozmaydi: default katalogda saqlanadi va eski qatorlar uchun o'sha qiymat qaytariladi. Django default= berilgan maydon uchun aynan shuni bajaradi, keyin bazadagi default'ni olib tashlaydi. Demak konstanta default xavfsiz holat (lock_timeout bilan, albatta).

Qiyin holat qiymat har bir qator uchun hisoblanishi kerak bo'lganda yuzaga keladi. Aytaylik, pulni Decimal dan butun tiyinga o'tkazyapmiz va total dan to'ldiriladigan total_tiyin ustuni kerak. Konstanta default bu yerda ma'nosiz, default'siz ADD COLUMN ... NOT NULL esa bo'sh bo'lmagan jadvalda xato beradi. Reja: kengaytirish, backfill, keyin cheklovni qattiqlashtirish:

-- 1. nullable column, no default: metadata only, instant
ALTER TABLE shop_order ADD COLUMN total_tiyin bigint;

-- 2. backfill in small batches, each in its own transaction (see below)

-- 3. constraint that is NOT checked against existing rows: instant
ALTER TABLE shop_order ADD CONSTRAINT order_total_tiyin_nn
    CHECK (total_tiyin IS NOT NULL) NOT VALID;

-- 4. full scan, but under SHARE UPDATE EXCLUSIVE: reads and writes continue
ALTER TABLE shop_order VALIDATE CONSTRAINT order_total_tiyin_nn;

-- 5. PostgreSQL sees the valid CHECK and skips its own full scan
ALTER TABLE shop_order ALTER COLUMN total_tiyin SET NOT NULL;

-- 6. the CHECK is now redundant
ALTER TABLE shop_order DROP CONSTRAINT order_total_tiyin_nn;

Asosiy hiyla 5-qadamda: PostgreSQL 12 dan beri, agar valid CHECK (col IS NOT NULL) constraint NULL yo'qligini allaqachon isbotlagan bo'lsa, SET NOT NULL to'liq skanni o'tkazib yuboradi. Shunday qilib qimmat skan 4-qadamda SHARE UPDATE EXCLUSIVE ostida bajariladi, bu lock esa o'qish va yozishni to'smaydi.

Endi xuddi shuni Django'da qilamiz. Avval o'tish davri uchun model. Yangi qatorlar ustun paydo bo'lgan paytdan boshlab to'g'ri bo'lishi kerak, aks holda backfill qochayotgan nishonni quvlab yuradi:

# shop/models.py (transition period)
from django.db import models


class Order(models.Model):
    total = models.DecimalField(max_digits=14, decimal_places=2)
    total_tiyin = models.BigIntegerField(null=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def save(self, *args, **kwargs):
        # dual write: new rows are already correct while the backfill runs
        self.total_tiyin = int(self.total * 100)
        super().save(*args, **kwargs)

0002-migratsiya lock_timeout bo'limida ko'rsatilgan: nullable BigIntegerField. Keyin backfill. U bitta ulkan UPDATE sifatida ishlamasligi kerak: bunday UPDATE butun bajarilish davomida jadvaldagi barcha qatorlarga row lock ushlab turadi, birdaniga juda ko'p dead tuple yaratadi va replikalar qayta o'ynashi kerak bo'lgan WAL portlashini beradi. Kichik batch'lar, har biri alohida commit bilan, primary key bo'ylab keyset pagination orqali yuramiz, toki jadval boshini qayta-qayta skan qilmaylik:

# shop/migrations/0003_backfill_total_tiyin.py
from django.db import migrations
from django.db.models import BigIntegerField, F
from django.db.models.functions import Cast

BATCH_SIZE = 5_000


def backfill_total_tiyin(apps, schema_editor):
    Order = apps.get_model("shop", "Order")
    last_pk = 0
    while True:
        ids = list(
            Order.objects.filter(pk__gt=last_pk)
            .order_by("pk")
            .values_list("pk", flat=True)[:BATCH_SIZE]
        )
        if not ids:
            break
        Order.objects.filter(pk__in=ids, total_tiyin__isnull=True).update(
            total_tiyin=Cast(F("total") * 100, output_field=BigIntegerField())
        )
        last_pk = ids[-1]


class Migration(migrations.Migration):
    atomic = False  # every UPDATE commits on its own

    dependencies = [("shop", "0002_order_total_tiyin")]

    operations = [
        migrations.RunPython(backfill_total_tiyin, migrations.RunPython.noop),
    ]

Har bir update() alohida commit bo'lishini aynan atomic = False ta'minlaydi. Migratsiya yarim yo'lda yiqilsa, uni qayta ishga tushirish xavfsiz: to'ldirilgan qatorlarni total_tiyin__isnull=True filtri o'tkazib yuboradi.

Keyin constraint, ikkita alohida migratsiyada:

# shop/migrations/0004_order_total_tiyin_nn.py
from django.contrib.postgres.operations import AddConstraintNotValid
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [("shop", "0003_backfill_total_tiyin")]

    operations = [
        AddConstraintNotValid(
            model_name="order",
            constraint=models.CheckConstraint(
                condition=models.Q(total_tiyin__isnull=False),
                name="order_total_tiyin_nn",
            ),
        ),
    ]
# shop/migrations/0005_validate_order_total_tiyin_nn.py
from django.contrib.postgres.operations import ValidateConstraint
from django.db import migrations


class Migration(migrations.Migration):
    dependencies = [("shop", "0004_order_total_tiyin_nn")]

    operations = [
        ValidateConstraint(model_name="order", name="order_total_tiyin_nn"),
    ]

Nega alohida? AddConstraintNotValid va ValidateConstraint bitta atomic migratsiyada tursa, birinchi amaldagi ACCESS EXCLUSIVE lock commit'gacha, ya'ni butun validatsiya skani davomida ushlab turiladi. Ishni ehtiyotkorlik bilan bo'lib, keyin yana yopishtirib qo'ygan bo'lasiz. Ularni turli migratsiyalarga ajrating yoki atomic = False qo'ying.

Xuddi shu CheckConstraint ni Order.Meta.constraints ga ham qo'shishni unutmang, aks holda keyingi makemigrations RemoveConstraint yaratadi.

Nihoyat ustun NOT NULL bo'ladi, yordamchi constraint esa olib tashlanadi (uni Meta.constraints dan ham o'chiring):

# shop/migrations/0006_order_total_tiyin_not_null.py
from django.db import migrations, models


class Migration(migrations.Migration):
    dependencies = [("shop", "0005_validate_order_total_tiyin_nn")]

    operations = [
        migrations.RunSQL(
            "SET LOCAL lock_timeout = '3s'",
            reverse_sql="SET LOCAL lock_timeout = '3s'",
        ),
        migrations.AlterField(
            model_name="order",
            name="total_tiyin",
            field=models.BigIntegerField(),
        ),
        migrations.RemoveConstraint(
            model_name="order",
            name="order_total_tiyin_nn",
        ),
    ]

Merge qilishdan oldin Django aslida qaysi SQL'ni bajarishini ko'ring:

python manage.py sqlmigrate shop 0006

Natijada SET NOT NULL va DROP CONSTRAINT bo'lishi, UPDATE esa bo'lmasligi kerak. Agar maydonda default bo'lganida, Django avval UPDATE ... SET total_tiyin = ... WHERE total_tiyin IS NULL ni chiqargan bo'lardi. sqlmigrate aynan shunday kutilmagan holatlarni ushlash uchun bor.

Index'lar: CREATE INDEX CONCURRENTLY

Oddiy CREATE INDEX SHARE lock ushlaydi: o'qish ishlaydi, ammo jadvaldagi har bir INSERT, UPDATE va DELETE index qurilib bo'lguncha kutadi. CREATE INDEX CONCURRENTLY esa SHARE UPDATE EXCLUSIVE oladi va index'ni bir necha bosqichda, yozish to'xtamagan holda quradi. Narxi: u sekinroq, o'zidan oldin boshlangan transaction'larni kutadi va transaction bloki ichida ishlay olmaydi.

Django'da buning uchun django.contrib.postgres da tayyor operatsiya bor:

# shop/migrations/0007_order_created_at_idx.py
from django.contrib.postgres.operations import AddIndexConcurrently
from django.db import migrations, models


class Migration(migrations.Migration):
    atomic = False  # CREATE INDEX CONCURRENTLY cannot run inside a transaction

    dependencies = [("shop", "0006_order_total_tiyin_not_null")]

    operations = [
        AddIndexConcurrently(
            model_name="order",
            index=models.Index(fields=["created_at"], name="order_created_at_idx"),
        ),
    ]

makemigrations oddiy AddIndex yaratadi; uni qo'lda AddIndexConcurrently ga almashtiring va atomic = False qo'shing. O'chirish uchun RemoveIndexConcurrently bor.

Agar concurrent qurish yiqilsa (deadlock, unique buzilishi, bekor qilingan buyruq), PostgreSQL ortida invalid index qoldiradi. U o'qishda ishlatilmaydi, lekin har bir yozishda yangilanib turadi. Qayta urinishdan oldin uni toping va o'chiring:

-- indexes left behind by a failed CREATE INDEX CONCURRENTLY
SELECT indexrelid::regclass AS index_name
FROM pg_index
WHERE NOT indisvalid;

-- drop it without blocking writes, then run the migration again
DROP INDEX CONCURRENTLY IF EXISTS order_created_at_idx;

Ustunni o'chirish va nomini o'zgartirish: ikki deploy

Bu yerda muammo lock'larda emas. DROP COLUMN bir zumda bajariladi. Muammo shundaki, rolling deploy paytida eski va yangi kod bir vaqtda bitta bazaga murojaat qiladi.

Django hech qachon SELECT * yozmaydi: u modelning har bir ustunini nomi bilan sanab chiqadi. Agar migratsiya legacy_status ni o'chirsa-yu, eski pod'lar hali trafik qabul qilayotgan bo'lsa, eski koddan kelgan har bir query column "legacy_status" does not exist xatosi bilan yiqiladi. Teskarisi ham buziladi: ustun bazada default'siz NOT NULL bo'lsa va yangi kod u haqida endi bilmasa, yangi koddan har bir INSERT yiqiladi.

Shuning uchun o'zgarish ikki relizga bo'linadi.

1-deploy. Maydonni modeldan olib tashlang, lekin faqat Django state'idan, va yangi kodning insert'lari ishlashi uchun ustunni nullable qiling:

# deploy 1: shop/migrations/0008_remove_legacy_status_from_state.py
from django.db import migrations


class Migration(migrations.Migration):
    dependencies = [("shop", "0007_order_created_at_idx")]

    operations = [
        migrations.SeparateDatabaseAndState(
            # Django forgets the field: new code no longer SELECTs or INSERTs it
            state_operations=[
                migrations.RemoveField(model_name="order", name="legacy_status"),
            ],
            # the column stays, but must accept rows that new code inserts
            database_operations=[
                migrations.RunSQL(
                    "ALTER TABLE shop_order "
                    "ALTER COLUMN legacy_status DROP NOT NULL",
                    reverse_sql=migrations.RunSQL.noop,
                ),
            ],
        ),
    ]

2-deploy, barcha pod'lar maydonni endi tilga olmaydigan kodda ishlay boshlagandan keyin:

# deploy 2: shop/migrations/0009_drop_legacy_status_column.py
from django.db import migrations


class Migration(migrations.Migration):
    dependencies = [("shop", "0008_remove_legacy_status_from_state")]

    operations = [
        migrations.RunSQL(
            "SET LOCAL lock_timeout = '3s'",
            reverse_sql=migrations.RunSQL.noop,
        ),
        migrations.RunSQL(
            "ALTER TABLE shop_order DROP COLUMN IF EXISTS legacy_status",
            reverse_sql=migrations.RunSQL.noop,
        ),
    ]

Nomini o'zgartirish ham xuddi shu hikoya, faqat battarroq: ikkala nom bir vaqtda mavjud bo'ladigan payt yo'q. Agar faqat Python'da chiroyliroq nom kerak bo'lsa, bazaga umuman tegmang:

from django.db import models


class Order(models.Model):
    # the Python name changes; the column in PostgreSQL stays "amount"
    total = models.DecimalField(max_digits=14, decimal_places=2, db_column="amount")

Hosil bo'lgan migratsiya uchun sqlmigrate ustun nomini o'zgartirishni ko'rsatmasligi kerak. Agar bazada haqiqatan yangi nom kerak bo'lsa, expand/contract usulini qo'llang: yangi ustun qo'shing, ikkalasiga yozing, backfill qiling, o'qishni yangisiga o'tkazing va eski ustunni yuqoridagidek keyingi deploy'da o'chiring.

Production'da uchraydigan tuzoqlar

  • AddField da default=uuid.uuid4. Django SQL yaratayotganda callable'ni bir marta chaqiradi va o'sha qiymatni barcha mavjud qatorlar uchun DEFAULT sifatida ishlatadi. Barcha eski qatorlar bir xil UUID oladi, unique=True bo'lsa migratsiya yiqiladi. Ustunni nullable qo'shing, har bir qator uchun backfill qiling, keyin qattiqlashtiring.
  • Idle-in-transaction sessiyalar. BEGIN qilib, keyin tashqi API'ni chaqirishga ketib qolgan ulanish butun shu vaqt lock'larini ushlab turadi. lock_timeout saytni qutqaradi, lekin migratsiya baribir oldinga siljiy olmaydi. pg_stat_activity da state = 'idle in transaction' ni qidiring va idle_in_transaction_session_timeout ni sozlang.
  • Dual write'dagi teshiklar. QuerySet.update(), bulk_create(), raw SQL va save(update_fields=[...]) yuqoridagi save() mantiqini chetlab o'tadi. Har bir yozish yo'lini tekshiring yoki backfill qayta ishga tushirilishi mumkinligiga tayanib, uni VALIDATE dan oldin yana bir marta ishga tushiring.
  • Foreign key'lar. ForeignKey qo'shish ham index, ham constraint yaratadi, constraint esa ikkala jadvalni qulflaydi va murojaat qiluvchi jadvalni skan qiladi. Katta jadvalda uni RunSQL orqali concurrent index va NOT VALID constraint'ga, keyin VALIDATE ga bo'lishni o'ylab ko'ring.
  • Tipni o'zgartirish. integer dan bigint ga ALTER COLUMN TYPE jadvalni ACCESS EXCLUSIVE ostida qayta yozadi. Buni AlterField emas, yangi ustun va backfill sifatida qiling.
  • CONCURRENTLY eski transaction'larni kutadi. U boshqalarni to'smaydi, lekin o'zidan oldin boshlangan transaction'larni kutadi, shuning uchun uzun hisobot migratsiya qadamining o'zini to'xtatib qo'yishi mumkin.
  • Replication lag. Backfill'ning har bir batch'i replikalar qo'llashi kerak bo'lgan WAL'ga aylanadi. Agar replikalardan o'qisangiz, lag'ni kuzating va u o'sib borsa, batch'lar orasiga qisqa pauza qo'shing.

Checklist

  • Har bir migratsiya uchun sqlmigrate ni ishga tushiring va faqat Python'ni emas, SQL'ni o'qing.
  • Katta yoki qizg'in ishlatiladigan jadvalga tegadigan har bir atomic migratsiya boshiga SET LOCAL lock_timeout qo'ying, deploy esa qayta urinsin.
  • Katta jadvalni skan qiladigan yoki qayta yozadigan hech narsa ACCESS EXCLUSIVE ostida ishlamasin.
  • Hisoblanadigan qiymatli NOT NULL: nullable ustun, dual write, batch'li backfill, CHECK ... NOT VALID, alohida migratsiyada VALIDATE, SET NOT NULL, CHECK ni o'chirish.
  • Jonli jadvallardagi index'lar: atomic = False bilan AddIndexConcurrently; yiqilishdan keyin invalid index'larni tekshiring.
  • Ustunlarni ikki deploy'da o'chiring yoki nomini o'zgartiring: avval kod undan foydalanishni to'xtatadi, keyin baza uni o'chiradi.
  • Katta migratsiyadan oldin pg_stat_activity da uzun transaction'lar bor-yo'qligiga qarang.

Xulosa

Migratsiya ikki sababga ko'ra xavfli: u og'ir ish bajarayotganda kuchli lock ushlab turishi mumkin, yoki lock uchun navbatga turib, qolgan barcha query'larni ham o'sha navbatga sudrab kirishi mumkin. Davo har safar bir xil: og'ir qismni kuchsizroq lock ostiga chiqaring (NOT VALID + VALIDATE, CONCURRENTLY, batch'li backfill), kuchli lock'li qadamlarni juda kichik tuting va ularni lock_timeout bilan himoyalang. Eski va yangi kod bitta bazani bo'lishar ekan, sxema o'zgarishiga bitta emas, ikkita deploy bering.

// izohlar

Izohlar yuklanmoqda...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯