Chapterبەش 8 · Lectureوانە 8.1

Transactions and ACIDمامەڵەکان و ACID

A supplementary lesson: what a transaction is, COMMIT and ROLLBACK, the four ACID properties explained with a bank transfer, the problems of many users at the same time (lost updates, dirty reads, locks and deadlocks), and the transaction log that makes recovery possible.

وانەیەکی تەواوکەر: چییە، و (COMMIT و ROLLBACK)، بە نموونەی گواستنەوەی پارە لە بانکدا، کێشەکانی چەندین لە هەمان کاتدا (، ، و ) و ئەو مومکین دەکات.

19 min read20 خولەک خوێندنەوە · 18 stepsهەنگاو

What you will learnچی فێر دەبیت

Explain what a transaction is and give everyday examples.
Use START TRANSACTION (or BEGIN), COMMIT and ROLLBACK, and predict their result.
Explain atomicity, consistency, isolation and durability with a bank transfer.
Describe the lost update and the dirty read, and how locks prevent them.
Explain how the transaction log lets a DBMS recover after a crash.

ڕوونی بکەیتەوە چییە و نموونەی ڕۆژانە بهێنیتەوە.
START TRANSACTION (یان BEGIN)، COMMIT و ROLLBACK بەکاربهێنیت و ئەنجامەکەیان پێشبینی بکەیت.
، ، و بە نموونەی گواستنەوەی پارە ڕوون بکەیتەوە.
و وەسف بکەیت و بڵێیت چۆن ڕێگرییان لێ دەکەن.
ڕوونی بکەیتەوە چۆن ڕێگە بە دەدات دوای بگەڕێتەوە.

Fifty thousand dinars that disappearپەنجا هەزار دینار کە ون دەبێت

A supplementary lessonوانەیەکی تەواوکەر

This lesson is not in the course slides. The course mentions atomic updates, concurrent access, the TCL commands and the journal (log), but never explains transactions, which are a whole part of every database textbook. It was written from Database System Concepts (Silberschatz, Korth and Sudarshan, chapters 17 to 19) and the MySQL and SQLite manuals.

ئەم وانەیە لە سلایدەکانی کۆرسەکەدا نییە. کۆرسەکە باسی نوێکردنەوەی دابەشنەبوو، ، فەرمانەکانی و دەکات، بەڵام هەرگیز ڕوون ناکاتەوە، کە لە هەموو کتێبێکی بەشێکی تەواویان بۆ تەرخان کراوە. لە کتێبی ⁦Database System Concepts⁩ (Silberschatz، Korth و Sudarshan، بەشەکانی ١٧ تا ١٩) و ڕێنماییەکانی MySQL و SQLiteـەوە نووسراوە.

Aram sends 50,000 dinars to Shilan through his bank's app. Inside the bank's database this is two changes: take 50,000 from Aram's account, then add 50,000 to Shilan's account. Now imagine the power goes off after the first change and before the second. Aram has lost 50,000, Shilan has received nothing, and the money has simply disappeared.

ئارام لە ڕێگەی بەرنامەی بانکەکەیەوە ٥٠٬٠٠٠ دینار بۆ شیلان دەنێرێت. لە ناو بانکەکەدا ئەمە دوو گۆڕانکارییە: ٥٠٬٠٠٠ لە هەژماری ئارام دەردەهێنرێت، پاشان ٥٠٬٠٠٠ دەخرێتە سەر هەژماری شیلان. ئێستا وێنا بکە کارەبا دوای گۆڕانکاریی یەکەم و پێش دووەم ببڕێت. ئارام ٥٠٬٠٠٠ی لەدەست داوە، شیلان هیچی وەرنەگرتووە و پارەکە بە سادەیی ون بووە.

In Files versus databases you met two weaknesses of file-based systems: an update cannot be made 'all or nothing', and many users at the same time spoil each other's work. A DBMS solves both with transactions. The commands that control them are the family you met in Database users.

لە وانەی فایلەکان بەرامبەر بنکەدراوەکان دوو لاوازیی بینی: نوێکردنەوە ناکرێت «هەمووی یان هیچ» بێت و چەندین لە هەمان کاتدا کاری یەکتر تێکدەدەن. هەردووکیان بە چارەسەر دەکات. فەرمانەکانی ، کە لە وانەی بەکارهێنەرەکانی بنکەدراوە بینیتن، کۆنترۆڵیان دەکەن.

What is a transaction?مامەڵە چییە؟

Definitionپێناسە

A group of SQL statements that must all succeed or all fail together. If one fails, a ROLLBACK undoes the others, so money cannot leave one account without arriving in the other.

کۆمەڵێک فەرمانی کە دەبێت هەموویان پێکەوە سەرکەوتوو بن یان هەموویان شکست بهێنن. ئەگەر یەکێکیان شکستی هێنا، ROLLBACK ئەوانی تر هەڵدەوەشێنێتەوە، بۆ ئەوەی پارە لە هەژمارێک دەرنەچێت بەبێ ئەوەی بگاتە هەژمارەکەی تر.

A transaction is a unit of work: one or more SQL statements that the DBMS treats as one whole. Either all of them take effect, or none of them does.

یەکەیەکی کارە: یەک یان چەند فەرمانێکی SQL کە وەک یەک گشت مامەڵەیان لەگەڵ دەکات. یان هەموویان کاریگەر دەبن، یان هیچیان.

A bank transfer: take money from one account and add it to another.
Booking a bus seat: mark the seat as taken and record the payment.
An online order: create the order and reduce the stock of each product.

گواستنەوەی پارە لە بانکدا: پارە لە هەژمارێک دەربهێنە و بیخەرە سەر هەژمارێکی تر.
حیجزکردنی کورسییەکی پاس: کورسییەکە وەک گیراو نیشان بکە و پارەدانەکە تۆمار بکە.
داواکارییەکی ئۆنلاین: داواکارییەکە دروست بکە و ژمارەی کۆگای هەر بەرهەمێک کەم بکەرەوە.

A transaction is all or nothing: both steps, or neither. هەمووی یان هیچە: هەردوو هەنگاوەکە، یان هیچیان.CêIT

The transfer as one transaction (MySQL)گواستنەوەکە وەک یەک مامەڵە ⁦(MySQL)⁩SQLRuns in the databaseلە ناو بنکەدراوە کار دەکات

START TRANSACTION;
UPDATE accounts SET balance = balance - 50000 WHERE account_id = 1;  -- Aram
UPDATE accounts SET balance = balance + 50000 WHERE account_id = 2;  -- Shilan
COMMIT;

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 1

From here on, nothing is final until COMMIT.

لێرەوە بەدواوە هیچ گۆڕانکارییەک یەکجاری نییە تا COMMIT.

Lineدێڕی 4

COMMIT makes both changes permanent at once.

COMMIT هەردوو گۆڕانکارییەکە پێکەوە جێگیر و هەمیشەیی دەکات.

Quick checkپشکنینی خێراAn online shop saves a new order and then reduces the stock. Why should these two statements be one transaction?فرۆشگایەکی ئۆنلاین داواکارییەکی نوێ پاشەکەوت دەکات و پاشان کۆگا کەم دەکاتەوە. بۆچی دەبێت ئەم دوو فەرمانە یەک بن؟So that there is never an order without the stock reduced, or the stock reduced without an orderبۆ ئەوەی هەرگیز داواکارییەک نەبێت بەبێ کەمبوونەوەی کۆگا، یان کۆگا کەم نەبێتەوە بەبێ داواکاریBecause SQL cannot run two statements otherwiseچونکە SQL بە شێوەیەکی تر ناتوانێت دوو فەرمان جێبەجێ بکاتBecause transactions make each statement fasterچونکە مامەڵەکان هەر فەرمانێک خێراتر دەکەن

What is a transaction?مامەڵە چییە؟

COMMIT and ROLLBACKCOMMIT و ROLLBACK

START TRANSACTION (or BEGIN) starts a transaction.
COMMIT ends it and makes all its changes permanent. This is called a .
ROLLBACK ends it and cancels all its changes, as if it had never started. This is called a .

