Algebra relazionale - operatori di base e join

Prerequisiti: Modello relazionale - relazioni, chiavi e vincoliIl modello relazionale (Codd, IBM, 1970) rappresenta i dati con relazioni, cioè tabelle, ed è basato su valori: i legami tra relazioni sono confronti di valori, non puntatori, il che garantisce indipendenza dalle strutture fisiche, portabilità e bidirezionalità. Una relazione matematica è un sottoinsieme del prodotto cartesiano di n domini (insieme di n-uple ordinate, senza duplicati né ordine tra le righe); una relazione del modello è un insieme di tuple, funzioni dagli attributi ai valori del dominio, quindi non posizionale. Si distinguono schema di relazione e istanza, schema di base di dati (relazioni più vincoli) e istanza. NULL è un valore speciale fuori da ogni dominio. I vincoli di integrità sono intra-relazionali (di dominio, di tupla, di chiave) e inter-relazionali (integrità referenziale, con la chiave esterna). Superchiave: insieme di attributi che non ripete mai i valori; chiave: superchiave minimale; ogni relazione ne ha almeno una (tutti gli attributi); la chiave primaria è una chiave scelta, senza NULL.Modello relazionale - relazioni, chiavi e vincoli → (relazione come insieme di tuple, chiavi, chiavi esterne) e Operazioni tra insiemiUnione, intersezione, differenza, complementare e prodotto cartesiano, con le leggi di De Morgan e il legame con la logica.Operazioni tra insiemi → (unione, intersezione, differenza e prodotto cartesiano di insiemi). Si prosegue con Algebra relazionale estesa - divisione, aggregazione e outer joinL'algebra relazionale di base lavora una tupla alla volta e non sa fare calcoli sui valori né riassumere più tuple. L'estensione aggiunge: la proiezione generalizzata π_{F1,...,Fn}(R), che calcola espressioni sugli attributi (prezzo per quantità); l'aggregazione ℱ_{SUM, MAX, MIN, AVG, COUNT}(R), che produce una sola tupla; il raggruppamento (A1,...,Am)ℱ_{f(B)}(R), che produce una tupla per gruppo (grado n+m, cardinalità = numero di gruppi). Le funzioni di aggregazione ignorano i NULL, COUNT() conta le tuple, i NULL formano un gruppo a sé. Gli outer join (left, right, full) mantengono con NULL le tuple dangling del join; i NULL nella chiave di join non si accoppiano mai. La divisione R÷S dà gli x tali che (x,y) sta in R per ogni y di S, e si ottiene con π, × e −. Ricette: massimo = aggregazione + join con il massimo, "tutti" = divisione o complemento, "almeno due" = self-join.Algebra relazionale estesa - divisione, aggregazione e outer join → e con SQL - interrogazioni, join e aggregazioniUn'interrogazione SQL ha almeno SELECT e FROM; le altre clausole (WHERE, GROUP BY, HAVING, ORDER BY) sono opzionali e HAVING richiede GROUP BY. Ordine logico di valutazione: FROM, WHERE, GROUP BY, HAVING, SELECT, DISTINCT, ORDER BY. SELECT corrisponde a π (ma senza DISTINCT non elimina i duplicati), WHERE a σ, gli alias ad AS/ρ, i join a ⋈ (INNER, LEFT, RIGHT, FULL). WHERE seleziona le righe prima del raggruppamento, HAVING seleziona i gruppi dopo. Le funzioni COUNT, SUM, AVG, MIN, MAX ignorano i NULL (COUNT() conta le righe, DISTINCT toglie i duplicati dentro la funzione); con un aggregato o con GROUP BY nella SELECT possono comparire solo colonne di raggruppamento o aggregati. LIKE usa % (qualsiasi sequenza) e _ (un carattere). I confronti con NULL non sono veri: serve IS NULL. Un filtro sulla tabella di destra di un LEFT JOIN va nella clausola ON, non in WHERE, altrimenti il join diventa interno. Con interi COUNT(a)/COUNT(b) è una divisione intera: serve CAST.SQL - interrogazioni, join e aggregazioni →, che è la sua implementazione "reale". Gli esercizi svolti sono in Esercizio - Algebra relazionale su impiegati e dirigenti (esercizi di algebra relazionale del corso).

Operazioni sul modello relazionale

Dati uno schema e un'istanza del database, le operazioni si dividono in due famiglie:

