4

4-ma’ruza matni · Korxona ilovalarini dasturlash

Biznes-logika va servis qatlami

Servis qatlami · Tranzaksiyalar · Qulflash · Invariantlar · Hujjat oqimi

Muammoli savol

Omborda UN-001 dan 5 dona qoldi. Ikki menejer bir soniyada 4 va 3 donalik buyurtmani rezerv qilsa, nima bo‘ladi? Hozircha javob bermang. Har bir menejerning so‘rovi serverda qanday qadamlar bilan bajarilishini tasavvur qiling.

Javob

Qulfsiz kodda ikkala so‘rov ham 5 ni o‘qiydi va rezerv qiladi: reserved = 7, mavjud qoldiq −2 — invariant buzildi. Yechim: rezervni tranzaksiya ichida, qoldiq qatorini lockForUpdate() bilan qulflab bajarish; ikkinchi so‘rov birinchisi tugashini kutadi va yangi qiymatni (1) ko‘radi.

O‘quv maqsadlari

  • Tushuntirish — biznes-logika nima uchun controller yoki modelda emas, servis qatlamida yashashini
  • Qo‘llash — DB::transaction() ni bir nechta jadvalga yozadigan biznes-amallarda
  • Farqlash — pessimistik (lockForUpdate) va optimistik (version, shartli UPDATE) qulflashni
  • Aniqlash — poyga holati (race condition) va deadlock xavfi bor kod bo‘laklarini
  • Himoyalash — invariantlarni uch qatlamda: servis tekshiruvi, domen istisnosi va baza CHECK cheklovi
  • Loyihalash — buyurtma → rezerv → hisob-faktura → jo‘natish hujjat oqimini va ombor harakatlari jurnalini
  • Yozish — OrderStatus enumi asosida holat mashinasini va taqiqlangan o‘tishlarni rad etishni
  • Hisoblash — QQS va jami summani butun tiyinda, float siz
Ma’ruza rejasi
  1. Biznes-logika qayerda yashaydi
  2. Tranzaksiyalar: hammasi yoki hech narsa
  3. Parallel so‘rovlar va qulflash
  4. Invariantlar va domen istisnolari
  5. Hujjat oqimi va holat mashinasi

1. Biznes-logika qayerda yashaydi

Semiz controller · servis qatlami · use-case metodlari · qayta ishlatish

Biznes-logika (domen logikasi) — dasturning texnik qismi emas, korxonaning qoidalari: buyurtmani qachon tasdiqlash mumkin, qancha rezerv qilish mumkin, QQS qanday hisoblanadi, bekor qilinganda nima qaytariladi. Bu qoidalar HTTP, Blade yoki ma’lumotlar bazasi turiga bog‘liq emas: xuddi shu “rezerv” qoidasi veb-formadan, REST API dan, Excel importdan va navbatdagi fon vazifasidan chaqirilishi mumkin. Shuning uchun uni bir joyga — servis qatlamiga (app/Services) yig‘amiz. 2-mavzuda qatlamli arxitektura va OrderService::create misolini ko‘rgan edik; bugun servisni to‘liq biznes-jarayon bilan to‘ldiramiz.

Eng keng tarqalgan xato — semiz controller (fat controller): OrderController::reserve() ichida qoldiqni o‘qish, tekshirish, stocks ni yangilash, harakat yozish va holatni o‘zgartirish. Bunday kodni API controllerida takrorlashga to‘g‘ri keladi, testlash uchun HTTP so‘rov yasash kerak bo‘ladi, bitta qoida o‘zgarsa uni bir necha joyda topib tuzatish lozim. Ikkinchi xato — hamma narsani Eloquent modeliga tiqish (“semiz model”): Order modeli Stock, Invoice, StockMovement ni boshqara boshlaydi va 2000 qatorli sinfga aylanadi.

Servis qatlamining qoidalari oddiy. Birinchidan, bitta public metod — bitta biznes-amal (use-case): confirm(), reserve(), invoice(), ship(), cancel(). Ikkinchidan, servis HTTP ni bilmaydi: Request, session(), redirect() ishlatmaydi — kirishda model yoki DTO (OrderData), chiqishda model yoki istisno. Uchinchidan, tranzaksiya chegarasi servisda: bir amal ichidagi barcha yozuvlar yoki to‘liq saqlanadi, yoki umuman saqlanmaydi. To‘rtinchidan, servislar bir-biriga konstruktor orqali ulanadi: OrderService o‘zi stocks jadvaliga yozmaydi, balki StockService ni chaqiradi.

Laravel servis konteyneri (service container) bog‘liqliklarni avtomatik yaratadi: controller metodida OrderService $orders parametrini yozsangiz, Laravel OrderService ni, uning konstruktoridagi StockService va InvoiceService ni o‘zi yaratib beradi (autowiring). Interfeys yoki maxsus sozlama kerak bo‘lmasa, AppServiceProvider da ro‘yxatdan o‘tkazish shart emas. Natijada controller uch-to‘rt qatorga tushadi: kirish ma’lumotini oladi, servisni chaqiradi, javob qaytaradi. Domen xatolari (masalan, qoldiq yetmasligi) istisno sifatida yuqoriga ko‘tariladi va bitta joyda — bootstrap/app.php dagi withExceptions() da — foydalanuvchiga tushunarli xabarga aylantiriladi.

QAYERGA YOZAMIZ?

Semiz controller va servis qatlami

Noto‘g‘ri: hamma narsa controllerda
  • OrderController::reserve() qoldiqni o‘qiydi, tekshiradi, stocks ni yangilaydi
  • API controllerida xuddi shu kod nusxalanadi
  • Importda yoki fon vazifasida bu qoidani chaqirib bo‘lmaydi
  • Test uchun HTTP so‘rov, sessiya, CSRF kerak
To‘g‘ri: yupqa controller + servis
  • Controller: kirish → $orders->reserve($order) → javob
  • Qoida bitta joyda: OrderService, StockService
  • Web, API, import, job, artisan — bir xil metodni chaqiradi
  • Servisni to‘g‘ridan-to‘g‘ri unit/feature testda chaqirish mumkin
