Práctica de Transacciones (Bases de Datos)

De Cuba-Wiki
Saltar a: navegación, buscar
Back.png Volver a la página de la materia

Ejercicio 1.1[editar]

  • a) Hacemos el grafo de lock/unlock:

Ti->(X)Tj: Ti hace unlock de X, luego Tj hace lock de X

        +------------+(C)
        |            V
T1->(B)T2->(B)T3(C)<-T4

El grafo no tiene ciclos dirigidos -> es serializable

  • b) T1 T2 T4 T3

Ejercicio 1.2[editar]

Schedule legal :
1) Una Ti no puede leer ni escribir un ítem X hasta tanto no haya hecho un lock de X.
2) Una Ti que desea obtener un lock sobre X que ha sido lockeado por Tj en un modo que conflictúa, debe esperar hasta que Tj haga unlock de X.

Schedule Legal Serializable'
T1 T2
WLOCK A
A = A + 1
WLOCK B
B = A + B
UNLOCK A
RLOCK A
UNLOCK B
TODO T2 aca

No se si era eso lo que habia que hacer, pero si era eso. Alguien sabe que sentido tenia hacer este ejercicio?

Ejercicio 1.3[editar]

Dirty Read : El dirty read o lectura sucia ocurre cuando una transacción T2 lee un valor de un ítem dejado por otra transacción T1 que no hizo commit antes de que T2 leyera el item.

Como no hay commit en ninguna de las dos Ti (schedule incompleto), cualquier schedule legal tendria dirty read

Ejercicio 1.4[editar]

El contra ejemplo es muy facil. Es algo que no cumple 2PL y el grafo no tenga ciclos

Ejercicio 1.5[editar]

 +------(?W)-----------V
T1<-(WR)-T2-(?W)->T3->T4
^--------(WR)-----+
         +-------------^

(Revisar) Es serializable. Schedule serial: T2 T3 T1 T4

Ejercicio 1.6[editar]

+-------V---V
T1  T2 T3->T4->T5
^---------------+

(Revisar) No es serializable

Ejercicio 1.7[editar]

Ejercicio 1.8[editar]

  • a)Falso (Teorema Serializabilidad)
  • b)Falso,contraejemplo. T1 cumple TPL, T2 no cumple TPL
Contraejemplo
T1 T2
LockA LockC
LockB UnlockC
LockC
UnlockA
LockA
UnlockA
UnlockB
UnlockC

El grafo que queda es un ciclo entre T1 y T2.

  • c)Verdadera, queda la demostracion de tarea para ud.
  • d)Falso, TPL no habla nada sobre los commits.
  • e)Verdadero ver Mendelzon

Ejercicio 1.9[editar]

  • a

Recordando : Dos historias H y H’ son equivalentes (H≡H’) si:
1) Si están definidas sobre el mismo conjunto de transacciones.
2) Las operaciones conflictivas tienen el mismo orden.

Como solo T3 usa D, podria ponerse el LOCKD y UNLOCK D en otro lugar, siempre que respete el orden de T3.Podria ponerse justo despues del ultimo UNLOCKA de T3.

  • b

Si existe. Este es

Contraejemplo
T1 T2 T3
WLOCK B
RLOCK A
RLOCK C
UNLOCK B
WLOCK B
UNLOCK C
RLOCK C
UNLOCK A
WLOCK A
UNLOCK B
UNLOCK A
RLOCK A
RLOCK B
UNLOCK B
UNLOCK A
RLOCK C
UNLOCK C
WLOCK C
UNLOCK C
RLOCK D
UNLOCK D

En una de esas me olvide de algo, pero la idea era "bajar" T1

  • c

Ejercicio 1.10[editar]

  • a
Respuesta
T1 T2 T3
RLOCK B
WLOCK B
WLOCK A
WLOCK C
UNLOCK A
RLOCK A
UNLOCK B
WLOCK B
UNLOCK C
UNLOCK B
UNLOCK A
RLOCK A
WLOCK B
RLOCK C
UNLOCK A
UNLOCK B
UNLOCK C
  • b no puede existir por teorema TPL

Ejercicio 1.11[editar]

Ejercicio 1.12[editar]

  • H1