• un aggiornamento è una funzione che porta l'istanza in una nuova istanza valida, cioè che rispetta tutti i vincoli di integrità;
• una interrogazione (query) è una funzione che porta l'istanza in una relazione (il risultato); il database non cambia.

Aggiornamenti e vincoli

Esempio. Dipendente(matricola, cognome, reparto) con reparto chiave esterna verso Reparto(codice, nome). Se si cancella il reparto D e tre dipendenti hanno reparto = 'D': con restrict la cancellazione è rifiutata; con cascade spariscono anche i tre dipendenti; con set null i tre restano con reparto = NULL; con set default passano al reparto di default (che deve esistere).

Set null è impossibile se l'attributo che punta fa parte della chiave primaria, perché una chiave primaria non può contenere NULL. In SQL queste scelte si dichiarano con ON DELETE e ON UPDATE, vedi SQL - definizione dei dati e vincoliSQL (standard ISO 9075) è un linguaggio dichiarativo con una parte di definizione dei dati (DDL: CREATE/DROP/ALTER di database, schemi, tipi enumerati, domini, tabelle) e una di manipolazione (DML: INSERT, DELETE, UPDATE, SELECT). Una tabella SQL è un multi-insieme di righe (può avere duplicati), quindi non è una relazione in senso stretto. CREATE TABLE elenca colonne con tipo e vincoli: NOT NULL, DEFAULT, CHECK (di colonna o di tupla), PRIMARY KEY (una sola, anche composta), UNIQUE, FOREIGN KEY ... REFERENCES con ON DELETE/ON UPDATE (NO ACTION, CASCADE, SET NULL, SET DEFAULT). I tipi principali sono CHAR/VARCHAR, NUMERIC, INTEGER, SERIAL, BOOLEAN, DATE, TIME, TIMESTAMP, più UUID, intervalli e JSON in PostgreSQL. DROP ... CASCADE cancella anche gli oggetti dipendenti, RESTRICT (predefinito) rifiuta se ce ne sono. DELETE e UPDATE senza WHERE agiscono su tutta la tabella.SQL - definizione dei dati e vincoli →.

L'algebra relazionale

L'algebra relazionale è un linguaggio procedurale: un'interrogazione dice come costruire il risultato, con una sequenza di operatori. Ogni operatore ha come operandi una o due relazioni e produce una relazione, quindi gli operatori si compongono in espressioni. (SQL invece è dichiarativo: dice che cosa si vuole.)

Poiché una relazione è un insieme, i duplicati non esistono: ogni risultato è privo di tuple ripetute. È la differenza principale rispetto a SQL, dove una tabella è un multi-insieme.

"Derivato" significa esprimibile con i primitivi, per esempio $R\cap S=R-(R-S)$ e $R\bowtie_\varphi S=\sigma_\varphi(R\times S)$.

Operatori insiemistici

