1 / 114

Lecture 5: Transactions in SQL

Explore the significance of transactions in SQL, including concurrency control, recovery mechanisms, and anomalies, as well as the basics of transaction management and properties such as ACID. Join us for an insightful lecture on database systems.

salazarl
Télécharger la présentation

Lecture 5: Transactions in SQL

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Lecture 5:Transactions in SQL Tuesday, February 6, 2007

  2. Outline • Transactions in SQL, the buffer manager • Recovery • Chapter 17 in Ullman’s book • Concurrency control • Chapter 18 in Ullman’s book

  3. Comments on the Textbook • Ullman’s book: chapters 17,18 • Gentle introduction • We follow mostly this text in class • Ramakrishnan: chapters 16,17,18 • Describes quite accurately existing systems (e.g. Aries) • Not recommended as first reading

  4. Transactions • Major component of database systems • Critical for most applications; arguably more so than SQL • Turing awards to database researchers: • Charles Bachman 1973 • Edgar Codd 1981 for inventing relational dbs • Jim Gray 1998 for inventing transactions

  5. Why Do We Need Transactions • Concurrency control • Recovery

  6. Concurrency control:Three Famous anomalies • Dirty read • T reads data written by T’ while T’ is running • Then T’ aborts • Lost update • Two tasks T and T’ both modify the same data • T and T’ both commit • Final state shows effects of only T, but not of T’ • Inconsistent read • One task T sees some but not all changes made by T’

  7. Dirty Reads Client 1: /* transfer $100 from account 1 to account 2 */ UPDATE Accounts SET balance = balance + 100WHERE accountNo = ‘11111’ X = SELECT balance FROM Accounts WHERE accountNo = ‘2222’ If X < 100 /* abort . . . . */ then UPDATE Accounts SET balance = balance - 100WHERE accountNo = ‘11111’ Else UPDATE Accounts SET balance = balance - 100WHERE accountNo = ‘2222’ Client 2: /* withdraw $100 from account 1 */ X = SELECT balance FROM Accounts WHERE accountNo = ‘1111’ If X > 100 then UPDATE Accounts SET balance = balance - 100WHERE accountNo = ‘11111’ . . . . . Dispense cash . . . .Cli

  8. Lost Updates Client 1: UPDATE ProductSET Price = Price – 1.99WHERE pname = ‘Gizmo’ Client 2:UPDATE ProductSET Price = Price*0.5WHERE pname=‘Gizmo’ Two managers attempt to do a discount.Will it work ?

  9. Inconsistent Read Client 1: UPDATE Products SET quantity = quantity + 5WHERE product = ‘gizmo’ UPDATE Products SET quantity = quantity - 5WHERE product = ‘gadget’ Client 2: SELECT sum(quantity) FROM Product What’s wrong ?

  10. Protection against crashes Client 1: UPDATE Products SET quantity = quantity + 5WHERE product = ‘gizmo’ UPDATE Products SET quantity = quantity - 5WHERE product = ‘gadget’ Crash ! What’s wrong ?

  11. Definition • A transaction = one or more operations, which reflects a single real-world transition • In the real world, this happened completely or not at all • Examples • Transfer money between accounts • Purchase a group of products • Register for a class (either waitlist or allocated) • If grouped in transactions, all problems in previous slides disappear

  12. Transactions in SQL • In “ad-hoc” SQL: • Default: each statement = one transaction • In a program: START TRANSACTION [SQL statements] COMMIT or ROLLBACK (=ABORT) May be omitted:first SQL querystarts txn

  13. Revised Code Client 1: START TRANSACTION UPDATE ProductSET Price = Price – 1.99WHERE pname = ‘Gizmo’ COMMIT Client 2: START TRANSACTIONUPDATE ProductSET Price = Price*0.5WHERE pname=‘Gizmo’COMMIT Now it works like a charm

  14. Transaction PropertiesACID • Atomic • State shows either all the effects of txn, or none of them • Consistent • Txn moves from a state where integrity holds, to another where integrity holds • Isolated • Effect of txns is the same as txns running one after another (ie looks like batch mode) • Durable • Once a txn has committed, its effects remain in the database

  15. ROLLBACK • If the app gets to a place where it can’t complete the transaction successfully, it can execute ROLLBACK • This causes the system to “abort” the transaction • The database returns to the state without any of the previous changes made by activity of the transaction

  16. Reasons for Rollback • User changes their mind (“ctl-C”/cancel) • Explicit in program, when app program finds a problem • e.g. when qty on hand < qty being sold • System-initiated abort • System crash • Housekeeping • e.g. due to timeouts

  17. Theory ofTransaction Management Two parts: • Recovery from crashes: ACID • Concurrency control: ACID Both operate on the buffer pool

  18. Recovery Mostfrequent

  19. Tracks Arm movement Arm assembly The Mechanics of Disk Cylinder Mechanical characteristics: • Rotation speed (5400RPM) • Number of platters (1-30) • Number of tracks (<=10000) • Number of bytes/track(105) Spindle Disk head Sector Unit of read or write: disk block Once in memory: page Typically: 4k or 8k or 16k Platters

  20. Disk Access Characteristics • Disk latency = time between when command is issued and when data is in memory • Disk latency = seek time + rotational latency • Seek time = time for the head to reach cylinder • 10ms – 40ms • Rotational latency = time for the sector to rotate • Rotation time = 10ms • Average latency = 10ms/2 • Transfer time = typically 40MB/s • Disks read/write one block at a time

  21. RAID:Protect against HW Failure Several disks that work in parallel • Redundancy: use parity to recover from disk failure • Speed: read from several disks at once Various configurations (called levels): • RAID 1 = mirror • RAID 4 = n disks + 1 parity disk • RAID 5 = n+1 disks, assign parity blocks round robin • RAID 6 = “Hamming codes”

  22. DB Buffer Management in a DBMS Page Requests from Higher Levels READ WRITE BUFFER POOL • Data must be in RAM for DBMS to operate on it! • Table of <frame#, pageid> pairs is maintained disk page INPUT OUTUPT free frame MAIN MEMORY DISK choice of frame dictated by replacement policy

  23. Buffer Manager • Needs to decide on page replacement policy • LRU • Clock algorithm • Both work well in OS, but not always in DB • Enables the higher levels of the DBMS to assume that the • needed data is in main memory.

  24. Least Recently Used (LRU) • Order pages by the time of last accessed • Always replace the least recently accessed P5, P2, P8, P4, P1, P9, P6, P3, P7 Access P6 P6, P5, P2, P8, P4, P1, P9, P3, P7 LRU is expensive (why ?); the clock algorithm is good approx

  25. Buffer Manager Why not use the Operating System for the task?? Two reasons: • May improve performance by knowing the access pattern • Need fined-grained access to the operations to ensure ACID semantics

  26. Transaction Manager Operates on the buffer pool • Recovery: • ‘log-file write-ahead’, • policy about which pages to force to disk • Concurrency: • locks at the page level, • Or multiversion concurrency control

  27. Transactions • Assumption: the database is composed of elements • Usually 1 element = 1 block • Can be smaller (=1 record) or larger (=1 relation) • Assumption: each transaction reads/writes some elements

  28. Primitive Operations of Transactions • READ(X,t) • copy element X to transaction local variable t • WRITE(X,t) • copy transaction local variable t to element X • INPUT(X) • read element X to memory buffer • OUTPUT(X) • write element X to disk

  29. START TRANSACTION READ(A,t); t := t*2; WRITE(A,t); READ(B,t); t := t*2; WRITE(B,t) COMMIT; Example Atomicity: BOTH A and Bare multiplied by 2

  30. READ(A,t); t := t*2; WRITE(A,t); READ(B,t); t := t*2; WRITE(B,t) Transaction Buffer pool Disk

  31. Crash ! Crash occurs after OUTPUT(A), before OUTPUT(B) We lose atomicity

  32. The Log • An append-only file containing log records • Note: multiple transactions run concurrently, log records are interleaved • After a system crash, use log to: • Redo some transaction that didn’t commit • Undo other transactions that didn’t commit • Three kinds of logs: undo, redo, undo/redo

  33. Undo Logging Log records • <START T> • transaction T has begun • <COMMIT T> • T has committed • <ABORT T> • T has aborted • <T,X,v> • T has updated element X, and its old value was v

  34. Crash ! WHAT DO WE DO ?

  35. Crash ! WHAT DO WE DO ?

  36. After Crash • In the first example: • We UNDO both changes: A=8, B=8 • The transaction is atomic, since none of its actions has been executed • In the second example • We don’t undo anything • The transaction is atomic, since both it’s actions have been executed

  37. Undo-Logging Rules U1: If T modifies X, then <T,X,v> must be written to disk before OUTPUT(X) U2: If T commits, then OUTPUT(X) must be written to disk before <COMMIT T> • Hence: OUTPUTs are done early, before the transaction commits

  38. Recovery with Undo Log After system’s crash, run recovery manager • Idea 1. Decide for each transaction T whether it is completed or not • <START T>….<COMMIT T>…. = yes • <START T>….<ABORT T>……. = yes • <START T>……………………… = no • Idea 2. Undo all modifications by incomplete transactions

  39. Recovery with Undo Log Recovery manager: • Read log from the end; cases: <COMMIT T>: mark T as completed <ABORT T>: mark T as completed <T,X,v>: if T is not completed then write X=v to disk else ignore <START T>: ignore

  40. Recovery with Undo Log … … <T6,X6,v6> … … <START T5> <START T4> <T1,X1,v1> <T5,X5,v5> <T4,X4,v4> <COMMIT T5> <T3,X3,v3> <T2,X2,v2> Question1 in class: Which updates areundone ? Question 2 in class: How far backdo we need toread in the log ? crash

  41. Recovery with Undo Log • Note: all undo commands are idempotent • If we perform them a second time, no harm is done • E.g. if there is a system crash during recovery, simply restart recovery from scratch

  42. Recovery with Undo Log When do we stop reading the log ? • We cannot stop until we reach the beginning of the log file • This is impractical Instead: use checkpointing

  43. Checkpointing Checkpoint the database periodically • Stop accepting new transactions • Wait until all current transactions complete • Flush log to disk • Write a <CKPT> log record, flush • Resume transactions

  44. Undo Recovery with Checkpointing … … <T9,X9,v9> … … (all completed) <CKPT> <START T2> <START T3 <START T5> <START T4> <T1,X1,v1> <T5,X5,v5> <T4,X4,v4> <COMMIT T5> <T3,X3,v3> <T2,X2,v2> other transactions During recovery, Can stop at first <CKPT> transactions T2,T3,T4,T5

  45. Nonquiescent Checkpointing • Problem with checkpointing: database freezes during checkpoint • Would like to checkpoint while database is operational • Idea: nonquiescent checkpointing • Quiescent = being quiet, still, or at rest; inactive • Non-quiescent = allowing transactions to be active

  46. Nonquiescent Checkpointing • Write a <START CKPT(T1,…,Tk)>where T1,…,Tk are all active transactions • Continue normal operation • When all of T1,…,Tk have completed, write <END CKPT>

  47. Undo Recovery with Nonquiescent Checkpointing … … … … … … <START CKPT T4, T5, T6> … … … … <END CKPT> … … … earlier transactions plus T4, T5, T6 During recovery, Can stop at first <CKPT> T4, T5, T6, plus later transactions later transactions Q: do we really need <END CKPT> ?

  48. Redo Logging Log records • <START T> = transaction T has begun • <COMMIT T> = T has committed • <ABORT T>= T has aborted • <T,X,v>= T has updated element X, and its new value is v

More Related