Outline. Review questions. Carnegie Mellon Univ. Dept. of Computer Science Database Applications

Size: px

Start display at page:

Download "Outline. Review questions. Carnegie Mellon Univ. Dept. of Computer Science Database Applications"

Grace Austin
5 years ago
Views:

1 arnegie Mellon Univ. Dept. of omputer Science Database pplications Lecture #22: oncurrency ontrol Part 2 (R&G ch. 17) aloutsos SS #1 Outline conflict/view serializability Two-phase locking (2PL); strict 2PL (== 2PL-, for ommit ) deadlocks prevention & detection Locking granularity Tree locking protocols Phantoms & predicate locking aloutsos SS #2 Review questions conflict serializability? 2PL theorem? what is strict 2PL? why do we need it? dirty read? cascading aborts? who generates the lock requests? aloutsos SS #3 1

2 Not in book: Lost update problem time aloutsos SS #4 Major conclusions so far: (strict) 2PL: extremely popular Deadlock may still happen detection: wait-for graph prevention: abort some xacts, defensively philosophically: concurrency control uses: locks and aborts aloutsos SS #5 Outline conflict/view serializability Two-phase locking (2PL); strict 2PL (== 2PL-, for ommit ) deadlocks prevention & detection Locking granularity Tree locking protocols Phantoms & predicate locking aloutsos SS #6 2

3 Lock granularity? - lock granularity - field? record? page? table? - Pros and cons? - (Ideally, each transaction should obtain a few locks) aloutsos SS #7 Multiple granularity Eg: D Table1 Table2 record1 record2 record-n attr1 attr2 attr1 aloutsos SS #8 What would you do? T1: read Smith s salary, while T2: give 10% raise to everybody what locks should they obtain? D Table1 Table2 record1 record2 record-n aloutsos SS #9 3

4 What types of locks? X/S locks for leaf level + intent locks, for higher levels aloutsos SS #10 What types of locks? X/S locks for leaf level + intent locks, for higher levels IS: intent to obtain S-lock underneath IX: intent X-lock... S: shared lock for this level X: ex- lock for this level SIX: shared lock here; + IX aloutsos SS #11 Protocol - each xact obtains appropriate lock at highest level - proceeds to desirable lower levels aloutsos SS #12 4

5 ompatibility matrix T2 wants T1 has IS IS IX S SIX X IX S SIX X aloutsos SS #13 ompatibility matrix T2 wants T1 has IS IS IX S SIX X Y Y Y Y N IX S SIX X aloutsos SS #14 ompatibility matrix T2 wants T1 has IS IX IS IX S SIX X Y Y Y Y N Y N N N S SIX X aloutsos SS #15 5

6 ompatibility matrix T2 wants T1 has IS IX IS IX S SIX X Y Y Y Y N Y N N N S Y N N SIX X aloutsos SS #16 ompatibility matrix T2 wants T1 has IS IX IS IX S SIX X Y Y Y Y N Y N N N S Y N N SIX N N X N aloutsos SS #17 Multiple Granularity Lock Protocol Each Xact: lock root. To get S or IS lock on a node, must hold at least IS on parent node. What if Xact holds SIX on parent? S on parent? To get X or IX or SIX on a node, must hold at least IX on parent node. Must release locks in bottom-up order. aloutsos SS #18 6

7 Multiple granularity protocol X SIX stronger (more privileges) S IX IS weaker aloutsos SS #19 Examples 2 level hierarchy T1 scans R, and updates a few tuples: Tables Tuples aloutsos SS #20 Examples 2 level hierarchy T1 scans R, and updates a few tuples: T1 gets an SIX lock on R, then get X lock on tuples that are updated. aloutsos SS #21 7

8 Examples 2 level hierarchy T2: find avg salary of Sales employees aloutsos SS #22 Examples 2 level hierarchy T2: find avg salary of Sales employees T2 gets an IS lock on R, and repeatedly gets an S lock on tuples of R. aloutsos SS #23 Examples 2 level hierarchy T3: sum of salaries of everybody in R : aloutsos SS #24 8

