118 lines
4.5 KiB
Typst
118 lines
4.5 KiB
Typst
#set page(paper: "a4", flipped: true, margin: 0.5cm, columns: 4)
|
|
#set text(size: 9pt)
|
|
#show heading: set block(spacing:0.6em)
|
|
|
|
= Storage
|
|
- Parts of disk
|
|
- Platter has 2 surfaces
|
|
- Surface has many tracks
|
|
- Each track is broken up into sectors
|
|
- Cylinder is the same tracks across all surfaces
|
|
- Block comprises of multiple sectors
|
|
- *Disk Access Time* - $"Seek time" + "Rotational Delay" + "Transfer Time"$
|
|
- *Seek Time* - Move arms to position disk head
|
|
- *Rotational Delay* - $1/2 60/"RPM"$
|
|
- *Transfer time*(for n sectors) - $n times "time for 1 revolution"/ "sectors per track"$
|
|
- $n$ is requested sectors on track
|
|
|
|
- Access Order
|
|
+ Contiguous Blocks within same track (same surface)
|
|
+ Cylinder track within same cylinder
|
|
+ next cylinder
|
|
|
|
== Buffer Manager
|
|
#image("buffer-manager.png")
|
|
- Data stored in block sized pages called frames
|
|
- Each frame maintains pin count(PC) and dirty flag
|
|
=== Replacement Policies
|
|
- Decide which unpinned page to replace
|
|
- *LRU* - queue of pointers to frames with PC = 0
|
|
- *clock* - LRU variant
|
|
- *Reference bit* - turns on when PC = 0
|
|
- Replace a page when ref bit off and PC = 0
|
|
#image("clock-replacement-policy.png")
|
|
|
|
== Files
|
|
- Heap File Implementation
|
|
- Linked List
|
|
- 2 linked lists, 1 of free pages, 1 of data pages
|
|
- Page Directory Implementation
|
|
- Directory structure, 1 entry per page.
|
|
- to insert, scan directory to find page with space to store record
|
|
*Page Formats*
|
|
- *RID* = (page id, slot number)
|
|
- Fixed Length records
|
|
- Packed Organization: Store records in contiguous slots (requires swapping last item to deleted location during deletion)
|
|
- Unpacked organization: Use bit array to maintain free slots
|
|
- *Variable Length Records*: Slotted page organization
|
|
|
|
*Record Formats*
|
|
- Fixed Length Records: Stored consecutively
|
|
- Variable length Records
|
|
- Delimit fields with special symbols (F1, \$, F2 \$, F3)
|
|
- Array of field offsets ($o_1, o_2, o_3, F 1, F 2, F 3$)
|
|
*Data Entry Formats*
|
|
1. $k*$ is an actual data record (with search key value k)
|
|
2. $k*$ is of the form *(k, rid)*
|
|
3. $k*$ is of the form *(k, rid-list)* list of rids of data with key $k$
|
|
|
|
= B+ Tree index
|
|
- *Search key* is sequence of $k$ data attributes $k >= 1$
|
|
- *Composite search key* if $k > 1$
|
|
- *unique key* if search key contains _candidate_ key of table
|
|
- index is stored as file
|
|
- *Clustered index* - Ordering of data is same as data entries
|
|
- key is known as *clustering key*
|
|
- Format 1 index is clustered index (Assume format 2 and 3 to be unclustered)
|
|
|
|
== Tree based Index
|
|
- *root node* at level 0
|
|
- Height of tree = no of levels of internal node
|
|
- *Leaf nodes*
|
|
- level h, where h is height of tree
|
|
- *internal nodes* store entries in form $(p_0, k_1, p_1, k_2, p_2, ..., p_n)$
|
|
- $k_1 < k_2 < ... < k_n$
|
|
- $p_i$ = disk page address
|
|
- *Order* of index tree
|
|
- Each non-root node has $m in [d, 2d]$ entries
|
|
- Root node has $m in [1, 2d]$ entries
|
|
- *Equality search*: At each _internal_ node $N$, find largest key $k_i$ in N, such that $k_i <= k$
|
|
- if $k_i$ exists, go subtree $p_i$, else $p_0$
|
|
- *Range search*: First matching record, and traverse doubly linked list
|
|
- *Min nodes at level* i is $2 times (d + 1)^(i-1), i >= 1$
|
|
- *Max nodes at level* i is $(2d + 1)^(i)$
|
|
|
|
== Operations (Right sibling first, then left)
|
|
=== Insertion
|
|
+ *Leaf node Overflow*
|
|
- Redistribute and then split
|
|
- *Split* - Create a new leaf $N$ with $d+1$ entries. Create a new index entry $(k, square.filled)$ where $k$ is smallest key in $N$
|
|
- *Redistribute* - If sibling is not full, take from it. If given right, update right's parent pointer, else current node's parent pointer
|
|
+ *Internal node Overflow*
|
|
- Node has $2d+1$ keys.
|
|
- Push middle $(d+1)$-th key up to parent.
|
|
=== Deletion
|
|
+ *Leaf node*
|
|
- Redistribute then merge
|
|
- *Redistribution*
|
|
- Sibling must have $> d$ recordsto borrow
|
|
- Update parent pointers to right sibling's smallest key)
|
|
- *Merge*
|
|
- If sibling has $d$ entries, then merge
|
|
- Combine with sibling, and then remove parent node
|
|
+ *Internal Node Underflow*
|
|
- Let $N'$ be adjacent _sibling_ node of $N$ with $l, l > d$ entries
|
|
- Insert $(K, N' . p_i)$ into $N$, where $i$ is the leftmost(0) or rightmost entry(l)
|
|
- Replace $K$ in parent node with $N'.k_i$
|
|
- Remove $(p_i, k_i)$ entry from $N'$
|
|
=== Bulk Loading
|
|
+ Sort entries by search keys.
|
|
+ Load leaf pages with $2d$ entries
|
|
+ For each leaf page, insert index entry to rightmost parent page
|
|
|
|
|
|
== Hash based Index
|
|
=== Static Hashing
|
|
=== Linear Hashing
|
|
=== Extensible Hashing
|