Barcha yozuvlar
Fintech

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. Yoniga transactions degan 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 + fee qo'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:

  1. 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 unique faqat bittasining commit'iga ruxsat beradi; ikkinchisi IntegrityError oladi va g'olibni qayta o'qishi mumkin (batafsil idempotentlik kalitlari haqidagi maqolada).
  2. Barqaror tartibda lock. order_by("id") bilan select_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.
  3. Har bir valyuta bo'yicha balans. Python'dagi tekshiruv tushunarli xatoni oldindan beradi, trigger esa sug'urta to'ri.
  4. Overdraft. Qatorlar lock qilingan ekan, keshlangan balans dolzarb va hech kim bir pulni parallel ravishda ikki marta sarflay olmaydi.
  5. Yozish. Bitta o'tkazma, uning qatorlari bulk_create orqali 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:

  1. Hisobdagi keshlangan balance, qatorlar bilan bitta transaction'da yangilanadi. Ilovada shuni ko'rsatamiz va overdraft'ni shu bo'yicha tekshiramiz.
  2. 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"]
  1. 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 TestCase har bir testni hech qachon commit qilinmaydigan transaction'ga o'raydi, shuning uchun kechiktirilgan tekshiruv siz kutgan joyda ishlamaydi. Uni SET CONSTRAINTS ALL IMMEDIATE bilan 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_entry kattaroq atomic() bloki ichida chaqirilsa, trigger tashqi commit'da ishlaydi va IntegrityError sababdan uzoqda, o'sha yerda chiqadi. Ledger yozuvlarini qisqa transaction'larda saqlang.
  • TRUNCATE trigger'i va test bazasini tozalash. TransactionTestCase va manage.py flush jadvallarni TRUNCATE bilan tozalaydi, shuning uchun trigger "ledger_posting is append-only" xatosini beradi. Yo ledger testlarini TestCaseda qoldiring, yoki aynan shu trigger'ni olib tashlab, production roli uchun REVOKE TRUNCATEga tayaning.
  • Issiq hisoblar. Har bir to'lov revenue:feesni kreditlaydi. Uni select_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_at commit'dan oldin qo'yiladi (Python'da auto_now_add orqali, PostgreSQL'dagi now() 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 InsufficientFunds bilan yiqiladi. Bu to'g'ri xatti-harakat, lekin biznes javob kerak: foydalanuvchi qarzi uchun debitorlik hisobi yoki qo'lda bajariladigan jarayon.
  • Admin panel. Posting uchun standart ModelAdmin tahrirlash va o'chirish tugmalarini taklif qiladi. Uni faqat o'qish uchun ro'yxatdan o'tkazing (has_change_permission va has_delete_permission False qaytaradi), 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 UPDATE bilan 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...

    // keyingi qadam

    Keling, birga nimadir quramiz.

    Telegramda yozish
    aslbek@asldev: ~
    ❯