Model — ma’lumot va kichik qoidalar (accessor, cast, munosabatlar); servis — bir nechta modelni o‘zgartiradigan jarayon.
YUPQA CONTROLLER

Controller faqat chaqiradi va javob beradi

use App\Models\Order;
use App\Services\OrderService;
use Illuminate\Http\RedirectResponse;

final class OrderController extends Controller
{
    public function reserve(
        Order $order,
        OrderService $orders,
    ): RedirectResponse {
        $orders->reserve($order);

        return redirect()
            ->route('orders.show', $order)
            ->with('status', 'Buyurtma rezerv qilindi');
    }
}
▶ Natija
POST /orders/124/reserve
→ 302 Found, Location: /orders/124
→ flash: “Buyurtma rezerv qilindi”
  • Order $order — route model binding: {order} parametridan model topiladi
  • OrderService $orders — servis konteyneri uni bog‘liqliklari bilan yaratadi
  • $orders->reserve() — barcha qoida va tranzaksiya — servis ichida
  • Qoldiq yetmasa? — servis istisno tashlaydi; uni global handler xabarga aylantiradi (4-bo‘lim)
APP/SERVICES

OrderService — use-case metodlari

namespace App\Services;

final class OrderService
{
    public function __construct(
        private readonly StockService $stock,
        private readonly InvoiceService $invoices,
    ) {}

    public function create(OrderData $data): Order { /* 2-mavzu */ }
    public function confirm(Order $order): Order { /* ... */ }
    public function reserve(Order $order): Order { /* ... */ }
    public function invoice(Order $order): Invoice { /* ... */ }
    public function ship(Order $order): Order { /* ... */ }
    public function cancel(Order $order): Order { /* ... */ }
}
▶ Natija
app/Services/OrderService.php    — jarayonni boshqaradi
app/Services/StockService.php    — stocks + stock_movements
app/Services/InvoiceService.php  — invoices, QQS
  • private readonly — PHP 8.1 konstruktor xossalari: bog‘liqlik bir marta beriladi
  • Bitta metod — bitta amal — reserve() faqat rezerv qiladi, invoice() faqat hisob-faktura yaratadi
  • StockService — qoldiqni faqat u o‘zgartiradi — invariantlar bir joyda
  • Qaytariladigan qiymat — yangilangan model; xato bo‘lsa — domen istisnosi
QOIDALAR

Yaxshi servisning 5 belgisi

HTTP ni bilmaydiRequest, session(), redirect() yo‘q — kirish: model yoki DTO.
Tranzaksiya chegarasiBir amalning barcha yozuvlari bitta DB::transaction ichida.
Domen istisnolariXato holat — InsufficientStockException, false yoki null emas.
Holatsiz (stateless)Xossalarda faqat bog‘liqliklar; so‘rov ma’lumoti metod parametrida.
Qayta ishlatiladiWeb, API, import, job va testdan bir xil chaqiriladi.
O‘zingizni tekshiring
Nima uchun rezerv qoidasi controllerda emas, servisda yozilishi kerak?

Qoida web, API, import va fon vazifalaridan bir xil chaqiriladi; controllerda bo‘lsa, har birida nusxalanadi va testlash qiyinlashadi.

Servis metodiga nima uchun Request obyektini uzatmaymiz?

Servis HTTP ga bog‘lanmasligi kerak: uni job, artisan buyrug‘i yoki testdan chaqirganda Request bo‘lmaydi. Kirish — model yoki DTO.

OrderService qoldiqni to‘g‘ridan-to‘g‘ri yangilashi kerakmi?

Yo‘q. Qoldiqni faqat StockService o‘zgartiradi, OrderService uni chaqiradi — shunda invariantlar va jurnal yozish bitta joyda qoladi.

2. Tranzaksiyalar: hammasi yoki hech narsa

ACID · DB::transaction · qayta urinish · commit dan keyingi hodisalar

Tranzaksiya — ma’lumotlar bazasidagi bir nechta o‘zgarishni bitta bo‘linmas birlik sifatida bajarish. Buyurtmani rezerv qilish kamida uch jadvalga yozadi: stocks (har bir mahsulot uchun reserved oshadi), stock_movements (har bir harakat) va orders (holat reserved ga o‘tadi). Agar uchinchi mahsulotda qoldiq yetmasa, birinchi ikkitasining rezervi ham bekor bo‘lishi kerak — aks holda omborda “osilib qolgan” rezerv paydo bo‘ladi va uni hech kim jo‘natmaydi. Tranzaksiya buni kafolatlaydi: xato bo‘lsa, ROLLBACK barcha o‘zgarishlarni qaytaradi.

Tranzaksiya xossalari ACID qisqartmasi bilan ataladi. Atomarlik (atomicity) — hammasi yoki hech narsa. Izchillik (consistency) — tranzaksiya bazani bir to‘g‘ri holatdan boshqa to‘g‘ri holatga o‘tkazadi, cheklovlar (CHECK, FOREIGN KEY, UNIQUE) buzilmaydi. Izolyatsiya (isolation) — parallel tranzaksiyalar bir-birining yarim tayyor o‘zgarishlarini ko‘rmaydi; PostgreSQL da standart daraja READ COMMITTED. Chidamlilik (durability) — COMMIT dan keyin ma’lumot server o‘chib qolsa ham saqlanadi.

Laravel da asosiy usul — DB::transaction(function () { ... }). Closure muvaffaqiyatli tugasa, COMMIT bajariladi va closure qaytargan qiymat natija bo‘ladi; ichida istalgan istisno tashlansa, ROLLBACK bajariladi va istisno yuqoriga qayta tashlanadi. Ikkinchi argument attempts — deadlock yoki boshqa parallellik xatosida necha marta qayta urinish. Ichma-ich chaqirilgan DB::transaction yangi tranzaksiya ochmaydi, balki savepoint yaratadi — shuning uchun OrderService::reserve() ichida StockService ning tranzaksiyali metodlarini bemalol chaqirish mumkin. Qo‘lda boshqarish (DB::beginTransaction(), DB::commit(), DB::rollBack()) ham bor, lekin catch da rollBack() ni unutish oson, shuning uchun closure uslubi tavsiya etiladi.