START TRANSACTION (یان BEGIN) دەست پێدەکات.
COMMIT کۆتایی پێدەهێنێت و هەموو گۆڕانکارییەکانی جێگیر و هەمیشەیی دەکات. ئەمە پێی دەوترێت .
ROLLBACK کۆتایی پێدەهێنێت و هەموو گۆڕانکارییەکانی هەڵدەوەشێنێتەوە، وەک ئەوەی هەرگیز دەستی پێنەکردبێت. ئەمە پێی دەوترێت .

Try it: a transfer that is committedتاقی بکەرەوە: گواستنەوەیەک کە جێگیر دەکرێتtransfer.sqlSQLRuns in the databaseلە ناو بنکەدراوە کار دەکات

CREATE TABLE accounts (
  account_id INT PRIMARY KEY,
  owner      VARCHAR(50) NOT NULL,
  balance    INT NOT NULL CHECK (balance >= 0)
);
INSERT INTO accounts VALUES (1, 'Aram', 200000), (2, 'Shilan', 80000);

-- Move 50,000 dinars from Aram to Shilan
BEGIN;
UPDATE accounts SET balance = balance - 50000 WHERE account_id = 1;
UPDATE accounts SET balance = balance + 50000 WHERE account_id = 2;
COMMIT;

SELECT * FROM accounts;

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 4

A rule: no balance may go below zero. We use it on the ACID screens.

ڕێسایەک: هیچ باڵانسێک نابێت لە سفر کەمتر بێت. لە شاشەکانی ACIDدا بەکاری دەهێنین.

Lineدێڕی 9

BEGIN works in SQLite and MySQL. MySQL also accepts the standard START TRANSACTION; SQLite does not. To run these lines yourself, see SQLite basics.

BEGIN لە SQLite و MySQL کار دەکات. MySQL START TRANSACTIONـی ستانداردیش وەردەگرێت؛ SQLite نا. بۆ ئەوەی خۆت ئەم دێڕانە جێبەجێ بکەیت، بڕوانە بنەماکانی SQLite.

Try it: a change that is rolled back (same database)تاقی بکەرەوە: گۆڕانکارییەک کە هەڵدەوەشێنرێتەوە (هەمان بنکەدراوە)rollback.sqlSQLRuns in the databaseلە ناو بنکەدراوە کار دەکات

BEGIN;
UPDATE accounts SET balance = balance - 50000 WHERE account_id = 1;
SELECT * FROM accounts;
ROLLBACK;
SELECT * FROM accounts;

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 3

Inside the transaction, Aram's new balance (100000) is already visible to this session.

لە ناو ، باڵانسە نوێیەکەی ئارام ⁦(100000)⁩ بۆ ئەم دیارە.

Lineدێڕی 4-5

ROLLBACK cancels it: Aram is back to 150000.

ROLLBACK هەڵیدەوەشێنێتەوە: ئارام دەگەڕێتەوە بۆ ⁦150000⁩.

A transaction can change more than values: it can add or delete whole rows, and even change the structure of the database. In SQLite and PostgreSQL a CREATE TABLE inside BEGIN … ROLLBACK disappears again, like any other change; MySQL commits structure changes at once (next screen).

دەتوانێت زیاتر لە بەهاکان بگۆڕێت: دەتوانێت تەواو زیاد بکات یان بسڕێتەوە و تەنانەت پێکهاتەی بگۆڕێت. لە SQLite و PostgreSQL، CREATE TABLEێک لە ناو BEGIN … ROLLBACKدا وەک هەر گۆڕانکارییەکی تر نامێنێتەوە؛ MySQL گۆڕانکاریی پێکهاتە یەکسەر جێگیر دەکات (شاشەی دواتر).

Harvard CS50’s Intro to Databases with SQL – Full University CoursefreeCodeCamp.org · Englishئینگلیزی · 505K viewsبینین · 12K likesلایک · Partبەشی 8:32:32–8:46:17 (ofلە 11:08:48)
A bank-account demo in SQLite: BEGIN TRANSACTION, then COMMIT saves both updates at once; when a CHECK rule fails, ROLLBACK undoes everything.
نموونەیەکی هەژماری بانکی لە : `BEGIN TRANSACTION`، پاشان `COMMIT` هەردوو گۆڕانکارییەکە پێکەوە پاشەکەوت دەکات؛ کاتێک مەرجێکی `CHECK` پێشێل دەکرێت، `ROLLBACK` هەموو شتێک هەڵدەوەشێنێتەوە.
Plays 8:32:32–8:46:17 of a long course: Alice pays Bob, BEGIN TRANSACTION and COMMIT, then ROLLBACK after a CHECK (balance ≥ 0) failure. Uses SQLite, like this screen.
لە کۆرسێکی درێژدا، لە ⁦8:32:32⁩ تا ⁦8:46:17⁩ پەخش دەبێت: Alice پارە دەداتە Bob، `BEGIN TRANSACTION` و `COMMIT`، پاشان `ROLLBACK` دوای پێشێلکردنی مەرجی `CHECK` (باڵانس ≥ ⁦0⁩). وەک ئەم شاشەیە بەکار دەهێنێت.

What is a transaction?مامەڵە چییە؟

Autocommit and the life of a transactionautocommit و ژیانی مامەڵەیەک

Autocommit, and what cannot be rolled backAutocommit و ئەوەی هەڵناوەشێتەوە

