Python kursi/Bazalar va ORM4/12-dars16 daqiqa

Mundarija (22)

23.4-dars: Tranzaksiyalar

23-QISM — BAZALAR VA ORM · 4-dars

1. Kirish va motivatsiya

Ba'zi amallar birga bajarilishi kerak — hammasi yoki hech biri. Pul o'tkazish: bir hisobdan ayirish va boshqasiga qo'shish — ikkalasi birga. Agar ayirish bajarilib, qo'shish xato bo'lsa — pul yo'qoladi! Yechim — tranzaksiya: bir necha amalni bir butun (atomik) qiladi — hammasi muvaffaqiyatli yoki hech biri.

Tranzaksiya — ma'lumot yaxlitligining kafolati: bir necha amal atomik (bo'linmas) bajariladi. Xato bo'lsa — hammasi bekor (rollback), baza oldingi holatga qaytadi. Bu 20.8, 21.4 dagi commitning chuqurroq tomoni. Bank, buyurtma, zaxira — har muhim amal tranzaksiyada.

Real vaziyat. Bir to'lov tizimi pul o'tkazardi: hisob A dan ayirish, hisob B ga qo'shish — ikki alohida amal. Bir kuni server ayirishdan keyin, qo'shishdan oldin o'chdi — pul yo'qoldi (A dan ketdi, B ga tushmadi). Jamoa tranzaksiyaga o'tdi: ikki amal bitta tranzaksiyada — server o'chsa, hammasi bekor (rollback). Endi pul hech qachon yo'qolmaydi. Tranzaksiya — ma'lumot yaxlitligining kafolati.

Bu darsda tranzaksiyalarni — BEGIN, COMMIT, ROLLBACK va ACIDni o'rganamiz.

Bu darsda:

Tranzaksiya nima (atomiklik)
BEGIN, COMMIT, ROLLBACK
Xato bo'lsa bekor qilish
ACID xususiyatlari
Context manager (with)
Izolyatsiya darajalari
Deadlock (o'lik nuqta)
Amaliy: pul o'tkazish

ℹ Misollarda sqlite3 bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. Tranzaksiya nima

Tranzaksiya — bir necha amalni bir butun (atomik):

BEGIN                              ← tranzaksiya boshi
    UPDATE ... (A dan ayir)
    UPDATE ... (B ga qo'sh)
COMMIT                             ← hammasi saqlanadi

Tranzaksiya — bir necha amal birga bajariladi: hammasi muvaffaqiyatli (COMMIT) yoki hech biri (ROLLBACK). "Hammasi yoki hech biri" (all-or-nothing) — atomiklik. Bu ma'lumot yaxlitligining kafolati.

2.2. `BEGIN`, `COMMIT`, `ROLLBACK`

Tranzaksiya buyruqlari:

python

conn.execute("BEGIN")                     # tranzaksiya boshi
conn.execute("UPDATE hisob SET balans = balans - 30 WHERE ism = 'Ali'")
conn.execute("UPDATE hisob SET balans = balans + 30 WHERE ism = 'Vali'")
conn.execute("COMMIT")                    # saqlash
# yoki xato bo'lsa:
conn.execute("ROLLBACK")                  # bekor qilish

Buyruq	Vazifa
`BEGIN`	Tranzaksiya boshi
`COMMIT`	Hammasini saqlash
`ROLLBACK`	Hammasini bekor

BEGIN — tranzaksiya boshi; COMMIT — amallarni doimiy saqlash; ROLLBACK — amallarni bekor (oldingi holatga qaytarish). COMMITgacha amallar vaqtincha — ROLLBACK ularni yo'qotadi.

2.3. Xato bo'lsa bekor qilish

Xato bo'lsa — ROLLBACK (baza toza qoladi):

python

try:
    conn.execute("BEGIN")
    conn.execute("UPDATE ...")            # amal 1
    conn.execute("UPDATE ...")            # amal 2 (xato bo'lsa)
    conn.execute("COMMIT")
except Exception:
    conn.execute("ROLLBACK")              # bekor

Xato holatda ROLLBACK — tranzaksiya bekor, baza oldingi holatga qaytadi (yarim bajarilgan amal qolmaydi). Bu yaxlitlik: "yarim ish" yo'q. Pul o'tkazishda xato — hech narsa o'zgarmaydi (pul yo'qolmaydi).

2.4. ACID xususiyatlari

Tranzaksiya ACID kafolatini beradi:

Harf	Xususiyat	Ma'no
A	Atomiklik	Hammasi yoki hech biri
C	Izchillik	Baza qoidalari saqlanadi
I	Izolyatsiya	Tranzaksiyalar bir-biriga xalaqit qilmaydi
D	Barqarorlik	`COMMIT`dan keyin doimiy

ACID — tranzaksiyaning to'rt kafolati: Atomiklik (hammasi/hech biri), Izchillik (baza yaxlitligi), Izolyatsiya (parallel tranzaksiyalar mustaqil), Barqarorlik (COMMITdan keyin server o'chsa ham saqlanadi). Bu relyatsion bazaning asosiy kuchi.