Uch tuzoqdan saqlaning. Istisnoni yutish: closure ichida try/catch qilib xatoni faqat log ga yozsangiz, Laravel ROLLBACK qilmaydi — yarim tayyor ma’lumot COMMIT bo‘ladi. Tashqi chaqiruvlar: tranzaksiya ichida HTTP so‘rov (to‘lov tizimi, cbu.uz), e-mail yoki SMS yubormang — tashqi tizim sekin javob bersa, qulflar uzoq ushlanadi, ROLLBACK bo‘lsa esa yuborilgan SMS qaytmaydi. Commit dan oldingi hodisalar: OrderConfirmed hodisasi yoki navbatdagi job tranzaksiya ichida jo‘natilsa, tinglovchi hali COMMIT bo‘lmagan buyurtmani o‘qiy olmaydi. Buning uchun hodisa ShouldDispatchAfterCommit interfeysini amalga oshiradi, job esa ->afterCommit() bilan jo‘natiladi.

ACID

Tranzaksiya kafolatlari

Tranzaksiya — bir nechta SQL buyrug‘ini bitta bo‘linmas birlikka birlashtirish: BEGIN … COMMIT yoki ROLLBACK.

Atomarlik
Rezerv, jurnal va holat — uchalasi ham saqlanadi yoki birortasi ham saqlanmaydi.
Izchillik
CHECK, FOREIGN KEY, UNIQUE cheklovlari buzilgan holat COMMIT bo‘lmaydi.
Izolyatsiya
Parallel so‘rov yarim tayyor o‘zgarishni ko‘rmaydi (PostgreSQL: READ COMMITTED).
Chidamlilik
COMMIT dan keyin ma’lumot disk/WAL da — server qayta ishga tushsa ham saqlanadi.
Izolyatsiya avtomatik ravishda “poyga”dan himoya qilmaydi: READ COMMITTED da ikki tranzaksiya bir xil qiymatni o‘qiy oladi (3-bo‘lim).
SOF PHP

ROLLBACK g‘oyasi: nusxa va qaytarish

$stock = ['UN-001' => 10, 'UN-002' => 3];
function transaction(array &$db, callable $work): void
{
    $backup = $db;                       // BEGIN
    try {
        $work($db);                      // COMMIT
    } catch (DomainException $e) {
        $db = $backup;                   // ROLLBACK
    }
}
transaction($stock, function (array &$db) {
    $db['UN-001'] -= 4;
    if ($db['UN-002'] < 5) {
        throw new DomainException('UN-002 yetarli emas');
    }
    $db['UN-002'] -= 5;
});
echo json_encode($stock);
▶ Natija
{"UN-001":10,"UN-002":3}
  • $backup = $db — baza ham ichki tarzda eski holatni saqlaydi (MVCC)
  • $db['UN-001'] -= 4 — birinchi o‘zgarish bajarildi…
  • throw — …lekin ikkinchi qadam xato — hammasi bekor
  • Natija — UN-001 yana 10: yarim tayyor holat qolmadi
LARAVEL

DB::transaction — closure va qayta urinish

use Illuminate\Support\Facades\DB;

public function confirm(Order $order): Order
{
    $order = DB::transaction(function () use ($order) {
        $order = Order::lockForUpdate()->findOrFail($order->id);
        $this->moveTo($order, OrderStatus::Confirmed);
        $order->update(['total' => $order->items()->sum('total')]);

        return $order;                   // COMMIT
    }, attempts: 3);                     // deadlock — qayta urinish

    OrderConfirmed::dispatch($order);    // COMMIT dan keyin
    return $order;
}
▶ Natija
BEGIN
select * from "orders" where "id" = 124 limit 1 for update
update "orders" set "status" = 'confirmed', ... where "id" = 124
update "orders" set "total" = 2650000.00, ... where "id" = 124
COMMIT
  • DB::transaction(fn) — istisno bo‘lsa — ROLLBACK va istisno qayta tashlanadi
  • attempts: 3 — faqat deadlock/parallellik xatosida qayta bajaradi
  • return $order — closure qaytargan qiymat transaction() natijasi
  • dispatch tashqarida — yoki hodisa ShouldDispatchAfterCommit ni amalga oshiradi
TUZOQLAR

Tranzaksiyadagi keng tarqalgan xatolar

XatoOqibatTo‘g‘ri yo‘l
Closure ichida istisnoni yutish (catch + log)ROLLBACK yo‘q, yarim ma’lumot saqlanadiLog yozing va throw $e; qiling
Tranzaksiya ichida HTTP/SMS/e-mailQulflar uzoq ushlanadi, ROLLBACK SMS ni qaytarmaydiTashqi chaqiruv — COMMIT dan keyin yoki navbatda
Hodisa/job commit dan oldinTinglovchi hali yo‘q buyurtmani o‘qiydiShouldDispatchAfterCommit, ->afterCommit()
Har bir yozuv alohida tranzaksiyadaAtomarlik yo‘qBitta use-case — bitta tashqi tranzaksiya
Juda uzun tranzaksiya (import 10 000 qator)Qulflar, deadlock, xotiraBo‘laklab (chunk) qayta ishlash
Ichma-ich DB::transaction savepoint yaratadi; tashqi ROLLBACK ichkisini ham bekor qiladi.
O‘zingizni tekshiring
DB::transaction closure ichida istisno tashlansa, nima bo‘ladi?

ROLLBACK bajariladi va istisno yuqoriga qayta tashlanadi — chaqiruvchi uni ko‘radi.

attempts: 3 qaysi holatda qayta urinadi?

Deadlock yoki boshqa parallellik (concurrency) xatosida; oddiy biznes-istisnoda qayta urinmaydi.

Nima uchun SMS yuborishni tranzaksiya ichida qilmaslik kerak?

SMS ni ROLLBACK bilan qaytarib bo‘lmaydi, tashqi xizmat sekin bo‘lsa qulflar uzoq ushlanadi. Uni COMMIT dan keyin yoki navbat orqali yuboring.