9 Examples 2 level hierarchy T3: sum of salaries of everybody in R : T3 gets an S lock on R. OR, T3 could behave like T2; can use lock escalation to decide which. Lock escalation dynamically asks for coarser-grained locks when too many low level locks acquired aloutsos SS #25 Multiple granularity Very useful in practice each xact needs only a few locks aloutsos SS #26 Outline... Locking granularity Tree locking protocols Phantoms & predicate locking aloutsos SS #27 9

10 Locking in + Trees What about locking indexes? aloutsos SS #28 Example +tree T1 wants to insert in H T2 wants to insert in I why not plain 2PL? root D E G H I aloutsos SS #29 Example +tree T1 wants to insert in H T2 wants to insert in I why not plain 2PL? root ecause: X/S locks for too long! D E G H I aloutsos SS #30 10

11 Two main ideas: crabbing : get lock for parent; get lock for child; release lock for parent (if safe ) safe nodes == nodes that won t split or merge, ie: not full (on insertion) more than half-full (on deletion) aloutsos SS #31 Example +tree T1 wants to insert in H crabbing: root D E G H I aloutsos SS #32 Example +tree T1 wants to insert in H root D E G H I aloutsos SS #33 11

12 Example +tree T1 wants to insert in H (if is safe ) root D E G H I aloutsos SS #34 Example +tree T1 wants to insert in H continue crabbing root D E G H I aloutsos SS #35 Simple Tree Locking lgorithm: crabbing Search: Start at root and go down; repeatedly, S lock child then unlock parent Insert/Delete: Start at root and go down, obtaining X locks as needed. Once child is locked, check if it is safe: If child is safe, release all locks on ancestors. aloutsos SS #36 12

13 ROOT Example Do: 1) Search 38* 2) Delete 38* 3) Insert 45* 4) Insert 25* G H I D E 20* 22* 23* 24* 35* 36* 38* 41* 44* aloutsos SS #37 nswers: 1. Search 38* crabbing : S, S, U, S, U, S D, U 2. Delete 38* X, X, X ; U, U, X D, U 3. Insert 45* X, X ; U, X, X E, U 4. Insert 25* X, X, U, X, U, X H aloutsos SS #38 nswer: search 38* D aloutsos SS #39 13

14 S S S S D U U U <read 38*> U D nswer: search 38* D aloutsos SS #40 nswer: delete 38* D aloutsos SS #41 X X X X D U U U <delete 38*> U D nswer: delete 38* max concurrency D aloutsos SS #42 14

15 nswer: insert 45* E aloutsos SS #43 X X X X E U U U <insert 45* > U E nswer: insert 45* E aloutsos SS #44 nswer: insert 25* H aloutsos SS #45 15

16 X X U X U X H <insert 25*> <split H> <update > U U H nswer: insert 25* aloutsos SS #46 H X X U X U X H <insert 25*> <split H> <update > U H U nswer: insert 25* Q: Why not swap? aloutsos SS #47 H X X U X U X H <insert 25*> <split H> <update > U H U nswer: insert 25* Q: Why not swap? aloutsos SS #48 H : swapping does not help concurrency! 16

17 nswers: 1. Search 38* crabbing : S, S, U, S, U, S D, U 2. Delete 38* X, X, X ; U, U, X D, U 3. Insert 45* X, X ; U, X, X E, U 4. Insert 25* X, X, U, X, U, X H aloutsos SS #49 nswers: 1. Search 38* crabbing : S, S, U, S, U, S D, U 2. Delete 38* X, X, X ; U, U, X D, U 3. Insert 45* X, X ; U, X, X E, U 4. Insert 25* X, X, U, X, U, X H aloutsos SS #50 N WE DO ETTER? an we do better? Yes [ayer and Schkolnik]: Idea: hope that the leaf is safe, and use S- locks & crabbing to reach it, and verify (if false, do previous algo) aloutsos SS #51 17

