Balans ustuni yolg'on gapirganda: double-entry ledger, debit = kredit va o'zgarmas yozuvlar
Bitta balance ustuni pul qayerdan kelib, qayerga ketganini aytmaydi. Hisoblar, o'tkazmalar va qatorlar, debit = kreditni PostgreSQL trigger bilan majburlash, storno va snapshot'lar: Django'da halol ledger quramiz.
Dushanba, ertalab, qo'llab-quvvatlash xizmatiga murojaat keladi: "Kecha hamyonimda 350 000 so'm bor edi, bugun 150 000. Men hech narsa sotib olmadim". Bazani ochasiz. wallets jadvalida foydalanuvchiga bitta qator, balance ustunida 150 000. Vassalom. Bu xaridmidi? Keyin bekor qilingan qaytarishmi? O'tgan haftadagi deploy'dagi xato ikki marta yechib oldimi? Raqam bor, uning ortidagi tarix esa yo'q.
Endi teskari holat, u yomonroq, chunki hech kim shikoyat qilmaydi: to'lov tizimidan kelgan callback qayta yuborilib, merchantga pul ikki marta tushadi. Merchant xursand, foydalanuvchi xursand, tizim esa jimgina havodan 2 million so'm yaratib qo'ydi. Tizimdagi hech narsa pul qayerdandir kelishi shartligini bilmaydi.
Ikkala muammoning ildizi bitta: balans yagona haqiqat manbai sifatida saqlanadi. Buxgalterlar buni asrlar oldin ikki tomonlama yozuv bilan hal qilishgan. Bu maqolada PostgreSQL va Django'da kichik, lekin halol double-entry ledger quramiz: hisoblar, o'tkazmalar, o'tkazma qatorlari, baza o'zi tekshiradigan "debit = kredit" qoidasi, snapshot'li balanslar va tarixni tahrirlamasdan tuzatish.
Nega balance ustuni yetarli emas
Ko'pchiligimiz qachondir yozgan versiya:
# wallets/services.py — the "simple" version
from django.db import transaction
from django.db.models import F
from .models import Wallet
@transaction.atomic
def transfer(sender_id: int, receiver_id: int, amount: int) -> None:
Wallet.objects.filter(user_id=sender_id).update(balance=F("balance") - amount)
Wallet.objects.filter(user_id=receiver_id).update(balance=F("balance") + amount)
U atomik, F() ishlatadi, demak parallel yangilanishlar bir-birining ustidan yozib yubormaydi. Shunga qaramay:
- Tarix yo'q.
UPDATEdan keyin oldingi qiymat yo'qoladi. Yonigatransactionsdegan log jadvali yozilsa ham, u balansning ostida emas, yonida yashaydi va ertami-kechmi ular ajralib ketadi: kimdir balansni qo'lda to'g'rilaydi, migratsiya log haqida unutadi, koddagi qaysidir yo'l uni chetlab o'tadi. - Invariant yo'q. Bir hamyondan chiqqan pul boshqasiga kelganini hech kim tekshirmaydi. Xato tufayli ikkinchi qator
amount + feeqo'shsa, baza e'tiroz bildirmaydi. - Tuzatish izlarni yo'q qiladi. Noto'g'ri balansni tuzatishning tabiiy yo'li yana bitta
UPDATE. Endi na xato, na tuzatish ko'rinadi. - Pulning kelib chiqishi yo'q. Kartadan to'ldirish shunchaki bitta raqamni oshiradi. Pul qayerdan keldi? To'lov provayderidan, endi u bizdan qarzdor. Bitta ustun bilan buni ifodalab bo'lmaydi.
Balans hosilaviy qiymat. Haqiqat manbai harakatlar ro'yxati, va har bir harakat pulni qayerdandir olib, qayergadir qo'yishi shart.
Model: hisoblar, o'tkazmalar, qatorlar
Ikki tomonlama yozuv bor-yo'g'i uchta tushunchadan iborat.
Hisob (account) qiymat saqlanadigan "savat": foydalanuvchi hamyoni, merchant hamyoni, provayder bizga qarzdor bo'lgan pul, komissiyadan tushgan daromadimiz. Har bir hisobning turi bor:
| Tur | Hamyon platformasidagi misol | Normal tomoni |
|---|---|---|
| Aktiv | Bankdagi pul / PSP'ning bizdan qarzi | Debit |
| Majburiyat | Foydalanuvchi va merchant hamyonlari (biz ulardan qarzdormiz) | Kredit |
| Daromad | Komissiyalar | Kredit |
| Xarajat | Keshbek, ekvayring xarajatlari | Debit |
| Kapital | Egalarning sarmoyasi | Kredit |
Dasturchilar uchun kutilmagan jihati: foydalanuvchi hamyoni platforma uchun majburiyat. Pul bizda turibdi, lekin unga tegishli, demak bu qarz.
O'tkazma (journal entry) bitta biznes hodisa: "hisobni to'ldirish", "#812 buyurtma uchun to'lov", "qaytarish". Uning tavsifi, vaqti va idempotentlik kaliti bor.
Qator (posting) bitta o'tkazma doirasida bitta hisobga tushadigan summa. O'tkazmada ikki yoki undan ko'p qator bo'ladi, qoida esa bitta: har bir o'tkazmada debitlar yig'indisi kreditlar yig'indisiga teng.
Kodda bitta ishorali butun son saqlash qulay: musbat debit, manfiy kredit. Shunda qoida "o'tkazma qatorlarining yig'indisi nolga teng" bo'lib qoladi, buni tekshirish esa juda oson.
Foydalanuvchi kartadan 200 000 so'm to'ldiradi:
| Hisob | Tur | Summa |
|---|---|---|
| asset:psp-clearing | Aktiv | +200 000 |
| wallet:user:42 | Majburiyat | −200 000 |
PSP bizdan ko'proq qarzdor (aktiv debit bilan o'sadi), biz foydalanuvchidan ko'proq qarzdormiz (majburiyat kredit bilan o'sadi). Keyin foydalanuvchi merchantga 1% komissiya bilan 150 000 so'm to'laydi:
| Hisob | Tur | Summa |
|---|---|---|
| wallet:user:42 | Majburiyat | +150 000 |
| wallet:merchant:7 | Majburiyat | −148 500 |
| revenue:fees | Daromad | −1 500 |
Debit 150 000, kredit 148 500 + 1 500. Yig'indi nol. Foydalanuvchi ko'radigan balans uning qatorlari yig'indisining teskari ishorasi: 200 000 − 150 000 = 50 000. Endi tizimdagi har bir so'mni uni harakatlantirgan o'tkazmagacha kuzatib borish mumkin.
PostgreSQL sxemasi va Django modellari
Summalar tiyindagi butun sonlar (float va Decimal haqidagi oldingi maqolaga qarang). Hisobda keshlangan balance bor, lekin haqiqat manbai baribir qatorlar.
# ledger/models.py
from django.db import models
from django.db.models import Q
class Account(models.Model):
class Kind(models.TextChoices):
ASSET = "asset", "Asset"
LIABILITY = "liability", "Liability"
EQUITY = "equity", "Equity"
REVENUE = "revenue", "Revenue"
EXPENSE = "expense", "Expense"
code = models.CharField(max_length=64, unique=True) # "wallet:user:42", "revenue:fees"
kind = models.CharField(max_length=16, choices=Kind.choices)
currency = models.CharField(max_length=3, default="UZS")
allow_negative = models.BooleanField(default=False)
# Cached sum of all postings, in tiyin, debit-positive.
balance = models.BigIntegerField(default=0)
@property
def is_debit_normal(self) -> bool:
return self.kind in (self.Kind.ASSET, self.Kind.EXPENSE)
@property
def display_balance(self) -> int:
return self.balance if self.is_debit_normal else -self.balance
class JournalEntry(models.Model):
description = models.CharField(max_length=255)
idempotency_key = models.CharField(max_length=64, unique=True)
reverses = models.OneToOneField(
"self",
null=True,
blank=True,
on_delete=models.PROTECT,
related_name="reversed_by",
)
created_at = models.DateTimeField(auto_now_add=True)
class Posting(models.Model):
entry = models.ForeignKey(JournalEntry, on_delete=models.PROTECT, related_name="postings")
account = models.ForeignKey(Account, on_delete=models.PROTECT, related_name="postings")
amount = models.BigIntegerField() # tiyin: + debit, - credit
created_at = models.DateTimeField(auto_now_add=True)
class Meta:
constraints = [
models.CheckConstraint(condition=~Q(amount=0), name="posting_amount_nonzero"),
]
indexes = [
models.Index(
fields=["account", "created_at"],
include=["amount"],
name="posting_acc_time_idx",
),
]
Bir nechta ongli qaror: hamma joyda on_delete=PROTECT, chunki ledger'da kaskadli o'chirish bo'lmaydi; reverses bu OneToOneField, shuning uchun bitta o'tkazmani ikki marta storno qilishga bazaning o'zi yo'l qo'ymaydi; (account, created_at) INCLUDE (amount) index'i visibility map yangi bo'lsa, PostgreSQL'ga "X paytdagi balans"ni index-only scan bilan hisoblash imkonini beradi. E'tibor bering: Django 5.1'dan boshlab CheckConstraint condition= qabul qiladi, eski check= argumenti Django 6.0'da olib tashlangan.
Debit = kredit qoidasini baza o'zi qo'riqlaydi
Python'da yig'indini tekshirish yaxshi, lekin kafolat koddagi har bir yo'l sizning servisingizdan o'tishiga bog'liq bo'lmasligi kerak. Oddiy CHECK boshqa qatorlarni ko'rmaydi, shuning uchun commit paytiga kechiktirilgan constraint trigger ishlatamiz:
CREATE FUNCTION ledger_check_entry_balanced() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
IF EXISTS (
SELECT 1
FROM ledger_posting p
JOIN ledger_account a ON a.id = p.account_id
WHERE p.entry_id = NEW.entry_id
GROUP BY a.currency
HAVING SUM(p.amount) <> 0
) THEN
RAISE EXCEPTION 'journal entry % is not balanced', NEW.entry_id
USING ERRCODE = 'check_violation';
END IF;
RETURN NULL;
END;
$$;
CREATE CONSTRAINT TRIGGER ledger_posting_balanced
AFTER INSERT ON ledger_posting
DEFERRABLE INITIALLY DEFERRED
FOR EACH ROW EXECUTE FUNCTION ledger_check_entry_balanced();
Nega DEFERRABLE INITIALLY DEFERRED? Qatorlar birma-bir (yoki bitta so'rov bilan) qo'shiladi va birinchi qatordan keyin o'tkazma tabiiyki muvozanatda bo'lmaydi. Kechiktirilgan constraint trigger COMMIT paytida, barcha qatorlar joyida bo'lganda ishga tushadi. ERRCODE = 'check_violation' psycopg'ni CheckViolation tashlashga majbur qiladi, Django esa uni IntegrityError sifatida beradi; oddiy RAISE EXCEPTION esa ancha kam ma'lumot beruvchi ProgrammingError bo'lib kelardi. Valyuta bo'yicha guruhlash o'tkazma har bir valyutada alohida muvozanatda bo'lishi kerakligini bildiradi: 100 USD'ni 100 UZS bilan "tenglashtirib" bo'lmaydi.
O'zgarmas yozuvlar
Qatorlar va o'tkazmalar faqat qo'shiladi. "Kelishuv bo'yicha" emas, majburiy ravishda:
CREATE FUNCTION ledger_forbid_change() RETURNS trigger
LANGUAGE plpgsql AS $$
BEGIN
RAISE EXCEPTION '% is append-only: % is not allowed', TG_TABLE_NAME, TG_OP;
END;
$$;
CREATE TRIGGER ledger_posting_append_only
BEFORE UPDATE OR DELETE ON ledger_posting
FOR EACH ROW EXECUTE FUNCTION ledger_forbid_change();
CREATE TRIGGER ledger_posting_no_truncate
BEFORE TRUNCATE ON ledger_posting
FOR EACH STATEMENT EXECUTE FUNCTION ledger_forbid_change();
CREATE TRIGGER ledger_entry_append_only
BEFORE UPDATE OR DELETE ON ledger_journalentry
FOR EACH ROW EXECUTE FUNCTION ledger_forbid_change();
Qator darajasidagi trigger'lar TRUNCATEda ishlamaydi, shu sabab u uchun alohida statement darajasidagi trigger bor. Bundan tashqari, agar ilova jadvallarga egalik qilmaydigan rol bilan ulansa, REVOKE UPDATE, DELETE, TRUNCATE ON ledger_posting, ledger_journalentry FROM app_role; eshikni huquqlar darajasida ham yopadi. SQL oddiy migratsiya bilan yetkaziladi:
# ledger/migrations/0002_ledger_triggers.py
from django.db import migrations
FORWARD = """
-- paste both SQL blocks from above here:
-- ledger_check_entry_balanced + ledger_posting_balanced,
-- ledger_forbid_change + the three append-only triggers
"""
REVERSE = """
DROP TRIGGER IF EXISTS ledger_posting_balanced ON ledger_posting;
DROP TRIGGER IF EXISTS ledger_posting_append_only ON ledger_posting;
DROP TRIGGER IF EXISTS ledger_posting_no_truncate ON ledger_posting;
DROP TRIGGER IF EXISTS ledger_entry_append_only ON ledger_journalentry;
DROP FUNCTION IF EXISTS ledger_check_entry_balanced();
DROP FUNCTION IF EXISTS ledger_forbid_change();
"""
class Migration(migrations.Migration):
dependencies = [("ledger", "0001_initial")]
operations = [migrations.RunSQL(FORWARD, reverse_sql=REVERSE)]
Django'dan o'tkazma yozish
Servis funksiyasi ledger'ga yozadigan yagona joy. U tekshiradi, tegishli hisoblarni lock qiladi, overdraft'ni tekshiradi, qatorlarni qo'shadi va keshlangan balanslarni yangilaydi, hammasi bitta transaction ichida:
# ledger/services.py
from collections import defaultdict
from dataclasses import dataclass
from django.db import transaction
from django.db.models import F
from .models import Account, JournalEntry, Posting
class LedgerError(Exception):
pass
class UnbalancedEntry(LedgerError):
pass
class InsufficientFunds(LedgerError):
pass
@dataclass(frozen=True)
class Line:
account_id: int
amount: int # tiyin: + debit, - credit
@transaction.atomic
def post_entry(
*,
description: str,
idempotency_key: str,
lines: list[Line],
reverses: JournalEntry | None = None,
) -> JournalEntry:
if any(line.amount == 0 for line in lines):
raise UnbalancedEntry("zero-amount line")
existing = JournalEntry.objects.filter(idempotency_key=idempotency_key).first()
if existing is not None:
return existing
deltas: dict[int, int] = defaultdict(int)
for line in lines:
deltas[line.account_id] += line.amount
# Stable lock order: A->B and B->A transfers cannot deadlock each other.
accounts = {
acc.id: acc
for acc in Account.objects.select_for_update()
.filter(id__in=list(deltas))
.order_by("id")
}
if len(accounts) != len(deltas):
raise LedgerError("unknown account")
per_currency: dict[str, int] = defaultdict(int)
for acc_id, delta in deltas.items():
per_currency[accounts[acc_id].currency] += delta
if any(total != 0 for total in per_currency.values()):
raise UnbalancedEntry(f"debits != credits: {dict(per_currency)}")
for acc_id, delta in deltas.items():
acc = accounts[acc_id]
new_balance = acc.balance + delta
shown = new_balance if acc.is_debit_normal else -new_balance
if shown < 0 and not acc.allow_negative:
raise InsufficientFunds(acc.code)
entry = JournalEntry.objects.create(
description=description,
idempotency_key=idempotency_key,
reverses=reverses,
)
Posting.objects.bulk_create(
[Posting(entry=entry, account_id=line.account_id, amount=line.amount) for line in lines]
)
for acc_id, delta in deltas.items():
Account.objects.filter(id=acc_id).update(balance=F("balance") + delta)
return entry
Qadam-baqadam nima bo'lyapti:
- Idempotentlik. Shu kalitli o'tkazma allaqachon bor bo'lsa, qayta yozish o'rniga o'shani qaytaramiz. Bir xil kalitli ikkita parallel so'rov ikkalasi ham tekshiruvdan o'tadi, lekin
uniquefaqat bittasining commit'iga ruxsat beradi; ikkinchisiIntegrityErroroladi va g'olibni qayta o'qishi mumkin (batafsil idempotentlik kalitlari haqidagi maqolada). - Barqaror tartibda lock.
order_by("id")bilanselect_for_update()hisob qatorlarini id o'sish tartibida lock qiladi. Ikkita qarama-qarshi o'tkazma bir xil tartibda lock qiladi va deadlock'ga tushish o'rniga bir-birini kutadi. - Har bir valyuta bo'yicha balans. Python'dagi tekshiruv tushunarli xatoni oldindan beradi, trigger esa sug'urta to'ri.
- Overdraft. Qatorlar lock qilingan ekan, keshlangan balans dolzarb va hech kim bir pulni parallel ravishda ikki marta sarflay olmaydi.
- Yozish. Bitta o'tkazma, uning qatorlari
bulk_createorqali va har bir hisob balansining yangilanishi.
Yuqoridagi merchant to'lovi uchun ishlatilishi:
# payments/services.py
from ledger.models import Account, JournalEntry
from ledger.services import Line, post_entry
def pay_merchant(
payer: Account, merchant: Account, fees: Account, amount: int, order_id: int
) -> JournalEntry:
fee = amount // 100 # 1%, rounded down to a whole tiyin
lines = [
Line(payer.id, amount), # debit: we owe the payer less
Line(merchant.id, -(amount - fee)), # credit: we owe the merchant more
Line(fees.id, -fee), # credit: our revenue
]
return post_entry(
description=f"order #{order_id}",
idempotency_key=f"order:{order_id}:pay",
lines=[line for line in lines if line.amount != 0],
)
Komissiyaning yaxlitlanishiga e'tibor bering: merchant alohida yaxlitlangan amount * 0.99 emas, amount - fee oladi. Bir tomonni hisoblang, ikkinchisini undan chiqaring, shunda qatorlar yig'indisi doim aniq nol bo'ladi.
Tuzatish: tahrirlash emas, storno
Summa noto'g'rimi? Merchant boshqami? Eski o'tkazmaga tegmaymiz. Xuddi shu qatorlarni teskari ishora bilan storno o'tkazmasi sifatida yozamiz, kerak bo'lsa keyin yangi, to'g'ri o'tkazma qo'shamiz:
# ledger/services.py (continued)
def reverse_entry(entry: JournalEntry, *, reason: str) -> JournalEntry:
return post_entry(
description=f"reversal of #{entry.pk}: {reason}",
idempotency_key=f"reversal:{entry.pk}",
lines=[Line(p.account_id, -p.amount) for p in entry.postings.all()],
reverses=entry,
)
Endi tarix aynan qanday bo'lgan bo'lsa, shunday o'qiladi: asl o'tkazma, storno, to'g'ri o'tkazma. Auditor (yoki tungi soat uchda siz) istalgan paytdagi istalgan balansni tiklay oladi. OneToOneField va idempotentlik kaliti birgalikda ikki marta storno qilishni imkonsiz qiladi.
Balanslar va snapshot'lar
"Balans qancha?" degan savolga uchta javob bor, haqiqiy tizim esa uchalasini ham ishlatadi:
- Hisobdagi keshlangan
balance, qatorlar bilan bitta transaction'da yangilanadi. Ilovada shuni ko'rsatamiz va overdraft'ni shu bo'yicha tekshiramiz. - Qatorlar yig'indisi — haqiqat. Muayyan paytga:
# ledger/queries.py
from datetime import datetime
from django.db.models import Sum
from .models import Account, Posting
def balance_at(account: Account, moment: datetime) -> int:
"""Debit-positive balance from all postings created before `moment`."""
return Posting.objects.filter(account=account, created_at__lt=moment).aggregate(
total=Sum("amount", default=0)
)["total"]
- Snapshot'lar. Ko'chirma uchun millionlab qatorlarni yig'ish sekin, shuning uchun har kunni alohida jadvalga yopamiz va faqat oxirgi snapshot'dan keyingi qatorlarni yig'amiz:
CREATE TABLE ledger_daily_balance (
account_id bigint NOT NULL REFERENCES ledger_account (id),
day date NOT NULL,
balance bigint NOT NULL, -- closing balance, debit-positive
PRIMARY KEY (account_id, day)
);
-- Closing balance of 2026-11-10 (Tashkent time) = previous day + that day's postings.
INSERT INTO ledger_daily_balance (account_id, day, balance)
SELECT a.id,
DATE '2026-11-10',
COALESCE(prev.balance, 0) + COALESCE(SUM(p.amount), 0)
FROM ledger_account a
LEFT JOIN ledger_daily_balance prev
ON prev.account_id = a.id AND prev.day = DATE '2026-11-09'
LEFT JOIN ledger_posting p
ON p.account_id = a.id
AND p.created_at >= TIMESTAMPTZ '2026-11-10 00:00:00+05'
AND p.created_at < TIMESTAMPTZ '2026-11-11 00:00:00+05'
GROUP BY a.id, prev.balance
ON CONFLICT (account_id, day) DO UPDATE SET balance = EXCLUDED.balance;
Istalgan paytdagi balans oldingi kun yakunidagi qoldiq plyus yarim tundan beri kelgan qatorlar. Bunga ishonishdan oldin o'lchang: eng band hisob uchun "paytdagi balans" so'roviga snapshot bilan va snapshot'siz EXPLAIN (ANALYZE, BUFFERS) ishga tushiring.
Va nihoyat, solishtirish (reconciliation). Muntazam ishga tushiring (tungi Celery vazifasi yetarli) va so'rov kamida bitta qator qaytarsa, alert ko'taring:
-- 1. Every account: cached balance must equal the sum of its postings.
SELECT a.id, a.code, a.balance, COALESCE(SUM(p.amount), 0) AS computed
FROM ledger_account a
LEFT JOIN ledger_posting p ON p.account_id = a.id
GROUP BY a.id
HAVING a.balance <> COALESCE(SUM(p.amount), 0);
-- 2. The whole ledger, per currency, must sum to zero.
SELECT a.currency, SUM(p.amount) AS total
FROM ledger_posting p
JOIN ledger_account a ON a.id = p.account_id
GROUP BY a.currency
HAVING SUM(p.amount) <> 0;
Production'dagi tuzoqlar
- Kechiktirilgan trigger'lar va testlar. Django'dagi
TestCasehar bir testni hech qachon commit qilinmaydigan transaction'ga o'raydi, shuning uchun kechiktirilgan tekshiruv siz kutgan joyda ishlamaydi. UniSET CONSTRAINTS ALL IMMEDIATEbilan majburlang, u to'plangan hodisalarni orqaga qarab tekshiradi:
# ledger/tests.py
from django.db import IntegrityError, connection, transaction
from django.test import TestCase
from ledger.models import Account, JournalEntry, Posting
class LedgerInvariantTests(TestCase):
def test_unbalanced_entry_is_rejected_by_db(self):
a = Account.objects.create(code="asset:psp", kind="asset")
b = Account.objects.create(code="wallet:user:1", kind="liability")
with self.assertRaises(IntegrityError):
with transaction.atomic():
entry = JournalEntry.objects.create(description="bad", idempotency_key="t1")
Posting.objects.create(entry=entry, account=a, amount=100)
Posting.objects.create(entry=entry, account=b, amount=-90)
# TestCase never commits, so force the deferred check right here.
with connection.cursor() as cur:
cur.execute("SET CONSTRAINTS ALL IMMEDIATE")
- Tashqi transaction'lar. Agar
post_entrykattaroqatomic()bloki ichida chaqirilsa, trigger tashqi commit'da ishlaydi vaIntegrityErrorsababdan uzoqda, o'sha yerda chiqadi. Ledger yozuvlarini qisqa transaction'larda saqlang. - TRUNCATE trigger'i va test bazasini tozalash.
TransactionTestCasevamanage.py flushjadvallarniTRUNCATEbilan tozalaydi, shuning uchun trigger "ledger_posting is append-only" xatosini beradi. Yo ledger testlariniTestCaseda qoldiring, yoki aynan shu trigger'ni olib tashlab, production roli uchunREVOKE TRUNCATEga tayaning. - Issiq hisoblar. Har bir to'lov
revenue:feesni kreditlaydi. Uniselect_for_update()bilan lock qilsangiz, barcha to'lovlar bitta qator uchun navbatga tizilib qoladi. Minusga tushishi mumkin bo'lgan yoki overdraft tekshiruvi kerak bo'lmagan hisoblarga (daromad, PSP clearing) lock ham, keshlangan balans ham shart emas: qatorlarni qo'shavering, balansni esa qatorlar va snapshot'lar bo'yicha hisoblang. - Vaqt commit tartibi emas.
created_atcommit'dan oldin qo'yiladi (Python'daauto_now_addorqali, PostgreSQL'daginow()esa transaction boshlangan vaqt). 23:59:59 da boshlanib, 00:00:01 da commit qilingan transaction "kecha"ga tushadi, holbuki kechagi snapshot allaqachon hisoblangan bo'lishi mumkin. Snapshot vazifasini vaqt zaxirasi bilan ishga tushiring va transaction'larni qisqa tuting. Xuddi shu sababdan "oxirgi qator id'si"ni hech qachon snapshot chegarasi sifatida ishlatmang: sequence qiymatlari commit paytida emas, insert paytida beriladi. - Storno overdraft'ga olib kelishi mumkin. Foydalanuvchi pulni sarflab bo'lgach, to'ldirishni storno qilish
InsufficientFundsbilan yiqiladi. Bu to'g'ri xatti-harakat, lekin biznes javob kerak: foydalanuvchi qarzi uchun debitorlik hisobi yoki qo'lda bajariladigan jarayon. - Admin panel.
Postinguchun standartModelAdmintahrirlash va o'chirish tugmalarini taklif qiladi. Uni faqat o'qish uchun ro'yxatdan o'tkazing (has_change_permissionvahas_delete_permissionFalseqaytaradi), trigger baribir rad etsa ham. - Bitta hisob, bitta valyuta. Konvertatsiya aralash valyutali bitta o'tkazma emas, FX hisobi orqali ikkita o'tkazma.
Checklist
- Pul eng kichik birlikdagi butun sonlarda (
BigIntegerField, tiyin), hech qachon float emas. - Har bir harakat — har bir valyuta bo'yicha yig'indisi nolga teng, kamida 2 qatorli o'tkazma.
- Kechiktirilgan constraint trigger yig'indini commit paytida tekshiradi.
- Qatorlar va o'tkazmalar faqat qo'shiladi: trigger'lar va olib qo'yilgan huquqlar.
- Xatolar storno bilan tuzatiladi, hech qachon
UPDATEbilan emas. - Hisoblar
select_for_update()bilan id o'sish tartibida lock qilinadi. - Har bir o'tkazmada noyob idempotentlik kaliti bor.
- Keshlangan balanslar jadval bo'yicha qatorlar bilan solishtiriladi, farq bo'lsa alert.
- Snapshot'lar faqat yopilgan davrlar uchun va vaqt zaxirasi bilan hisoblanadi.
Xulosa
balance ustuni sizga raqamni aytadi, double-entry ledger esa nega raqam aynan shunday ekanini aytadi. Dizayn kichik: hisoblar, o'tkazmalar, qatorlar va bitta invariant — har bir o'tkazma yig'indisi nolga teng, buni esa yaxshi niyat emas, PostgreSQL qo'riqlaydi. O'zgarmaslik va stornoni qo'shing, shunda tizimdagi har bir so'mning kelib chiqishini kuzatsa bo'ladi.
// izohlar
Izohlar yuklanmoqda...