3. Parallel so‘rovlar va qulflash

Poyga holati · lockForUpdate · shartli UPDATE · optimistik qulf · deadlock

Poyga holati (race condition) — natija so‘rovlarning bajarilish tartibiga bog‘liq bo‘lib qoladigan vaziyat. Isinish savolidagi misol: menejer A va menejer B bir vaqtda stocks qatorini o‘qiydi, ikkalasi ham mavjud = 5 ni ko‘radi, ikkalasi ham tekshiruvdan o‘tadi va reserved ni oshiradi. Har bir so‘rov o‘z-o‘zidan to‘g‘ri, lekin birgalikda reserved = 7 — mavjud qoldiq manfiy. Bu xato lokal kompyuterda deyarli ko‘rinmaydi (bitta foydalanuvchi), lekin ishlab chiqarishda — aksiyalar kuni, 20 ta menejer ishlaganda — albatta uchraydi. Tranzaksiyaning o‘zi bundan himoya qilmaydi: READ COMMITTED da ikkala tranzaksiya ham eski qiymatni o‘qiy oladi.

Pessimistik qulflash — o‘qishda qatorni qulflash. Laravel da ->lockForUpdate() so‘rovga FOR UPDATE qo‘shadi: qatorni o‘qigan tranzaksiya COMMIT yoki ROLLBACK qilguncha boshqa tranzaksiyalar shu qatorni o‘zgartira olmaydi va FOR UPDATE bilan o‘qiy olmaydi — ular kutadi. Shunda menejer B birinchisi tugagach yangi qiymatni (mavjud = 1) ko‘radi va to‘g‘ri rad etiladi. Muhim: qulf faqat tranzaksiya ichida ma’noga ega — tranzaksiyasiz lockForUpdate() so‘rov tugashi bilan qulfni bo‘shatadi. ->sharedLock() (FOR SHARE) esa o‘qishga ruxsat beradi, faqat o‘zgartirishni to‘xtatadi.

Ikkinchi usul — atomar shartli UPDATE: tekshiruv va o‘zgartirishni bitta SQL buyrug‘iga birlashtirish: UPDATE stocks SET reserved = reserved + 4 WHERE id = ? AND quantity - reserved >= 4. Baza bu buyruqni qatorni qulflab bajaradi, increment() esa yangilangan qatorlar sonini qaytaradi: 0 bo‘lsa — qoldiq yetmagan. Optimistik qulflash esa qulfsiz o‘qiydi, lekin yozishda version ustuni o‘zgarmaganini tekshiradi: WHERE id = ? AND version = 7. Laravel da tayyor optimistik qulf yo‘q — uni shu kabi shart bilan o‘zingiz yozasiz. Optimistik usul to‘qnashuv kam bo‘lganda (masalan, mahsulot kartochkasini tahrirlash) qulay, ombor qoldig‘i kabi “issiq” qatorlar uchun esa pessimistik qulf yoki shartli UPDATE ishonchliroq.

Deadlock (o‘zaro bloklanish) — ikki tranzaksiya bir-birining qulfini kutib qolishi: A avval UN-001 ni, keyin UN-002 ni qulflaydi, B esa aksincha. PostgreSQL buni aniqlab, tranzaksiyalardan birini deadlock detected (SQLSTATE 40P01) xatosi bilan to‘xtatadi. Oldini olishning oddiy qoidasi — qulflarni har doim bir xil tartibda olish: buyurtma qatorlarini product_id bo‘yicha saralab, keyin qulflash. Qo‘shimcha himoya — DB::transaction(..., attempts: 3): Laravel deadlock xatosini taniydi va tranzaksiyani boshidan qayta bajaradi. Shuningdek, tranzaksiyani qisqa saqlang: avval hisob-kitob va validatsiya, keyin qisqa tranzaksiyada qulflash va yozish.

SOF PHP

Qulfsiz rezerv: ikki so‘rov — manfiy qoldiq

$stock = ['quantity' => 5, 'reserved' => 0];

// Ikki menejer bir vaqtda o‘qiydi (qulf yo‘q)
$a = $stock['quantity'] - $stock['reserved'];   // A ko‘radi: 5
$b = $stock['quantity'] - $stock['reserved'];   // B ko‘radi: 5

if ($a >= 4) {
    $stock['reserved'] += 4;                    // A rezerv qiladi
}
if ($b >= 3) {
    $stock['reserved'] += 3;                    // B ham!
}
echo "reserved={$stock['reserved']}, mavjud=",
    $stock['quantity'] - $stock['reserved'];
▶ Natija
reserved=7, mavjud=-2
  • $a va $b — ikkala so‘rov ham COMMIT dan oldingi bir xil qiymatni o‘qidi
  • if ($b >= 3) — tekshiruv eskirgan ma’lumotga asoslangan
  • mavjud=-2 — invariant buzildi: 2 dona “havodagi” tovar sotildi
PESSIMISTIK QULF

lockForUpdate — ikkinchi so‘rov kutadi

DB::transaction(function () use ($warehouseId, $productId, $qty) {
    $stock = Stock::where('warehouse_id', $warehouseId)
        ->where('product_id', $productId)
        ->lockForUpdate()                // SELECT ... FOR UPDATE
        ->firstOrFail();

    // B shu yerda A ning COMMIT ini kutib turadi
    $available = $stock->quantity - $stock->reserved;
    if ($available < $qty) {
        throw new InsufficientStockException(
            $productId, $qty, $available);
    }
    $stock->increment('reserved', $qty);
});
▶ Natija
A: select * from "stocks" where ... limit 1 for update   → 5
B: select ... for update                               → kutadi…
A: update "stocks" set "reserved" = "reserved" + 4 ...; COMMIT
B:                                                      → 1
B: InsufficientStockException → ROLLBACK
  • lockForUpdate() — qator COMMIT/ROLLBACK gacha boshqalar uchun yopiq
  • DB::transaction — qulf faqat tranzaksiya ichida ishlaydi
  • increment() — reserved = reserved + ? — baza tomonida hisoblanadi
  • sharedLock() — FOR SHARE: o‘qishga ruxsat, o‘zgartirishga yo‘q