In MySQL and SQLite, autocommit is on by default: a statement outside START TRANSACTION … COMMIT is committed as soon as it finishes, and you cannot ROLLBACK it afterwards. In MySQL, statements that define the structure, such as CREATE TABLE, ALTER TABLE and DROP TABLE, cause an implicit commit: they end the open transaction and cannot be rolled back. And ROLLBACK only works on transactional tables (InnoDB, MySQL's default), not on old MyISAM tables. Autocommit as a mode is also explained in Database users.

لە MySQL و SQLite، autocommit بە شێوەی بنەڕەتی هەڵکراوە: فەرمانێک لە دەرەوەی START TRANSACTION … COMMIT هەر کە تەواو بوو جێگیر دەکرێت و دواتر ناتوانیت بە ROLLBACK هەڵیبوەشێنیتەوە. لە MySQL، ئەو فەرمانانەی پێکهاتە دیاری دەکەن، وەک CREATE TABLE، ALTER TABLE و DROP TABLE، بە شێوەیەکی ناڕاستەوخۆ ئەنجام دەدەن (implicit commit): کۆتایی پێدەهێنن و خۆیان هەڵناوەشێنرێنەوە. هەروەها ROLLBACK تەنها لەسەر (InnoDB، بنەڕەتی MySQL) کار دەکات، نەک لەسەر ⁦MyISAM. autocommit⁩ وەک دۆخێک لە وانەی بەکارهێنەرەکانی بنکەدراوەـیش ڕوون کراوەتەوە.

The life of a transactionژیانی مامەڵەیەک

A transaction is active while it runs. After its last statement it is partially committed, and once the commit is safely recorded it is committed. If something goes wrong it becomes failed, and after the rollback it is aborted: the database is back to how it was before the transaction started. SAVEPOINT lets you roll back only part of a transaction.

لە کاتی کارکردندا چالاکە. دوای دوا فەرمانی بە بەشێک جێگیرکراوە و کاتێک بە سەلامەتی تۆمار کرا جێگیرکراوە. ئەگەر شتێک هەڵە بچێت دەبێتە شکستخواردوو و دوای وەستێنراوە: دەگەڕێتەوە بۆ ئەو دۆخەی پێش دەستپێکردنی هەیبوو. SAVEPOINT ڕێگە دەدات تەنها بەشێکی هەڵبوەشێنیتەوە.

Quick checkپشکنینی خێراAutocommit is on. Dilan runs DELETE FROM accounts WHERE account_id = 2; and then ROLLBACK;. What happens?Autocommit هەڵکراوە. دیلان DELETE FROM accounts WHERE account_id = 2; و پاشان ROLLBACK; جێبەجێ دەکات. چی ڕوودەدات؟The row comes back.ڕیزەکە دەگەڕێتەوە.The row stays deleted: the DELETE was already committed on its own.ڕیزەکە سڕاوە دەمێنێتەوە: DELETEـەکە پێشتر بە تەنها جێگیر کرابوو.

The ACID propertiesتایبەتمەندییەکانی ACID

Every DBMS that supports transactions makes four promises about them. Their first letters spell ACID:

هەر کە پشتگیریی دەکات چوار بەڵێن دەربارەیان دەدات. پیتی یەکەمی ناوە ئینگلیزییەکانیان ACID دروست دەکەن:

Propertyتایبەتمەندی	The promiseبەڵێنەکە	In the bank transferلە گواستنەوەی پارەدا
Atomicity (A)	All of the transaction happens, or none of it.یان هەموو ڕوودەدات یان هیچی.	Never 'taken from Aram but not given to Shilan'.هەرگیز «لە ئارام دەرهێنرا بەڵام نەدرا بە شیلان» نابێت.
Consistency (C)	It starts from a correct database and leaves a correct one: every rule still holds.لە دروستەوە دەست پێدەکات و دروست بەجێدەهێڵێت: هەموو ڕێسایەک هێشتا ڕاستە.	Aram + Shilan is 280,000 before and after; no balance is negative.ئارام + شیلان پێش و دوای ٢٨٠٬٠٠٠ـە؛ هیچ باڵانسێک سالب نییە.
Isolation (I)	Transactions running at the same time do not see each other's unfinished work.کاتێک چەند لە هەمان کاتدا کار دەکەن، کاری تەواونەکراوی یەکتر نابینن.	A report run in the middle never sees the 50,000 'missing'.ڕاپۆرتێک کە لە ناوەڕاستدا کار دەکات هەرگیز ٥٠٬٠٠٠ـەکە بە «ونبوو» نابینێت.
Durability (D)	Once committed, the changes survive a power cut or a crash.کاتێک جێگیر کرا، گۆڕانکارییەکان دوای بڕانی کارەبا یان هەر دەمێننەوە.	When the app says 'Transfer complete', it stays complete.کاتێک بەرنامەکە دەڵێت «گواستنەوە تەواو بوو»، تەواو دەمێنێتەوە.

Definitionپێناسە

The four promises a makes about every : Atomicity (all or nothing), Consistency (the rules still hold afterwards), Isolation (transactions do not see each other's half-finished work) and Durability (committed changes survive a crash).

ئەو چوار بەڵێنەن کە بۆ هەموو دەیدات: (هەمووی یان هیچ)، (ڕێساکان دوای تەواوبوون هێشتا ڕاستن)، ( کاری نیوەچڵی یەکتر نابینن) و (گۆڕانکارییە جێگیرکراوەکان لە کاتی لەکارکەوتنیشدا دەمێننەوە).

ACID Properties in Databases With ExamplesByteByteGo · Englishئینگلیزی · 314K viewsبینین · 9.2K likesلایک
The four ACID properties with bank examples, plus dirty reads, non-repeatable reads and isolation levels, in five minutes.
(هەر چواریان) بە نموونەی بانک، لەگەڵ ، non-repeatable read و ئاستەکانی ، لە پێنج خولەکدا.
Whole video (4:57): atomicity, consistency, isolation (with read problems) and durability.
هەموو ڤیدیۆکە ⁦(4:57)⁩: ، ، (لەگەڵ کێشەکانی خوێندنەوە) و .

The ACID propertiesتایبەتمەندییەکانی ACID

Atomicity and consistencyدابەشنەبوون و پاراستنی کۆکی

Atomicity. 'Atom' once meant 'cannot be split'. If a transaction fails half-way, for example because of a power cut after the first UPDATE, the DBMS undoes the part that was already done when it restarts. The user sees either the whole transfer or nothing.

. «ئەتۆم» لە کۆندا بە واتای «دابەش ناکرێت» بوو. ئەگەر لە نیوەی ڕێگادا شکست بهێنێت، بۆ نموونە بەهۆی بڕانی کارەبا دوای UPDATEـی یەکەم، کاتێک دووبارە دەست پێدەکاتەوە ئەو بەشەی ئەنجام درابوو هەڵدەوەشێنێتەوە. یان هەموو گواستنەوەکە دەبینێت یان هیچ.

Consistency. The database must obey its rules (primary keys, foreign keys, CHECK constraints) before and after every transaction. In the middle it may briefly be 'wrong' (Aram already paid, Shilan not yet paid), which is why nobody else may see the middle. If a statement would break a rule, the DBMS refuses it, and the transaction is rolled back:

. دەبێت پێش و دوای هەموو پابەندی ڕێساکانی بێت (، ، ڕێساکانی CHECK). لە ناوەڕاستدا دەکرێت بۆ ماوەیەکی کورت «هەڵە» بێت (ئارام پارەی داوە، شیلان هێشتا وەرینەگرتووە)، بۆیە کەسی تر نابێت ناوەڕاستەکە ببینێت. ئەگەر فەرمانێک ڕێسایەک بشکێنێت، ڕەتی دەکاتەوە و هەڵدەوەشێنرێتەوە:

Shilan tries to send 300,000 but has only 130,000شیلان هەوڵ دەدات ٣٠٠٬٠٠٠ بنێرێت بەڵام تەنها ١٣٠٬٠٠٠ی هەیەtoo-much.sqlSQLRuns in the databaseلە ناو بنکەدراوە کار دەکات

BEGIN;
UPDATE accounts SET balance = balance + 300000 WHERE account_id = 1;
UPDATE accounts SET balance = balance - 300000 WHERE account_id = 2;
ROLLBACK;
SELECT * FROM accounts;

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 2

This line succeeds: Aram would get 300,000 from nowhere.

ئەم دێڕە سەرکەوتوو دەبێت: ئارام ٣٠٠٬٠٠٠ لە هیچەوە وەردەگرێت.

Lineدێڕی 3

This line breaks CHECK (balance >= 0), so the DBMS refuses it.

ئەم دێڕە CHECK (balance >= 0) دەشکێنێت، بۆیە ڕەتی دەکاتەوە.

Lineدێڕی 4

The program sees the error and rolls back, which also undoes line 2.

بەرنامەکە هەڵەکە دەبینێت و هەڵیدەوەشێنێتەوە، کە دێڕی ٢یش هەڵدەوەشێنێتەوە.

Quick checkپشکنینی خێراThe power fails after Aram's balance is reduced but before Shilan's is increased. What does the DBMS do when it restarts?کارەبا دوای کەمکردنەوەی باڵانسی ئارام و پێش زیادکردنی باڵانسی شیلان دەبڕێت. کاتێک دووبارە دەست پێدەکاتەوە چی دەکات؟It keeps the reduction and asks Shilan to call the bank.کەمکردنەوەکە دەهێڵێتەوە و داوا لە شیلان دەکات پەیوەندی بە بانکەوە بکات.It adds 50,000 to Shilan to finish the job.٥٠٬٠٠٠ دەخاتە سەر شیلان بۆ تەواوکردنی کارەکە.It undoes the reduction, because the transaction never committed.کەمکردنەوەکە هەڵدەوەشێنێتەوە، چونکە مامەڵەکە هەرگیز جێگیر نەکرا.

The ACID propertiesتایبەتمەندییەکانی ACID

Isolation and durabilityدابڕاوی و هەمیشەیی

Isolation. Suppose the bank prints a report of 'total money in all accounts' while the transfer is half done. It would show 50,000 less than the truth. Isolation means each transaction behaves as if it were running alone: others see the state before it, or after it, but never the middle.

. وا دابنێ بانکەکە ڕاپۆرتێکی «کۆی پارەی هەموو هەژمارەکان» چاپ دەکات لە کاتێکدا گواستنەوەکە تا نیوە ئەنجام دراوە. ٥٠٬٠٠٠ لە ڕاستی کەمتر پیشان دەدات. واتە هەر وا ڕەفتار دەکات وەک ئەوەی بە تەنها کار بکات: ئەوانی تر دۆخی پێش یان دوای ئەو دەبینن، بەڵام هەرگیز ناوەڕاست نا.

Durability. When COMMIT returns and the app shows 'Transfer complete', the change must survive anything: a power cut a second later, a crashed server, a restart. The DBMS keeps this promise by writing the change to its transaction log on disk before it reports success (see the transaction log).

. کاتێک COMMIT تەواو دەبێت و بەرنامەکە «گواستنەوە تەواو بوو» پیشان دەدات، گۆڕانکارییەکە دەبێت لە هەموو شتێک بمێنێتەوە: بڕانی کارەبا چرکەیەک دواتر، لەکارکەوتوو، دووبارە هەڵکردنەوە. ئەم بەڵێنە بەوە جێبەجێ دەکات کە پێش ڕاگەیاندنی سەرکەوتن، گۆڕانکارییەکە لە سەر دیسک دەنووسێت (بڕوانە فایلی لۆگ).

The shop's receipt bookدەفتەری پسوولەی دووکان

A careful shopkeeper in the bazaar writes every sale in his receipt book before handing over the goods. If someone interrupts him, he finishes one customer before serving the next (isolation). If the lights go out, the receipt book still shows what was really sold (durability).

دووکاندارێکی وریا لە بازاڕدا هەموو فرۆشتنێک لە دەفتەری پسوولەکەیدا دەنووسێت پێش ئەوەی کاڵاکە ڕادەست بکات. ئەگەر کەسێک قسەی پێ ببڕێت، کاری یەک کڕیار تەواو دەکات پێش ئەوەی خزمەتی کڕیاری دواتر بکات (). ئەگەر کارەبا بڕا، دەفتەری پسوولەکە هێشتا پیشان دەدات بە ڕاستی چی فرۆشراوە ().

Where the analogy stops workingسنووری ئەم نموونەیە

A DBMS does not really serve one transaction at a time: it runs many together and only makes the result look as if they had run one after another.

بە ڕاستی یەک لە یەک کاتدا جێبەجێ ناکات: چەندینیان پێکەوە کار پێدەکات و تەنها ئەنجامەکە وا دەردەخات وەک ئەوەی یەک لە دوای یەک کرابن.

Quick checkپشکنینی خێراThe app says 'Transfer complete'. One second later the server crashes. After the restart, which ACID property guarantees that the transfer is still there?بەرنامەکە دەڵێت «گواستنەوە تەواو بوو». چرکەیەک دواتر لەکاردەکەوێت. دوای دووبارە هەڵکردنەوە، کام تایبەتمەندیی ACID دەستەبەر دەکات کە گواستنەوەکە لەدەست نەچووە؟IsolationدابڕاویDurabilityهەمیشەییAtomicityدابەشنەبوون

Many users at the same timeچەندین بەکارهێنەر لە هەمان کاتدا

A bank's database serves thousands of people at once. Running their transactions one after another would be safe but slow. So the DBMS runs them at the same time: one transaction can use the processor while another waits for the disk, and short transactions do not wait behind long ones. Concurrency control is the part of the DBMS that makes this safe. Without it, three problems appear.

بانکێک لە یەک کاتدا خزمەتی هەزاران کەس دەکات. جێبەجێکردنی یەک لە دوای یەک سەلامەت دەبوو بەڵام هێواش. بۆیە لە هەمان کاتدا کاریان پێدەکات: دەتوانێت بەکاربهێنێت لە کاتێکدا یەکێکی تر چاوەڕێی دیسک دەکات و لە پشت درێژەکانەوە چاوەڕێ ناکەن. ئەو بەشەی کە ئەمە سەلامەت دەکات. بەبێ ئەو، سێ کێشە دەردەکەون.

Many users at the same timeچەندین بەکارهێنەر لە هەمان کاتدا

Problem 1: the lost updateکێشەی ١: نوێکردنەوەی ونبوو

Aram has 100,000 in his account. At the same moment, one clerk deposits 20,000 and another withdraws 30,000. Each program reads the balance, calculates the new one, and writes it back:

ئارام ١٠٠٬٠٠٠ی لە هەژمارەکەیدا هەیە. لە هەمان ساتدا، فەرمانبەرێک ٢٠٬٠٠٠ دادەنێت و یەکێکی تر ٣٠٬٠٠٠ ڕادەکێشێت. هەر بەرنامەیەک باڵانسەکە دەخوێنێتەوە، باڵانسە نوێیەکە دەژمێرێت و دەینووسێتەوە:

Both clerks read 100,000; the second write covers the first.هەردوو فەرمانبەر ١٠٠٬٠٠٠ دەخوێننەوە؛ نووسینی دووەم نووسینی یەکەم دادەپۆشێت.CêIT

Definitionپێناسە

A problem of : two transactions read the same value, both change it, and the second write covers the first, so the first change disappears.

کێشەیەکی : دوو هەمان بەها دەخوێننەوە، هەردووکیان دەیگۆڕن و نووسینی دووەم نووسینی یەکەم دادەپۆشێت، بۆیە گۆڕانکاریی یەکەم ون دەبێت.

Many users at the same timeچەندین بەکارهێنەر لە هەمان کاتدا

Problem 2 and 3: dirty and changing readsکێشەی ٢ و ٣: خوێندنەوەی پیس و خوێندنەوەی گۆڕاو

Dirty read. Transaction 1 changes a value but has not committed yet. Transaction 2 reads the new value and uses it. Then transaction 1 rolls back. Transaction 2 has used a value that never really existed, for example it approved a loan because of money that was never deposited.

. ١ بەهایەک دەگۆڕێت بەڵام هێشتا جێگیری نەکردووە. ٢ بەها نوێیەکە دەخوێنێتەوە و بەکاری دەهێنێت. پاشان ١ هەڵدەوەشێتەوە. ٢ بەهایەکی بەکارهێناوە کە هەرگیز بە ڕاستی نەبووە، بۆ نموونە قەرزێکی پەسەند کردووە لەسەر بنەمای پارەیەک کە هەرگیز دانەنرا.

Non-repeatable read. A transaction reads the same row twice and gets two different answers, because another transaction changed and committed it in between.

خوێندنەوەی دووبارەنەکراوە (non-repeatable read). هەمان دوو جار دەخوێنێتەوە و دوو وەڵامی جیاواز وەردەگرێت، چونکە تر لە نێوانیاندا گۆڕیویەتی و جێگیری کردووە.

The four isolation levels of the SQL standard (strictest last)چوار ئاستی ستانداردی SQL (توندترینیان لە کۆتاییدا)
Levelئاست	What it allowsڕێگە بە چی دەدات
`READ UNCOMMITTED`	Dirty reads can happen. دەکرێت ڕووبدات.
`READ COMMITTED`	No dirty reads, but a row can change between two reads. نییە، بەڵام دەکرێت لە نێوان دوو خوێندنەوەدا بگۆڕێت.
`REPEATABLE READ`	Rows already read do not change during the transaction. The default in MySQL's InnoDB.ئەو خوێندراونەتەوە لە ماوەی ناگۆڕێن. بنەڕەتیی InnoDBـی MySQL.
`SERIALIZABLE`	The result is the same as running the transactions one after another.ئەنجامەکە هەمانە وەک ئەوەی یەک لە دوای یەک کار بکەن.

Many users at the same timeچەندین بەکارهێنەر لە هەمان کاتدا

Locks, and when they block each otherقفڵەکان و کاتێک ڕێگە لە یەکتر دەگرن

Definitionپێناسە

A mark that a puts on a row or a table so that other transactions must wait. A shared lock lets others read but not change; an exclusive lock lets nobody else read or change until it is released.

نیشانەیەکە کە لەسەر ڕیزێک یان دایدەنێت بۆ ئەوەی تر چاوەڕێ بکەن. قفڵی هاوبەش ڕێگە بە ئەوانی تر دەدات بیخوێننەوە بەڵام نەیگۆڕن؛ قفڵی تایبەت ڕێگە بە هیچ کەسێکی تر نادات بیخوێنێتەوە یان بیگۆڕێت تا ئازاد دەکرێت.

Locks fix the lost update. If clerk 1 locks Aram's row before reading it, clerk 2 must wait until clerk 1 commits. Then clerk 2 reads 120,000 and writes 90,000: correct. In MySQL a program asks for this lock with SELECT ... FOR UPDATE inside a transaction. The locks are released at COMMIT or ROLLBACK. An even simpler fix is to let the database do the arithmetic in one statement: UPDATE accounts SET balance = balance - 30000 WHERE account_id = 1;.

چارەسەر دەکەن. ئەگەر فەرمانبەری ١ ئارام پێش خوێندنەوە قفڵ بکات، فەرمانبەری ٢ دەبێت چاوەڕێ بکات تا فەرمانبەری ١ جێگیری دەکات. پاشان فەرمانبەری ٢ ١٢٠٬٠٠٠ دەخوێنێتەوە و ٩٠٬٠٠٠ دەنووسێت: دروستە. لە MySQL بەرنامەیەک بە SELECT ... FOR UPDATE لە ناو داوای ئەم دەکات. لە کاتی COMMIT یان ROLLBACKدا ئازاد دەکرێن. چارەسەرێکی سادەتریش ئەوەیە کە بهێڵیت خۆی بە یەک فەرمان ژمێرکارییەکە بکات: UPDATE accounts SET balance = balance - 30000 WHERE account_id = 1;.

Locks have a danger. Transaction 1 locks Aram's row and then wants Shilan's; at the same moment transaction 2 locks Shilan's row and then wants Aram's. Each waits for the other for ever: a deadlock. The DBMS notices it, rolls one of them back (the 'victim') and lets the other finish. The program should simply try the rolled-back transaction again. Keeping transactions short, and always locking rows in the same order, makes deadlocks rare.

مەترسییەکیان هەیە. ١ ئارام قفڵ دەکات و پاشان شیلانی دەوێت؛ لە هەمان ساتدا ٢ شیلان قفڵ دەکات و پاشان ئارامی دەوێت. هەر یەکەیان بۆ هەتاهەتایە چاوەڕێی ئەوی تر دەکات: . هەستی پێدەکات، یەکێکیان هەڵدەوەشێنێتەوە («قوربانی») و ڕێگە بە ئەوی تر دەدات تەواو بێت. بەرنامەکە تەنها دەبێت ئەو هەڵوەشێنراوە دووبارە بکاتەوە. کورت هێشتنەوەی و قفڵکردنی هەمیشە بە هەمان ڕیزبەندی، دەگمەن دەکەن.

Two cars on a narrow bridgeدوو ئۆتۆمبێل لەسەر پردێکی تەسک

Two cars meet in the middle of a one-lane bridge. Each driver waits for the other to reverse, and nobody moves. A traffic policeman tells one car to reverse so the other can pass; then the first one crosses. The DBMS plays the policeman.

دوو ئۆتۆمبێل لە ناوەڕاستی پردێکی یەک هێڵیدا بەیەک دەگەن. هەر شۆفێرێک چاوەڕێ دەکات ئەوی تر بگەڕێتەوە دواوە و کەس ناجووڵێت. پۆلیسێکی هاتوچۆ بە یەکێکیان دەڵێت بگەڕێتەوە دواوە بۆ ئەوەی ئەوی تر تێبپەڕێت؛ پاشان یەکەمیان دەپەڕێتەوە. ڕۆڵی پۆلیسەکە دەبینێت.

Where the analogy stops workingسنووری ئەم نموونەیە

The rolled-back transaction loses its work and must start again from the beginning, not just back up a little.

کارەکەی لەدەست دەدات و دەبێت لە سەرەتاوە دەست پێبکاتەوە، نەک تەنها کەمێک بگەڕێتەوە دواوە.

Quick checkپشکنینی خێراWhat does InnoDB do when it detects a deadlock?InnoDB کاتێک دەدۆزێتەوە چی دەکات؟It waits until one user gives up.چاوەڕێ دەکات تا یەکێک لە بەکارهێنەرەکان واز دەهێنێت.It rolls back one transaction so that the other can finish.یەکێک لە مامەڵەکان هەڵدەوەشێنێتەوە بۆ ئەوەی ئەوی تر تەواو بێت.It commits both transactions.هەردوو مامەڵەکە جێگیر دەکات.

Many users at the same timeچەندین بەکارهێنەر لە هەمان کاتدا

Shared and exclusive locks: how much to lock?قفڵە هاوبەشەکان و قفڵە تاکانەکان: چەندە قفڵ بکرێت؟

Readers do not harm each other, so a DBMS uses two kinds of lock. A shared lock is for reading: many transactions can hold one on the same row at once. An exclusive lock is for changing: while one transaction holds it, no other transaction can lock that row at all.

خوێنەران زیان بە یەکتر ناگەیەنن، بۆیە دوو جۆر بەکاردەهێنێت. بۆ خوێندنەوەیە: چەندین دەتوانن لە هەمان کاتدا یەکێکی لەسەر هەمان هەبێت. بۆ گۆڕینە: تا هەیەتی، هیچ تر ناتوانێت بە هیچ شێوەیەک ئەو قفڵ بکات.

Which lock requests can be granted togetherکام داواکاریی پێکەوە دەدرێن
One transaction holds… هەیەتی…	Another asks for a shared lockیەکێکی تر داوای دەکات	Another asks for an exclusive lockیەکێکی تر داوای دەکات
a shared lock	given at onceیەکسەر دەدرێت	waitsچاوەڕێ دەکات
an exclusive lock	waitsچاوەڕێ دەکات	waitsچاوەڕێ دەکات

Lock granularity is how much one lock covers: the whole database, one table or one row. Smaller locks let more users work at once, but they cost the DBMS more bookkeeping. MySQL's InnoDB locks single rows. SQLite locks the whole database file while it writes, which keeps it simple but lets only one program write at a time.

ئەوەیە کە یەک چەندە دەگرێتەوە: هەموو ، یەک یان یەک . بچووکتر ڕێگە دەدەن زیاتر پێکەوە کار بکەن، بەڵام کاری ڕێکخستنی زیاتر بۆ دروست دەکەن. InnoDBـی MySQL تاکە قفڵ دەکات. SQLite لە کاتی نووسیندا هەموو فایلی قفڵ دەکات، کە سادەی دەهێڵێتەوە، بەڵام لە یەک کاتدا تەنها یەک دەتوانێت بنووسێت.

Quick checkپشکنینی خێراAram's transaction holds a shared lock on a row while it reads. Shilan's transaction wants to update the same row. What happens? ئارام لە کاتی خوێندنەوەدا لەسەر هەیە. شیلان دەیەوێت هەمان نوێ بکاتەوە. چی ڕوودەدات؟Shilan's transaction waits until Aram's lock is releasedمامەڵەی شیلان چاوەڕێ دەکات تا قفڵی ئارام ئازاد دەکرێتBoth change and read the row at the same momentهەردووکیان لە هەمان ساتدا ڕیزەکە دەگۆڕن و دەخوێننەوەAram's read is cancelledخوێندنەوەکەی ئارام هەڵدەوەشێتەوە

Many users at the same timeچەندین بەکارهێنەر لە هەمان کاتدا

Livelock, and reading without waitingبنبەستی زیندوو و خوێندنەوە بەبێ چاوەڕوانی

A deadlock has a close relative. Two transactions collide, both step back, both try again at the same moment and collide again, for ever: busy, but never finishing, like two people in a narrow corridor who keep stepping to the same side. This is a livelock. The cure is a short random wait before each retry, so that one of them goes first.

خزمێکی نزیکی هەیە. دوو بەیەکدا دەکەون، هەردووکیان دەکشێنەوە، هەردووکیان لە هەمان ساتدا دووبارە هەوڵ دەدەنەوە و دووبارە بەیەکدا دەکەونەوە، بۆ هەتاهەتایە: سەرقاڵن بەڵام هەرگیز تەواو نابن، وەک دوو کەس لە ڕاڕەوێکی تەسکدا کە هەمیشە بەرەو هەمان لا هەنگاو دەنێن. ئەمە . چارەسەرەکەی چاوەڕوانییەکی کورتی هەڕەمەکییە پێش هەر هەوڵدانێکی دووبارە، بۆ ئەوەی یەکێکیان یەکەم جار بڕوات.

Locks are not the only way. Many DBMSs, among them MySQL InnoDB, PostgreSQL and Oracle, also keep older versions of the rows being changed: multiversion concurrency control (MVCC). A plain SELECT reads a consistent snapshot of committed data and does not wait for the writer's lock, so reading does not block writing and writing does not block reading. Two writers changing the same row still lock each other.

تاکە ڕێگا نین. زۆر ، لەوانە InnoDBـی MySQL، PostgreSQL و Oracle، وەشانە کۆنەکانی ئەو هەڵدەگرن کە دەگۆڕدرێن: . SELECTێکی ئاسایی وێنەیەکی یەکگرتووی جێگیرکراو دەخوێنێتەوە و چاوەڕێی نووسەر ناکات، بۆیە خوێندن ڕێگە لە نووسین ناگرێت و نووسینیش ڕێگە لە خوێندن ناگرێت. بەڵام دوو نووسەر کە هەمان دەگۆڕن هێشتا یەکتر قفڵ دەکەن.

Quick checkپشکنینی خێراWith MVCC, a report reads the accounts while a transfer is changing one of them. What does the report see?بە ، ڕاپۆرتێک هەژمارەکان دەخوێنێتەوە لە کاتێکدا گواستنەوەیەک یەکێکیان دەگۆڕێت. ڕاپۆرتەکە چی دەبینێت؟An error, because the row is lockedهەڵەیەک، چونکە ڕیزەکە قفڵ کراوەThe half-finished new balanceباڵانسە نوێیە نیوەچڵەکەThe last committed balance, without waitingدوایین باڵانسی جێگیرکراو، بەبێ چاوەڕوانی

The transaction logفایلی لۆگی مامەڵەکان

How can a DBMS undo half a transaction after a power cut, and redo a committed one whose data had not reached the disk yet? It keeps a log (the journal): a file to which it writes, in order, a record of every change, with the value before and the value after.

چۆن دەتوانێت دوای بڕانی کارەبا نیوەی هەڵبوەشێنێتەوە و جێگیرکراو دووبارە بکاتەوە کە هێشتا نەگەیشتبووە سەر دیسک؟ هەڵدەگرێت: فایلێک کە بە ڕیز تۆمارێکی هەموو گۆڕانکارییەکی تێدا دەنووسێت، لەگەڵ بەهای پێشوو و بەهای دواتر.

The log records of the transfer (simplified)تۆمارەکانی فایلی لۆگ بۆ گواستنەوەکە (سادەکراو)TEXT

<T1 start>
<T1, Aram.balance,   200000, 150000>
<T1, Shilan.balance,  80000, 130000>
<T1 commit>

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 2-3

Each update record holds the old value (for undo) and the new value (for redo).

هەر تۆمارێکی نوێکردنەوە بەهای کۆن (بۆ هەڵوەشاندنەوە) و بەهای نوێ (بۆ دووبارەکردنەوە) هەڵدەگرێت.

Lineدێڕی 4

The transaction counts as committed once this record is safely on disk.

کاتێک جێگیرکراو دەژمێردرێت کە ئەم تۆمارە بە سەلامەتی لەسەر دیسک بێت.

Log first, data later. A log record is written to stable storage before the change itself reaches the database file (write-ahead logging).
After a crash, the DBMS reads the log. A transaction with <commit> is redone, so its changes are surely on disk (durability). A transaction with <start> but no <commit> is undone with the old values (atomicity).
Backups: the same log lets a DBA restore last night's backup and then replay the log up to a chosen moment, for example one minute before someone dropped a table. This is point-in-time recovery, taught in Backup and recovery.

سەرەتا ، پاشان . تۆمارێکی پێش ئەوەی خودی گۆڕانکارییەکە بگاتە فایلی ، لەسەر بیرگەی جێگیر دەنووسرێت (⁦write-ahead logging⁩).
دوای ، دەخوێنێتەوە. کە <commit>ـی هەیە دووبارە دەکرێتەوە، بۆ ئەوەی گۆڕانکارییەکانی بە دڵنیاییەوە لەسەر دیسک بن (). کە <start>ـی هەیە بەڵام <commit>ـی نییە بە بەها کۆنەکان هەڵدەوەشێنرێتەوە ().
: هەمان ڕێگە بە دەدات شەوی ڕابردوو بگەڕێنێتەوە و پاشان تا ساتێکی هەڵبژێردراو دووبارە جێبەجێ بکاتەوە، بۆ نموونە خولەکێک پێش ئەوەی کەسێک بسڕێتەوە. ئەمە کە لە باکئەپ و گەڕاندنەوەی دراوە فێر دەبیت.

Definitionپێناسە

Keeping a (journal) of all changes made to the database, so that it can be recovered after a failure.

هەڵگرتنی (ڕۆژنامچە) بۆ هەموو گۆڕانکارییەکانی بنکەدراوە، بۆ ئەوەی دوای تێکچوون بتوانرێت بگەڕێنرێتەوە.

Quick checkپشکنینی خێراAfter a crash, the log contains <T7 start> and two update records for T7, but no <T7 commit>. What does the DBMS do with T7?دوای ، <T7 start> و دوو تۆماری نوێکردنەوەی ⁦T7⁩ی تێدایە، بەڵام <T7 commit>ی تێدا نییە. چی بە ⁦T7⁩ دەکات؟Redo it, because it has update recordsدووبارەی دەکاتەوە، چونکە تۆماری نوێکردنەوەی هەیەUndo it with the old values, because it never committedبە بەها کۆنەکان هەڵیدەوەشێنێتەوە، چونکە هەرگیز جێگیر نەکراAsk the user what to doلە بەکارهێنەر دەپرسێت چی بکات

Write-Ahead Logs. The secret to fast database queries.Ben Dicken · Englishئینگلیزی · 44K viewsبینین · 1.3K likesلایک · Partبەشی 3:06–10:45 (ofلە 11:10)
A database writes each change to a log on disk first and updates the data pages later; after a crash it uses the log to recover.
سەرەتا هەر گۆڕانکارییەک لە لەسەر دیسک دەنووسێت و دواتر لاپەڕەکانی نوێ دەکاتەوە؛ دوای ، بە یارمەتیی ئەنجام دەدات.
Plays 3:06–10:45: log first, data later; a log record with the old and the new value; checkpoints; and using the log to recover after a crash.
لە ⁦3:06⁩ تا ⁦10:45⁩ پەخش دەبێت: سەرەتا لۆگ و دواتر ، لۆگ بە کۆن و نوێوە، خاڵەکانی پشکنین (checkpoints) و بەکارهێنانی لۆگ بۆ دوای .

Common mistakesهەڵە باوەکان

Mistakeهەڵە	What goes wrongچی تێکدەچێت	Do this insteadلە جیاتی ئەوە
Two related changes run with autocommit, one after the otherدوو گۆڕانکاریی پەیوەندیدار یەک لە دوای یەک و بە autocommit جێبەجێ دەکرێن	A crash between them leaves half the work done. لە نێوانیاندا نیوەی کارەکە بە ئەنجامدراوی بەجێدەهێڵێت.	Put them between `START TRANSACTION` and `COMMIT`.بیانخەرە نێوان `START TRANSACTION` و `COMMIT`.
Forgetting `COMMIT` at the endلەبیرکردنی `COMMIT` لە کۆتاییدا	The changes are lost when the connection closes, and the locks block other users meanwhile.کاتێک پەیوەندییەکە دادەخرێت گۆڕانکارییەکان ون دەبن و لەو ماوەیەدا ڕێگە لە تر دەگرن.	End every transaction with `COMMIT` or `ROLLBACK`.هەموو بە `COMMIT` یان `ROLLBACK` کۆتایی پێبهێنە.
Keeping a transaction open while waiting for a person to typeکراوە هێشتنەوەی لە کاتی چاوەڕوانیی نووسینی کەسێکدا	Its locks block everyone else for minutes. بۆ چەند خولەکێک ڕێگە لە هەموو کەسێکی تر دەگرن.	Collect the input first, then run a short transaction.سەرەتا نووسینەکان کۆ بکەرەوە، پاشان کورت جێبەجێ بکە.
Expecting `ROLLBACK` to undo `DROP TABLE` in MySQLچاوەڕوانیی ئەوەی `ROLLBACK` لە MySQL `DROP TABLE` هەڵبوەشێنێتەوە	Structure statements commit implicitly and cannot be rolled back.فەرمانەکانی پێکهاتە خۆکارانە جێگیر دەکەن و خۆیان هەڵناوەشێنرێنەوە.	Take a backup before changing the structure.پێش گۆڕینی پێکهاتە بگرە.
Reading a balance into the program, changing it there and writing it backخوێندنەوەی باڵانس بۆ ناو بەرنامە، گۆڕینی لەوێ و نووسینەوەی	Lost updates when two users do it at once. کاتێک دوو لە هەمان کاتدا دەیکەن.	`UPDATE ... SET balance = balance - 30000`, or lock the row with `SELECT ... FOR UPDATE`.`UPDATE ... SET balance = balance - 30000`، یان بە `SELECT ... FOR UPDATE` قفڵ بکە.
Showing an error when a deadlock happensپیشاندانی هەڵە کاتێک ڕوودەدات	The user's work fails for no real reason.کاری بەبێ هۆکارێکی ڕاستەقینە شکست دەهێنێت.	Retry the transaction automatically. بە خۆکاری دووبارە هەوڵ بدەرەوە.

Exercisesڕاهێنانەکان

Exerciseڕاهێنان1. Which ACID property?١. کام تایبەتمەندیی ACID؟

(a) A ticket is never marked as sold unless the payment is also saved. (b) A report run during a transfer never sees money 'in the air'. (c) After 'Order confirmed' appears, a power cut does not lose the order. (d) An order for 5 items is refused because only 3 are in stock and stock may not go below zero.

(أ) بلیتێک هەرگیز وەک فرۆشراو نیشان ناکرێت مەگەر پارەدانەکەش پاشەکەوت کرابێت. (ب) ڕاپۆرتێک لە کاتی گواستنەوەدا هەرگیز پارەی «لە هەوادا» نابینێت. (ج) دوای دەرکەوتنی «داواکاری پشتڕاست کرایەوە»، بڕانی کارەبا داواکارییەکە ون ناکات. (د) داواکارییەک بۆ ٥ دانە ڕەت دەکرێتەوە چونکە تەنها ٣ لە کۆگادا هەیە و کۆگا نابێت لە سفر کەمتر بێت.

Show answerوەڵامەکە پیشان بدە

(a) Atomicity.
(b) Isolation.
(c) Durability.
(d) Consistency (a CHECK rule).

(أ) .
(ب) .
(ج) .
(د) (ڕێسایەکی CHECK).

Exerciseڕاهێنان2. Predict the output٢. دەرئەنجامەکە پێشبینی بکە

The table accounts holds Aram 150000 and Shilan 130000. What does this script print?

accounts ئارام ⁦150000⁩ و شیلان ⁦130000⁩ هەڵدەگرێت. ئەم سکریپتە چی چاپ دەکات؟

SQL

BEGIN;
UPDATE accounts SET balance = balance + 10000 WHERE account_id = 2;
DELETE FROM accounts WHERE account_id = 1;
ROLLBACK;
SELECT * FROM accounts;

Show answerوەڵامەکە پیشان بدە

Output (sqlite3)دەرئەنجام ⁦(sqlite3)⁩

1|Aram|150000
2|Shilan|130000

ROLLBACK cancels both the update and the delete.

ROLLBACK هەم نوێکردنەوەکە و هەم سڕینەوەکە هەڵدەوەشێنێتەوە.

Exerciseڕاهێنان3. An order that must be all or nothing٣. داواکارییەک کە دەبێت هەمووی یان هیچ بێت

A shop has 5 USB cables. Write two orders as transactions: the first for 3 cables, the second for 4. Each order inserts a row into orders and reduces stock. What is left in the tables at the end?

دووکانێک ٥ کێبڵی USBـی هەیە. دوو داواکاری وەک بنووسە: یەکەم بۆ ٣ کێبڵ، دووەم بۆ ٤. هەر داواکارییەک دەخاتە ناو orders و stock کەم دەکاتەوە. لە کۆتاییدا چی لە دەمێنێتەوە؟

Hintئاماژە

Put CHECK (stock >= 0) on the stock column.

CHECK (stock >= 0) لەسەر stock دابنێ.

Show answerوەڵامەکە پیشان بدە

order.sqlSQL

CREATE TABLE products (
  product_id INT PRIMARY KEY,
  name       VARCHAR(50) NOT NULL,
  stock      INT NOT NULL CHECK (stock >= 0)
);
CREATE TABLE orders (
  order_id   INT PRIMARY KEY,
  product_id INT NOT NULL,
  quantity   INT NOT NULL
);
INSERT INTO products VALUES (1, 'USB cable', 5);

BEGIN;
INSERT INTO orders VALUES (1, 1, 3);
UPDATE products SET stock = stock - 3 WHERE product_id = 1;
COMMIT;

BEGIN;
INSERT INTO orders VALUES (2, 1, 4);
UPDATE products SET stock = stock - 4 WHERE product_id = 1;
ROLLBACK;

SELECT * FROM products;
SELECT * FROM orders;

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 20-21

Only 2 cables are left, so the UPDATE breaks the CHECK rule; the program rolls back, which also removes order 2.

تەنها ٢ کێبڵ ماونەتەوە، بۆیە UPDATE ڕێسای CHECK دەشکێنێت؛ بەرنامەکە هەڵیدەوەشێنێتەوە، کە داواکاریی ٢یش لادەبات.

Exerciseڕاهێنان4. Find the lost update٤. نوێکردنەوەی ونبوو بدۆزەرەوە

A cinema has 10 free seats in a showing. Two booking programs each read '10 free', each sell 2 seats, and each write '8 free'. How many seats are really free? Give two ways to fix it.

سینەمایەک لە نمایشێکدا ١٠ کورسیی بەتاڵی هەیە. دوو بەرنامەی حیجزکردن هەر یەکەیان «١٠ بەتاڵ» دەخوێنێتەوە، هەر یەکەیان ٢ کورسی دەفرۆشێت و هەر یەکەیان «٨ بەتاڵ» دەنووسێت. بە ڕاستی چەند کورسی بەتاڵە؟ دوو ڕێگای چارەسەر بدە.

Show answerوەڵامەکە پیشان بدە

6 seats are really free, but the database says 8: one sale was lost, and two seats may be sold twice. Fix 1: lock the row (SELECT ... FOR UPDATE inside a transaction), so the second program waits and then reads 8. Fix 2: let the database do the arithmetic in one statement, UPDATE showings SET free_seats = free_seats - 2 WHERE showing_id = 7;, with CHECK (free_seats >= 0).

بە ڕاستی ٦ کورسی بەتاڵە، بەڵام دەڵێت ٨: یەک فرۆشتن ون بوو و دەکرێت دوو کورسی دوو جار بفرۆشرێن. چارەسەری ١: قفڵ بکە (SELECT ... FOR UPDATE لە ناو )، بۆ ئەوەی بەرنامەی دووەم چاوەڕێ بکات و پاشان ٨ بخوێنێتەوە. چارەسەری ٢: بهێڵە بە یەک فەرمان ژمێرکارییەکە بکات، UPDATE showings SET free_seats = free_seats - 2 WHERE showing_id = 7;، لەگەڵ CHECK (free_seats >= 0).

Exercisesڕاهێنانەکان

More practice: two dispatchers, one ambulanceڕاهێنانی زیاتر: دوو فەرمانبەری ناردن و یەک ئەمبولانس

Exerciseڕاهێنان5. Two dispatchers, one ambulance٥. دوو فەرمانبەری ناردن و یەک ئەمبولانس

At an emergency centre in Sulaymaniyah, two dispatchers take calls at the same moment. Each program reads that ambulance 7 is free and then gives it to its own call. What goes wrong? Give two ways to fix it.

لە ناوەندێکی فریاکەوتن لە سلێمانی، دوو فەرمانبەری ناردن لە هەمان ساتدا پەیوەندی وەردەگرن. هەر دەخوێنێتەوە کە ئەمبولانسی 7 بەتاڵە و پاشان دەیداتە پەیوەندییەکەی خۆی. چی هەڵە دەبێت؟ دوو ڕێگای چارەسەر بدە.

Show answerوەڵامەکە پیشان بدە

Both programs read 'free' before either one writes, so ambulance 7 is sent to two calls and one patient waits for nothing: the same race as the lost update. Fix 1: inside one transaction, lock the row while reading it (SELECT … FOR UPDATE), so the second dispatcher waits and then reads 'busy'. Fix 2: make the check and the change one statement, and look at how many rows it changed:

هەردوو پێش ئەوەی هیچیان بنووسێت «بەتاڵ» دەخوێننەوە، بۆیە ئەمبولانسی 7 بۆ دوو پەیوەندی دەنێردرێت و نەخۆشێک بە بێهودە چاوەڕێ دەکات: هەمان پێشبڕکێی . چارەسەری ١: لە ناو یەک لە کاتی خوێندنەوەدا قفڵ بکە (SELECT … FOR UPDATE)، بۆ ئەوەی فەرمانبەری دووەم چاوەڕێ بکات و پاشان «سەرقاڵ» بخوێنێتەوە. چارەسەری ٢: پشکنین و گۆڕین بکە بە یەک فەرمان و سەیر بکە چەند گۆڕیوە:

ambulance.sqlSQLRuns in the databaseلە ناو بنکەدراوە کار دەکات

CREATE TABLE ambulances (
  ambulance_id INT PRIMARY KEY,
  status       VARCHAR(10) NOT NULL,
  call_id      INT
);
INSERT INTO ambulances VALUES (7, 'free', NULL);
-- dispatcher A
UPDATE ambulances SET status = 'busy', call_id = 101
WHERE ambulance_id = 7 AND status = 'free';
SELECT changes();
-- dispatcher B, a moment later
UPDATE ambulances SET status = 'busy', call_id = 102
WHERE ambulance_id = 7 AND status = 'free';
SELECT changes();
SELECT * FROM ambulances;

Explain the codeڕوونکردنەوەی کۆدەکە

Lineدێڕی 8-9

The WHERE checks that the ambulance is still free in the same statement that takes it.

WHERE لە هەمان ئەو فەرمانەدا کە ئەمبولانسەکە دەبات دەپشکنێت کە هێشتا بەتاڵە.

Lineدێڕی 10, 14

changes() is SQLite; in MySQL the program reads the affected-row count (ROW_COUNT()).

changes() هی SQLiteـە؛ لە MySQL ژمارەی گۆڕاوەکان دەخوێنێتەوە (ROW_COUNT()).

Summary and reviewپوختە و پێداچوونەوە

A transaction is a unit of work: its statements all take effect or none does.
START TRANSACTION / BEGIN starts it. COMMIT (a commit) makes it permanent and ROLLBACK (a rollback) cancels it. With autocommit, each statement is its own transaction.
ACID: atomicity (all or nothing), consistency (the rules still hold), isolation (no one sees half-done work), durability (committed means permanent).
Without concurrency control, users at the same time cause lost updates, dirty reads and changing reads. Isolation levels choose how strict the DBMS is.
Locks make other transactions wait; a deadlock is solved by rolling one transaction back, which the program should retry.
The transaction log records every change with its old and new value. After a crash it is used to redo committed and undo unfinished transactions, and with backups it allows point-in-time recovery.

یەکەیەکی کارە: یان هەموو فەرمانەکانی کاریگەر دەبن یان هیچیان.
START TRANSACTION / BEGIN دەستی پێدەکات. COMMIT () هەمیشەیی دەکات و ROLLBACK () هەڵیدەوەشێنێتەوە. لەگەڵ autocommit، هەر فەرمانێک خۆیەتی.
ACID: (هەمووی یان هیچ)، (ڕێساکان هێشتا ڕاستن)، (کەس کاری نیوەچڵ نابینێت)، (جێگیرکراو واتە هەمیشەیی).
بەبێ ، چەند لە هەمان کاتدا دەبنە هۆی ، و خوێندنەوەی گۆڕاو. ئاستەکانی دیاری دەکەن چەند توند بێت.
تر چاوەڕێ دەخەن؛ بە هەڵوەشاندنەوەی یەک چارەسەر دەکرێت، کە بەرنامەکە دەبێت دووبارە هەوڵی بداتەوە.
هەموو گۆڕانکارییەک لەگەڵ بەهای کۆن و نوێی تۆمار دەکات. دوای بەکاردێت بۆ دووبارەکردنەوەی و هەڵوەشاندنەوەی تەواونەکراوەکان و لەگەڵ مومکین دەکات.

Review questionsپرسیارەکانی پێداچوونەوە

What is a transaction? Give an everyday example.مامەڵە چییە؟ نموونەیەکی ڕۆژانە بهێنەوە.

A group of statements that must all succeed or all fail together, for example a bank transfer: money leaves one account and arrives in another.

کۆمەڵێک فەرمان کە دەبێت هەموویان پێکەوە سەرکەوتوو بن یان هەموویان شکست بهێنن، بۆ نموونە گواستنەوەی پارە لە بانکدا: پارە لە هەژمارێک دەردەچێت و دەگاتە هەژمارێکی تر.

What is the difference between COMMIT and ROLLBACK?جیاوازیی نێوان COMMIT و ROLLBACK چییە؟

COMMIT makes all the transaction's changes permanent (a commit); ROLLBACK cancels all of them (a rollback).

COMMIT هەموو گۆڕانکارییەکانی هەمیشەیی دەکات ()؛ ROLLBACK هەموویان هەڵدەوەشێنێتەوە ().

What do the four letters of ACID stand for?چوار پیتەکەی ACID بۆ چی دەگەڕێنەوە؟

Atomicity, Consistency, Isolation, Durability.

، ، ، .

Explain the lost update in one sentence.نوێکردنەوەی ونبوو بە یەک ڕستە ڕوون بکەرەوە.

Two transactions read the same value and both write a new one, so the second write covers the first and one change disappears.

دوو هەمان بەها دەخوێننەوە و هەردووکیان بەهایەکی نوێ دەنووسن، بۆیە نووسینی دووەم نووسینی یەکەم دادەپۆشێت و گۆڕانکارییەک ون دەبێت.

Why does the DBMS write to the log before it changes the data?بۆچی سیستەمی بەڕێوەبردنی بنکەدراوە پێش گۆڕینی دراوە لە فایلی لۆگ دەنووسێت؟

So that after a crash it always knows what to redo and what to undo. That is how it keeps atomicity and durability.

بۆ ئەوەی دوای هەمیشە بزانێت چی دووبارە بکاتەوە و چی هەڵبوەشێنێتەوە. بەم شێوەیە و دەپارێزێت.

Lesson complete!وانەکە تەواو بوو!

Well done. Review the key terms, then go on to the next lesson.دەستخۆش. سەیرێکی زاراوە سەرەکییەکان بکەرەوە، پاشان بڕۆ بۆ وانەی داهاتوو.

Key termsزاراوە سەرەکییەکان

Next lessonوانەی داهاتوو

Backup and Recoveryباکئەپ و گەڕاندنەوەی دراوە

Related lecturesوانە پەیوەندیدارەکان

References and further readingسەرچاوەکان و خوێندنەوەی زیاتر

This lecture is a first edition. The Kurdish text and terminology are waiting for review by Kurdish IT teachers.ئەم وانەیە چاپی یەکەمە. دەقە کوردییەکە و زاراوەکانی چاوەڕێی پێداچوونەوەی مامۆستایانی کوردی بواری IT ن.