2.5. Context manager (`with`)

Python'da with conn — avtomatik COMMIT/ROLLBACK:

python

with conn:                                # tranzaksiya
    conn.execute("UPDATE ...")
    conn.execute("UPDATE ...")
    # xato yo'q → avtomatik COMMIT
    # xato bor → avtomatik ROLLBACK

with conn: — Python'dagi tranzaksiya konteksti: blok muvaffaqiyatli tugasa avtomatik COMMIT, xato (istisno) bo'lsa avtomatik ROLLBACK. Bu qo'lda try/exceptdan toza. Django/SQLAlchemy'da ham (transaction.atomic(), session.begin()).

2.6. Izolyatsiya darajalari

Parallel tranzaksiyalar bir-birini qanday ko'radi (izolyatsiya):

Daraja	Muammo
Read Uncommitted	"Iflos o'qish" (commit qilinmagan)
Read Committed	Faqat commit qilingan
Repeatable Read	Bir xil o'qish
Serializable	To'liq izolyatsiya

Izolyatsiya darajasi — parallel tranzaksiyalar bir-birini qanchalik ko'rishini belgilaydi. Yuqoriroq daraja — ko'proq izolyatsiya (xavfsizroq), lekin sekinroq. Ko'p baza standarti — Read Committed. Bu murakkab mavzu (ma'lumot bazasi kursi), lekin ACIDning "I" si.