QULFSIZ USULLAR

Shartli UPDATE va optimistik qulf

// 1) Tekshiruv va o‘zgartirish — bitta atomar UPDATE
$affected = Stock::query()
    ->where('warehouse_id', $warehouseId)
    ->where('product_id', $productId)
    ->whereRaw('quantity - reserved >= ?', [$qty])
    ->increment('reserved', $qty);

if ($affected === 0) {
    throw new InsufficientStockException($productId, $qty);
}

// 2) Optimistik qulf: `version` ustuni (qo‘shsangiz)
$ok = Stock::whereKey($stock->id)
    ->where('version', $stock->version)
    ->update(['reserved' => $stock->reserved + $qty,
              'version' => $stock->version + 1]);
// $ok === 0 — kimdir oldinroq yozgan: qayta o‘qing
▶ Natija
update "stocks" set "reserved" = "reserved" + 4
  where "warehouse_id" = 1 and "product_id" = 7
  and quantity - reserved >= 4
→ 1 qator (muvaffaqiyat) yoki 0 qator (yetarli emas)
  • whereRaw(..., [$qty]) — qiymat binding orqali — SQL injection yo‘q
  • increment() → int — Query Builder yangilangan qatorlar sonini qaytaradi
  • version — Laravel da tayyor optimistik qulf yo‘q — shart bilan yoziladi
  • Qachon qaysi? — issiq qator (qoldiq) — pessimistik/shartli; kam to‘qnashuv — optimistik
DEADLOCK

Qulflar tartibi

Noto‘g‘ri: tasodifiy tartib
  • A: UN-001 ni qulfladi, UN-002 ni kutmoqda
  • B: UN-002 ni qulfladi, UN-001 ni kutmoqda
  • PostgreSQL: deadlock detected (40P01) — biri to‘xtatiladi
  • Foydalanuvchi tasodifiy “500” xatosini ko‘radi
To‘g‘ri: doim bir xil tartib
  • Qatorlar product_id bo‘yicha saralanadi: orderBy('product_id')
  • A va B ikkalasi ham avval UN-001 ni so‘raydi — B shunchaki kutadi
  • attempts: 3 — kamdan-kam deadlockda avtomatik qayta urinish
  • Tranzaksiya qisqa: hisob-kitob oldin, qulf va yozish oxirida
Qoida: bir nechta qatorni qulflaydigan har bir kod qulflarni bitta, hujjatlashtirilgan tartibda oladi.
O‘zingizni tekshiring
Nima uchun lockForUpdate() tranzaksiyasiz foyda bermaydi?

Tranzaksiyasiz har bir so‘rov alohida COMMIT bo‘ladi va qulf SELECT tugashi bilan bo‘shaydi — keyingi UPDATE gacha himoya yo‘q.

Shartli UPDATE da qoldiq yetmaganini qanday bilamiz?

increment() yangilangan qatorlar sonini qaytaradi; 0 bo‘lsa, WHERE quantity - reserved >= ? sharti bajarilmagan.

Deadlockning oldini olishning eng oddiy qoidasi qaysi?

Qulflarni har doim bir xil tartibda olish, masalan, buyurtma qatorlarini product_id bo‘yicha saralab.

4. Invariantlar va domen istisnolari

Qoldiq qoidalari · domen istisnolari · pul tiyinda · CHECK cheklovi

Invariant — tizim har doim, har qanday amaldan keyin rioya qiladigan qoida. OmborPro ning asosiy invariantlari: quantity ≥ 0; 0 ≤ reserved ≤ quantity, ya’ni mavjud qoldiq (quantity − reserved) hech qachon manfiy emas; rezerv faqat mavjud ≥ miqdor bo‘lganda; jo‘natish (out) quantity va reserved ni birga kamaytiradi; har bir qoldiq o‘zgarishi stock_movements ga yoziladi; buyurtma jami summasi uning qatorlari yig‘indisiga teng. Invariantni “ba’zan” tekshirish yetarli emas — u har bir yozuvda tekshirilishi kerak, aks holda bitta noto‘g‘ri import yoki qo‘lda yozilgan SQL butun hisobotni buzadi.

Invariantlarni uch qatlamda himoyalaymiz. Birinchi — servis: StockService::reserve() qatorni qulflab, mavjud qoldiqni tekshiradi va yetmasa istisno tashlaydi. Ikkinchi — domen obyekti yoki model: available() kabi metod qoldiq formulasini bitta joyda saqlaydi. Uchinchi — ma’lumotlar bazasi: CHECK (reserved >= 0 AND reserved <= quantity) cheklovi. Baza cheklovi “oxirgi chegara”: servisni chetlab o‘tgan kod (seeder, tinker, qo‘lda SQL, keyingi dasturchining xatosi) ham invariantni buza olmaydi — PostgreSQL 23514 check violation xatosini qaytaradi. Laravel 12 migratsiyalarida CHECK uchun alohida fluent metod yo‘q, shuning uchun DB::statement() bilan yoziladi.

Qoida buzilganda servis false yoki null qaytarmaydi — domen istisnosi tashlaydi. Spetsifikatsiyadagi InsufficientStockException va InvalidStatusTransitionException PHP ning DomainException sinfidan meros oladi: bu “dastur xatosi emas, biznes-qoida rad etdi” degan ma’no. Istisno ichida kerakli kontekst saqlanadi (mahsulot, so‘ralgan va mavjud miqdor) — xabar foydalanuvchiga, kontekst esa log va testga kerak. Laravel 12 da istisnolar bootstrap/app.php dagi withExceptions() da bir marta sozlanadi: render() web uchun forma xatosiga, API uchun 422 JSON ga aylantiradi, dontReport() esa kutilgan biznes-rad etishlarni xatolar logiga yozmaydi.