H1 es RC, porque toda Ti que lee de Tj, cumple que ci < cj.
H1 no es ACA,porque T3 leer de T4, pero todavia T4 no hizo el commit.

  • H2 es RC porque todo lo que hace T2 esta recien despues del commit de T1...osea es serial trivialmente

Tambien es ACA porque es trivialmente serial, ademas el unico read de T2 es de algo que ni toco T1.Tambien es ST porque es serial,recien T2 si toca algo lo hace despues del commit.esto calculo vale para el caso general.

  • H3

Es Rc , ya que son todos writes.
Es ACA, ya que son todos writes.
No es ST, T1 escribe en X, pero despues T2 escribe en X sin embargo T1 no hizo el commit.

  • H4

Es RC, ya que se cumple que para toda Ti que lee de Tj, Ci < Cj. No es ACA , ya que T1 lee de T2 sin embargo T2 todavia no hizo el commit.

  • H5

Es RC, ya que no hay read de una Ti a otra Tj.
Es ACA por la misma razon.
No es ST, ya que T3 escribe en T1, pero T1 no hizo el commit todavia.
para el punto b), buenos si es ACA ya no puede tener dirty read....justamente ACA dice que no se hace un read de algo no commiteado por otra T. Lost update tampoco, para eso estan los locks.

Ejercicio 1.13[editar]


a) Para ver si es 2PL lo ideal es armar la tablita, calculo que pide saber si todas son 2PL...pero no lo es T1 (y en este caso se ve facil). hace el rl(A),ul(A) y despues wl(C).

b)

Ejercicio 1.14[editar]

  • a
  • H1

No es RC, ya que T2 escribe en C, luego T1 la lee...pero C1 < C2.

  • H2

Es RC, ya que T2 lee B de T1, pero C1 < C2. T1 nunca lee de T2. No es ACA,ya que T2 lee B, pero todavia T1 no hizo el commit.

  • H3

Es RC, ya que solo T2 lee algo de T1 (en ese caso B),pero en este caso C1 < C2. No es ACA, ya que el primer Read de B que hace T2, esta antes del C1.

  • H4

No es RC, ya que T2 lee B de T1,pero C2<C1.

  • H5

Es RC, solo T2 lee algo de otra T. En este caso T2 lee B de T1 y se mantiene que C1 < C2. Es ACA, ya que el unico read de una Ti a otra Tj lo hace T2 y es justo despues de C1. No es ST, ya que T3 escribe en C justo despues de T1 escribe en C...pero todavia T1 no hizo el commit.

  • b Para saber si es SR hay que los grafos de precedencia,porque es ortogonal el concepto. aunque solo si es ST vale

Ejercicio 1.15[editar]

a) si es legal.
b) no es 2PL ya que T3 por lo menos hace locks mezclados con unlocks.
c)
Eh15transacciones.jpg

Ejercicio 1.16[editar]

a)
i) W1(B) R2(B) R1(C) W1(C) R2(D) W2(C) C2 C1. No es RC porque T2 lee algo de T1 y C2 comitea primero
ii) R2(B) W1(B) R1(C) W1(C) R2(D) W2(C) C2 C1. Es ACA porque todo lo que se lee no fue tocado entre las transacciones. No es ST porque hay W1(C) y despues W2(C), pero los commits vienen despues
iii) R2(B) W1(B) R1(C) W1(C) R2(D) C1 W2(C) C2.
b)
i)si es legal, ni me fije pero para que los otros items...no?
ii) no es 2PL porque T2 hace lock mezclados con unlocks
iii)
Ej16bases.jpg
Como no tiene ciclos es SR.
T1T3T2T4T5
T1T3T2T5T4
T1T3T4T2T5

Ejercicio 1.17[editar]

a)
H1 Es RC, la unica lectura de algo modificado por otra transaccion lo hace T2 de Y que toco T3, pero C3 < C2. Es ACA porque la lectura de Y es despues del commit de T3.Tambien es ST.
H2 No es RC, porque T2 lee Y , que escribio T3...sin embargo C2 < C3, deberia ser C3 < C2.
H3 Es RC, porque nadie lee algo modificado por otra T. Tambien es ACA. No es ST porque T3 escribe Y, luego T2 tambien pero no se hizo el commit.
b)fue ni a palos, otro dia! encima la birra esta re fria, chau!