kristoferssolo/Databases-II-Cheatsheet
1
0
Fork 0
mirror of https://github.com/kristoferssolo/Databases-II-Cheatsheet.git synced 2025-10-21 18:20:35 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

fix issues

Browse Source
This commit is contained in:
Kristofers Solo 2024-05-07 00:34:35 +03:00
parent 97934dd5ac
commit 1cd6f44af8
1 changed files with 15 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
main.typ
View File

@ -87,10 +87,10 @@ Simplified version (to get the idea)
for each tuple tr in r: (for each tuple ts in s: test pair (tr, ts))
```
Block transfer cost: $n_r ∗ b_s + b_r$ block transfers would be required,
Block transfer cost: $n_r dot b_s + b_r$ block transfers would be required,
where $b_r$ -- blocks in relation $r$, same for $s$. Each scan of the inner
relation requires one seek, and the scan of the outer relation requires one
seek per block, leading to a total of $2 ∗b_r$ seeks.
relation requires one seek, and the scan of the outer relation requires one seek
per block, leading to a total of $2 dot b_r$ seeks.
== Block-nested join
@ -306,19 +306,20 @@ serializable.
== Protocols
We say that a schedule S is *legal* under a given locking protocol if S is a possible
schedule for a set of transactions that follows the rules of the locking protocol. We say
that a locking protocol ensures conflict serializability if and only if all legal schedules
are *conflict serializable*; in other words, for all legal schedules the associated →relation
is acyclic.
\ *Recoverable* schedule is one where, for each pair of transactions $T_i$ and
We say that a schedule S is *legal* under a given locking protocol if S is a
possible schedule for a set of transactions that follows the rules of the
locking protocol. We say that a locking protocol ensures conflict
serializability if and only if all legal schedules are *conflict serializable*;
in other words, for all legal schedules the associated $->$ relation is acyclic.
*Recoverable* schedule is one where, for each pair of transactions $T_i$ and
$T_j$ such that $T_j$ reads a data item previously written by $T_i$, the commit
operation of $T_i$ appears before the commit operation of $T_j$.
\ *Cascadeless* schedule is one where, for each pair of transactions $T_i$ and
$T_j$ such that $T_j$ reads a data item previously written by $T_i$, the commit
operation of $T_i$ appears before the read operation of $T_j$.
Every cascadeless schedule is also recoverable.
*Cascadeless* schedule is one where, for each pair of transactions $T_i$ and
$T_j$ such that $T_j$ reads a data item previously written by $T_i$, the commit
operation of $T_i$ appears before the read operation of $T_j$. Every cascadeless
schedule is also recoverable.
=== Lock-based
@ -485,7 +486,7 @@ $B=5;T_"disk"=0.001;T_"seek"=0.1$
=== Nested-Loop Join Method
+ Nested-loop join:
- For each pattern in $r_1$, search all patterns in $r_2$.
+ Total Combinations: $75435 dot 11456=$
+ Total Combinations: $75435 dot 11456$
+ Time Calculation for Nested-Loop Join:
- Reading and searching time for each combination: $0.001+0.1=0.101 "ms"$
- Total time: $75435 dot 11456 dot 0.101 = 87282519.36 "ms"$