2.7. Deadlock (o'lik nuqta)

Ikki tranzaksiya bir-birini kutsa — deadlock:

Tranzaksiya 1: A ni qulfladi, B ni kutadi
Tranzaksiya 2: B ni qulfladi, A ni kutadi
→ ikkalasi bir-birini kutadi (o'lik nuqta)

Deadlock — ikki tranzaksiya bir-birining resursini kutsa (halqa). Baza buni aniqlab, birini bekor qiladi (ROLLBACK). Oldini olish: resurslarni bir xil tartibda qulflash, tranzaksiyani qisqa qilish. Bu parallel tizimlarning muammosi.

2.8. Tranzaksiya — yaxlitlik kafolati

Tranzaksiyasiz	Tranzaksiya bilan
Yarim ish qolishi mumkin	Hammasi yoki hech biri
Ma'lumot buzilish xavfi	Yaxlitlik kafolati
Server o'chsa — noaniq	ACID (barqarorlik)

Tranzaksiya — bir necha bog'liq amal (pul o'tkazish, buyurtma) uchun majburiy. U ma'lumot yaxlitligini kafolatlaydi (yarim ish yo'q, server o'chsa ham). Har muhim, bog'liq amal — tranzaksiyada. Bu 20.8 commitning to'liq ma'nosi.

3. Tez ma'lumotnoma

python

# qo'lda:
try:
    conn.execute("BEGIN")
    conn.execute("UPDATE hisob SET balans = balans - 30 WHERE ism = 'Ali'")
    conn.execute("UPDATE hisob SET balans = balans + 30 WHERE ism = 'Vali'")
    conn.execute("COMMIT")
except Exception:
    conn.execute("ROLLBACK")

# context manager (avtomatik):
with conn:
    conn.execute("UPDATE ...")   # xato → ROLLBACK, muvaffaqiyat → COMMIT

ACID

Atomiklik (hammasi/hech biri) · Izchillik · Izolyatsiya · Barqarorlik
BEGIN → COMMIT (saqlash) / ROLLBACK (bekor)

4. Batafsil misollar

Misollarda sqlite3 bilan sinaladi.

Misol 1 — `BEGIN`, `COMMIT`, `ROLLBACK`

python

"""BEGIN/COMMIT (saqlash); ROLLBACK (bekor); atomiklik (hammasi yoki hech biri)."""

import warnings
warnings.filterwarnings("ignore")

import sqlite3


def main() -> None:
    conn = sqlite3.connect(":memory:", isolation_level=None)
    conn.row_factory = sqlite3.Row
    cur = conn.cursor()
    cur.execute("CREATE TABLE hisob (id INTEGER PRIMARY KEY, ism TEXT, balans INTEGER)")
    cur.executemany("INSERT INTO hisob (ism, balans) VALUES (?, ?)", [("Ali", 100), ("Vali", 50)])

    def balans():
        return {r["ism"]: r["balans"] for r in cur.execute("SELECT ism, balans FROM hisob")}

    print("=== 1. Boshlang'ich balans ===")
    print(f"  {balans()}")

    print("\n=== 2. Tranzaksiya (COMMIT — pul o'tkazish) ===")
    cur.execute("BEGIN")
    cur.execute("UPDATE hisob SET balans = balans - 30 WHERE ism = 'Ali'")
    cur.execute("UPDATE hisob SET balans = balans + 30 WHERE ism = 'Vali'")
    cur.execute("COMMIT")
    print(f"  COMMIT dan keyin: {balans()}")

    print("\n=== 3. ROLLBACK (bekor qilish) ===")
    cur.execute("BEGIN")
    cur.execute("UPDATE hisob SET balans = balans - 1000 WHERE ism = 'Ali'")
    print(f"  ROLLBACK oldidan: {balans()}")
    cur.execute("ROLLBACK")
    print(f"  ROLLBACK dan keyin: {balans()} (bekor qilindi)")

    print("\n=== 4. Atomiklik ===")
    print("  COMMIT — hammasi saqlanadi; ROLLBACK — hammasi bekor")
    print("  ⭐ BEGIN → COMMIT (saqlash) yoki ROLLBACK (bekor)")

    conn.close()


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Boshlang'ich balans ===
  {'Ali': 100, 'Vali': 50}

=== 2. Tranzaksiya (COMMIT — pul o'tkazish) ===
  COMMIT dan keyin: {'Ali': 70, 'Vali': 80}

=== 3. ROLLBACK (bekor qilish) ===
  ROLLBACK oldidan: {'Ali': -930, 'Vali': 80}
  ROLLBACK dan keyin: {'Ali': 70, 'Vali': 80} (bekor qilindi)

=== 4. Atomiklik ===
  COMMIT — hammasi saqlanadi; ROLLBACK — hammasi bekor
  ⭐ BEGIN → COMMIT (saqlash) yoki ROLLBACK (bekor)

Nima ko'rsatdi: 2.1, 2.2, 2.3-bo'limlar.

Misol 2 — Xato bo'lsa bekor (atomiklik)

python

"""xato bo'lganda ROLLBACK; yarim ish qolmaydi; atomiklik kafolati; try/except."""

import warnings
warnings.filterwarnings("ignore")

import sqlite3


def main() -> None:
    conn = sqlite3.connect(":memory:", isolation_level=None)
    conn.row_factory = sqlite3.Row
    cur = conn.cursor()
    cur.execute("CREATE TABLE hisob (id INTEGER PRIMARY KEY, ism TEXT, balans INTEGER)")
    cur.executemany("INSERT INTO hisob (ism, balans) VALUES (?, ?)", [("Ali", 100), ("Vali", 50)])

    def balans():
        return {r["ism"]: r["balans"] for r in cur.execute("SELECT ism, balans FROM hisob")}

    def pul_otkaz(kimdan, kimga, miqdor):
        try:
            cur.execute("BEGIN")
            cur.execute("UPDATE hisob SET balans = balans - ? WHERE ism = ?", (miqdor, kimdan))
            joriy = cur.execute("SELECT balans FROM hisob WHERE ism = ?", (kimdan,)).fetchone()["balans"]
            if joriy < 0:
                raise ValueError("mablag' yetarli emas")
            cur.execute("UPDATE hisob SET balans = balans + ? WHERE ism = ?", (miqdor, kimga))
            cur.execute("COMMIT")
            return "muvaffaqiyatli"
        except ValueError as e:
            cur.execute("ROLLBACK")
            return f"bekor: {e}"

    print("=== 1. Boshlang'ich ===")
    print(f"  {balans()}")

    print("\n=== 2. Muvaffaqiyatli o'tkazish ===")
    print(f"  Ali->Vali 30: {pul_otkaz('Ali', 'Vali', 30)}")
    print(f"  balans: {balans()}")

    print("\n=== 3. ⚠️ Yetarsiz mablag' (ROLLBACK) ===")
    print(f"  Ali->Vali 1000: {pul_otkaz('Ali', 'Vali', 1000)}")
    print(f"  balans: {balans()} (o'zgarmadi)")

    print("\n=== 4. Atomiklik kafolati ===")
    print("  xato -> ROLLBACK -> yarim ish yo'q (pul yo'qolmaydi)")
    print("  ⭐ xato bo'lsa ROLLBACK — baza oldingi holatga qaytadi")

    conn.close()


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Boshlang'ich ===
  {'Ali': 100, 'Vali': 50}

=== 2. Muvaffaqiyatli o'tkazish ===
  Ali->Vali 30: muvaffaqiyatli
  balans: {'Ali': 70, 'Vali': 80}

=== 3. ⚠️ Yetarsiz mablag' (ROLLBACK) ===
  Ali->Vali 1000: bekor: mablag' yetarli emas
  balans: {'Ali': 70, 'Vali': 80} (o'zgarmadi)

=== 4. Atomiklik kafolati ===
  xato -> ROLLBACK -> yarim ish yo'q (pul yo'qolmaydi)
  ⭐ xato bo'lsa ROLLBACK — baza oldingi holatga qaytadi

Nima ko'rsatdi: 2.3, 2.4-bo'limlar.

Misol 3 — Context manager (`with`)

python

"""with conn — avtomatik COMMIT/ROLLBACK; xato -> rollback; muvaffaqiyat -> commit; toza kod."""

import warnings
warnings.filterwarnings("ignore")

import sqlite3


def main() -> None:
    conn = sqlite3.connect(":memory:")
    conn.row_factory = sqlite3.Row
    conn.execute("CREATE TABLE hisob (id INTEGER PRIMARY KEY, ism TEXT, balans INTEGER)")
    conn.executemany("INSERT INTO hisob (ism, balans) VALUES (?, ?)", [("Ali", 100), ("Vali", 50)])
    conn.commit()

    def balans():
        return {r["ism"]: r["balans"] for r in conn.execute("SELECT ism, balans FROM hisob")}

    print("=== 1. Boshlang'ich ===")
    print(f"  {balans()}")

    print("\n=== 2. with conn (muvaffaqiyat -> COMMIT) ===")
    with conn:
        conn.execute("UPDATE hisob SET balans = balans - 20 WHERE ism = 'Ali'")
        conn.execute("UPDATE hisob SET balans = balans + 20 WHERE ism = 'Vali'")
    print(f"  with dan keyin: {balans()}")

    print("\n=== 3. with conn (xato -> ROLLBACK) ===")
    try:
        with conn:
            conn.execute("UPDATE hisob SET balans = balans - 50 WHERE ism = 'Ali'")
            raise ValueError("kutilmagan xato")
    except ValueError:
        pass
    print(f"  xatodan keyin: {balans()} (rollback)")

    print("\n=== 4. Toza kod ===")
    print("  with conn — avtomatik COMMIT/ROLLBACK (try/except'siz)")
    print("  ⭐ with conn — Python tranzaksiya konteksti (avtomatik)")

    conn.close()


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Boshlang'ich ===
  {'Ali': 100, 'Vali': 50}

=== 2. with conn (muvaffaqiyat -> COMMIT) ===
  with dan keyin: {'Ali': 80, 'Vali': 70}

=== 3. with conn (xato -> ROLLBACK) ===
  xatodan keyin: {'Ali': 80, 'Vali': 70} (rollback)

=== 4. Toza kod ===
  with conn — avtomatik COMMIT/ROLLBACK (try/except'siz)
  ⭐ with conn — Python tranzaksiya konteksti (avtomatik)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — Amaliy: buyurtma tranzaksiyasi

Buyurtma yaratish — bir necha bog'liq amal (buyurtma yozuvi, zaxira kamaytirish) — tranzaksiyada bo'lishi kerak. Bu — real bog'liq amallarning yaxlitlik namunasi.

python

"""buyurtma tranzaksiyasi: buyurtma yozuvi + zaxira kamaytirish (birga); zaxira yetmasa ROLLBACK."""

import warnings
warnings.filterwarnings("ignore")

import sqlite3


def main() -> None:
    conn = sqlite3.connect(":memory:")
    conn.row_factory = sqlite3.Row
    conn.execute("CREATE TABLE mahsulot (id INTEGER PRIMARY KEY, nom TEXT, zaxira INTEGER)")
    conn.execute("CREATE TABLE buyurtma (id INTEGER PRIMARY KEY, mahsulot_id INTEGER, soni INTEGER)")
    conn.execute("INSERT INTO mahsulot (id, nom, zaxira) VALUES (1, 'Python kursi', 5)")
    conn.commit()

    def holat():
        z = conn.execute("SELECT zaxira FROM mahsulot WHERE id = 1").fetchone()["zaxira"]
        b = conn.execute("SELECT COUNT(*) c FROM buyurtma").fetchone()["c"]
        return f"zaxira={z}, buyurtmalar={b}"

    def buyurtma_yarat(mahsulot_id, soni):
        try:
            with conn:
                zaxira = conn.execute("SELECT zaxira FROM mahsulot WHERE id = ?", (mahsulot_id,)).fetchone()["zaxira"]
                if zaxira < soni:
                    raise ValueError("zaxira yetarli emas")
                conn.execute("INSERT INTO buyurtma (mahsulot_id, soni) VALUES (?, ?)", (mahsulot_id, soni))
                conn.execute("UPDATE mahsulot SET zaxira = zaxira - ? WHERE id = ?", (soni, mahsulot_id))
            return "buyurtma qabul qilindi"
        except ValueError as e:
            return f"rad etildi: {e}"

    print("=== 1. Boshlang'ich ===")
    print(f"  {holat()}")

    print("\n=== 2. Buyurtma (zaxira yetarli) ===")
    print(f"  3 dona: {buyurtma_yarat(1, 3)}")
    print(f"  {holat()}")

    print("\n=== 3. ⚠️ Buyurtma (zaxira yetmasa) ===")
    print(f"  10 dona: {buyurtma_yarat(1, 10)}")
    print(f"  {holat()} (o'zgarmadi — ROLLBACK)")

    print("\n=== 4. Yaxlitlik ===")
    print("  buyurtma + zaxira birga (tranzaksiya)")
    print(f"  {buyurtma_yarat(1, 2)}, {holat()}")
    print("  ⭐ bog'liq amallar (buyurtma+zaxira) — tranzaksiyada (yaxlitlik)")

    conn.close()


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text

=== 1. Boshlang'ich ===
  zaxira=5, buyurtmalar=0

=== 2. Buyurtma (zaxira yetarli) ===
  3 dona: buyurtma qabul qilindi
  zaxira=2, buyurtmalar=1

=== 3. ⚠️ Buyurtma (zaxira yetmasa) ===
  10 dona: rad etildi: zaxira yetarli emas
  zaxira=2, buyurtmalar=1 (o'zgarmadi — ROLLBACK)

=== 4. Yaxlitlik ===
  buyurtma + zaxira birga (tranzaksiya)
  buyurtma qabul qilindi, zaxira=0, buyurtmalar=2
  ⭐ bog'liq amallar (buyurtma+zaxira) — tranzaksiyada (yaxlitlik)

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr	To'g'risi
"Bog'liq amallar alohida"	Tranzaksiyada (birga)
"Xato — yarim ish qoladi"	ROLLBACK (hech biri)
"`COMMIT`siz saqlanadi"	`COMMIT` kerak
"Tranzaksiya sekin"	Yaxlitlik uchun zarur
"`with`siz qo'lda `try`"	`with conn` (toza)
"ACID keraksiz"	Ma'lumot yaxlitligi
"Deadlock bo'lmaydi"	Parallel tranzaksiyada mumkin
"Har `SELECT` tranzaksiya"	Faqat bog'liq o'zgarish

6. Keng tarqalgan xatolar va yechimlari

1. Bog'liq amallar tranzaksiyasiz

python

conn.execute("UPDATE A ...")                  # ⚠️ alohida
conn.execute("UPDATE B ...")                  # A bajarilib B xato -> buziladi
# with conn: (ikkalasi birga)                  # ✅

2. Xato holatda ROLLBACK yo'q

python

try: conn.execute("BEGIN"); ...               # ⚠️ except'siz
except: conn.execute("ROLLBACK")               # ✅

3. COMMITni unutish

python

conn.execute("BEGIN"); conn.execute("UPDATE ...")   # ⚠️ commit yo'q
... conn.execute("COMMIT")                     # ✅

4. Uzun tranzaksiya (deadlock xavfi)

python

# BEGIN ... uzoq hisob ... COMMIT              # ⚠️ boshqalarni kutdiradi
# tranzaksiyani qisqa qiling                    # ✅

5. Tranzaksiyada tashqi amal (email)

python

with conn:
    conn.execute("UPDATE ..."); email_yubor()  # ⚠️ email rollback qilinmaydi
# ✅ tranzaksiyadan tashqarida (fon vazifasi)

6. with connda qo'lda commit

python

with conn:
    conn.execute("UPDATE ..."); conn.commit()  # ⚠️ ikki marta
with conn: conn.execute("UPDATE ...")          # ✅ avtomatik

7. Resurslarni turli tartibda qulflash (deadlock)

python

# T1: A->B, T2: B->A                            # ⚠️ deadlock
# bir xil tartib (A->B har doim)                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

20.8-dars (o'tilgan): commit — tranzaksiya asosi
21.4-dars (o'tilgan): migratsiya — tranzaksiyada
23.7-dars: SQLAlchemy — session tranzaksiyasi
21.15-dars (o'tilgan): signal — tranzaksiyada ehtiyot
29-qism: miqyoslash — taqsimlangan tranzaksiya

8. Eng yaxshi amaliyotlar

Bog'liq amallarni tranzaksiyada (pul, buyurtma).
Xato bo'lsa ROLLBACK (try/except yoki with).
with conn bilan avtomatik COMMIT/ROLLBACK.
Tranzaksiyani qisqa qiling (deadlock, qulf).
Tashqi amalni (email) tranzaksiyadan tashqarida.
Resurslarni bir xil tartibda qulflang (deadlock).
ACID kafolatiga tayaning (yaxlitlik).
Django/SQLAlchemy tranzaksiya vositalarini ishlating.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python

1.  # tranzaksiya nima?
2.  # BEGIN nima?
3.  # COMMIT nima?
4.  # ROLLBACK nima?
5.  # atomiklik nima?
6.  # xato bo'lsa?
7.  # ACID nima?
8.  # with conn nima?
9.  # izolyatsiya nima?
10. # deadlock nima?
11. # barqarorlik (D) nima?
12. # bog'liq amallar qayerda?

Javoblar

Bir necha amalni bir butun (atomik)
Tranzaksiya boshi
Hammasini saqlash
Hammasini bekor
Hammasi yoki hech biri
ROLLBACK (hech biri)
Atomiklik, Izchillik, Izolyatsiya, Barqarorlik
Avtomatik COMMIT/ROLLBACK
Parallel tranzaksiyalar mustaqilligi
Ikki tranzaksiya bir-birini kutsa
COMMITdan keyin doimiy (server o'chsa ham)
Tranzaksiyada (birga)

Vazifa 2: Xatolarni tuzating

python

1.  conn.execute("UPDATE A"); conn.execute("UPDATE B")   # tranzaksiya

2.  try: BEGIN; ...                        # except (ROLLBACK)

3.  BEGIN; UPDATE ...                      # COMMIT

4.  with conn: ...; conn.commit()          # avtomatik

5.  # T1: A->B, T2: B->A                    # tartib

Javoblar

python

1.  with conn:
        conn.execute("UPDATE A"); conn.execute("UPDATE B")

2.  except: conn.execute("ROLLBACK")

3.  BEGIN; UPDATE ...; COMMIT

4.  with conn: ...   # avtomatik commit

5.  # bir xil tartib (A->B har doim)

Vazifa 3: Pul o'tkazish

Bank tranzaksiyasi:

Ikki hisob, o'tkazish
Yetarsizlik tekshiruvi -> ROLLBACK
with conn
Har holatni test

Vazifa 4: Buyurtma

Buyurtma tranzaksiyasi:

Buyurtma + zaxira (birga)
Zaxira yetmasa -> bekor
Yaxlitlik
Test

Vazifa 5: ACID namoyish

Har xususiyat:

Atomiklik (rollback)
Izchillik (cheklov)
Barqarorlik (commit)
Namoyish

Vazifa 6: Context manager

with conn:

Muvaffaqiyat -> COMMIT
Xato -> ROLLBACK
Qo'lda try bilan taqqoslash
Test

Vazifa 7: O'ylash

Tranzaksiya — bir necha amalni atomik (bo'linmas) qiladi: "hammasi yoki hech biri". Bu ma'lumot yaxlitligini kafolatlaydi — yarim ish (pul A dan ketdi, B ga tushmadi) mumkin emas. "Atomiklik" (bo'linmaslik) tushunchasi nima uchun ma'lumot bazasida muhim, va bu "hammasi yoki hech biri" tamoyili boshqa qaysi joylarda uchraydi (masalan, deploy, git commit)?

Javob

Qisqa javob: Atomiklik — amal bo'linmas: to'liq bajariladi yoki umuman bajarilmaydi, "yarim" holat yo'q. Ma'lumot bazasida muhim, chunki bog'liq amallar (pul o'tkazish: ayir + qo'sh) yarim bajarilsa, ma'lumot buziladi (pul yo'qoladi). Atomiklik yarim holatni oldini oladi (xato -> hammasi bekor). "Hammasi yoki hech biri" tamoyili keng: git commit (butun commit yoki hech biri), deploy (to'liq deploy yoki rollback), fayl yozish (to'liq yoki eski qoladi). Bu tamoyil — tizim izchil holatda qolishini kafolatlaydi (yarim, buziq holat yo'q).

1. Atomiklik (bo'linmaslik)

Amal — bitta, bo'linmas birlik: to'liq yoki umuman. "Yarim" holat yo'q.

2. Nega ma'lumot bazasida muhim

Bog'liq amallar (pul: ayir+qo'sh) yarim bajarilsa — ma'lumot buziladi (pul yo'qoladi). Atomiklik buni oldini oladi.

3. "Hammasi yoki hech biri" boshqa joyda

Soha	Atomik
Baza	Tranzaksiya
Git	Commit (butun)
Deploy	To'liq yoki rollback
Fayl	To'liq yozish yoki eski

4. Nega bu tamoyil kuchli

Atomiklik tizimni izchil holatda saqlaydi: har doim to'liq holat (yarim, buziq emas). Xato bo'lsa — oldingi izchil holat (rollback).

5. Muhandislik saboqlari

Atomiklik — bo'linmaslik (hammasi/hech biri)
Yarim holat — ma'lumot buziladi
Atomik amal — izchil holat kafolati
Tamoyil keng (baza, git, deploy)

6. Xulosa

Atomiklik — bo'linmas amal
Yarim holat yo'q (ma'lumot izchil)
"Hammasi yoki hech biri" — universal
Tranzaksiya — atomiklik kafolati

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda tranzaksiyalarni o'rgandik.

Eng muhim uch fikr:

Tranzaksiya — atomiklik. Tranzaksiya — bir necha amalni bir butun (atomik): hammasi muvaffaqiyatli (COMMIT) yoki hech biri (ROLLBACK) — "hammasi yoki hech biri". BEGIN (boshi), COMMIT (doimiy saqlash), ROLLBACK (bekor — oldingi holatga qaytarish). Xato holatda ROLLBACK — baza toza qoladi (yarim ish yo'q). Pul o'tkazish (ayir + qo'sh) — ikki amal birga, xato -> hech narsa o'zgarmaydi (pul yo'qolmaydi).
ACID va context manager. Tranzaksiya ACID kafolatini beradi: Atomiklik (hammasi/hech biri), Izchillik (baza yaxlitligi), Izolyatsiya (parallel tranzaksiyalar mustaqil), Barqarorlik (COMMITdan keyin server o'chsa ham saqlanadi). Python'da with conn: — avtomatik tranzaksiya: muvaffaqiyat -> COMMIT, xato -> ROLLBACK (qo'lda try/exceptdan toza). Django (transaction.atomic()), SQLAlchemy (session.begin()) ham.
Yaxlitlik kafolati. Tranzaksiya bir necha bog'liq amal (pul, buyurtma, zaxira) uchun majburiy — ma'lumot yaxlitligini kafolatlaydi (yarim ish yo'q, server o'chsa ham). Ehtiyot: tranzaksiyani qisqa qiling (deadlock — ikki tranzaksiya bir-birini kutsa), tashqi amalni (email) tranzaksiyadan tashqarida, resurslarni bir xil tartibda qulflang. "Atomiklik" ("hammasi yoki hech biri") — tizimni izchil holatda saqlovchi universal tamoyil (baza, git commit, deploy).

Keyingi darsda PostgreSQL bilan ishlash ni o'rganamiz: ishlab chiqarishdagi eng mashhur relyatsion baza — ulanish, xususiyatlar va SQLite'dan farqlari.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

Hozircha izoh yo'q. Birinchi bo'ling!

23.4-dars: Tranzaksiyalar

1. Kirish va motivatsiya

2. Nazariya — chuqur tushuntirish

2.1. Tranzaksiya nima

2.2. BEGIN, COMMIT, ROLLBACK

2.3. Xato bo'lsa bekor qilish

2.4. ACID xususiyatlari

2.5. Context manager (with)

2.6. Izolyatsiya darajalari

2.7. Deadlock (o'lik nuqta)

2.8. Tranzaksiya — yaxlitlik kafolati

3. Tez ma'lumotnoma

4. Batafsil misollar

Misol 1 — BEGIN, COMMIT, ROLLBACK

Misol 2 — Xato bo'lsa bekor (atomiklik)

Misol 3 — Context manager (with)

Misol 4 — Amaliy: buyurtma tranzaksiyasi

5. To'g'ri va noto'g'ri tushunishlar

6. Keng tarqalgan xatolar va yechimlari

7. Integratsiya — bu bilim qayerda kerak bo'ladi

8. Eng yaxshi amaliyotlar

9. Amaliy topshiriq

Xulosa

Izohlar (0)

2.2. `BEGIN`, `COMMIT`, `ROLLBACK`

2.5. Context manager (`with`)

Misol 1 — `BEGIN`, `COMMIT`, `ROLLBACK`

Misol 3 — Context manager (`with`)