Pul ham invariant manbai. float ikkilik kasr: 0.1 + 0.2 aniq 0.3 emas, 19.99 * 100 esa 1998.9999…, uni (int) ga aylantirsangiz 1998 tiyin chiqadi — bir tiyin yo‘qoldi. Minglab hisob-fakturada bu sezilarli farq va buxgalteriya bilan kelishmovchilik. Shuning uchun bazada decimal(14,2), PHP da esa butun tiyin (int) yoki 1-mavzudagi Money obyekti ishlatiladi. Eloquent decimal:2 cast qiymatni satr sifatida qaytaradi ('19.99') — uni satr bo‘yicha tiyinga aylantirib, barcha hisobni butun sonlarda bajaramiz; QQS ni esa aniq qoida bilan yaxlitlaymiz: intdiv($subtotal * 12 + 50, 100).

OMBORPRO

Qoldiq invariantlari

Har bir amaldan keyin quyidagilar rost bo‘lishi shart. Bittasi buzilsa — tranzaksiya ROLLBACK.

quantity ≥ 0Omborda manfiy tovar bo‘lmaydi.
0 ≤ reserved ≤ quantityRezerv bor tovardan oshmaydi: mavjud = quantity − reserved ≥ 0.
Rezerv shartireserve(n) faqat mavjud ≥ n bo‘lsa.
Jo‘natishout(n): quantity −= n, reserved −= n — birga.
JurnalHar bir o‘zgarish — bitta stock_movements yozuvi.
Jami summaorders.total = qatorlar total yig‘indisi.
SOF PHP

Invariantni qo‘riqlaydigan obyekt

final class StockRow
{
    public function __construct(public int $qty, public int $res) {}
    public function available(): int
    {
        return $this->qty - $this->res;
    }
    public function reserve(int $n): void
    {
        if ($n <= 0 || $n > $this->available()) {
            throw new DomainException("Mavjud: {$this->available()}");
        }
        $this->res += $n;
    }
}
$s = new StockRow(10, 7);            // 7 tasi allaqachon band
try { $s->reserve(4); }
catch (DomainException $e) { echo $e->getMessage(), ' / ', $s->res; }
▶ Natija
Mavjud: 3 / 7
  • available() — formula bitta joyda — hamma shu metodni chaqiradi
  • $n <= 0 — nol va manfiy miqdor ham qoida buzilishi
  • DomainException — biznes-rad etish; xabarda kontekst bor
  • Natija — 10 − 7 = 3 mavjud; 4 ta so‘ralganda rad etildi, res 7 bo‘lib qoldi
DOMEN ISTISNOLARI

Istisno va uni bitta joyda ko‘rsatish

// bootstrap/app.php
use App\Exceptions\InsufficientStockException;
use Illuminate\Foundation\Application;
use Illuminate\Foundation\Configuration\Exceptions;
use Illuminate\Http\Request;

return Application::configure(basePath: dirname(__DIR__))
    ->withExceptions(function (Exceptions $exceptions) {
        $exceptions->dontReport(InsufficientStockException::class);
        $exceptions->render(function (
            InsufficientStockException $e,
            Request $request,
        ) {
            return $request->expectsJson()
                ? response()->json(['message' => $e->getMessage()], 422)
                : back()->withErrors(['stock' => $e->getMessage()]);
        });
    })->create();
▶ Natija
Web: ← orqaga, @error('stock'): “Mahsulot #7: so‘ralgan 4, mavjud 1”
API: 422 {"message": "Mahsulot #7: so‘ralgan 4, mavjud 1"}
  • extends DomainException — InsufficientStockException — biznes-qoida rad etdi
  • render() — istisnoni web/API javobiga aylantiradi — controllerda try kerak emas
  • dontReport() — kutilgan rad etishlar xatolar logini to‘ldirmaydi
  • 422 — Unprocessable Content: so‘rov to‘g‘ri, lekin qoida bajarilmadi
SOF PHP

Pul: float emas, butun tiyin

function toTiyin(string $amount): int
{
    [$som, $frac] = explode('.', $amount . '.00');
    return (int) $som * 100 + (int) substr($frac . '0', 0, 2);
}

var_dump(0.1 + 0.2 == 0.3);
echo (int) (19.99 * 100), "\n";        // float: 1 tiyin yo‘qoldi
echo toTiyin('19.99'), "\n";            // satrdan — aniq
echo toTiyin('1250000.5'), "\n";
$vat = intdiv(toTiyin('19.99') * 3 * 12 + 50, 100);
echo $vat, " tiyin QQS\n";
▶ Natija
bool(false)
1998
1999
125000050
720 tiyin QQS
  • 19.99 * 100 — ikkilik kasr 1998.999… — (int) kesadi
  • toTiyin('19.99') — decimal:2 cast satr qaytaradi — satrdan aylantiramiz
  • intdiv(x * 12 + 50, 100) — QQS 12 %, yarmidan yuqoriga yaxlitlash, faqat butun sonlar
  • Manfiy summa? — bu soddalashtirilgan funksiya faqat musbat summalar uchun
BAZA — OXIRGI CHEGARA

CHECK cheklovi migratsiyada

public function up(): void
{
    DB::statement(<<<'SQL'
        ALTER TABLE stocks
        ADD CONSTRAINT stocks_quantity_chk CHECK (quantity >= 0),
        ADD CONSTRAINT stocks_reserved_chk
            CHECK (reserved >= 0 AND reserved <= quantity)
    SQL);
}

