Base De Datos Normativa Especificación 1. TAD Dato
Anuncio
1er
Algoritmos y Estructuras de Datos II - DC - UBA
cuatrimestre de 2016
Trabajo práctico 2: Especicación
Base De Datos
Normativa
Límite de entrega:
Miércoles 25 de mayo
con asunto "Grupo N" siendo
N
hasta las 22:00 hs.
Enviar PDF a
algo2.dc+TP2@gmail.com
el número de grupo asignado.
Normas de entrega: Ver Información sobre la cursada
en el sitio Web de la materia.
(http://www.dc.uba.ar/materias/aed2/2016/1c/cursada)
Versión: 1.1 del 11 de mayo de 2016 (ver TP2_Changelog.txt)
Especicación
1. TAD
TAD
Tipo
Dato
es
Bool
TAD Dato
géneros
dato
usa
string, nat, tipo
exporta
generadores, observadores básicos y otras operaciones
igualdad observacional
≡ tipo?(d2 ) ∧L
d2 ⇐⇒ ((Nat?(d1 ) ⇒L valorNat(d1 ) =obs valorNat(d2 )) ∧
(String?(d1 ) ⇒L valorStr(d1 ) =obs valorStr(d2 )))
tipo?(d1 )
(∀d1 , d2 : dato) d1 =obs
generadores
datoString
: string
datoNat
: nat
−→
−→
observadores básicos
tipo?
: dato
valorNat
: dato
valorStr
: dato
−→
−→
−→
d
d
dato
dato
tipo
nat
{Nat?(d)}
string
{String?(d)}
otras operaciones
mismoTipo? : dato
String?
×
dato
: dato
Nat?
: dato
min
: conj(dato)
max
: conj(dato)
•≤•
: dato
d1 ×
cd
cd
dato
d2
−→
−→
−→
−→
−→
−→
bool
bool
bool
{¬∅?(cd)}
dato
dato
{¬∅?(cd)}
bool
{mismoTipo?(d1 ,d2 )}
axiomas
(∀s: string,
∀n:
∀d, d1 , d2 : dato, paratodoconj(dato)cd)
tipo?(datoNat(n))
≡ true
tipo?(datoString(s))
≡ false
valorNat(datoNat(n))
≡ n
valorStr(datoString(s)) ≡ s
mismoTipo?(d1 , d2 )
≡ (Nat?(d1 ) ≡ Nat?(d2 ))
Nat?(d)
≡ tipo?(d)
String?(d)
≡ ¬Nat?(d)
nat,
1/6
1er
Algoritmos y Estructuras de Datos II - DC - UBA
if
≡
min(cd)
=
#(cd)
∨L
1
if
≡
max(cd)
#(cd)
=
1
dameUno(cd)
if
≤(d1 ,d2 ) ≡
String?(d1 )
dameUno(cd)
min(sinUno(cd))
∨L
dameUno(cd)
then
valorStr(d1 )
≤
≤
≤
then
min(sinUno(cd))
then
max(sinUno(cd))
valorStr(d2 )
else
cuatrimestre de 2016
else
dameUno(cd)
else
max(sinUno(cd))
valorNat(d1 )
≤
valorNat(d2 )
Fin TAD
2. TAD
TAD
Registro
Campo
es
String
TAD Registro
TAD
Registro
extiende a
Diccionario(Campo, Dato)
géneros
registro
usa
string, dato, campo, dicc
exporta
otras operaciones
otras operaciones
campos
: registro
borrar?
: registro
criterio × registro r
r1 × registro r2
conj(campo) cc × registro r1 ×
registro r1 × conj(campo) cc ×
agregarCampos : registro
copiarCampos
:
coincideAlguno
:
registro
registro
r2
r2
−→
−→
−→
−→
−→
conj(campo)
{#campos(criterio)
bool
: registro
enTodos
: campo
combinarTodos
: campo
r1 ×
conj(campo)
cc ×
registro
r2 −→
bool
−→
−→
bool
cr
conj(registro)
registro
r1 ×
conj(registro)
cr
∈
campos(r2 )}
campos(r1 )
∩
campos(r2 )}
campos(r1 )
∩
campos(r2 )}
bool
{cc ⊆
c×
c×
1}
{cc
registro
{cc ⊆
coincidenTodos
≡
registro
conj(registro)
{c ∈
campos(r1 )
∧
enTodos(c,cr )}
axiomas
(∀c: campo,
∀v, d1 , d2 :
∀r, r1 , r2 , crit: registro, ∀cc: conj(campo), ∀cr: conj(registro))
≡ claves(r)
borrar?(crit, r )
≡ coincidenTodos(crit,campos(crit), r)
agregarCampos(r1 , r2 )
≡ copiarCampos(campos(r2 ) − campos(r1 ), r1 , r2 )
copiarCampos(cc, r1 , r2 )
≡ if ∅?(cc) then r1 else copiarCampos(sinUno(cc), denir(dameUno(cc),
obtener(dameUno(cc), r2 ), r1 ), r2 ) coincideAlguno(r1 , cc, r2 ) ≡ ¬ ∅?(cc) ∧L (obtener(dameUno(cc), r1 ) = obtener(dameUno(cc), r2 )) ∨
coincideAlguno(r1 , sinUno(cc), r2 ) )
coincidenTodos(r1 , cc, r2 ) ≡ ∅?(cc) ∨L (obtener(dameUno(cc), r1 ) = obtener(dameUno(cc), r2 ) ∧
coincidenTodos(r1 , sinUno(cc), r2 ))
enTodos(c,cr)
≡ ∅?(cr) ∨L (c ∈ campos(dameUno(cr)) ∧ enTodos(c,sinUno(cr)))
combinarTodos(c, r , cr )
≡ if ∅?(cr) then
∅
dato,
campos(r)
else
combinarTodos(c,
Fin TAD
obtener(c,
r)
r,
then
2/6
sinUno(cr ))
∪
(
if
obtener(c, dameUno(cr )) =
{agregarCampos(r , dameUno(cr ))}
else
∅
)
1er
Algoritmos y Estructuras de Datos II - DC - UBA
3. TAD
cuatrimestre de 2016
Tabla
TAD Tabla
géneros
tabla
usa
campo, clave, registro, conj, string
exporta
Generadores, observadores, otras operaciones
igualdad observacional
= nombre(t2 ) ∧ campos(t1 ) =obs
campos(t2 ) ∧L (∀c: campo) ( c ∈ campos(t1 ) ⇒L
tipoCampo(c, t1 ) =obs tipoCampo(c,t2 ) ) ∧ claves(t1 )
t2 ⇐⇒
=obs claves(t2 ) ∧ registros(t1 ) =obs registros(t2 ) ∧
indices(t1 ) =obs indices(t2 ) ∧ cantidadDeAccesos(t1 )
= cantidadDeAccesos(t2 )
nombre(t1 )
(∀t1 , t2 : tabla) t1 =obs
observadores básicos
nombre
: tabla
claves
: tabla
indices
: tabla
campos
: tabla
tipoCampo
: campo
registros
: tabla
c×
tabla
cantidadDeAccesos : tabla
−→
−→
−→
−→
t −→
−→
−→
string
conj(campo)
conj(campo)
conj(campo)
{c
tipo
∈
campos(t)}
conj(registro)
nat
generadores
nuevaTabla
: string
nombre ×
agregarRegistro : registro
r×
conj(campo)
tabla
−→
t
claves ×
columnas −→
{claves 6= ∅ ∧ claves ⊆
registro
tabla
{campos(r) =obs
borrarRegistro
: registro
indexar
: campo
crit ×
c×
tabla
tabla
t
tabla
campos(columnas)}
t −→ tabla
{#campos(crit) =
−→ tabla
1
campos(t)
∧
puedoInsertar?(r ,
∧L dameUno(campos(crit)) ∈
t)}
claves(t)}
{puedeIndexar(c,t)}
otras operaciones
× tabla t
registro × tabla
campo c × tabla t
campo c × tabla t
campo c × tabla t
puedoInsertar? : registro r
compatible
:
minimo
:
maximo
:
puedeIndexar
:
: registro
coincidencias
:
dameColumna
:
mismosTipos
:
bool
bool
dato
{¬∅?(registros(t))
dato
{¬∅?(registros(t))
∧c∈
∧c∈
indices(t) }
indices(t) }
bool
× conj(campo) × conj(registro)
−→ bool
registro × conj(registro)
−→ conj(registro)
campo c × conj(registro) cr1 × conj(registro) cr2) −→ conj(registro)
campo c × conj(registro) cr
−→ conj(dato)
registro r × tabla t
−→ bool
{campos(r) ⊆ campos(t)}
hayCoincidencia
combinarRegistros :
−→
−→
−→
−→
−→
axiomas
(∀cc, cp: conj(campo),∀t: tabla,
∀r:
nombre(nuevaTabla(n,
cc, r))
t))
nombre(borrarRegistro(crit, t))
nombre(indexar(c, t))
nombre(agregarRegistro(r ,
claves(nuevaTabla(n,
cc, r))
t))
claves(borrarRegistro(crit, t))
claves(agregarRegistro(r ,
∀cr: conj(registro) ∀n:
≡ n
≡ nombre(t)
≡ nombre(t)
≡ nombre(t)
registro,
≡ cc
≡ claves(t)
≡ claves(t)
3/6
string)
1er
Algoritmos y Estructuras de Datos II - DC - UBA
claves(indexar(c,
≡
t))
claves(t)
cc, r))
t))
indices(borrarRegistro(crit, t))
indices(indexar(c, t))
≡ ∅
≡ indices(t)
≡ indices(t)
≡ Ag(c,indices(t))
campos(nuevaTabla(n,
cc, r))
campos(agregarRegistro(r , t))
campos(borrarRegistro(crit, t))
campos(indexar(c, t))
≡
≡
≡
≡
campos(r )
tipoCampo(c, nuevaTabla(n,
cc, r))
tipoCampo(c, agregarRegistro(r , t))
tipoCampo(c, borrarRegistro(crit, t))
tipoCampo(c, indexar(c, t))
≡
≡
≡
≡
tipo?(obtener(c,r ))
registros(nuevaTabla(n,
≡ ∅
≡ Ag(r, registros(t))
≡ registros(t) − coincidencias(crit,
≡ registros(t)
indices(nuevaTabla(n,
indices(agregarRegistro(r ,
cc, r))
registros(agregarRegistro(r , t))
registros(borrarRegistro(crit, t))
registros(indexar(c, t))
campos(t)
campos(t)
campos(t)
tipoCampo(c,t)
tipoCampo(c,t)
tipoCampo(c,t)
cantidadDeAccesos(nuevaTabla(n,
cc, r))
cantidadDeAccesos(agregarRegistro(r , t)
cantidadDeAccesos(borrarRegistro(crit, t)
cantidadDeAccesos(indexar(c, t))
puedoInsertar?(r ,
t)
compatible(r, t)
puedeIndexar(c,t)
combinarRegistros(c,
cr1 , cr2 )
hayCoincidencia(r, cc,
coincidencias(crit,
cr)
cr)
cuatrimestre de 2016
≡
≡
≡
≡
registros(t))
0
1 + cantidadDeAccesos(t)
#coincidencias(crit, registros(t))+cantidadDeAccesos(t)
cantidadDeAccesos(t)
≡ compatible(r,t) ∧ ¬ hayCoincidencia(r, claves(t), registros(t))
≡ campos(r) = campos(t) ∧L mismosTipos(r,t)
≡ c ∈ campos(t) ∧L c 6∈ indices(t) ∧ (#indices(t) ≤1 ∧ (#indices(t)=1
⇒L ¬ tipoCampo(c, t) ≡ tipoCampo(dameUno(indices(t)), t)))
≡ if ∅?(cr1 ) then ∅ else combinarTodos(c, dameUno(cr1 ), cr2 ) ∪
combinarRegistros(c, sinUno(cr1 ), t2 ) ≡ ¬∅?(cr) ∧L ( coincideAlguno(r, cc, dameUno(cr)) ∨ hayCoincidencia?(r, cc, sinUno(cr )) )
≡ if ∅?(cr) then
∅
else
if
coincidenTodos(crit, campos(crit), dameUno(cr ))
then
Ag(dameUno(cr ), coincidencias(crit, sinUno(cr )))
else
minimo(c,t)
maximo(c,t)
dameColumna(c,cr )
≡
≡
≡
coincidencias(crit, sinUno(cr ))
min(dameColumna(c,registros(t)))
max(dameColumna(c,registros(t)))
if
∅?(cr)
then
∅
else
{obtener(c,dameUno(cr ))}
mismosTipos(r ,
t)
≡ ∅?(r)
∧
∨L
(if
else
c ∈ campos(dameUno(cr)) then
∅ ) ∪ dameColumna(c,sinUno(cr))
(mismosTipos(borrar(dameUno(campos(r )),r ),t)
tipo?(obtener(dameUno(campos(r1 )),r1 )
tipoCampo(dameUno(campos(r1 )),t)))
Fin TAD
4/6
≡
1er
Algoritmos y Estructuras de Datos II - DC - UBA
4. TAD
cuatrimestre de 2016
BaseDeDatos
TAD BaseDeDatos
géneros
base
usa
Nat, String, Tabla, Registro, Campo, Dato
exporta
generadores, observadores básicos y otras operaciones
igualdad observacional
=obs tablas(b2 ) ∧L (∀t: string) t ∈
tablas(b1 ) ⇒L dameTabla(t,b1 ) =obs dameTabla(t,
b2 ⇐⇒
b2 ) ∧ (∀t1 , t2 , c: string) {t1 , t2 } ⊆ tablas(b1 ) ⇒L
hayJoin?(t1 , t2 , c, b1 ) =obs hayJoin?(t1 , t2 , c, b2 )
tablas(b1 )
(∀b1 , b2 : base) b1 =obs
observadores básicos
tablas
db
t × base db
string t1 × string t2 ×
string t1 × string t2 ×
: base
dameTabla : string
hayJoin?
:
campoJoin
:
base
base
−→
−→
db −→
db −→
conj(string)
{t
tabla
∈
tablas(db)}
bool
{hayJoin?(t1 ,
campo
t2 , db)}
generadores
nuevaDB
−→ base
−→ base
{∅?(registros(ta))}
−→ base
{t ∈ tablas(db) ∧L puedoInsertar?(reg , t)}
−→ base
{#campos(cr)=1 ∧ t ∈ tablas(db)}
db −→ base
:
ta × base db
reg × string t ×
agregarTabla
: tabla
insertarEntrada
: registro
borrar
: registro
cr ×
string
t×
base
base
db
db
t1 × string t2 × campo c × base
t1 6= t2 ∧ {t1 , t2 } ⊆ tablas(db) ∧L
c ∈ claves(dameTabla(t1 , db)) ∧ c ∈ claves(dameTabla(t2 , db)) ∧ ¬hayJoin?(t1 , t2 , db)
: string t1 × string t2 × base db
−→ base
{hayJoin?(t1 , t2 , db)}
generarVistaJoin : string
borrarJoin
otras operaciones
t × base db
t1 × string t2 × base db
string t × base db
base db
string t × conj(string) ct × base db
registro criterio × string t × base db
registros
: string
vistaJoin
: string
cantidadDeAccesos :
tablaMaxima
:
encontrarMaximo
:
buscar
:
−→
−→
−→
−→
−→
−→
∈
conj(registro)
{t
conj(registro)
{hayJoin?(t1 ,
nat
string
string
conj(registro)
tablas(db)}
t2 , db)}
{t ∈ tablas(db)}
{tablas(db)6= ∅}
{{t} ∪ ct ⊆ tablas(db)}
{t ∈ tablas(db)}
axiomas
(∀cp: conj(campo),∀t, t1 , t2 , t3 , t4 : string,
tablas(nuevaDB)
tablas(agregarTabla(tbl,
db))
t, db))
tablas(insertarEntrada(reg,
tablas(borrar(cr ,
t, db))
tablas(generarVistaJoin(t1 ,
tablas(borrarJoin(t1 ,
t2 , c, db))
t2 , db))
dameTabla(t, agregarTabla(tbl,
dameTabla(t, borrarJoin(t1 ,
t2 ,
t2 , db))
t2 , db))
dameTabla(t, generarVistaJoin(t1 ,
hayJoin?(t1 ,
≡
db))
dameTabla(t1 , insertarEntrada(reg,
dameTabla(t1 , borrar(cr ,
∀tbl: tabla, ∀reg : registro, ∀nom:
≡ ∅
≡ Ag(nombre(tbl), tablas(db))
≡ tablas(db)
≡ tablas(db)
≡ tablas(db)
≡ tablas(db)
nuevaDB)
t2 , c, db))
t2 , db))
if
if
nombre(tbl)
≡t
string,∀cr1 , cr2 : conj(registro))
then
tbl
else
dameTabla(t,db)
t1 = t2 then agregarRegistro(reg,
db)) else dameTabla(t1 , db) ≡ if t1 = t2 then borrarRegistro(cr,
db)) else dameTabla(t1 , db) ≡ dameTabla(t, db)
≡ dameTabla(t, db)
≡
≡
5/6
false
dameTabla(t1 ,
dameTabla(t1 ,
1er
Algoritmos y Estructuras de Datos II - DC - UBA
hayJoin?(t1 ,
hayJoin?(t1 ,
hayJoin?(t1 ,
hayJoin?(t1 ,
hayJoin?(t1 ,
t2 ,
t2 ,
t2 ,
t2 ,
t2 ,
campoJoin(t1 ,
campoJoin(t1 ,
campoJoin(t1 ,
campoJoin(t1 ,
agregarTabla(tbl,
db))
insertarEntrada(reg, t3, db))
borrar(cr , c, db))
generarVistaJoin(t3 , t4 , c2 , db))
borrarJoin(t3 , t4 , c2 , db))
t2 ,
t2 ,
t2 ,
t2 ,
cuatrimestre de 2016
≡ hayJoin?(t1 , t2 , db)
≡ hayJoin?(t1 , t2 , db)
≡ hayJoin?(t1 , t2 , db)
≡ (t1 = t3 ∧ t2 = t4 )∨ hayJoin?(t1 , t2 , db)
≡ ¬(t1 = t3 ∧ t2 = t4 ) ∧ hayJoin?(t1 , t2 , db)
agregarTabla(tbl,
db))
insertarEntrada(reg, t, db))
borrar(cr , t, db))
generarVistaJoin(t3 , t4 , c, db))
≡
≡
≡
≡
campoJoin(t1 ,
t2 , db)
campoJoin(t1 , t2 , db)
campoJoin(t1 , t2 , db)
if t1 = t3 ∧ t2 = t4 then
c
else
campoJoin(t1 ,
registros(t,
t2 ,
borrarJoin(t3 ,
db)
cantidadDeAccesos(t,
db)
tablaMaxima(db)
≡
t4 , db))
campoJoin(t1 ,
ct, db)
t2 , db)
t2 , db)
≡
≡
registros(dameTabla(t,
≡
dameTabla(encontrarMaximo(dameUno(tablas(db)),
≡
db))
cantidadDeAccesos(dameTabla(t,
sinUno(tablas(db)),
encontrarMaximo(t,
campoJoin(t1 ,
if
∅?(ct)
t
then
db))
db), db)
else
if cantidadDeAccesos(t, db) ≥ cantidadDeAccesos(dameUno(ct),db)
then
encontrarMaximo(t, sinUno(ct),
else
vistaJoin(t1 ,
t2 , db)
≡
buscar(r ,t,db)
≡
encontrarMaximo(dameUno(ct), sinUno(ct),
combinarRegistros( campoJoin(t1 ,
db)),
db)
registros( dameTabla(t2 ,
db)
t2 , db),
) )
coincidencias(r ,registros(dameTabla(t,db)))
Fin TAD
6/6
db)
registros(dameTabla(t1 ,