cta Inf. 9: 1-21 (1977) etter Tree Locking lgorithm (rom ayer-schkolnick paper) Search: s before.

If leaf is not safe, release all locks, and restart Xact using previous Insert/Delete protocol.

18 an we do better? Yes [ayer and Schkolnik]: Rudolf ayer, Mario Schkolnick: oncurrency aloutsos SS #52 of Operations on -Trees. cta Inf. 9: 1-21 (1977) etter Tree Locking lgorithm (rom ayer-schkolnick paper) Search: s before. Insert/Delete: Set locks as if for search, get to leaf, and set X lock on leaf. If leaf is not safe, release all locks, and restart Xact using previous Insert/Delete protocol. Gambles that only leaf node will be modified; if not, S locks set on the first pass to leaf are wasteful. In practice, better than previous alg. aloutsos SS #53 ROOT Example 20 Do: 1) Delete 38* 2) Insert 25* G H I D E 20* 22* 23* 24* 35* 36* 38* 41* 44* aloutsos SS #54 18

19 nswers: 1. Delete 38* S, S, U, S, U, X D, U 2. Insert 25* S, S, U, S, U, X H; U H; X, X, U, X, U, X H aloutsos SS #55 Notice: Textbook has a third variation, that uses lock-upgrades (and may lead to deadlocks) aloutsos SS #56 Outline Locking granularity Tree locking protocols Phantoms & predicate locking aloutsos SS #57 19

20 Dynamic Databases The Phantom Problem so far: only reads and updates no insertions/ deletions with insertions/deletions, new problems: aloutsos SS #58 The phantom problem T1 T2 time select max(age)... where rating=1 select max(age)... where rating=1 insert... age=96 rating=1 aloutsos SS #59 Why? because T1 locked only *existing* records not ones under way! Solution? aloutsos SS #60 20

21 Solution theoretical solution: predicate locking : e.g., lock all records (current or incoming) with rating=1 VERY EXPENSIVE aloutsos SS #61 Solution practical solution: index locking: if an index (on rating ) exists, lock the appropriate entries (rating=1 in our case) otherwise, lock whole table (and thus block insertions/deletions) aloutsos SS #62 Transaction Support in SQL-92 SERILIZLE No phantoms, all reads repeatable, no dirty (uncommited) reads. REPETLE REDS phantoms may happen. RED OMMITTED phantoms and unrepeatable reads may happen RED UNOMMITTED all of them may happen. recommended aloutsos SS #63 21

22 Transaction Support in SQL-92 SERILIZLE : obtains all locks first; plus index locks, plus strict 2PL REPETLE REDS as above, but no index locks RED OMMITTED as above, but S- locks are released immediately RED UNOMMITTED as above, but allowing dirty reads (no S-locks) aloutsos SS #64 Transaction Support in SQL-92 SET TRNSTION ISOLTION LEVEL SERILIZLE RED ONLY Defaults: SERILIZLE RED WRITE isolation level access mode aloutsos SS #65 Summary Multiple granularity locking: leads to few locks, at appropriate levels Tree-structured indexes: crabbing and safe nodes (notice: Multiple gran. locking: releases locks bottomup Tree-locking: top-down (to max. concurrency) aloutsos SS #66 22

23 Summary phantom problem, if insertions/deletions (Predicate locking prevents phantoms) Index locking, or table locking aloutsos SS #67 23

Goal of Concurrency Control. Concurrency Control. Example. Solution 1. Solution 2. Solution 3

Goal of Concurrency Control. Concurrency Control. Example. Solution 1. Solution 2. Solution 3 Goal of Concurrency Control Concurrency Control Transactions should be executed so that it is as though they executed in some serial order Also called Isolation or Serializability Weaker variants also