1

return sum / count

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class SumAgg():

    def __init__(self):
        self.sum = 0
        self.count = 0

    def update(self,a):
        self.sum += a
        self.count += 1

    def close(self):
        return self.sum / self.count


agg = SumAgg()

for i in range(1,100):
    agg.update(i)

print(agg.close())

50.0

• for sorting we need number of blocks of R B(R) and the number of blocks of memory M

• B(R) is less then M

  • read R then write R and use any in memory sorting algo. $2 \cdot B(R)$

• run generation: read chunks of size $M$ into memory and sort them, then write them back

  • number of I/O $2 \cdot B(R)$
  • $\lceil \frac{B(R)}{M} \rceil$ generated runs

• merging merge $M-1$ runs at a time: reduced number of runs by a factor of $M-1$ in each merge iteration

  • $i = \lceil{\log_{M-1}(\lceil \frac{B(R)}{M} \rceil)\rceil$ merge phases
  • $2 \cdot B(R)$

• total I/O

  • $(1 + i) \cdot 2 \cdot B(R)$

• input: B(R), B(S), M

• T1 reads from T2 if T1 reads a data item A and T2 was the last one to write the data item A before the read
• a schedule is recoverable if for every transaction Ti that reads from a transaction Tj the commit of Tj is before the commit of Ti

1
2
3
4
5

1: r2(A), -- 4
2: w1(A), -- 10
3: w2(A), -- 5
4: c2,
5: c1

• not recoverable

1
2
3
4
5

1: w1(A), -- 10
2: r2(A), -- 10
3: w2(A), -- 11
4: c2,
5: a1

• recoverable

1
2
3
4
5

1: w1(A), -- 10
2: r2(A), -- 10
3: w2(A), -- 11
4: c1,
5: c2

• T1 reads from T2 if T1 reads a data item A and T2 was the last one to write the data item A before the read

• a schedule is cascadeless if for every transaction Ti that reads from a transaction Tj the commit of Tj is before the read of Ti

  • we only read committed data
• check for this wi(A) …. ci …. rj(A)

1
2
3
4
5

1: w1(A), -- 10
2: r2(A), -- 10
3: w2(A), -- 11
4: a1, -- have to abort T2 now
5: a2

1

w1(A), w2(A), w3(A)

1

r1(A), r2(A), r3(A)

• a schedule is strict if every transaction is only reading and writing committed data
• w1(A) …. c1 …. w2(A)

• construct conflict graph

  • conflicting operations

    • same data item
    • different transactions
    • at least one of them is a read
    • pi(X) … qj(X) means there is an edge from i to j

1

r2(A),r2(E),w1(C),r1(E),r2(C),c2,w3(A),w3(C),c3,r1(D),c1

1

r2(E),r1(A),r2(C),r1(B),r1(C),r2(A),w2(C),r2(B),c2,r1(C),w1(E),w1(A),c1