Definizione (compatibilità all'unione). Due relazioni sono compatibili all'unione se hanno lo stesso numero di attributi e ogni coppia di attributi ha stesso nome e stesso dominio.

Intersezione, unione e differenza richiedono relazioni compatibili all'unione. Dati

i tre operatori danno (sempre senza duplicati):

• $\text{Graduated}\cap\text{Manager}=\{t\mid t\in\text{Graduated}\wedge t\in\text{Manager}\}=\{(7432,\text{Neri},54),(9824,\text{Verdi},45)\}$;
• $\text{Graduated}\cup\text{Manager}$: le quattro tuple distinte $(7274,\text{Rossi},42)$, $(7432,\text{Neri},54)$, $(9297,\text{Neri},33)$, $(9824,\text{Verdi},45)$ (le due tuple comuni compaiono una volta sola);
• $\text{Graduated}-\text{Manager}=\{(7274,\text{Rossi},42)\}$: i laureati che non sono dirigenti. La differenza non è commutativa.

Definizione (prodotto). Date $R_1(X_1,\dots,X_n)$ e $R_2(Y_1,\dots,Y_m)$, il prodotto $R_1\times R_2$ ha schema $(X_1,\dots,X_n,Y_1,\dots,Y_m)$, grado $n+m$ e cardinalità $|R_1|\cdot|R_2|$: ogni tupla del primo operando è concatenata a ogni tupla del secondo.

Il nome "prodotto cartesiano" è un po' improprio: il risultato non è l'insieme di coppie di tuple, ma di tuple "incollate". Con $\text{Graduated}\times\text{Manager}$ si hanno $3\cdot3=9$ tuple di 6 attributi; poiché i due schemi hanno gli stessi nomi, per scrivere il prodotto bisogna prima rinominare (altrimenti ci sarebbero due attributi Badge).

Rinomina

Definizione (rinomina). $\rho_{A_1,\dots,A_k\leftarrow B_1,\dots,B_k}(R)$ cambia i nomi degli attributi $B_i$ in $A_i$. Si modifica lo schema, non l'istanza: domini e valori restano.

Serve a due scopi: rendere compatibili all'unione due relazioni e distinguere gli attributi omonimi in un prodotto o in un join.

Esempio (compatibilità). Paternity(Father, Child) e Maternity(Mother, Child) non sono compatibili (Father ≠ Mother). Per ottenere tutti i genitori: $$\rho_{\text{Parent}\leftarrow\text{Father}}(\text{Paternity})\ \cup\ \rho_{\text{Parent}\leftarrow\text{Mother}}(\text{Maternity})$$ con schema $(\text{Parent},\text{Child})$ e le sei tuple dei due operandi, per esempio $(\text{Adamo},\text{Abele})$ e $(\text{Eva},\text{Abele})$.

Esempio (più attributi). $\rho_{\text{Site},\text{Pay}\leftarrow\text{Office},\text{Salary}}(\text{Clerk})\cup\rho_{\text{Site},\text{Pay}\leftarrow\text{Factory},\text{Wages}}(\text{Worker})$ unisce Clerk(Surname, Office, Salary) e Worker(Surname, Factory, Wages) nello schema $(\text{Surname},\text{Site},\text{Pay})$.

Selezione

Definizione (selezione). $\sigma_\varphi(R)$ ha lo stesso schema di $R$ e contiene il sottoinsieme delle tuple di $R$ che soddisfano la proposizione $\varphi$. La proposizione è:

• $A_i\ \theta\ A_j$, con $A_i,A_j$ attributi di $R$ sullo stesso dominio;
• $A_i\ \theta\ c$, con $c$ costante;
• dove $\theta\in\{<,>,=,\neq,\leq,\geq\}$;
• combinazione di proposizioni con $\wedge$, $\vee$, $\neg$.

Dati Employee(Badge, Surname, Branch, Salary) con $(7309,\text{Rossi},\text{Roma},55)$, $(5998,\text{Neri},\text{Milano},64)$, $(9553,\text{Milano},\text{Milano},44)$, $(5698,\text{Rossi},\text{Roma},64)$:

• stipendio maggiore di 50: $\sigma_{\text{Salary}>50}(\text{Employee})$ restituisce tre tuple (tutte tranne la terza);
• stipendio maggiore di 50 e filiale Milano: $\sigma_{\text{Salary}>50\ \wedge\ \text{Branch}=\text{Milano}}(\text{Employee})$ restituisce solo $(5998,\text{Neri},\text{Milano},64)$;
• cognome uguale alla filiale (confronto tra due attributi): $\sigma_{\text{Surname}=\text{Branch}}(\text{Employee})$ restituisce $(9553,\text{Milano},\text{Milano},44)$.

Proiezione

Definizione (proiezione). $\pi_{A_1,\dots,A_k}(R)$ ha come schema un sottoinsieme degli attributi di $R$ e contiene le tuple di $R$ ristrette a quegli attributi. Il grado è $k$; la cardinalità è $\le|R|$: è minore se, dopo aver tolto colonne, alcune tuple diventano uguali e (essendo $R$ un insieme) i duplicati spariscono; è uguale a $|R|$ se gli attributi proiettati contengono una superchiave.

Con lo stesso Employee, $\pi_{\text{Badge},\text{Surname}}(\text{Employee})$ ha quattro tuple, mentre $\pi_{\text{Surname},\text{Branch}}(\text{Employee})$ ne ha tre: $(\text{Rossi},\text{Roma})$ compare una volta sola.

Selezione e proiezione insieme

Sono operatori ortogonali: la selezione fa una decomposizione orizzontale (sceglie righe), la proiezione una verticale (sceglie colonne).

"Badge e cognome dei dipendenti con stipendio maggiore di 50" si scrive $\pi_{\text{Badge},\text{Surname}}(\sigma_{\text{Salary}>50}(\text{Employee}))$: si valuta dall'interno all'esterno. Scambiare l'ordine, $\sigma_{\text{Salary}>50}(\pi_{\text{Badge},\text{Surname}}(\text{Employee}))$, è sbagliato: dopo la proiezione l'attributo Salary non esiste più e la selezione non è definita. In generale $\sigma$ e $\pi$ non commutano; commutano solo quando gli attributi usati dalla selezione sono un sottoinsieme di quelli della proiezione.

Join

Il prodotto da solo produce quasi sempre tuple prive di senso (si accoppia ogni dipendente con ogni reparto). Il join accoppia solo le tuple "giuste".

Definizione (theta-join). Date $R_1(X)$ e $R_2(Y)$ senza attributi omonimi e una proposizione $\varphi$ che confronta attributi di $R_1$ con attributi di $R_2$ (e costanti), $$R_1\bowtie_\varphi R_2=\sigma_\varphi(R_1\times R_2).$$ Grado $n+m$; cardinalità $0\le|R_1\bowtie_\varphi R_2|\le|R_1|\cdot|R_2|$ (detta anche selettività).

Se $\varphi$ è una congiunzione di uguaglianze $A_i=B_j$ si parla di equi-join.

Esempio (equi-join). Con Employee(Surname, Dep) = $\{(\text{Rossi},A),(\text{Neri},B),(\text{Bianchi},B)\}$ e Department(Code, Manager) = $\{(A,\text{Mori}),(B,\text{Bruni})\}$, $\text{Employee}\bowtie_{\text{Dep}=\text{Code}}\text{Department}$ dà $(\text{Rossi},A,A,\text{Mori})$, $(\text{Neri},B,B,\text{Bruni})$, $(\text{Bianchi},B,B,\text{Bruni})$: l'attributo di join compare due volte, con nomi diversi.

Definizione (join naturale). Siano $R_1(X,W)$ e $R_2(Y,Z)$ con $W=(W_1,\dots,W_m)$ e $Z=(Z_1,\dots,Z_m)$ gli attributi con lo stesso nome. Allora $$R_1\bowtie R_2=\pi_{X,W_1,\dots,W_m,Y}\big(R_1\bowtie_{W_1=Z_1\wedge\dots\wedge W_m=Z_m}R_2\big).$$

È un equi-join sugli attributi omonimi, seguito da una proiezione che tiene una sola copia di ogni attributo comune. Con Department(Dep, Manager) (stesso nome Dep in entrambe) $\text{Employee}\bowtie\text{Department}$ dà $(\text{Rossi},A,\text{Mori})$, $(\text{Neri},B,\text{Bruni})$, $(\text{Bianchi},B,\text{Bruni})$.

Il join naturale è comodo ma fragile: se due relazioni hanno per caso un attributo omonimo che non va usato per il join (per esempio due Nome), il risultato cambia in silenzio. Nei temi d'esame conviene scrivere il join con la condizione esplicita (equi-join) e rinominare dove serve.

Cardinalità del join

Siano $R_1(X)$, $R_2(Y)$ e $Z=X\cap Y$ gli attributi su cui si fa il join naturale (o l'equi-join).

Esempio. Employee: $(\text{Rossi},A),(\text{Neri},B),(\text{Bianchi},B),(\text{Neri},C)$ (4 tuple).

• Department = $(A,\text{Mori}),(B,\text{Bruni}),(B,\text{Verdi})$: Dep non è chiave, risultano 5 tuple (su un massimo di $4\cdot3=12$): $\text{Neri}$ e $\text{Bianchi}$ si accoppiano con entrambi i dirigenti di $B$, $\text{Neri},C$ non si accoppia.
• Department = $(A,\text{Mori}),(B,\text{Bruni}),(D,\text{Verdi})$: Dep è chiave ma non chiave esterna di Employee (c'è $C$ senza reparto): 3 tuple, meno delle 4 di Employee.
• Con $(\text{Neri},D)$ al posto di $(\text{Neri},C)$ e lo stesso Department: Dep è chiave di Department e chiave esterna di Employee: 4 tuple $=|\text{Employee}|$.

Tuple dangling

Una tupla che non trova corrispondente nell'altro operando non contribuisce al risultato: si dice dangling (pendente). Nell'esempio, $(\text{Neri},C)$ di Employee e $(D,\text{Verdi})$ di Department scompaiono dal join. Per mantenerle, con valori NULL, servono gli outer join (Algebra relazionale estesa - divisione, aggregazione e outer joinL'algebra relazionale di base lavora una tupla alla volta e non sa fare calcoli sui valori né riassumere più tuple. L'estensione aggiunge: la proiezione generalizzata π_{F1,...,Fn}(R), che calcola espressioni sugli attributi (prezzo per quantità); l'aggregazione ℱ_{SUM, MAX, MIN, AVG, COUNT}(R), che produce una sola tupla; il raggruppamento (A1,...,Am)ℱ_{f(B)}(R), che produce una tupla per gruppo (grado n+m, cardinalità = numero di gruppi). Le funzioni di aggregazione ignorano i NULL, COUNT(*) conta le tuple, i NULL formano un gruppo a sé. Gli outer join (left, right, full) mantengono con NULL le tuple dangling del join; i NULL nella chiave di join non si accoppiano mai. La divisione R÷S dà gli x tali che (x,y) sta in R per ogni y di S, e si ottiene con π, × e −. Ricette: massimo = aggregazione + join con il massimo, "tutti" = divisione o complemento, "almeno due" = self-join.Algebra relazionale estesa - divisione, aggregazione e outer join →).

Join di una relazione con se stessa

Per accoppiare tuple della stessa relazione si usa la rinomina. Con Employee(Badge, Surname, Age, Salary) e Manage(Employee, Manager) (tutti gli attributi sono badge), "i dipendenti che guadagnano più del loro dirigente" richiede due copie di Employee: una per il dipendente, una rinominata per il dirigente.

$$\pi_{\text{Badge},\text{Surname},\text{Salary},\text{M.Bdg},\text{M.Srn},\text{M.Slry}}\Big(\text{Manage}\bowtie_{\text{Employee}=\text{Badge}}\text{Employee}\ \bowtie_{\text{M.Bdg}=\text{Manager}\ \wedge\ \text{Salary}>\text{M.Slry}}\ \rho_{\text{M.Bdg},\text{M.Srn},\text{M.Age},\text{M.Slry}\leftarrow\text{Badge},\text{Surname},\text{Age},\text{Salary}}(\text{Employee})\Big)$$

Il passaggio con theta-join evita una selezione dopo un equi-join. Il risultato completo è nell'esercizio Esercizio - Algebra relazionale su impiegati e dirigenti (esercizi di algebra relazionale del corso).

Valori NULL

La selezione valuta ogni condizione atomica separatamente, e un confronto con NULL non è vero (il risultato è "sconosciuto"). Con Employee(Badge, Surname, Age, Branch): $(7309,\text{Rossi},34,\text{Roma})$, $(5998,\text{Bianchi},42,\text{Milano})$, $(9553,\text{Neri},\text{NULL},\text{Milano})$:

• $\sigma_{\text{Age}>40}(\text{Employee})$ restituisce solo Bianchi;
• $\sigma_{\text{Age}\le40}(\text{Employee})$ restituisce solo Rossi;
• quindi $\sigma_{\text{Age}>40}\cup\sigma_{\text{Age}\le40}\neq\text{Employee}$: Neri sparisce da entrambe. Lo stesso vale per $\sigma_{\text{Age}>40\ \vee\ \text{Age}\le40}$.

Per gestire i NULL si introducono le condizioni specifiche $A\ \text{IS NULL}$ e $A\ \text{IS NOT NULL}$:

$$\sigma_{\text{Age}>40\ \vee\ \text{Age}\le40\ \vee\ \text{Age IS NULL}}(\text{Employee})=\text{Employee}.$$

Con la logica a tre valori (vero, falso, sconosciuto) $\wedge$, $\vee$, $\neg$ si comportano così, e la selezione tiene solo le tuple per cui la condizione è vera:

Anche nei join gli attributi NULL non si accoppiano mai: $\text{NULL}=\text{NULL}$ non è vero.

Come si scrive una query

1. Individuare le relazioni coinvolte e gli attributi che servono nel risultato.
2. Collegarle con join (sui legami chiave-chiave esterna), rinominando gli attributi omonimi o le copie della stessa relazione.
3. Filtrare con $\sigma$ (meglio il prima possibile, sulle relazioni piccole, prima dei join: il risultato è lo stesso ma l'espressione è più efficiente).
4. Proiettare con $\pi$ solo gli attributi richiesti (e solo alla fine, se la selezione usa attributi che non si vedono nel risultato).
5. Assegnare nomi alle relazioni intermedie ($R_1\leftarrow\dots$) per leggibilità; le espressioni si leggono dall'interno all'esterno e da sinistra a destra.
6. Controllare su due o tre tuple a mano, con attenzione ai duplicati, ai NULL e ai casi limite ("nessuno", "tutti", "almeno due").

Per i casi con "massimo", "tutti", "per ciascuno" servono l'aggregazione e la divisione, vedi Algebra relazionale estesa - divisione, aggregazione e outer joinL'algebra relazionale di base lavora una tupla alla volta e non sa fare calcoli sui valori né riassumere più tuple. L'estensione aggiunge: la proiezione generalizzata π_{F1,...,Fn}(R), che calcola espressioni sugli attributi (prezzo per quantità); l'aggregazione ℱ_{SUM, MAX, MIN, AVG, COUNT}(R), che produce una sola tupla; il raggruppamento (A1,...,Am)ℱ_{f(B)}(R), che produce una tupla per gruppo (grado n+m, cardinalità = numero di gruppi). Le funzioni di aggregazione ignorano i NULL, COUNT(*) conta le tuple, i NULL formano un gruppo a sé. Gli outer join (left, right, full) mantengono con NULL le tuple dangling del join; i NULL nella chiave di join non si accoppiano mai. La divisione R÷S dà gli x tali che (x,y) sta in R per ogni y di S, e si ottiene con π, × e −. Ricette: massimo = aggregazione + join con il massimo, "tutti" = divisione o complemento, "almeno due" = self-join.Algebra relazionale estesa - divisione, aggregazione e outer join →. Con i soli operatori di questa nota si possono già esprimere i "per tutti" con la differenza: "i dirigenti i cui dipendenti guadagnano tutti più di 42" $=\pi_{\text{Manager}}(\text{Manage})-\pi_{\text{Manager}}\big(\text{Manage}\bowtie_{\text{Employee}=\text{Badge}}\sigma_{\text{Salary}\le42}(\text{Employee})\big)$, cioè tutti i dirigenti meno quelli che hanno almeno un dipendente sotto soglia. È il metodo del complemento: "tutti" = "non esiste nessuno che non".

Errori tipici

• Scrivere $\sigma_{\text{Manager}=\text{Employee}}(\text{Manage})$ per "dirigenti che hanno a loro volta un dirigente": confronta due attributi della stessa tupla, quindi trova chi dirige se stesso (nessuno). Serve un join della relazione con una sua copia rinominata.
• Fare la proiezione prima della selezione quando la selezione usa attributi eliminati.
• Usare un join naturale tra relazioni con attributi omonimi che non c'entrano.
• Dimenticare la rinomina nelle unioni (relazioni non compatibili) e nei join con se stessi.
• Ignorare i NULL: $\sigma_{A>c}\cup\sigma_{A\le c}\neq R$.
• Dare per scontato che il risultato contenga duplicati: in algebra non ce ne sono.

Domande d'esame

1. Quando due relazioni sono compatibili all'unione e perché la rinomina serve prima di un'unione? Traccia. Stesso numero di attributi con stessi nomi e domini. Se i nomi sono diversi (Father/Mother) l'unione non è definita: si rinominano gli attributi con $\rho$ cambiando solo lo schema, poi si fa $\cup$.

2. Perché $\pi_{\text{Badge},\text{Surname}}(\sigma_{\text{Salary}>50}(E))$ non si può riscrivere come $\sigma_{\text{Salary}>50}(\pi_{\text{Badge},\text{Surname}}(E))$? Traccia. La proiezione elimina Salary, quindi la selezione che segue usa un attributo inesistente. Selezione e proiezione commutano solo se gli attributi della selezione sono tra quelli proiettati.

3. Quante tuple ha $R_1\bowtie R_2$ se l'attributo di join è chiave di $R_2$ e chiave esterna di $R_1$? Traccia. Esattamente $|R_1|$: ogni tupla di $R_1$ ha una sola tupla corrispondente in $R_2$ (esiste per l'integrità referenziale ed è unica perché è una chiave).

4. Cosa restituisce $\sigma_{A>40}(R)\cup\sigma_{A\le40}(R)$ se $A$ ha valori NULL? Traccia. Non tutta $R$: un confronto con NULL non è vero, quindi le tuple con $A$ nullo mancano in entrambe. Servono $A\ \text{IS NULL}$ / $A\ \text{IS NOT NULL}$.