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
AddFielddadefault=uuid.uuid4. Django SQL yaratayotganda callable'ni bir marta chaqiradi va o'sha qiymatni barcha mavjud qatorlar uchunDEFAULTsifatida ishlatadi. Barcha eski qatorlar bir xil UUID oladi,unique=Truebo'lsa migratsiya yiqiladi. Ustunni nullable qo'shing, har bir qator uchun backfill qiling, keyin qattiqlashtiring.- Idle-in-transaction sessiyalar.
BEGINqilib, keyin tashqi API'ni chaqirishga ketib qolgan ulanish butun shu vaqt lock'larini ushlab turadi.lock_timeoutsaytni qutqaradi, lekin migratsiya baribir oldinga siljiy olmaydi.pg_stat_activitydastate = 'idle in transaction'ni qidiring vaidle_in_transaction_session_timeoutni sozlang. - Dual write'dagi teshiklar.
QuerySet.update(),bulk_create(), raw SQL vasave(update_fields=[...])yuqoridagisave()mantiqini chetlab o'tadi. Har bir yozish yo'lini tekshiring yoki backfill qayta ishga tushirilishi mumkinligiga tayanib, uniVALIDATEdan oldin yana bir marta ishga tushiring. - Foreign key'lar.
ForeignKeyqo'shish ham index, ham constraint yaratadi, constraint esa ikkala jadvalni qulflaydi va murojaat qiluvchi jadvalni skan qiladi. Katta jadvalda uniRunSQLorqali concurrent index vaNOT VALIDconstraint'ga, keyinVALIDATEga bo'lishni o'ylab ko'ring. - Tipni o'zgartirish.
integerdanbigintgaALTER COLUMN TYPEjadvalniACCESS EXCLUSIVEostida qayta yozadi. BuniAlterFieldemas, 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
sqlmigrateni 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_timeoutqo'ying, deploy esa qayta urinsin. - Katta jadvalni skan qiladigan yoki qayta yozadigan hech narsa
ACCESS EXCLUSIVEostida ishlamasin. - Hisoblanadigan qiymatli
NOT NULL: nullable ustun, dual write, batch'li backfill,CHECK ... NOT VALID, alohida migratsiyadaVALIDATE,SET NOT NULL,CHECKni o'chirish. - Jonli jadvallardagi index'lar:
atomic = FalsebilanAddIndexConcurrently; 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_activityda 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...