Si consideri il seguente schema di basi di dati che rappresenta le

Si consideri il seguente schema di basi di dati che rappresenta le informazioni per la
gestione di un laboratorio di analisi mediche:
PAZIENTI(Codice, Nome, Cognome, Indirizzo)
ANALISI(Codice, Paziente, Data)
ESAMI(Analisi, TipoEsame, Valore)
TIPIESAMI(Codice, Nome)
Occorre definire vincoli di integrità referenziale fra:
1. ANALISI.Paziente e PAZIENTI.Codice
2. ESAMI.Analisi e ANALISI.Codice
3. ESAMI.TipoEsame e TIPIESAMI.Codice
A. Trovare nome e cognome dei pazienti nelle cui analisi il valore di glicemia è risultato
superiore a 200.
Algebra relazionale
π Nome,Cognome (PAZIENTI
Codice=Paziente
π Paziente (ANALISI
π Analisi(σValore>200 (ESAMI
Codice=Analisi
TipoEsame=Codice σ Nome=’glicemia’ (TIPIESAMI)))))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ ANALISI(Codice: ca, Paziente: cp, Data: d)
∧ ESAMI(Analisi: ca, TipoEsame: e, Valore: v)
∧ TIPIESAMI(Codice: e, Nome: ne)
∧ (ne = ‘glicemia’) ∧ (v>200)
}
Calcolo su tuple
{ p.(Nome, Cognome) | p(PAZIENTI), a(ANALISI), e(ESAMI), t(TIPIESAMI) |
p.Codice = a.Paziente ∧ a.Codice = e.Analisi ∧
e.TipoEsame = t.Codice ∧ t.Nome = ‘glicemia’ ∧
e.Valore > 200
}
B. Trovare nome e cognome dei pazienti che hanno fatto almeno due volte lo stesso
esame in analisi diverse dello stesso giorno.
Algebra relazionale
ESAMIANALISI =
πAnalisi,TipoEsame,Data,Paziente (ρAnalisi←Codice(ANALISI)
π Nome,Cognome (ρ Paziente←Codice (PAZIENTI)
σ¬(Analisi1=Analisi2)(ρAnalisi1←Analisi (ESAMIANALISI)
ESAMI)
π Paziente (
ρAnalisi2←Analisi (ESAMIANALISI))))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ ANALISI(Codice: ca, Paziente: cp, Data: d)
∧ ESAMI(Analisi: ca, TipoEsame: e, Valore: v)
∧ ANALISI(Codice: ca1, Paziente: cp, Data: d)
∧ ESAMI(Analisi: ca1, TipoEsame: e, Valore: v1)
∧ ¬(ca=ca1)
}
Calcolo su tuple
{ p.(Nome, Cognome) | p(PAZIENTI), a(ANALISI), e(ESAMI) |
p.Codice = a.Paziente ∧ a.Codice = e.Analisi ∧
∃ a1(ANALISI) ∃ e1(ESAME)
(a1.Paziente = p.Codice ∧ a1.Codice = e1.Analisi ∧
e1.TipoEsame = e.TipoEsame ∧ a1.Data = a.Data ∧
¬(a1.Codice=a.Codice))
}
Si consideri il seguente schema di basi di dati che rappresenta le informazioni per la
gestione di una sala operatoria:
PAZIENTI(Codice, Nome, Cognome, Indirizzo)
INTERVENTI(Codice, Paziente, Data)
EQUIPE(Intervento, Medico, Ruolo)
MEDICI(Codice, Nome)
Occorre definire vincoli di integrità referenziale fra:
1. INTERVENTI.Paziente e PAZIENTI.Codice
2. EQUIPE.Intervento e INTERVENTI.Codice
3. EQUIPE.Medico e MEDICI.Codice
A. Trovare nome e cognome dei pazienti che hanno subito interventi in cui il dott. Kildare
era Anestesista
Algebra relazionale
π Nome,Cognome (PAZIENTI
Codice=Paziente
π Paziente (INTERVENTI
π InterventoσRuolo=’Anestesista’ (EQUIPE
Codice=Intervento
Medico=Codice σ Nome=’Kildare’(MEDICI))))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ INTERVENTI(Codice: ci, Paziente: cp, Data: d)
∧ EQUIPE(Intervento: ci, Medico m: e, Ruolo: r)
∧ MEDICI(Codice: m, Nome: nm)
∧ (nm = ‘Kildare’) ∧ (r=’Anestesista’)
}
Calcolo su tuple
{ p.(Nome, Cognome) | p(PAZIENTI), i(INTERVENTI), e(EQUIPE), m(MEDICI) |
p.Codice = i.Paziente ∧ i.Codice = e.Intervento ∧
e.Medico = m.Codice ∧ m.Nome = ‘Kildare’ ∧
e.Ruolo = ‘Anestesista’
}
B. Trovare i nomi dei medici che hanno partecipato a più di un intervento nello stesso
giorno.
Algebra relazionale
EQUIPEINTERVENTI =
π Intervento,Data,Medico (ρ Intervento←Codice(INTERVENTI)
π Nome (ρ Medico←Codice (MEDICI)
EQUIPE))
π Medico (σ¬(Intervento1=Intervento2)
(ρ Intervento1←Intervento (EQUIPEINTERVENTI)
ρ Intervento2←Intervento (EQUIPEINTERVENTI))))
Calcolo su domini
{ NomeMedico: n | MEDICI(Codice: cm, Nome: n) ∧
EQUIPE(Intervento: ci, Medico: cm, Ruolo: r)
∧ INTERVENTI(Codice:ci, Paziente: cp, Data: d)
∧ EQUIPE(Intervento: ci1, Medico: cm, Ruolo: r1)
∧ INTERVENTI(Codice: ci1, Paziente: cp1, Data: d)
∧ ¬(ci=ci1)
}
Calcolo su tuple
{ m.(Nome) | m(MEDICI), i(INTERVENTI), e(EQUIPE) |
e.Medico = m.Codice ∧ i.Codice = e.Intervento ∧
∃ i1(INTERVENTI) ∃ e1(EQUIPE)
(e1.Medico = m.Codice ∧ i1.Codice = e1.Intervento ∧
i1.Data = i.Data ∧ ¬(i1.Codice=i.Codice))
}
Si consideri il seguente schema di basi di dati che rappresenta le informazioni per la
gestione di uno studio dentistico:
PAZIENTI(Codice, Nome, Cognome, Indirizzo)
MEDICAZIONI(Codice, Paziente, Data)
TIPOMEDICAZIONE(Medicazione, Dente , Descrizione)
TIPIDENTI(Codice, Nome)
Occorre definire vincoli di integrità referenziale fra:
1. MEDICAZIONI.Paziente e PAZIENTI.Codice
2. TIPOMEDICAZIONE.Medicazione e MEDICAZIONI.Codice
3. TIPOMEDICAZIONE.Dente e TIPIDENTE.Codice
A. Trovare nome e cognome dei pazienti a cui è stato otturato il molare M4S.
Algebra relazionale
π Nome,Cognome (PAZIENTI
Codice=Paziente
π Paziente (MEDICAZIONI
π MedicazioneσDescrizione=’otturazione’ (TIPOMEDICAZIONE
Codice=Medicazione
Dente=Codice σ Nome=’M4S’(TIPIDENTE))))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ MEDICAZIONI(Codice: cm, Paziente: cp, Data: d)
∧ TIPOMEDICAZIONE(Medicazione: cm, Dente: cd, Descrizione: dsc)
∧ TIPIDENTI(Codice: cd, Nome: nd)
∧ (dsc = ‘otturazione’) ∧ (nd=’M4S’)
}
Calcolo su tuple
{ p.(Nome, Cognome) | p(PAZIENTI), m(MEDICAZIONI),
tm(TIPOMEDICAZIONI), d(TIPIDENTI) |
p.Codice = m.Paziente ∧ m.Codice = tm.Medicazione ∧
tm.Dente = d.Codice ∧ tm.Descrizione = ‘otturazione’ ∧
d.Nome = ‘molare’
}
B. Trovare nome e cognome dei pazienti a cui è stato tolto più di un dente nello stesso
giorno.
Algebra relazionale
ESTRAZIONI =
π Dente,Paziente,Data (ρ Medicazione←Codice (MEDICAZIONI)
σDescrizione=’estrazione’(TIPIMEDICAZIONE))
π Nome,Cognome (ρ Paziente←Codice (PAZIENTI)
π Paziente σ¬(Dente1=Dente2)(ρDente1←Dente(ESTRAZIONI)
ρ Dente2←Dente (ESTRAZIONI)))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ MEDICAZIONI(Codice: cm1, Paziente: cp, Data: d)
∧ TIPOMEDICAZIONE(Medicazione: cm1, Dente: cd1, Descrizione: desc)
∧ MEDICAZIONI(Codice: cm2, Paziente: cp, Data: d)
∧ TIPOMEDICAZIONE(Medicazione: cm2, Dente: cd2, Descrizione: desc)
∧ (desc='estrazione') ∧ ¬(cd1=cd2)
}
Calcolo su tuple
{ p.(Nome,Cognome) | p(PAZIENTI), m(MEDICAZIONI), t(TIPOMEDICAZIONI) |
p.Codice = m.Paziente ∧ m.Codice = t.medicazione ∧
t.Descrizione = 'estrazione' ∧
∃ m1(MEDICAZIONI) ∃ t1(TIPOMEDICAZIONI)
(p.Codice = m1.Paziente ∧ m1.Codice = t1.medicazione ∧
t1.Descrizione = 'estrazione' ∧
m1.Data = m.Data ∧ ¬(t1.Dente=t.Dente))
}
Si consideri il seguente schema di basi di dati che rappresenta le informazioni per la
gestione di un ambulatorio medico:
PAZIENTI(Codice, Nome, Cognome, Indirizzo)
VISITA(Codice, Paziente, Data)
PRESCRIZIONE(Visita, Medicinale, Posologia)
MEDICINALE(Codice, Nome)
Occorre definire vincoli di integrità referenziale fra:
1. VISITA.Paziente e PAZIENTI.Codice
2. PRESCRIZIONE.Visita e VISITA.Codice
3. PRESCRIZIONE.Medicinale e MEDICINALE.Codice
A. Trovare nome e cognome dei pazienti a cui sono stati prescritti più di 100mg di
Cortisone.
Algebra relazionale
π Nome,Cognome (PAZIENTI
Codice=Paziente
π Paziente (VISITA
πVisitaσPosologia>100 (PRESCRIZIONE
Codice=Visita
Medicinale=Codice σ Nome=’Cortisone’(MEDICINALE))))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ VISITA(Codice: cv, Paziente: cp, Data: d)
∧ PRESCRIZIONE(Visita: cv, Medicinale: cm, Posologia: p)
∧ MEDICINALE(Codice: cm, Nome: nm)
∧ (nm = ‘Cortisone’) ∧ (p>100)
}
Calcolo su tuple
{ p.(Nome, Cognome) | p(PAZIENTI), v(VISITA),
pr(PRESCRIZIONE), m(MEDICINALE) |
p.Codice = v.Paziente ∧ v.Codice = pr.Visita ∧
pr.Medicinale = m.Codice ∧ m.Nome = ‘Cortisone’ ∧
pr.Posologia > 100
}
B. Trovare nome e cognome dei pazienti ai quali è stato prescritto lo stesso medicinale in
almeno due visite diverse.
Algebra relazionale
VISITAPRESCRIZIONE =
πVisita,Medicinale,Paziente (ρVisita←Codice(VISITA)
PRESCRIZIONE)
π Nome,Cognome (ρ Paziente←Codice (PAZIENTI)
(ρVisita1←Visita (VISITAPRESCRIZIONE)
π Paziente (σ¬(Visita1=Visita2)
ρVisita2←Visita (VISITAPRESCRIZIONE))))
Calcolo su domini
{ Cognome: c, Nome: n | PAZIENTI(Codice: cp, Nome: n, Cognome: c, Indirizzo: i)
∧ VISITA(Codice: cv1, Paziente: cp, Data: d1)
∧ PRESCRIZIONE(Visita: cv, Medicinale: cm, Posologia: pos1)
∧ VISITA(Codice: cv2, Paziente: cp, Data: d2)
∧ PRESCRIZIONE(Visita: cv2, Medicinale: cm, Posologia: pos2)
∧ ¬(cv1=cv2)
}
Calcolo su tuple
{ p.(Nome,Cognome) | p(PAZIENTI), v1(VISITA), pr1(PRESCRIZIONE) |
p.Codice = v1.Paziente ∧ v1.Codice = pr1.Visita ∧
∃ v2(VISITA) ∃ pr2(PRESCRIZIONE)
(p.Codice = v2.Paziente ∧ v2.Codice = pr2.Visita ∧
¬(v2.Codice=v1.Codice) ∧
pr1.Medicinale = pr2.Medicinale
}