public function down(): void
{
    DB::statement('ALTER TABLE stocks
        DROP CONSTRAINT stocks_quantity_chk,
        DROP CONSTRAINT stocks_reserved_chk');
}
▶ Natija
php artisan tinker
> DB::update('update stocks set reserved = quantity + 1 where id = 1');
Illuminate\Database\QueryException  SQLSTATE[23514]: Check violation:
  new row for relation "stocks" violates check constraint "stocks_reserved_chk"
  • DB::statement() — Laravel 12 Blueprint da CHECK uchun fluent metod yo‘q
  • <<<'SQL' — nowdoc: satr ichida o‘zgaruvchi almashtirilmaydi
  • 23514 — servisni chetlab o‘tgan kod ham invariantni buza olmaydi
  • down() — migratsiya orqaga qaytariladigan bo‘lsin
O‘zingizni tekshiring
OmborPro da mavjud qoldiq qanday hisoblanadi va qaysi invariant uni himoyalaydi?

mavjud = quantity − reserved; invariant 0 ≤ reserved ≤ quantity uni hech qachon manfiy bo‘lishiga yo‘l qo‘ymaydi.

Nima uchun servis tekshiruvi bor bo‘lsa ham bazada CHECK cheklovi kerak?

Servisni chetlab o‘tadigan kod (seeder, tinker, qo‘lda SQL, boshqa dasturchi) ham bor; baza cheklovi oxirgi himoya chizig‘i.

(int) (19.99 * 100) nima uchun 1999 emas?

float ikkilik kasr: ko‘paytma 1998.999…, (int) esa kasr qismini kesadi — 1998. Pulni satr yoki butun tiyinda hisoblang.

5. Hujjat oqimi va holat mashinasi

Buyurtma → rezerv → hisob-faktura → jo‘natish · OrderStatus · ombor harakatlari jurnali

Korxona ilovasida ma’lumotlar ikki xil: ma’lumotnomalar (mahsulot, kontragent, ombor) va hujjatlar (buyurtma, hisob-faktura, to‘lov) — 3-mavzuda bu farqni ma’lumotlar modeli darajasida ko‘rgan edik. Hujjat hayotiy siklga ega va bir hujjat keyingisini tug‘diradi: hujjat oqimi (document flow). OmborPro da: menejer buyurtma yaratadi (draft), mijoz bilan kelishgach tasdiqlaydi (confirmed), tovar omborda band qilinadi (reserved), buxgalter hisob-faktura chiqaradi (invoiced), omborchi tovarni jo‘natadi (shipped). Har bir qadam aniq hujjatga va aniq ombor harakatiga bog‘langan — 1C yoki SAP da ham xuddi shu mantiq.

Hujjat holatlari holat mashinasi (state machine) bilan boshqariladi: holatlar to‘plami va ruxsat etilgan o‘tishlar ro‘yxati. Spetsifikatsiya bo‘yicha: draft → confirmed → reserved → invoiced → shipped; cancelled ga faqat draft, confirmed, reserved dan o‘tish mumkin, reserved dan bekor qilinganda rezerv bo‘shatiladi (release). Boshqa barcha o‘tishlar taqiqlangan: jo‘natilgan buyurtmani bekor qilib bo‘lmaydi (u uchun qaytarish hujjati kerak), draft dan to‘g‘ridan-to‘g‘ri invoiced ga sakrab bo‘lmaydi. Qoidalar PHP 8.1 enum ichida — App\Enums\OrderStatus::canTransitionTo() — saqlanadi, servis esa har bir o‘tishdan oldin shu metodni chaqiradi va rad etilsa InvalidStatusTransitionException tashlaydi.

Holat mashinasining foydasi: qoidalar bitta jadvalda va kodda bir xil, ularni testlash oson (har bir juftlik uchun bitta test), interfeys esa faqat ruxsat etilgan tugmalarni ko‘rsatadi. Keng tarqalgan xato — holatni if ($order->status == 'reserved') kabi satrlar bilan, kodning turli joylarida tekshirish. status ustuni OrderStatus::class ga cast qilinganda u enum obyekti, satr emas: === 'reserved' har doim false qaytaradi. To‘g‘ri yozuv — $order->status === OrderStatus::Reserved. Holatni o‘zgartirish ham tranzaksiya ichida va buyurtma qatori qulflangan holda bajariladi — ikki foydalanuvchi bir vaqtda “Tasdiqlash” va “Bekor qilish” ni bossa, ulardan biri albatta rad etiladi.

Ombor harakatlari jurnali (stock_movements) — qoldiqning “buxgalteriya daftari”. stocks jadvali joriy holatni saqlaydi, jurnal esa qanday qilib shu holatga kelinganini: in (kirim), reserve (rezerv), release (rezervni bo‘shatish), out (jo‘natish), adjust (inventarizatsiya tuzatishi). Har bir yozuvda hujjat (document_type, document_id — polimorf havola), foydalanuvchi va vaqt bor. Jurnal faqat qo‘shiladi (append-only): xato harakat o‘chirilmaydi, balki teskari harakat bilan tuzatiladi. Shu tufayli istalgan payt stocks ni jurnaldan qayta hisoblab, solishtirish (reconciliation) mumkin — amaliy mashg‘ulotda shunday SQL so‘rov yozamiz.

HUJJAT OQIMI

Buyurtmadan jo‘natishgacha

  1. Yaratish → draft — Menejer OrderService::create() — qatorlar va jami summa; qoldiq o‘zgarmaydi.
  2. Tasdiqlash → confirmed — Mijoz bilan kelishildi; narxlar qotiriladi, OrderConfirmed hodisasi.
  3. Rezerv → reserved — StockService::reserve() har bir qator uchun: reserved += n, jurnalga reserve.
  4. Hisob-faktura → invoiced — InvoiceService::createForOrder(): subtotal, QQS 12 %, jami; HF-2026-000045.
  5. Jo‘natish → shipped — StockService::ship(): quantity −= n, reserved −= n, jurnalga out.
  6. Bekor qilish → cancelled — Faqat draft/confirmed/reserved dan; reserved bo‘lsa — release.
Har bir qadam — OrderService ning bitta metodi va bitta tranzaksiya.
HARAKATLAR JURNALI

Harakat turi va qoldiqqa ta’siri

TurquantityreservedShart (invariant)
in — kirim+n—n > 0
reserve — rezerv—+nquantity − reserved ≥ n
release — bo‘shatish—−nreserved ≥ n
out — jo‘natish−n−nreserved ≥ n (avval rezerv qilingan)
adjust — tuzatish±n—natijada quantity ≥ reserved
Har bir qatorda: document_type/document_id (Order, Invoice…), user_id, created_at. Jurnal faqat qo‘shiladi — o‘chirilmaydi.
APP/ENUMS

OrderStatus: o‘tishlar qoidasi enum ichida

// enum OrderStatus: string — Draft, Confirmed, Reserved,
//                            Invoiced, Shipped, Cancelled
public function canTransitionTo(self $to): bool
{
    return in_array($to, match ($this) {
        self::Draft => [self::Confirmed, self::Cancelled],
        self::Confirmed => [self::Reserved, self::Cancelled],
        self::Reserved => [self::Invoiced, self::Cancelled],
        self::Invoiced => [self::Shipped],
        self::Shipped, self::Cancelled => [],
    }, true);
}

public function isFinal(): bool
{
    return $this === self::Shipped || $this === self::Cancelled;
}
▶ Natija
OrderStatus::Draft->canTransitionTo(OrderStatus::Confirmed)  // true
OrderStatus::Shipped->canTransitionTo(OrderStatus::Cancelled) // false
OrderStatus::from('reserved')                                  // Reserved
  • match ($this) — barcha holatlar sanab o‘tilgan — yangi holat qo‘shilsa, PHP UnhandledMatchError beradi
  • in_array(..., true) — qat’iy taqqoslash: enum obyektlari bo‘yicha
  • isFinal() — yakuniy holatlar: tugmalarni yashirish, tahrirni taqiqlash
  • label(), color() — xuddi shu enumda — interfeys uchun yorliq (6-mavzu)
SOF PHP

O‘tishni tekshirish: ruxsat yoki istisno

const NEXT = [
    'draft' => ['confirmed', 'cancelled'],
    'confirmed' => ['reserved', 'cancelled'],
    'reserved' => ['invoiced', 'cancelled'],
    'invoiced' => ['shipped'],
];
function transition(string $from, string $to): string
{
    if (!in_array($to, NEXT[$from] ?? [], true)) {
        throw new DomainException("$from → $to taqiqlangan");
    }
    return $to;
}
$s = transition('draft', 'confirmed');
$s = transition($s, 'reserved');
echo $s, "\n";
try { transition('shipped', 'cancelled'); }
catch (DomainException $e) { echo $e->getMessage(); }
▶ Natija
reserved
shipped → cancelled taqiqlangan
  • NEXT — holat mashinasi — oddiy ma’lumot: holat → ruxsat etilgan holatlar
  • ?? [] — yakuniy holatlarda (shipped, cancelled) ro‘yxat bo‘sh
  • throw — servisda bu InvalidStatusTransitionException
  • Zanjir — draft → confirmed → reserved — har bir qadam alohida tekshiriladi

Bu o‘tish ruxsat etilganmi?

Har bir holat o‘tishini to‘g‘ri qutiga joylashtiring.

Ruxsat etilgan
  • draft → confirmed — Oqimning birinchi qadami.
  • confirmed → reserved — Tasdiqlangan buyurtma uchun tovar band qilinadi.
  • reserved → cancelled — Ruxsat etilgan, lekin rezerv release bilan bo‘shatiladi.
  • invoiced → shipped — Hisob-fakturadan keyin jo‘natish.
  • draft → cancelled — Qoralamani bekor qilish mumkin.
Taqiqlangan
  • shipped → cancelled — Jo‘natilgan tovar uchun qaytarish hujjati kerak, bekor qilish emas.
  • draft → invoiced — Tasdiq va rezervsiz hisob-faktura — oqimdan sakrash.
  • invoiced → cancelled — Hisob-faktura chiqqan; spetsifikatsiya bo‘yicha taqiqlangan.
  • reserved → confirmed — Orqaga qaytish yo‘q; kerak bo‘lsa — bekor qilib, qayta yaratish.
  • cancelled → draft — Yakuniy holatdan chiqish yo‘q.
O‘zingizni tekshiring
Qaysi holatlardan buyurtmani bekor qilish mumkin va reserved dan bekor qilinganda nima bo‘ladi?

draft, confirmed, reserved dan. reserved bo‘lsa, har bir qator uchun release harakati bilan rezerv bo‘shatiladi.

status enumga cast qilingan bo‘lsa, $order->status === 'reserved' nima qaytaradi?

Har doim false: status — OrderStatus enum obyekti, satr emas. === OrderStatus::Reserved yozish kerak.

Nima uchun ombor harakatlari jurnalidagi yozuvlar o‘chirilmaydi?

Jurnal qoldiqning tarixi va audit manbai; xato teskari harakat bilan tuzatiladi, shunda qoldiqni istalgan payt jurnaldan qayta hisoblash mumkin.

Asosiy xulosalar

Takrorlash savollari

Semiz controllerning asosiy zarari nima?

Qoida nusxalanadi (web, API, import), testlash qiyin, o‘zgartirish ko‘p joyda.

DB::transaction ichida istisno tashlansa?

ROLLBACK va istisno chaqiruvchiga qayta tashlanadi.

Ichma-ich DB::transaction nima yaratadi?

Savepoint — tashqi tranzaksiya ichida qisman qaytarish nuqtasi.

lockForUpdate() qanday SQL qo‘shadi?

SELECT ... FOR UPDATE — qator COMMIT gacha qulflanadi.

Deadlockni qanday kamaytirasiz?

Qulflarni bir xil tartibda olish, qisqa tranzaksiya, attempts bilan qayta urinish.

Mavjud qoldiq formulasi?

quantity − reserved, har doim ≥ 0.

shipped → cancelled mumkinmi?

Yo‘q — cancelled faqat draft, confirmed, reserved dan.

Hodisani COMMIT dan keyin qanday jo‘natish mumkin?

Hodisa ShouldDispatchAfterCommit ni amalga oshiradi yoki tranzaksiyadan keyin dispatch() qilinadi.

Chiqish chiptasi

  1. Ikki menejer bir vaqtda oxirgi tovarni rezerv qilsa, sizning kodingiz buni qaysi qatorda to‘xtatadi?
  2. reserve() metodida qaysi uchta jadvalga yoziladi va nima uchun ular bitta tranzaksiyada bo‘lishi kerak?
  3. Bugungi mavzuda sizga eng qiyin tuyulgan tushuncha qaysi: tranzaksiya, qulf yoki holat mashinasi?