Algebra relazionale

Posted by On Filed under Basi di dati

Operatori primitivi

Gli operatori primitivi sono sei:

  1. Ridenominazione (AS)
  2. Unione (UNION)
  3. Differenza
  4. Proiezione (SELECT)
  5. Restrizione (WHERE)
  6. Prodotto (JOIN)

Ridenominazione

Nell'algebra relazionale il nome di un attributo è molto importante, perché permette di fare NATURAL JOIN e, come nel linguaggio SQL, permette di risolvere ambiguità sulla relazione a cui un nome di attributo si riferisce.
La notazione ρA←B(R) indica che nella relazione R l'attributo B è il nuovo alias con cui si identifica A
(A = vecchio nome, B = nuovo nome)

Unione

L'unione di due relazioni è possibile solo se le due relazioni hanno lo stesso tipo ennupla.
L'unione è denotata dal simbolo usato per l'unione in algebra: ⋃.
La notazione A⋃B indica la relazione comprendente tutti gli elementi di A più tutti gli elementi di B.

Differenza

La differenza tra due relazioni è possibile solo se le due relazioni hanno lo stesso tipo ennupla.
La differenza è denotata dal simbolo meno -
La notazione A-B indica la relazione comprendente tutti gli elementi di A che non sono presenti in B.

Proiezione

La proiezione indica una relazione in cui sono presenti solo gli attributi specificati e ne restituisce solo i valori distinti.
La proiezione è denotata con π
La notazione πA1,A2,...An(R) indica la relazione comprendente solo gli attributi specificati e solo per i valori distinti.

Restrizione

La restrizione indica una relazione dello stesso tipo della relazione originale limitata alle sole ennuple che soddisfano la condizione specificata.
La restrizione è denotata con σ.
La notazione σNome=Marco(R) indica che della relazione R interessano solo le ennuple in cui per l'attributo nome sia presente il valore Marco.

Prodotto

Il prodotto di due relazioni restituisce una relazione in cui sono presenti tutti gli attributi di entrambe le relazioni e il prodotto delle loro ennuple (per ogni A, ogni B).
Il prodotto si indica con ×
La notazione A×B indica una relazione contenente gli attributi di A + gli attributi di B e il prodotto delle loro ennuple.
Esempio:

+--------------------+
| A                  |
+---+------+---------+
|id | nome | cognome |
+---+------+---------+
| 1 | Lino | Tesser  |
+---+------+---------+
| 2 | Gino | Baroni  |
+---+------+---------+

+------------+
| B          |
+---+--------+
|cod| pasto  |
+---+--------+
| 1 | Pranzo |
+---+--------+
| 2 | Cena   |
+---+--------+

+-----------------------------------+
| A×B                               |
+---+------+---------+----+---------+
|id | nome | cognome | cod| pasto   |
+---+------+---------+----+---------+
| 1 | Lino | Tesser  |  1 | Pranzo  |
+---+------+---------+----+---------+
| 2 | Gino | Baroni  |  1 | Pranzo  |
+---+------+---------+----+---------+
| 1 | Lino | Tesser  |  2 | Cena    |
+---+------+---------+----+---------+
| 2 | Gino | Baroni  |  2 | Cena    |
+---+------+---------+----+---------+

Il prodotto, così com'è, è piuttosto inutile, ma è necessario per poter introdurre l'operatore (derivato) JOIN.